Arduino im RC-Modellbau - Leseprobe - files.elv.com · PDF file5 Vorwort Den Arduino kennen mittlerweile viele. Darüber geschrieben wurde auch bereits eine Men - ge. Es gibt unzählige

Das Franzis Know-how-Paket

Arduino™ im RC-ModellbauArduino™-Anwendungen für RC-Modelle

65168-4_Titelei_A5 27.03.13 13:13 Seite 3

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 Me-

dien. 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 be-

trachtet werden. Der Verlag folgt bei den Produktbezeichnungen im Wesentlichen den Schreibweisen der Hersteller.

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 entwik-

kelt, 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 Be-

stimmungen. 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 Vertrags-

pflichten. Der Schadensersatzanspruch für die Verletzung wesentlicher Vertragspflichten ist auf den vertragstypi-

schen, vorhersehbaren Schaden begrenzt, soweit nicht ein Fall der zwingenden Haftung nach dem Produkthaf-

tungsgesetz 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.

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.

Franzis

65168-4_Titelei_A5 27.03.13 13:13 Seite 4

5

Vorwort

Den Arduino kennen mittlerweile viele. Darüber geschrieben wurde auch bereits eine Men-ge. Es gibt unzählige Anleitungen, Beispiele, Schaltungen usw. Was bisher aber fehlte, wareine 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 Modellbaueinsetzen lässt und welche enormen Möglichkeiten man mit ihm hat. Programmierkennt-nisse sind zwar von Vorteil, aber nicht zwingend erforderlich.

Natürlich kann man in einem solchen Buch nicht alle Bereiche beleuchten, aber es wird einkleiner Rundblick gegeben.

Im Paket befi ndet sich neben dem Arduino Uno eine spezielle Treiberplatine für die Licht-steuerung eines RC-Autos. Im Internet fi nden Sie die aktuelle Version der Arduino-IDE undauch 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 565168-4 Arduino im RC-Modellbau_NEU2.indd 5 20.03.2013 16:41:3420.03.2013 16:41:34

7

Inhalt

1 Die Software ...................................................................................................9

1.1 Arduino-Installation ..............................................................................91.2 Projektinstallation .................................................................................91.3 Sketchverzeichnis einstellen ...............................................................101.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 ..............................................................................................174.2 Funktionen ..........................................................................................274.3 Bibliotheken – Librarys .......................................................................404.4 RC Receive ..........................................................................................434.5 SoftPWM .............................................................................................47

5 Elektronik ................................................................................................... 49

5.1 Berechnung der LED-Vorwiderstände ...................................................495.2 Schaltstufen........................................................................................51

6 Allgemeine Projekte .................................................................................... 55

6.1 Blinken, Flackern und Co. ....................................................................556.2 Akku-Tiefenentladeschutz ...................................................................656.3 Servotester .........................................................................................r 686.4 Fail-safe für zwei Kanäle ......................................................................696.5 2-Kanal-Schalter..................................................................................r 736.6 Servoverzögerung und -verlangsamung...............................................g 756.7 Servowegbegrenzung, Servorevers ......................................................786.8 Kreuzmischer, V-Mischer .....................................................................r 796.9 5-/6-Kanal-Schalter .............................................................................r 84


8 Inhaltsverzeichnis

7 Projekte im Schiffsmodellbau ...................................................................... 87

7.1 Lichttonne mit Rundumlicht ................................................................877.2 Sonderfunktionen Feuerwehrschiff......................................................f 897.3 Jet-Antrieb mit 2 Kanälen .....................................................................917.4 Schraubenantrieb mit Steuerunterstützung .........................................g 937.5 RC-Ruderer ..........................................................................................r 97

8 Projekte im Automodellbau ....................................................................... 101

8.1 K.I.T.T. ...............................................................................................1018.2 Einfache Startampel ..........................................................................1038.3 Steuerung eines Kettenfahrzeugs ......................................................1058.4 Lichtsteuerung eines Modellautos .....................................................1068.5 Dynamische Servowegbegrenzung ....................................................g 111

