close

Anmelden

Neues Passwort anfordern?

Anmeldung mit OpenID

Arduino im RC-Modellbau - Leseprobe - ELV

EinbettenHerunterladen
65168-4_Titelei_A5 27.03.13 13:13 Seite 3
Das Franzis Know-how-Paket
Arduino™ im
RC-Modellbau
Arduino™-Anwendungen für RC-Modelle
65168-4_Titelei_A5 27.03.13 13:13 Seite 4
Bibliografische Information der Deutschen Bibliothek
Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie;
detaillierte Daten sind im Internet über http://dnb.ddb.de abrufbar.
Alle in diesem Buch vorgestellten Schaltungen und Programme wurden mit der größtmöglichen Sorgfalt entwikkelt, geprüft und getestet. Trotzdem können Fehler im Buch und in der Software nicht vollständig ausgeschlossen
werden. Verlag und Autor haften in Fällen des Vorsatzes oder der groben Fahrlässigkeit nach den gesetzlichen Bestimmungen. Im Übrigen haften Verlag und Autor nur nach dem Produkthaftungsgesetz wegen der Verletzung
des Lebens, des Körpers oder der Gesundheit oder wegen der schuldhaften Verletzung wesentlicher Vertragspflichten. Der Schadensersatzanspruch für die Verletzung wesentlicher Vertragspflichten ist auf den vertragstypischen, vorhersehbaren Schaden begrenzt, soweit nicht ein Fall der zwingenden Haftung nach dem Produkthaftungsgesetz gegeben ist.
Liebe Kunden!
Dieses Produkt wurde in Übereinstimmung mit den geltenden europäischen Richtlinien hergestellt
und trägt daher das CE-Zeichen. Der bestimmungsgemäße Gebrauch ist in der beiliegenden Anleitung
beschrieben.
Franzis
Bei jeder anderen Nutzung oder Veränderung des Produktes sind allein Sie für die Einhaltung der geltenden
Regeln verantwortlich. Bauen Sie die Schaltungen deshalb genau so auf, wie es in der Anleitung beschrieben wird.
Das Produkt darf nur zusammen mit dieser Anleitung weitergegeben werden.
Das Symbol der durchkreuzten Mülltonne bedeutet, dass dieses Produkt getrennt vom
Hausmüll als Elektroschrott dem Recycling zugeführt werden muss. Wo Sie die nächstgelegene
kostenlose Annahmestelle finden, sagt Ihnen Ihre kommunale Verwaltung.
Arduino™ ist ein eingetragenes Markenzeichen der Firma Arduino LLC und den damit verbundenen Firmen.
Autor: Wilfried Klaas
© 2013 Franzis Verlag GmbH, Richard-Reitzner-Allee 2, 85540 Haar bei München
Alle Rechte vorbehalten, auch die der fotomechanischen Wiedergabe und der Speicherung in elektronischen Medien. Das Erstellen und Verbreiten von Kopien auf Papier, auf Datenträgern oder im Internet, insbesondere als PDF,
ist nur mit ausdrücklicher Genehmigung des Verlags gestattet und wird widrigenfalls strafrechtlich verfolgt.
Die meisten Produktbezeichnungen von Hard- und Software sowie Firmennamen und Firmenlogos, die in diesem
Werk genannt werden, sind in der Regel gleichzeitig auch eingetragene Warenzeichen und sollten als solche betrachtet werden. Der Verlag folgt bei den Produktbezeichnungen im Wesentlichen den Schreibweisen der Hersteller.
5
Vorwort
Den Arduino kennen mittlerweile viele. Darüber geschrieben wurde auch bereits eine Menge. Es gibt unzählige Anleitungen, Beispiele, Schaltungen usw. Was bisher aber fehlte, war
eine Anleitung speziell für den Modellbau. Diese Lücke möchten wir schließen.
In diesem Know-how-Paket werden Sie lernen, wie vielfältig sich der Arduino im Modellbau
einsetzen lässt und welche enormen Möglichkeiten man mit ihm hat. Programmierkenntnisse sind zwar von Vorteil, aber nicht zwingend erforderlich.
Natürlich kann man in einem solchen Buch nicht alle Bereiche beleuchten, aber es wird ein
kleiner Rundblick gegeben.
Im Paket befindet sich neben dem Arduino Uno eine spezielle Treiberplatine für die Lichtsteuerung eines RC-Autos. Im Internet finden Sie die aktuelle Version der Arduino-IDE und
auch der hier vorgestellten Beispielprogramme.
Besuchen Sie doch einmal meine Internetseite www.rcarduino.tk. Ich würde mich freuen.
Ich wünsche Ihnen nun viel Spaß mit diesem Paket.
Wilfried Klaas
Abb. 0.1: Arduino Uno SMD Version
65168-4 Arduino im RC-Modellbau_NEU2.indd 5
20.03.2013 16:41:34
7
Inhalt
1
Die Software ...................................................................................................9
1.1 Arduino-Installation .............................................................................. 9
1.2 Projektinstallation ................................................................................. 9
1.3 Sketchverzeichnis einstellen ...............................................................10
1.4 Treiberinstallation Arduino Uno unter Windows 7, Vista oder XP ..........10
2
Einkaufsliste................................................................................................ 13
3
Arduino-Hardware ....................................................................................... 15
4
Arduino-Sprachreferenz ............................................................................... 17
4.1 Sprache ..............................................................................................17
4.2 Funktionen..........................................................................................27
4.3 Bibliotheken – Librarys .......................................................................40
4.4 RC Receive ..........................................................................................43
4.5 SoftPWM .............................................................................................47
5
Elektronik ................................................................................................... 49
5.1 Berechnung der LED-Vorwiderstände ...................................................49
5.2 Schaltstufen........................................................................................51
6
Allgemeine Projekte .................................................................................... 55
6.1 Blinken, Flackern und Co. ....................................................................55
6.2 Akku-Tiefenentladeschutz ...................................................................65
6.3 Servotesterr ......................................................................................... 68
6.4 Fail-safe für zwei Kanäle ......................................................................69
6.5 2-Kanal-Schalter..................................................................................
r
73
6.6 Servoverzögerung und -verlangsamung
g ............................................... 75
6.7 Servowegbegrenzung, Servorevers ......................................................78
6.8 Kreuzmischer, V-Mischerr ..................................................................... 79
6.9 5-/6-Kanal-Schalter.............................................................................
r
84
65168-4 Arduino im RC-Modellbau_NEU2.indd 7
20.03.2013 16:41:52
8
Inhaltsverzeichnis
7
Projekte im Schiffsmodellbau ...................................................................... 87
7.1 Lichttonne mit Rundumlicht ................................................................87
7.2 Sonderfunktionen Feuerwehrschiff......................................................
f
89
7.3 Jet-Antrieb mit 2 Kanälen.....................................................................91
7.4 Schraubenantrieb mit Steuerunterstützung
g ......................................... 93
7.5 RC-Rudererr .......................................................................................... 97
8
Projekte im Automodellbau ....................................................................... 101
8.1 K.I.T.T. ...............................................................................................101
8.2 Einfache Startampel ..........................................................................103
8.3 Steuerung eines Kettenfahrzeugs ......................................................105
8.4 Lichtsteuerung eines Modellautos .....................................................106
8.5 Dynamische Servowegbegrenzung
g .................................................... 111
9
Projekte im Flugmodellbau ........................................................................ 113
9.1 Flugblitzer, ACL und Strobe inkl. Landescheinwerferr .......................... 113
9.2 Fahrwerk, Flaps (Servoverlangsamung)..............................................115
10
Internetseiten mit weiterführenden Informationen..................................... 119
65168-4 Arduino im RC-Modellbau_NEU2.indd 8
20.03.2013 16:41:52
87
7 Projekte im Schiffsmodellbau
Know-how:
•
PWM Lib
7.1 Lichttonne mit Rundumlicht
Wir beginnen mit einem Projekt ohne Empfänger. Deswegen ist es aber nicht weniger interessant. Wir bauen ein drehendes Rundumlicht – aber nicht mit Spiegel und Motor, sondern
mit mehreren LEDs. Wir können es als Blaulicht oder auch als gelbes Rundumlicht verwenden. Im Beispiel dient es als »Leuchtmittel« für einen Leuchtturm. Dazu nehmen wir 12
weiße Leuchtdioden und verbinden diese mit den entsprechenden Vorwiderständen mit den
Ausgängen D0..11. Das Ganze wird über einen Schalter an Pin D12 ein- und ausgeschaltet.
In diesem Programm wird eine neue Bibliothek eingebunden. Die SoftPWM-Bibliothek
M
kann jeden Ausgang als PWM-Ausgang verwenden. Somit ist man nicht mehr auf die vorhandenen 6 Ausgänge beschränkt. Das Ganze kostet aber Rechenzeit, da die Ausgänge per
Interrupt gesteuert werden.
65168-4 Arduino im RC-Modellbau_NEU2.indd 87
20.03.2013 16:42:12
88
7 Projekte im Schiffsmodellbau
Abb. 7.1: Leuchtturm schematisch
In der setup()-Funktion definieren wir zunächst den Schalter-Pin als Eingang mit Pull-up.
Dadurch müssen wir den Schalter nur gegen Masse schalten. Dann starten wir die SoftPWMBibliothek mit SoftPWMBegin(). Jetzt definieren wir alle Pins und setzen den Wert auf 0
(SoftPWMSet(i, 0)). Zuletzt wird die Fading-Zeit der Bibliothek gesetzt. Damit kann man
ein automatisches Fading erzeugen.
SoftPWMSetFadeTime(ALL, 100, 100)
Die loop()-Funktion ist jetzt einfach. Zunächst wird der Schalter abgefragt. Ist der Schalter
geschlossen (also gegen Masse geschaltet), werden alle Ausgänge auf 0 geschaltet. Ist der
Schalter offen, wird zunächst der Inhalt des Steuerungs-Arrays (leuchtfolge[]) auf die Ausgänge gebracht. Dann wird der Inhalt des Arrays einfach einen Index weiter geschoben. Das
Ende, das herausgeschoben wird, wird dann an den Anfang gestellt. So etwas nennt man einen Ringpuffer. Zuletzt wird eine Verzögerung eingebaut. Diese steuert die »Drehgeschwindigkeit«. Fertig ist unsere »Leuchtturm-Beleuchtung«. Durch die verschiedenen Werte im
Array wird ein »Nachlauf« simuliert.
65168-4 Arduino im RC-Modellbau_NEU2.indd 88
20.03.2013 16:42:13
7.2 Sonderfunktionen Feuerwehrschiff
89
Als Initialisierung für das Array kann man auch folgende Folge probieren:
byte leuchtfolge[] = { 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0}
Versuchen Sie nun selbst, das Programm so zu erweitern, dass Sie mit einem Trimmer die
Drehgeschwindigkeit einstellen können.
7.2 Sonderfunktionen Feuerwehrschiff
Know-how:
•
•
Kombinieren von Programmen
Treiberstufen
Selbst für ein kleines Modell-Feuerwehrschiff braucht man ein paar Sonderfunktionen.
Was natürlich immer mit dabei sein muss, sind ein Blaulicht und die Wasserkanone, beides
möglichst drehbar. Für die Pumpe brauchen wir einen Schaltkanal, für das Blinklicht natürlich auch. Beide sollten unabhängig voneinander schaltbar sein – und das möglichst ohne
1.000 € in eine Fernsteuerung mit Multinaut-Baustein zu investieren.
Das nachfolgend beschriebene kleine Programm erledigt die beiden Aufgaben auf sehr einfache Art, und das mit nur einem zurückstellenden Proportionalkanal. In die eine Richtung
wird das Blinklicht ein- und beim nächsten Mal wieder ausgeschaltet, in der anderen Richtung wird die Pumpe betrieben. Die Pumpe läuft aber nur, solange man den Hebel in die
entsprechende Richtung hält.
Ähnliches haben wir bereits beim 2-Kanal-Schalter gemacht. Wir verwenden den Sketch
weiter und setzen die entsprechenden Konstanten fest ins Programm. Da der Controller
maximal 40 mA liefern kann, betreiben wir die Pumpe über ein Relais. Ein Blinklicht mit
2 blauen LEDs könnten wir direkt betreiben. Im Schaltplan wurde eine Treiberstufe vorgesehen. Somit können wir auch mehr als 2 LEDs anschließen, ohne den Arduino damit zu
belasten. Die Stufe kann bis zu 100mA schalten. Das Relais ist ein 6-V-Typ.
65168-4 Arduino im RC-Modellbau_NEU2.indd 89
20.03.2013 16:42:13
90
7 Projekte im Schiffsmodellbau
Abb. 7.2: RelaisSwitch
Das Programm basiert mit einigen vordefinierten Einstellungen auf dem Programm zum
2-Kanal-Schalter. Kanal 1 ist als Kanal für das Blinklicht konfiguriert und arbeitet im Impulsbetrieb. D. h., dass das Blinklicht bei einem Impuls mit dem Hebel des Kanals an- und
beim nächsten Impuls wieder ausgeht. Kanal 2 ist für die Pumpe und arbeitet im Dauerbetrieb. Solange der Hebel in Stellung 2 ist, wird gepumpt.
Eingang für den Empfänger ist Pin 2. Ausgänge sind Pin 0 für das Blinklicht und Pin 1 für
die Pumpe. Das Programm selbst ist sehr verkürzt. Damit passt das Ganze aber auch in
einen kleineren Controller (z. B. ATTiny44). Auch diesen kann man mit der Arduino-Entwicklungsumgebung programmieren. Dazu benötigt man nur einen Programmieradapter
und die entsprechende Bibliothek für die Arduino-IDE. Das Thema würde aber den Rahmen dieses Buchs sprengen. Eine Einführung zu dem Thema findet man im Internet unter
http://RCArduino.tk.
65168-4 Arduino im RC-Modellbau_NEU2.indd 90
20.03.2013 16:42:14
7.3 Jet-Antrieb mit 2 Kanälen
91
7.3 Jet-Antrieb mit 2 Kanälen
Know-how:
•
•
EEPROM lesen
EEPROM schreiben
Ein Jet-Antrieb braucht eigentlich drei Kanäle: einen für das Steuer, einen für den ESC und
einen für die Rückfahrklappe. Hat man eine 3-Kanal-Fernsteuerung, ist das alles kein Problem. Aber ein schnelles Boot mit Jet-Antrieb fährt sich sehr gut mit einer Pistolenfernsteuerung aus dem Autobereich, und diese haben meist nur zwei Kanäle. Bei einer dreikanaligen
Version ist dann der dritte Kanal in der Regel ein Schaltkanal. Das würde zwar reichen,
aber es ist schöner, wenn man, wie beim Modellauto, mit einem Proportionalkanal sowohl
vorwärts- als auch rückwärts fahren kann. Das lässt sich auch wesentlich einfacher steuern.
Das hier vorgestellte Programm automatisiert die Rückfahrklappe. Die Steuerung erfolgt
folgendermaßen: Bei Vorwärtsfahrt wird das Motorsignal ohne Änderung direkt an den
Regler geschickt. Der Klappenservo bleibt in der gespeicherten Position Upp stehen. Wird
nun auf Rückwärtsfahrt gestellt, werden die Reglersignale (ESC) so modifiziert, dass wieder
Signale für Vorwärtsfahrt generiert werden. Aber der Klappenservo wird in die andere Position (down) gefahren. Außerdem kann man, wenn gewünscht, den Fahrtregler bei Rückwärtsfahrt auf halbe Leistung programmieren.
Der Empfänger wird von Pin 2 gelesen, die Ausgänge liegen auf Pin 9 (Klappenservo) und
10 (ESC). An Anschluss 5 wird ein Taster (PRG) gegen Masse angeschlossen. Der Nullpunkt
des Kanals wird wie immer automatisch beim Start ermittelt.
Im Programm gibt es einen Programmiermodus, wenn der Taster PRG beim Einschalten
gedrückt wird. Dann können die beiden Positionen des Klappenservos und die minimale
und maximale Ansteuerung des ESC gespeichert werden. Zunächst muss aber die obere Position gespeichert werden. Dazu wird die Steuerung auf den gewünschten Wert eingestellt
und PRG gedrückt. Zur Quittierung blinkt die Board-LED. Danach wird die untere Position
angefahren und genauso gespeichert, dann die maximale Stellung des ESC und danach die
Minimalposition. Der Programmiermodus wird dann automatisch verlassen. Die Werte für
die Klappe und den ESC werden im EEPROM abgelegt und beim erneuten Start auch wieder gelesen. Die minimale Position steht im EEPROM in Adresse 0, die maximale Position
in Adresse 1. Es ist dabei völlig egal, welchen Wert die untere bzw. obere Position tatsächlich
hat. Unten definiert nur die Servostellung für den Rückwärtsbetrieb. Es wird beim Speichern die vorher programmierte Position angefahren. Das Gleiche gilt auch für die andere
Position. Adresse 3 enthält den ESC-Max-Wert und 2 den ESC-Min-Wert.
65168-4 Arduino im RC-Modellbau_NEU2.indd 91
20.03.2013 16:42:14
92
7 Projekte im Schiffsmodellbau
Das Programm teilt sich in die zwei üblichen Bestandteile auf.
setup() dient der Einrichtung der Hardware:
Ausgänge
•
Servo für den Klappenservo (Pin 10)
•
ESC zum Regler (Pin 9)
•
LED zur Anzeige des Status (Pin 13/Board-LED)
Eingänge
•
ESC vom Empfänger (Pin 2)
•
Taster PRG für den Programmiermodus (Pin 5)
Nachdem alle Ein- und Ausgänge gesetzt sind und auch die Empfängerbibliothek im Interruptmodus initialisiert wurde, werden die beiden Werte für den Klappenservo aus dem
EEPROM gelesen. Der minimale Wert steht in Speicherzelle 0, der maximale in Speicherzelle 1. Sind die Speicherzellen gelöscht (Wert ist dann $FF) werden Default-Werte benutzt.
Minimaler Wert ist dann 45°, maximaler 135° (die Gradangaben beziehen sich auf einen
180°-Servo). Das Gleiche gilt für den Bereich des Reglers. Auch hier werden der minimale und der maximale Wert definiert (Speicherzellen 2 und 3, Defaultwerte: 90° und 180°).
Dann wird der Klappenservo mit dem Minimalwert initialisiert. Der Minimalwert ist gleichzeitig auch immer der Fail-safe-Wert – sowohl beim Klappenservo als auch beim ESC.
Nun wird der Programmierungstaster abgefragt. Ist er gedrückt (==0), wird die Unterroutine für die Programmierung aufgerufen und damit in den Programmiermodus gewechselt.
Erst wenn im Setup alles abgeschlossen ist, blinkt die LED einmal kurz.
programServo() ist die Funktion zur Programmierung von minimalen und maximalen
Werten für Klappe und Regler. Zunächst geht die Board-LED an. Sie bleibt so lange an,
bis die Programmiertaste nicht mehr gedrückt wird. Jetzt beginnt der bereits beschriebene
Programmiervorgang. Die Programmierung ist als Zustandsautomat implementiert. Nach
jedem erfolgreich programmierten Wert blinkt die LED: 1x nach dem Up-Wert des Klappenservos, 2x nach dem Down-Wert, 3x nach dem maximalen ESC-Wert, und 4x nach dem
minimalen ESC-Wert. Die Werte werden per EEPROM.write(adr, value) in den EEPROM
geschrieben. Auch das Lesen aus dem EEPROM ist einfach: byte value = EEPROM.read(adr).
In der loop()-Funktion beginnt nun die eigentliche Verarbeitung. Zunächst wird getestet, ob
der Nullpunkt des Empfängers bereits bestimmt worden ist. Nur wenn dieser vorliegt, geht
es weiter. Andernfalls wartet das Programm. Ist der Nullpunkt bestimmt, wird getestet, ob
65168-4 Arduino im RC-Modellbau_NEU2.indd 92
20.03.2013 16:42:15
7.4 Schraubenantrieb mit Steuerunterstützung
93
kein Fehler vorliegt. Liegt ein Fehler vor, werden die Fail-safe-Werte in die Servos geschrieben.
else {
// Fehlerfall failsafe ...
myServo.write(minValue);
myEsc.write(minEscValue);
}
Liegt kein Fehler vor, wird nun der Wert vom Empfänger ausgewertet. Wir erwarten einen
Wert von 0.. 255, wobei Werte < 128 Rückwärtsfahrt und > 128 Vorwärtsfahrt bedeuten. Um
den Nullpunkt (128) herum wird eine kleine 3-Werte-Schranke aufgebaut. Dadurch zittert
der Klappenservo nicht. Liegen wir in diesem Nullbereich, wird, wenn nötig, die Klappe in
die minimale Position gefahren und der Regler abgeschaltet (minEscValue).
Ist der Wert größer als Nullpunkt + 3, geht das System in Vorwärtsfahrt. Der Regler wird
entsprechend eingestellt und die Klappe, wenn nötig, in die minimale Position gefahren.
Die Umrechnung des Empfängerwerts in den Wert für den ESC übernimmt die map()Funktion.
escValue = map(escValue,128,255,minEscValue,maxEscValue);
Ist der Wert vom Empfänger kleiner als Nullpunkt –3, geht das System in Rückwärtsfahrt.
D. h., der ESC wird wie vorwärts angesteuert, aber die Klappe wird in die maximale Position
gefahren. Zusätzlich wird die Konstante HALF_BACK_THROTTLE
E ausgewertet. Ist diese
True, läuft der ESC nur mit maximal halber Fahrt.
if (HALF_BACK_THROTTLE) {
escValue= map(escValue,128,0,minEscValue,maxEscValue/2);
} else {
escValue= map(escValue,128,0,minEscValue,maxEscValue);
}
7.4 Schraubenantrieb mit Steuerunterstützung
Know-how:
•
•
serielle Schnittstelle
Debuggen
Bei einem Schiff mit zwei oder mehr Schrauben kann man zur Unterstützung des Ruders
auch die Motoren verwenden. Dazu muss der jeweils kurvenäußere Motor mehr, der kurven-
65168-4 Arduino im RC-Modellbau_NEU2.indd 93
20.03.2013 16:42:15
94
7 Projekte im Schiffsmodellbau
innere Motor weniger drehen. Es handelt sich hier quasi um den bereits beschriebenen VMischer. Wir sollten diese Ruderunterstützung jedoch nur bei höheren Geschwindigkeiten
einsetzen. Also modifizieren wir das Programm entsprechend.
Zunächst definieren wir die Nullpunkte der beiden Regler. Das brauchen wir für den Failsafe.
// Nullpunkt der beiden Regler
const byte ESC_NP_1 = 90;
const byte ESC_NP_2 = 90;
Dann definieren wir die Schranke, ab der der Einfluss auf die Motoren erfolgen soll.
// Ab wann soll der Einfluss erfolgen (Bereich 0..128)
const byte ESC_MIN = 64;
Wir müssen auch noch definieren, wie stark der Einfluss sein soll. Diese Zahl ist der Wert,
durch den der Ruderwert geteilt wird. Deswegen wird der Einfluss bei größeren Werten
kleiner.
// Wie stark soll der Einfluss sein.
// ACHTUNG: Höhere Werte ergeben weniger Effekt
const byte RUDDER_IMPACT = 2;
Damit das Ganze nicht zu schnell wird, brauchen wir noch eine Schleifenverzögerung.
// die Schleifenverzögerung, damit das alles nicht zu schnell geht
const int LOOP_DELAY = 10;
Im setup()-Teil entdecken wir nichts Besonderes. Hier werden die Empfängerkanäle und die
ESCs definiert. Auch die loop() ist Standard.
In der doWork() ist mehr zu tun. Zunächst lesen wir den Fahrtreglerkanal und normieren
ihn auf einen Bereich von max. ±128 um den ermittelten Nullpunkt. Für die beiden Fahrtregler werden dann zwei Variablen definiert, die später den Wert für die beiden Fahrtregler
enthalten.
Nun gilt es nachzusehen, ob der Wert für den Fahrtregler überhaupt größer als die definierte
Schranke ESC_MIN
N ist. Dazu bilden wir den Absolutwert, denn auch bei Rückwärtsfahrt
soll die Ruderunterstützung greifen.
if (abs(escValue) >= ESC_MIN) {
65168-4 Arduino im RC-Modellbau_NEU2.indd 94
20.03.2013 16:42:15
7.4 Schraubenantrieb mit Steuerunterstützung
95
Ist der Wert größer, besorgen wir uns den aktuellen Servowert. Auch dieser wird auf ±128
normiert. Nun beschränken wir den Einfluss, indem wir den Servowert durch die Definition
von RUDDER_IMPACT dividieren.
int servoValue = servoReceiver.getValue();
servoValue = servoValue - servoReceiver.getNP();
// jetzt Wertebereich für den Einfluss verkleinern
servoValue = servoValue / RUDDER_IMPACT;
Jetzt berechnen wir die neuen ESC-Werte. Dabei machen wir eine Abfrage auf den Compiler-Schalter SWITCH_RUDDER_IMPACT. Dieser Schalter vertauscht den Einfluss auf die
ESCs.
#ifdef SWITCH_RUDDER_IMPACT
esc_value_1 = escValue esc_value_2 = escValue +
#else
esc_value_1 = escValue +
esc_value_2 = escValue #endif
servoValue;
servoValue;
servoValue;
servoValue;
Nun werden die ESC Werte auf den ±128-Wertebereich beschränkt. Damit sind wir mit dem
ruderspezifischen Teil fertig. Nach dem Ganzen wird nun der virtuelle ±128-Wert auf den
realen ESC-Wert von 0..180 gemappt. Dann wird das Ganze auf die beiden ESCs ausgegeben. Zuletzt kommt die Schleifenverzögerung, damit das Ganze nicht zu schnell wird.
// Auf die ESCs umsetzen
esc_value_1 = map(esc_value_1,-128, 128,0,180);
esc_value_2 = map(esc_value_2,-128, 128,0,180);
// und einstellen
esc1.write(esc_value_1);
esc2.write(esc_value_2);
// Schleifenverzögerung
delay(LOOP_DELAY);
Ein paar Befehle wurden bei der Beschreibung ausgelassen. Ganz oben finden wir:
#define debug
Im setup()-Teil finden wir z. B. noch:
initDebug();
dbgOutLn("Mehrschrauben");
65168-4 Arduino im RC-Modellbau_NEU2.indd 95
20.03.2013 16:42:15
96
7 Projekte im Schiffsmodellbau
Abb. 7.3: Serial Monitor
Damit initialisieren wir einen Debug-Modus über die serielle Schnittstelle (implementiert
in der debug.h-Bibliothek). Damit kann der Arduino Kontakt mit dem PC aufnehmen,
während das Programm abgearbeitet wird. Wichtig ist dabei aber, dass die Pins 0 und 1
beim Uno dann nicht mehr benutzbar sind, da sie für die serielle Schnittstelle verwendet
werden. In der IDE können wir nun einfach über das Menü [Tools]/[Serial Monitor] ein
Terminalprogramm starten. Unten rechts kann man dann die richtige Baudrate einstellen,
in unserem Fall wären das 57.600 Baud (je schneller, um so schneller sind die Ausgaben und
umso weniger wird das Programm gestört). In der doWork()-Methode geben wir nun die
beiden berechneten Werte der ESCs aus. Das geschieht mit:
debug.h:
#ifdef debug#define dbgOut(S) \Serial.print(S);
#define dbgOutLn(S) \Serial.println(S);
#else
#define dbgOut(S)#define dbgOutLn(S)
65168-4 Arduino im RC-Modellbau_NEU2.indd 96
20.03.2013 16:42:16
7.5
RC-Ruderer
97
#endif
dbgOut("ESC:");
dbgOut(esc_value_1);
dbgOut(",");
dbgOutLn(esc_value_2);
dbgOutt bzw. dbgOutLn
n sind 2 Funktionen aus der Bibliothek debug.h. Beide sind als reine
Makros definiert. Ist die Compiler-Variable debugg definiert, werden die beiden Funktionen
Serial.print()/Serial.println() benutzt. Ist debugg nicht definiert, wird nichts definiert, d. h.,
die Funktion wird durch nichts ersetzt.
Somit kann man schnell beim Testlauf Werte auf die Schnittstelle ausgeben und sehen, ob
die Werte genau dem entsprechen, was man sich erhofft hat. Braucht man die Ausgabe nicht
mehr, muss man nur den #define debugg auskommentieren, das Programm neu kompilieren
und in den Arduino laden.
7.5 RC-Ruderer
Ruder- und Paddelboote sieht man selten als RC-Modelle. Das Problem ist, neben der doch
recht anspruchsvollen Mechanik, die komplexe Steuerung. Für einen Ruderer, der zwei
Ruder bewegt, braucht man pro Ruder zwei Servos. Ein Servo bewegt das Ruder auf und ab
und ein weiterer Servo steuert die Vorwärts-/Rückwärtsbewegung. Das kann man mechanisch lösen.
Wir müssen mit den Rudern sowohl die Geschwindigkeit als auch das Kurvenfahren ermöglichen. Beim Rudern werden elliptische Bewegungen gemacht.
Abb. 7.4: Ruderbewegung
65168-4 Arduino im RC-Modellbau_NEU2.indd 97
20.03.2013 16:42:16
98
7 Projekte im Schiffsmodellbau
Die Vorwärtsgeschwindigkeit können wir durch die Geschwindigkeit der Ruderbewegung
(Pull) bestimmen, also durch die Rundenzeit. Die Richtungssteuerung könnte man durch
unterschiedliche Rundenzeiten des linken und des rechten Ruders umsetzen. Das sieht aber
auf dem Wasser nicht wirklichkeitsgetreu aus, denn schon nach kurzer Zeit laufen die beiden Ruder nicht mehr gleichmäßig. Aber auch hier hilft es, sich einfach das Original anzusehen. Kleine Richtungsänderungen erfolgen durch unterschiedliches Eintauchen und
dadurch durch unterschiedliche Längen in der Ruderbewegung. Es geht sogar so weit, dass
wir nur noch ein Ruder verwenden. Genau dieses Verhalten ist in der Software abgebildet.
Diesen Teil der Software kann man seinem Bedarf anpassen. Die Software ermöglicht z. B.
nicht, rückwärts zu rudern. Auch ein Drehen beherrscht sie (noch) nicht.
Zunächst folgt die unumgängliche Definition der Empfängereingänge. Pin 2 ist für die
Fahrt, Pin 3 ist für die Steuerung. Dann definieren wir ein paar Konstanten für die Ruderanlenkung selbst. Zunächst definieren wir die Werte für »Ruder hoch« und »Ruder runter«
und zusätzlich noch eine kleine Wartezeit, damit die Servos auch ein wenig Zeit zum Stellen
haben.
const byte RUDER_UP = 90;
const byte RUDER_DOWN = 1;
const int RUDER_DELAY = 100;
Das Gleiche erfolgt jetzt für die eigentliche Ruderbewegung.
const byte PULL_MIN = 1;
const byte PULL_MAX = 180;
Nun brauchen wir noch die maximale und die minimale Rundenzeit sowie eine Schranke
zur Erkennung des Nullpunkts.
const int ROUND_MIN = 5000;
const int ROUND_MAX = 1500;
const byte JITTER_NP = 3;
Hier definieren wir die verschiedenen Ausgänge der Servos.
const
const
const
const
byte
byte
byte
byte
LEFTPULL = 5;
LEFTLIFT = 6;
RIGHTPULL = 9;
RIGHTLIFT = 10;
Die setup()-Funktion ist einfach gehalten. Die Debug-Bibliothek wird initialisiert, Ein-/Ausgänge werden definiert (LED; Servos, Empfänger) und Fail-safe gesetzt. Da hier 4 Servos betrieben werden, kann man für den Fail-safe eine eigene Funktion Namens »nop()« erstellen.
Der Empfänger wird per Interrupt abgefragt.
65168-4 Arduino im RC-Modellbau_NEU2.indd 98
20.03.2013 16:42:16
7.5
RC-Ruderer
99
Auch in der loop()-Funktion findet sich nicht viel Neues. Einzig die Board-LED blinkt bei
Empfangsproblemen oder wenn der Arduino versucht, den Nullpunkt des Empfängers zu
bestimmen.
Die Ruderbewegung wird in zwei Teile aufgeteilt. Diese werden über die Variable statee vom
Typ STATE (PULL, LIFT) repräsentiert. Anders als bei den anderen Programmen holen wir
in diesem Programm die Empfängerwerte nicht bei jedem doWork()-Durchlauf. Vielmehr
wird der Empfänger nur an 2 Punkten (Punkt 2 und 4 im Bild) ausgewertet, nämlich an den
jeweiligen Umschaltpunkten. Dazu dient die Funktion readRc(). Neben dem reinen Abfragen des Empfängers erfolgen auch direkt die Vorberechnungen für die Rundenzeit und die
Steuereinflüsse.
rcValue = escReceiver.getValue();
// Rundenzeiten berechnen
roundTime = map(rcValue, escReceiver.getNP(), 255, ROUND_MIN, ROUND_MAX);
halfTime = roundTime / 2;
// Ausschlagkorrektur zum Lenken
rudValue = rudReceiver.getValue();
if (rudValue > 128) { maxPullLeft = map(rudValue, 128,255, PULL_MAX, PULL_
MIN);
} else {
maxPullRight = map(rudValue, 128, 0, PULL_MAX, PULL_MIN);
maxPullLeft = PULL_MAX;
}
Zurück zur doWork(). Verarbeitet wird natürlich nur, wenn wir auch vorwärts fahren wollen.
if (rcValue > (escReceiver.getNP()+JITTER_NP)) {
Dann holen wir uns die aktuelle Zeit und berechnen daraus die aktuelle Rundenzeit. Je
nachdem, ob wir < ½ definierte Rundenzeit sind oder nicht, befinden wir uns entweder im
PULL- oder im BACK-Status.
if (time <= halfTime) {
state = PULL;
Im nächsten Schritt überprüfen wir, ob die Ruder hoch- oder heruntergefahren werden
müssen.
if (srvLeftLift.read() != RUDER_DOWN) {
srvLeftLift.write(RUDER_DOWN);
}
if (srvRightLift.read() != RUDER_DOWN) {
srvRightLift.write(RUDER_DOWN);
delay(RUDER_DELAY);
}
65168-4 Arduino im RC-Modellbau_NEU2.indd 99
20.03.2013 16:42:16
100
7 Projekte im Schiffsmodellbau
(Ebenso beim Back-Status)
Dann berechnen wir die aktuelle Position der beiden Pull-Servos.
int posLeft = map(time, 0, halfTime, PULL_MIN, maxPullLeft);
srvLeftPull.write(posLeft);
svPosLeft = posLeft;
int posRight = map(time, 0, halfTime, PULL_MIN, maxPullRight);
srvRightPull.write(posRight);
svPosRight = posRight;
(Ebenso beim Back-Status)
Am Ende einer ganzen Runde holen wir dann die neuen RC-Werte.
if (time > roundTime) {
readRc();
lastStart = millis();
}
Nun sind wir wieder am Anfang.
65168-4 Arduino im RC-Modellbau_NEU2.indd 100
20.03.2013 16:42:16
119
10 Internetseiten mit
weiterführenden Informationen
www.rcarduino.tk
Die Internetseite des Autors behandelt das Thema Arduino im Modellbau. Dort finden Sie
die aktuelle Software zu diesem Know-how-Paket sowie weiterführende Kapitel.
www.arduino.cc/
Zentrale Seite für das Arduino Projekt
www.elo-web.de/
ELO-Web
www.franzis.de/
Franzis Verlag
http://code.google.com/p/rogue-code/wiki/SoftPWMLibraryDocumentation
SoftPWM-Bibliothek
fritzing.org/
Designprogramm von Fritzing zur Dokumentation von Schaltungen
arduino.cc/en/Tutorial/PWM
Tutorial zum Thema Arduino und PWM
65168-4 Arduino im RC-Modellbau_NEU2.indd 119
20.03.2013 16:42:22
Document
Kategorie
Technik
Seitenansichten
19
Dateigröße
3 435 KB
Tags
1/--Seiten
melden