In diesem Kapitel geht es darum, erste Erfahrungen mit dem ftDuino und der Arduino-IDE zu sammeln. Voraussetzung ist, dass der ftDuino von einem passenden Treiber auf dem PC unterstützt wird und dass die Arduino-IDE wie in Kapitel 2 beschrieben installiert und für die Verwendung des ftDuinos vorbereitet wurde.
Zusätzlich zum ftDuino wird ein handelsübliches Mini-USB-Kabel benötigt, wie es z.B. auch mit den fischertechnik TX und TXT verwendet wird.
Für die ersten Versuche benötigt der ftDuino keine separate Stromversorgung. Es genügt, wenn er per USB vom PC versorgt wird. Die fischertechnik-Ein- und Ausgänge bleiben zunächst unbenutzt.
Als erstes kann man den folgenden Sketch direkt in der Arduino-IDE
eingeben. Das Beispiel muss aber nicht zwingend manuell eingetippt
werden, denn es findet sich als fertig mitgeliefertes Beispiel im
Datei-Menü der Arduino-IDE unter Datei ► Beispiele ► FtduinoSimple ► Blink.
Alle vorinstallierten Beispiele können mit einem Klick geladen werden und es öffnet sich ein neues Fenster mit dem ausgewählten Beispiel.
1 /*
2 Blink
3
4 Schaltet die interne rote LED des ftDuino für eine Sekunde ein
5 und für eine Sekunde aus und wiederholt dies endlos.
6
7 Original:
8 http://www.arduino.cc/en/Tutorial/Blink
9 */
10
11 // die setup-Funktion wird einmal beim Start aufgerufen
12 void setup() {
13 // Konfiguriere den Pin, an den die interne LED angeschlossen ist, als Ausgang
14 pinMode(LED_BUILTIN, OUTPUT);
15 }
16
17 // die loop-Funktion wird immer wieder aufgerufen
18 void loop() {
19 digitalWrite(LED_BUILTIN, HIGH); // schalte die LED ein (HIGH ist der hohe Spannungspegel)
20 delay(1000); // warte 1000 Millisekunden (eine Sekunde)
21 digitalWrite(LED_BUILTIN, LOW); // schalte die LED aus, indem die Spannung auf
22 // niedrigen Pegel (LOW) geschaltet wird
23 delay(1000); // warte eine Sekunde
24 }
Der Blink-Sketch sollte nun geöffnet sein. Der ftDuino sollte an
den PC angeschlossen sein und im Menü unter
Werkzeuge ► Board der ftDuino ausgewählt sowie
der richtige COM:-Port unter
Werkzeuge ► Port ausgewählt sein.
Dies zeigt die Arduino-IDE auch ganz unten rechts in der Statusleiste
an.
Der Download des Sketches auf den ftDuino erfordert nur noch einen
Klick auf die Download-Pfeil-Schaltfläche in der Arduino-IDE oben
links.
Der Sketch wird von der IDE zunächst in Maschinencode übersetzt. Wenn die Übersetzung erfolgreich war wird der Maschinencode über die USB-Verbindung auf den ftDuino übertragen und dort im Flash-Speicher abgelegt.
Während des Downloads zeigt die interne rote Leuchtdiode des ftDuino wie in Abschnitt 1.2.4 beschrieben an, dass der Bootloader aktiviert wird und dass der Download stattfindet.
Nach erfolgreichem Download startet der Sketch sofort und die interne
rote Leuchtdiode blinkt langsam.
Der Sketch-Code besteht zum überwiegenden Teil aus erklärenden Kommentaren, die für die Funktion des Sketches völlig unbedeutend sind und lediglich dem Verständnis durch einen menschlichen Leser dienen. Kommentarzeilen beginnen mit einem doppelten Schrägstrich (//). Mehrzeilige Kommentare werden durch /* und */ eingeschlossen. In diesem Dokument sowie in der Arduino-IDE sind Kommentare an ihrer hellgrauen Färbung leicht zu erkennen. Tatsächlicher Code befindet sich lediglich in den Zeilen 12 bis 15 sowie den Zeilen 18 bis 24.
Jeder Arduino-Sketch enthält mindestens die beiden Funktionen setup() (englisch für Einrichtung) und loop() (englisch für Schleife). Zwischen den beiden geschweiften Klammern ({ und }) befinden sich jeweils durch Semikolon abgetrennt die eigentlichen durch den ftDuino auszuführenden Befehle. Die Befehle in der Funktion setup() werden einmal bei Sketch-Start ausgeführt. Sie werden üblicherweise verwendet, um initiale Einstellungen vorzunehmen oder Ein- und Ausgänge zu parametrieren. Die Befehle der loop()-Funktion werden hingegen immer wieder ausgeführt solange der ftDuino eingeschaltet bleibt oder bis er neu programmiert wird. Hier findet die eigentliche Sketch-Funktion statt und hier wird auf Sensoren reagiert und Aktoren werden angesteuert.
Auch das Blink-Beispiel arbeitet so. In der setup()-Funktion wird in Zeile 14 der mit der roten Leuchtdiode verbundene interne Anschluss im ftDuino zum Ausgang erklärt.
In der loop()-Funktion wird dann in Zeile 19 der interne Anschluss der roten Leuchtdiode eingeschaltet (Spannungspegel hoch, HIGH) und in Zeile 21 wird er ausgeschaltet (Spannungspegel niedrig, LOW). Zwischendurch wird jeweils in den Zeilen 20 und 23 1000 Millisekunden bzw. eine Sekunde gewartet. Die Leuchtdiode wird also eingeschaltet, es wird eine Sekunde gewartet, sie wird ausgeschaltet und es wird eine weitere Sekunde gewartet. Dies passiert immer und immer wieder, so dass die Leuchtdiode mit einer Frequenz von 0,5 Hertz blinkt.
Für den Einstieg ist es oft sinnvoll, mit einem vorgefertigten Sketch
zu starten und dann eigene Änderungen vorzunehmen. Die Beispiele der
Arduino-IDE stehen aber allen Benutzern eines PCs zur Verfügung und
können daher zunächst nicht verändert werden. Nimmt man an einem
Beispiel-Sketch Änderungen vor und versucht sie zu speichern, dann
weist einen die Arduino-IDE darauf hin, dass man eine eigene Kopie
anlegen soll. Dazu öffnet die Arduino-IDE einen Dateidialog und man
hat die Möglichkeit, den Sketch vor dem Speichern umzubenennen z.B. in
SchnellBlink.
Sobald man auf diese Weise eine eigene Kopie angelegt hat kann man sie
beliebig verändern. Die eigene Kopie wird im Menü der Arduino-IDE
unter Datei ► Sketchbook eingefügt und kann von dort
später jederzeit wieder geladen werden.
Im Sketch kann man nun beispielsweise aus den 1000 Millisekunden in den Zeilen 20 und 23 jeweils 500 Millisekunden machen.
18 void loop() {
19 digitalWrite(LED_BUILTIN, HIGH); // schalte die LED ein (HIGH ist der hohe Spannungspegel)
20 delay(500); // warte 500 Millisekunden (eine halbe Sekunde)
21 digitalWrite(LED_BUILTIN, LOW); // schalte die LED aus, indem die Spannung auf
22 // niedrigen Pegel (LOW) geschaltet wird
23 delay(500); // warte eine halbe Sekunde
24 }
Um die interne Leuchtdiode des ftDuino blinken zu lassen hätten wir keinen ftDuino benötigt. Alle Arduinos verfügen über eine solche interne Leuchtdiode und hätten für unser erstes Beispiel verwendet werden können.
Seine speziellen Fähigkeiten spielt der ftDuino aus, wenn es darum geht mit den üblichen fischertechnik-Sensoren und -Aktoren umzugehen. Der Blink-Sketch soll daher so erweitert werden, dass zusätzlich zu Leuchtdiode eine am Ausgang O1 angeschlossene Lampe blinkt.
Angeschlossen wird dazu eine normale fischertechnik-Lampe mit einem
Stecker an den Ausgang O1 des ftDuino und mit dem zweiten Stecker
an einen der Masseanschlüsse des ftDuino. Masseanschlüsse sind die 12
Anschlüsse, die in der Abbildung 3.8 mit einem Massesymbol
⏊ verbunden sind.
Da nun die mit 9 Volt betriebenen fischertechnik-Ausgänge verwendet werden muss der ftDuino zusätzlich mit 9 Volt versorgt werden. Das kann z.B. über ein übliches fischertechnik-Netzteil erfolgen oder über einen Batteriehalter. Beide Anschlüsse sind verpolungsgeschützt, speziell beim Anschluss der Batterie kann man also keinen Schaden anrichten.
Der folgende Beispiel-Sketch BlinkO1 findet sich auch im Datei-Menü der Arduino-IDE unter Datei ► Beispiele ► FtduinoSimple ► BlinkO1.
1 // BlinkO1.ino
2 //
3 // Blinken einer Lamoe an Ausgang O1
4 //
5 // (c) 2018 by Till Harbaum <till@harbaum.org>
6
7 #include <FtduinoSimple.h>
8
9 void setup() {
10 // LED initialisieren
11 pinMode(LED_BUILTIN, OUTPUT);
12 }
13
14 void loop() {
15 // schalte die interne LED und den Ausgang O1 ein (HIGH bzw. HI)
16 digitalWrite(LED_BUILTIN, HIGH);
17 ftduino.output_set(Ftduino::O1, Ftduino::HI);
18
19 delay(1000); // warte 1000 Millisekunden (eine Sekunde)
20
21 // schalte die interne LED und den Ausgang O1 aus (LOW bzw. LO)
22 digitalWrite(LED_BUILTIN, LOW);
23 ftduino.output_set(Ftduino::O1, Ftduino::LO);
24
25 delay(1000); // warte eine Sekunde
26 }
Der Sketch unterscheidet sich nur in wenigen Details vom ursprünglichen Blink-Sketch. Neu hinzugekommen sind die Zeilen 7, 17 und 23. In Zeile 7 wird eine Bibliothek eingebunden, die speziell für den ftDuino mitgeliefert wird und den Zugriff auf die Ein- und Ausgänge des ftDuino vereinfacht. In den Zeilen 17 und 23 wird der Ausgang O1 eingeschaltet (HI) bzw. ausgeschaltet (LO). Weitere Details zu dieser Bibliothek finden sich in Kapitel 9.
Die Kommandos zum Ein- und Ausschalten der internen Leuchtdiode sind nach wie vor vorhanden, so dass die interne Leuchtdiode nun parallel zur extern angeschlossenen Lampe blinkt.
Weitere einfache Beispiele und Erklärungen zur Benutzung der Ein- und Ausgänge in eigenen Sketches finden sich in Abschnitt 9.1.1.
Zum Anschluss an übliche fischertechnik-Taster, -Fototransistoren und
ähnlich verfügt der ftDuino über die acht Eingänge I1 bis
I8 und die Zählereingänge C1 bis C4.
Der Zugriff auf diese Eingänge erfolgt über passende Bibliotheken wie in Abschnitt 9 dargestellt. Über die FtduinoSimple-Bibliothek kann der Schaltzustand eines Tasters abgefragt werden:
1 #include <FtduinoSimple.h>
2
3 void setup() {
4 // keine Initialisierung noetig
5 }
6
7 void loop() {
8 // lies den Zustand einer Taste an Eingang I1
9 if(ftduino.input_get(Ftduino::I1)) {
10 /* ... tue etwas ... */
11 }
12 }
1 #include <Ftduino.h>
2
3 void setup() {
4 // Initialisierung der Ftduino-Bibliothek
5 ftduino.init();
6
7 // Eingang I1 zur Widerstandsmessung vorbereiten
8 ftduino.input_set_mode(Ftduino::I1, Ftduino::RESISTANCE);
9 }
10
11 void loop() {
12 // Auswertung des Widerstands an Eingang I1
13 uint16_t widerstand = ftduino.input_get(Ftduino::I1);
14 /* ... tue etwas ... */
15 }
Der ftDuino ist primär dafür gedacht, ein Modell autonom zu steuern und während des Betriebs nicht auf die Hilfe eines PC angewiesen zu sein. Trotzdem gibt es Gründe, warum auch im laufenden Betrieb ein Datenaustausch mit einem PC erwünscht sein kann.
Vor allem während der Sketch-Entwicklung und bei der Fehlersuche hilft es oft sehr, wenn man sich z.B. bestimmte Werte am PC anzeigen lassen kann oder wenn man Fehlermeldungen im Klartext an den PC senden kann. Aber auch die Ausgabe z.B. von Messwerten an den PC zur weiteren Auswertung oder Speicherung ist oft hilfreich.
Ein Sketch kann dazu den COM:-Port zwischen ftDuino und PC für den Datenaustausch nutzen. Der ftDuino-Beispiel-Sketch ComPort zum Beispiel verwendet den COM:-Port, um ein paar einfache Textausgaben am PC zu erzeugen. Das ComPort-Beispiel findet sich im Datei-Menü der Arduino-IDE unter Datei ► Beispiele ► FtduinoSimple ► USB ► ComPort. Auch der ComPort-Sketch verwendet keinen der Ausgänge und benötigt daher neben der USB-Verbindung keinerlei weitere Spannungsversorgung.
1 /*
2 ComPort - Kommunikation mit dem PC über den COM:-Port
3
4 */
5
6 int zaehler = 0;
7
8 void setup() {
9 // Port initialisieren und auf USB-Verbindung warten
10 Serial.begin(9600);
11 while(!Serial); // warte auf USB-Verbindung
12
13 Serial.println("ftDuino COM:-Port test");
14 }
15
16 void loop() {
17 Serial.print("Zähler: "); // gib "Zähler:" aus
18 Serial.println(zaehler, DEC); // gib zaehler als Dezimalzahl aus
19
20 zaehler = zaehler+1; // zaehler um eins hochzählen
21
22 delay(1000); // warte 1 Sekunde (1000 Millisekunden)
23 }
Man kann ein beliebiges sogenanntes Terminalprogramm auf dem PC
nutzen, um Textausgaben des ftDuino via COM:-Port zu
empfangen. Die Arduino-IDE bringt praktischerweise selbst ein solches
Terminal mit. Es findet sich im Menü unter
Werkzeuge ► Serieller Monitor.
Man muss den COM:-Port nicht separat einstellen, sondern es wird der COM:-Port übernommen, der bereits für den Sketch-Download eingestellt wurde.
Nach der Auswahl im Menü öffnet der serielle Monitor ein eigenes
zusätzliches Fenster auf dem PC. Wurde der ComPort-Sketch
bereits auf den ftDuino geladen, dann erscheinen sofort
entsprechende Ausgaben, sobald der serielle Monitor geöffnet wurde.
Der serielle Monitor hat am unteren Fensterrand eine recht
unscheinbare Option, das Zeilenende zu markieren. Für einfache
Textausgaben vom ftDuino zum PC ist diese Option bedeutungslos. Aber
sobald Eingaben vom PC erwartet werden wie zum Beispiel im Modell des
Hochregallagers in Abschnitt 7.1 kommt dieser Option
eine Bedeutung zu. Die Option muss auf Neue Zeile oder
Zeilenumbruch (CR) stehen, damit die Befehlseingabe klappt.
Die Nutzung des COM:-Ports wird automatisch zwischen Sketch-Download und seriellem Monitor geteilt. Man kann also jederzeit bei geöffnetem seriellen Monitor den Sketch-Editor in den Vordergrund holen und einen Download starten. Der seriellem Monitor wird dann automatisch für die Zeit des Downloads deaktiviert.
Eine Besonderheit des USB-COM:-Ports die der ftDuino vom Arduino Leonardo erbt ist, dass die sogenannte Bitrate (oft auch Baudrate genannt) keine Bedeutung hat. Im ComPort-Beispiel wird in Zeile 10 eine Bitrate von 9600 Bit pro Sekunde eingestellt, in Abbildung 3.11 ist aber unten rechts eine Bitrate von 115200 Bit pro Sekunde eingestellt. Die USB-Verbindung ignoriert diese Einstellungen und kommuniziert trotzdem fehlerfrei. Einige andere Mitglieder der Arduino-Familie wie der Arduino-Uno benötigen hier aber übereinstimmende Einstellungen.
Der Sketch besteht aus wenig mehr als den eigentlich Aufrufen zur Bedienung des COM:-Ports. Da der COM:-Port auch oft ``serieller Port'', englisch ``Serial'' genannt wird fangen die entsprechenden Funktionsaufrufe alle mit Serial. an.
In Zeile 10 der sofort bei Sketchstart aufgerufenen setup()-Funktion wird zunächst der COM:-Port für die Kommunikation geöffnet. In Zeile 11 dann wird gewartet, bis der COM:-Port auf PC-Seite verfügbar ist und die erste Kommunikation stattfinden kann. In Zeile 13 wird danach eine erste Startmeldung an den PC geschickt.
Innerhalb der wiederholt durchlaufenen loop()-Funktion wird dann in den Zeilen 17 und 18 zunächst der Text ``Zähler: `` ausgegeben, gefolgt von dem Inhalt der Variablen zaehler in Dezimaldarstellung. Die println()-Funktion führt nach der Ausgabe einen Zeilenvorschub aus. Die folgende Ausgabe erfolgt daher am Beginn der nächsten Bildschirmzeile.
Schließlich wird in Zeile 20 die zaehler-Variable um eins erhöht und eine Sekunde (1000 Millisekunden) gewartet.
Bei Geräten wie dem Arduino Uno, die einen separaten USB-Kommunikationsbaustein für die USB-Kommunikation nutzen, besteht die USB-Verbindung durchgängig, sobald das Gerät mit dem PC verbunden ist. Beim ftDuino sowie beim Arduino Leonardo übernimmt der Mikrocontroller wichtige Aspekte der USB-Kommunikation selbst. Das bedeutet, dass die logische USB-Verbindung jedes Mal getrennt und neu aufgebaut wird, wenn ein neuer Sketch auf den Mikrocontroller übertragen wird.
Beginnt der ftDuino direkt nach dem Download mit der Textausgabe auf dem COM:-Port, so gehen die ersten Nachrichten verloren, da die USB-Verbindung noch nicht wieder aufgebaut ist. Daher wartet der Sketch in Zeile 11 darauf, dass die Kommunikationsverbindung zwischen ftDuino und PC wieder besteht, bevor die ersten Ausgaben erfolgen.
Man kann testweise diese Zeile einmal löschen oder auskommentieren (Programmcode, der per // in einen Kommentar verwandelt wurde, wird nicht ausgeführt).
8 void setup() {
9 // Port initialisieren und auf USB-Verbindung warten
10 Serial.begin(9600);
11 // while(!Serial); // warte auf USB-Verbindung
12
13 Serial.println("ftDuino COM:-Port test");
14 }