9 Projekte im Flugmodellbau ........................................................................ 113

9.1 Flugblitzer, ACL und Strobe inkl. Landescheinwerfer ..........................r 1139.2 Fahrwerk, Flaps (Servoverlangsamung)..............................................115

10 Internetseiten mit weiterführenden Informationen ..................................... 119


87

7 Projekte im Schiffsmodellbau

• PWM Lib

Know-how:

7.1 Lichttonne mit Rundumlicht

Wir beginnen mit einem Pro jekt ohne Empfänger. Deswegen ist es aber nicht weniger inter-essant. Wir bauen ein drehendes Rundumlicht – aber nicht mit Spiegel und Motor, sondernmit mehreren LEDs. Wir können es als Blaulicht oder auch als gelbes Rundumlicht verwen-den. Im Beispiel dient es als »Leuchtmittel« für einen Leuchtturm. Dazu nehmen wir 12weiße Leuchtdioden und verbinden diese mit den entsprechenden Vorwiderständen mit denAusgä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 MMkann jeden Ausgang als PWM-Ausgang verwenden. Somit ist man nicht mehr auf die vor-handenen 6 Ausgänge beschränkt. Das Ganze kostet aber Rechenzeit, da die Ausgänge perInterrupt gesteuert werden.


7 Projekte im Schiffsmodellbau88

Abb. 7.1: Leucht-turm schematisch

In der setup()-Funktion defi nieren 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 SoftPWM-Bibliothek mit SoftPWMBegin(). Jetzt defi nieren wir alle Pins und setzen den Wert auf 0(SoftPWMSet(i, 0)). Zuletzt wird die Fading-Zeit der Bibliothek gesetzt. Damit kann manein automatisches Fading erzeugen.

SoftPWMSetFadeTime(ALL, 100, 100)

Die loop()-Funktion ist jetzt einfach. Zunächst wird der Schalter abgefragt. Ist der Schaltergeschlossen (also gegen Masse geschaltet), werden alle Ausgänge auf 0 geschaltet. Ist derSchalter offen, wird zunächst der Inhalt des Steuerungs-Arrays (leuchtfolge[]) auf die Aus-gänge gebracht. Dann wird der Inhalt des Arrays einfach einen Index weiter geschoben. DasEnde, das herausgeschoben wird, wird dann an den Anfang gestellt. So etwas nennt man ei-nen Ringpuffer. Zuletzt wird eine Verzögerung eingebaut. Diese steuert die »Drehgeschwin-digkeit«. Fertig ist unsere »Leuchtturm-Beleuchtung«. Durch die verschiedenen Werte imArray wird ein »Nachlauf« simuliert.


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 dieDrehgeschwindigkeit einstellen können.

7.2 Sonderfunktionen Feuerwehrschiff

• Kombinieren von Programmen

• Treiberstufen

Know-how:

Selbst für ein kleines Modell-Feuerwehrschiff br aucht man ein paar Sonderfunktionen.Was natürlich immer mit dabei sein muss, sind ein Blaulicht und die Wasserkanone, beidesmöglichst drehbar. Für die Pumpe brauchen wir einen Schaltkanal, für das Blinklicht natür-lich auch. Beide sollten unabhängig voneinander schaltbar sein – und das möglichst ohne1.000 € in eine Fernsteuerung mit Multinaut-Baustein zu investieren.

Das nachfolgend beschriebene kleine Programm erledigt die beiden Aufgaben auf sehr ein-fache Art, und das mit nur einem zurückstellenden Proportionalkanal. In die eine Richtungwird das Blinklicht ein- und beim nächsten Mal wieder ausgeschaltet, in der anderen Rich-tung wird die Pumpe betrieben. Die Pumpe läuft aber nur, solange man den Hebel in dieentsprechende Richtung hält.

Ähnliches haben wir bereits beim 2-Kanal-Schalter gemacht. Wir verwenden den Sketchweiter und setzen die entsprechenden Konstanten fest ins Programm. Da der Controllermaximal 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 vorge-sehen. Somit können wir auch mehr als 2 LEDs anschließen, ohne den Arduino damit zubelasten. Die Stufe kann bis zu 100mA schalten. Das Relais ist ein 6-V-Typ.



Abb. 7.2: RelaisSwitch

Das Programm basiert mit einigen vordefi nierten Einstellungen auf dem Programm zum2-Kanal-Schalter. Kanal 1 ist als Kanal für das Blinklicht konfi guriert und arbeitet im Im-pulsbetrieb. D. h., dass das Blinklicht bei einem Impuls mit dem Hebel des Kanals an- undbeim nächsten Impuls wieder ausgeht. Kanal 2 ist für die Pumpe und arbeitet im Dauerbe-trieb. 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ürdie Pumpe. Das Programm selbst ist sehr verkürzt. Damit passt das Ganze aber auch ineinen kleineren Controller (z. B. ATTiny44). Auch diesen kann man mit der Arduino-Ent-wicklungsumgebung programmieren. Dazu benötigt man nur einen Programmieradapterund die entsprechende Bibliothek für die Arduino-IDE. Das Thema würde aber den Rah-men dieses Buchs sprengen. Eine Einführung zu dem Thema fi ndet man im Internet unterhttp://RCArduino.tk.


7.3 Jet-Antrieb mit 2 Kanälen 91

7.3 Jet-Antrieb mit 2 Kanälen

• EEPROM lesen

• EEPROM schreiben

Know-how:

Ein Jet-Antrieb braucht eigentlich drei Kanäle: einen für das Steuer, einen für den ESC undeinen für die Rückfahrklappe. Hat man eine 3-Kanal-Fernsteuerung, ist das alles kein Prob-lem. Aber ein schnelles Boot mit Jet-Antrieb fährt sich sehr gut mit einer Pistolenfernsteue-rung aus dem Autobereich, und diese haben meist nur zwei Kanäle. Bei einer dreikanaligenVersion 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 sowohlvorwä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 erfolgtfolgendermaßen: Bei Vorwärtsfahrt wird das Motorsignal ohne Änderung direkt an denRegler geschickt. Der Klappenservo bleibt in der gespeicherten Position Up stehen. Wirdpnun auf Rückwärtsfahrt gestellt, werden die Reglersignale (ESC) so modifi ziert, dass wiederSignale für Vorwärtsfahrt generiert werden. Aber der Klappenservo wird in die andere Po-sition (down) gefahren. Außerdem kann man, wenn gewünscht, den Fahrtregler bei Rück-wärtsfahrt auf halbe Leistung programmieren.

Der Empfänger wird von Pin 2 gelesen, die Ausgänge liegen auf Pin 9 (Klappenservo) und10 (ESC). An Anschluss 5 wird ein Taster (PRG) gegen Masse angeschlossen. Der Nullpunktdes Kanals wird wie immer automatisch beim Start ermittelt.

Im Programm gibt es einen Programmiermodus, wenn der Taster PRG beim Einschaltengedrückt wird. Dann können die beiden Positionen des Klappenservos und die minimaleund maximale Ansteuerung des ESC gespeichert werden. Zunächst muss aber die obere Po-sition gespeichert werden. Dazu wird die Steuerung auf den gewünschten Wert eingestelltund PRG gedrückt. Zur Quittierung blinkt die Board-LED. Danach wird die untere Positionangefahren und genauso gespeichert, dann die maximale Stellung des ESC und danach dieMinimalposition. Der Programmiermodus wird dann automatisch verlassen. Die Werte fürdie Klappe und den ESC werden im EEPROM abgelegt und beim erneuten Start auch wie-der gelesen. Die minimale Position steht im EEPROM in Adresse 0, die maximale Positionin Adresse 1. Es ist dabei völlig egal, welchen Wert die untere bzw. obere Position tatsächlichhat. Unten defi niert nur die Servostellung für den Rückwärtsbetrieb. Es wird beim Spei-chern die vorher programmierte Position angefahren. Das Gleiche gilt auch für die anderePosition. Adresse 3 enthält den ESC-Max-Wert und 2 den ESC-Min-Wert.



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 In-terruptmodus initialisiert wurde, werden die beiden Werte für den Klappenservo aus demEEPROM gelesen. Der minimale Wert steht in Speicherzelle 0, der maximale in Speicher-zelle 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 einen180°-Servo). Das Gleiche gilt für den Bereich des Reglers. Auch hier werden der minima-le und der maximale Wert defi niert (Speicherzellen 2 und 3, Defaultwerte: 90° und 180°).Dann wird der Klappenservo mit dem Minimalwert initialisiert. Der Minimalwert ist gleich-zeitig 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 Unterrou-tine 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 maximalenWerten 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 beschriebeneProgrammiervorgang. Die Programmierung ist als Zustandsautomat implementiert. Nachjedem erfolgreich programmierten Wert blinkt die LED: 1x nach dem Up-Wert des Klap-penservos, 2x nach dem Down-Wert, 3x nach dem maximalen ESC-Wert, und 4x nach demminimalen 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, obder Nullpunkt des Empfängers bereits bestimmt worden ist. Nur wenn dieser vorliegt, gehtes weiter. Andernfalls wartet das Programm. Ist der Nullpunkt bestimmt, wird getestet, ob


7.4 Schraubenantrieb mit Steuerunterstützung 93

kein Fehler vorliegt. Liegt ein Fehler vor, werden die Fail-safe-Werte in die Servos geschrie-ben.

else { // Fehlerfall failsafe ... myServo.write(minValue); myEsc.write(minEscValue); }

Liegt kein Fehler vor, wird nun der Wert vom Empfänger ausgewertet. Wir erwarten einenWert von 0.. 255, wobei Werte < 128 Rückwärtsfahrt und > 128 Vorwärtsfahrt bedeuten. Umden Nullpunkt (128) herum wird eine kleine 3-Werte-Schranke aufgebaut. Dadurch zittertder Klappenservo nicht. Liegen wir in diesem Nullbereich, wird, wenn nötig, die Klappe indie minimale Position gefahren und der Regler abgeschaltet (minEscValue).

Ist der Wert größer als Nullpunkt + 3, geht das System in Vorwärtsfahrt. Der Regler wirdentsprechend 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 Positiongefahren. Zusätzlich wird die Konstante HALF_BACK_THROTTLE ausgewertet. Ist diese ETrue, 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

• serielle Schnittstelle

• Debuggen

Know-how:

Bei einem Schiff mit zwei oder mehr Schrauben kann man zur Unterstützung des Rudersauch die Motoren verwenden. Dazu muss der jeweils kurvenäußere Motor mehr, der kurven-



innere Motor weniger drehen. Es handelt sich hier quasi um den bereits beschriebenen V-Mischer. Wir sollten diese Ruderunterstützung jedoch nur bei höheren Geschwindigkeiteneinsetzen. Also modifi zieren wir das Programm entsprechend.

Zunächst defi nieren wir die Nullpunkte der beiden Regler. Das brauchen wir für den Fail-safe.

// Nullpunkt der beiden Reglerconst byte ESC_NP_1 = 90;const byte ESC_NP_2 = 90;

Dann defi nieren wir die Schranke, ab der der Einfl uss auf die Motoren erfolgen soll.

// Ab wann soll der Einfluss erfolgen (Bereich 0..128)const byte ESC_MIN = 64;

Wir müssen auch noch defi nieren, wie stark der Einfl uss sein soll. Diese Zahl ist der Wert,durch den der Ruderwert geteilt wird. Deswegen wird der Einfl uss bei größeren Wertenkleiner.

// Wie stark soll der Einfluss sein. // ACHTUNG: Höhere Werte ergeben weniger Effektconst 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 gehtconst int LOOP_DELAY = 10;

Im setup()-Teil entdecken wir nichts Besonderes. Hier werden die Empfängerkanäle und dieESCs defi niert. Auch die loop() ist Standard.

In der doWork() ist mehr zu tun. Zunächst lesen wir den Fahrtreglerkanal und normierenihn auf einen Bereich von max. ±128 um den ermittelten Nullpunkt. Für die beiden Fahrt-regler werden dann zwei Variablen defi niert, die später den Wert für die beiden Fahrtreglerenthalten.

Nun gilt es nachzusehen, ob der Wert für den Fahrtregler überhaupt größer als die defi nierteSchranke ESC_MIN ist. Dazu bilden wir den Absolutwert, denn auch bei RückwärtsfahrtNsoll die Ruderunterstützung greifen.

if (abs(escValue) >= ESC_MIN) {


7.4 Schraubenantrieb mit Steuerunterstützung 95

Ist der Wert größer, besorgen wir uns den aktuellen Servowert. Auch dieser wird auf ±128normiert. Nun beschränken wir den Einfl uss, indem wir den Servowert durch die Defi nitionvon 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 Compi-ler-Schalter SWITCH_RUDDER_IMPACT. Dieser Schalter vertauscht den Einfl uss auf dieESCs.

#ifdef SWITCH_RUDDER_IMPACT esc_value_1 = escValue - servoValue; esc_value_2 = escValue + servoValue;#else esc_value_1 = escValue + servoValue; esc_value_2 = escValue - servoValue;#endif

Nun werden die ESC Werte auf den ±128-Wertebereich beschränkt. Damit sind wir mit demruderspezifi schen Teil fertig. Nach dem Ganzen wird nun der virtuelle ±128-Wert auf denrealen ESC-Wert von 0..180 gemappt. Dann wird das Ganze auf die beiden ESCs ausgege-ben. 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 fi nden wir:

#define debug

Im setup()-Teil fi nden wir z. B. noch:

initDebug();dbgOutLn("Mehrschrauben");



Abb. 7.3: Serial Monitor

Damit initialisieren wir einen Debug-Modus über die serielle Schnittstelle (implementiertin 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 1beim Uno dann nicht mehr benutzbar sind, da sie für die serielle Schnittstelle verwendetwerden. In der IDE können wir nun einfach über das Menü [Tools]/[Serial Monitor] einTerminalprogramm 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 undumso weniger wird das Programm gestört). In der doWork()-Methode geben wir nun diebeiden 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)


7.5 RC-Ruderer 97

#endif

dbgOut("ESC:"); dbgOut(esc_value_1); dbgOut(","); dbgOutLn(esc_value_2);

dbgOut bzw. t dbgOutLn sind 2 Funktionen aus der Bibliothek n debug.h. Beide sind als reineMakros defi niert. Ist die Compiler-Variable debug defi niert, werden die beiden Funktionen gSerial.print()/Serial.println() benutzt. Ist debug nicht defi niert, wird nichts defi niert, d. h.,gdie Funktion wird durch nichts ersetzt.

Somit kann man schnell beim Testlauf Werte auf die Schnittstelle ausgeben und sehen, obdie Werte genau dem entsprechen, was man sich erhofft hat. Braucht man die Ausgabe nichtmehr, muss man nur den #defi ne debug auskommentieren, das Programm neu kompilierengund in den Arduino laden.

7.5 RC-Ruderer

Ruder- und Paddelboote sieht man selten als RC-Modelle. Das Problem ist, neben der dochrecht anspruchsvollen Mechanik, die komplexe Steuerung. Für einen Ruderer, der zweiRuder bewegt, braucht man pro Ruder zwei Servos. Ein Servo bewegt das Ruder auf und abund ein weiterer Servo steuert die Vorwär ts-/Rückwärtsbewegung. Das kann man mecha-nisch lösen.

Wir müssen mit den Rudern sowohl die Geschwindigkeit als auch das Kurvenfahren ermög-lichen. Beim Rudern werden elliptische Bewegungen gemacht.

Abb. 7.4: Ruderbewegung



Die Vorwärtsgeschwindigkeit können wir durch die Geschwindigkeit der Ruderbewegung(Pull) bestimmen, also durch die Rundenzeit. Die Richtungssteuerung könnte man durchunterschiedliche Rundenzeiten des linken und des rechten Ruders umsetzen. Das sieht aberauf dem Wasser nicht wirklichkeitsgetreu aus, denn schon nach kurzer Zeit laufen die bei-den Ruder nicht mehr gleichmäßig. Aber auch hier hilft es, sich einfach das Original an-zusehen. Kleine Richtungsänderungen erfolgen durch unterschiedliches Eintauchen unddadurch durch unterschiedliche Längen in der Ruderbewegung. Es geht sogar so weit, dasswir 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 Defi nition der Empfängereingänge. Pin 2 ist für dieFahrt, Pin 3 ist für die Steuerung. Dann defi nieren wir ein paar Konstanten für die Ruder-anlenkung selbst. Zunächst defi nieren 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 Stellenhaben.

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 Schrankezur Erkennung des Nullpunkts.

const int ROUND_MIN = 5000;const int ROUND_MAX = 1500;const byte JITTER_NP = 3;

Hier defi nieren wir die verschiedenen Ausgänge der Servos.

const byte LEFTPULL = 5;const byte LEFTLIFT = 6;const byte RIGHTPULL = 9;const byte RIGHTLIFT = 10;

Die setup()-Funktion ist einfach gehalten. Die Debug-Bibliothek wird initialisiert, Ein-/Aus-gänge werden defi niert (LED; Servos, Empfänger) und Fail-safe gesetzt. Da hier 4 Servos be-trieben werden, kann man für den Fail-safe eine eigene Funktion Namens »nop()« erstellen.Der Empfänger wird per Interrupt abgefragt.


7.5 RC-Ruderer 99

Auch in der loop()-Funktion fi ndet sich nicht viel Neues. Einzig die Board-LED blinkt beiEmpfangsproblemen oder wenn der Arduino versucht, den Nullpunkt des Empfängers zubestimmen.

Die Ruderbewegung wird in zwei Teile aufgeteilt. Diese werden über die Variable state vom eTyp STATE (PULL, LIFT) repräsentiert. Anders als bei den anderen Programmen holen wirin 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 denjeweiligen Umschaltpunkten. Dazu dient die Funktion readRc(). Neben dem reinen Abfra-gen des Empfängers erfolgen auch direkt die Vorberechnungen für die Rundenzeit und dieSteuereinfl üsse.

rcValue = escReceiver.getValue();// Rundenzeiten berechnenroundTime = map(rcValue, escReceiver.getNP(), 255, ROUND_MIN, ROUND_MAX);halfTime = roundTime / 2;// Ausschlagkorrektur zum LenkenrudValue = 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. Jenachdem, ob wir < ½ defi nierte Rundenzeit sind oder nicht, befi nden wir uns entweder imPULL- oder im BACK-Status.

if (time <= halfTime) { state = PULL;

Im nächsten Schritt überprüfen wir, ob die Ruder hoch- oder heruntergefahren werdenmüssen.

if (srvLeftLift.read() != RUDER_DOWN) { srvLeftLift.write(RUDER_DOWN); } if (srvRightLift.read() != RUDER_DOWN) { srvRightLift.write(RUDER_DOWN); delay(RUDER_DELAY); }



(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.


119

10 Internetseiten mit

weiterführenden Informationen

www.rcarduino.tk

Die Internetseite des Autors behandelt das Thema Arduino im Modellbau. Dort fi nden Siedie 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


Documents

Arduino im RC-Modellbau - Leseprobe - files.elv.com · PDF file5 Vorwort Den Arduino kennen mittlerweile viele. Darüber geschrieben wurde auch bereits eine Men - ge. Es gibt unzählige