ftDuino/Programmieren in C++

Aus ZUM-Unterrichten
Wechseln zu: Navigation, Suche
ISO C++ Logo.svg

Unsere ersten Versuche führten wir mit Scratch durch.

Profis programmieren aber in Programmiersprachen wie C++Wikipedia-logo.png.

In diesem Abschnitt erfahrt ihr etwas über die Syntax - die Grammatik und Rechtschreibregeln - der Programmiersprache C++.

Das ftDuino-Manual zeigt im 3. Kapitel einige Sketches (Programme) in C++. Die Einführung in die Sprache C++ findet sich aber erst im Kapitel 4, in der auch auf die Vorteile gegenüber grafischer Programmierumgebungen eingegangen wird.

Einrichten

Aufgabe
  1. Verbinde den ftDuino mit dem Computer.
  2. Öffne die Arduino IDE im Computer
  3. Überprüfe, ob der ftDuino als aktuelles Board ausgewählt ist.

Mehr Infos finden sich auf:

ftDuino/Einrichten


Blink

Der Sketch basiert auf einem Beispiel von Arduino.cc.[1]. Er ist auch in Till Harbaums Manual zu finden.[2]

Das Beispiel muss aber nicht zwingend per Hand eingetippt werden, denn es findet sich auch als fertig mitgeliefertes Beispiel im Datei-Menü der Arduino-IDE unter Datei ► Beispiele ► FtduinoSimple ► Blink.

Funktionen

Alle Arduino-Sketche (Programme) enthalten je eine setup() und eine loop()-Funktion.[3]. Nach ihr folgt ein Paar geschweifter Klammern, in deren Anweisungsblock mehrere Anweisungen notiert werden.

// die setup-Funktion wird einmal beim Start aufgerufen
void setup() {
       // ...
}

// die loop-Funktion wird immer wieder aufgerufen
void loop() {
     // ...
}


Achtung
Jede Klammer, die ihr öffnet, muss auch wieder geschlossen werden!



Funktion

Eine Funktion ist ein Konstrukt, mit dem mehrere Anweisungen zusammengefasst und nacheinander ausgeführt werden. Sie hat einen Namen, mit dem man sie mehrfach aufrufen kann. Nach dem Namen kann man in den Klammern Parameter übergeben, mit denen innerhalb der Funktion gearbeitet wird.

Die beiden setup() und eine loop()-Funktionen werden von der Arduino-IDE automatisch aufgerufen. (siehe harbaum.github.io)

Anweisungen

In diesem Sketch gibt es nun bereits einige Anweisungen:

 1 void setup() {
 2      pinMode(LED_BUILTIN, OUTPUT);
 3 }
 4 
 5 void loop() {
 6      digitalWrite(LED_BUILTIN, HIGH);   // schalte die LED ein (HIGH =5V)
 7      delay(1000);                       // warte 1000 Millisekunden (eine Sekunde)
 8 
 9      digitalWrite(LED_BUILTIN, LOW);    // schalte die LED aus, 
10                                         // (Low = kein Strom)
11      delay(1000);                       
12 }
  • pinMode(LED_BUILTIN, OUTPUT);
    Im setup() wird die eingebaute LED als Ausgang zugewiesen[4]

In der Hauptschleife loop() werden …

  • digitalWrite(LED_BUILTIN, HIGH);
    Diese Anweisung liefert 5V an den Ausgang. Die LED erhält nun Strom und leuchtet.
  • digitalWrite(LED_BUILTIN, LOW);
    Der Ausgang LED_BUILTIN wird zurück auf 0V geschaltet, die LED geht aus.
  • delay(1000);
    Damit dies auch sichtbar wird, gibt diese Anweisung dem Board den Befehl nichts zu tun und zu warten.
    Zeitangaben in der Computerwelt arbeiten immer mit Millisekunden - es wird also eine Sekunde gewartet.

Kommentare

Du kannst Deinen Sketch mit Kommentaren versehen, die nicht ausgeführt werden. Dafür verwendet man zwei slashes: //, die der Erklärung vorangestellt werden.

1 // Kommentarzeile 1
2 // Kommentarzeile 2
3 //   ...
4 
5 /*
6    Kommentarzeile 1
7    Kommentarzeile 2
8    ...
9 */

Hier gilt es einen Kompromiss zwischen guter Lesbarkeit des Codes und der Notwendigkeit, diesen auch später noch zu verstehen, zu finden.

Mit /* ... */ kann man auch Code auskommentieren, um so festzustellen, welche Programmteile funktionieren.

Ansteuerung von fischertechnik-Komponenten

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.

Der ftDuino spielt seine speziellen Fähigkeiten aus, wenn es darum geht, die fischertechnik-Sensoren und -Aktoren anzusteuern. 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 mit einem Massesymbol ⏊ verbunden sind.

Schaltplan: Blinkende fischertechnik-Lampe am ftDuino


Da nun die mit 9 Volt betriebenen fischertechnik-Ausgänge verwendet werden, muss der ftDuino zusätzlich mit 9 Volt versorgt werden (rot ≙ plus; grün ≙ minus). Die Anschlüsse sind verpolungsgeschützt, speziell beim Anschluss der Batterie kann man also keinen Schaden anrichten.

der Sketch

Der folgende Beispiel-Sketch BlinkO1 findet sich auch im Datei-Menü der Arduino-IDE unter Datei ► Beispiele ► FtduinoSimple ► BlinkO1.

 1 // BlinkO1.ino
 2 
 3 #include <FtduinoSimple.h>
 4 
 5 void setup() {
 6      pinMode(LED_BUILTIN, OUTPUT);
 7 }
 8 
 9 void loop() {
10      // schalte die interne LED und den Ausgang O1 ein (HIGH bzw. HI)
11      digitalWrite(LED_BUILTIN, HIGH);
12      ftduino.output_set(Ftduino::O1, Ftduino::HI);
13      delay(1000);                       
14 
15      // schalte die interne LED und den Ausgang O1 aus (LOW bzw. LO)
16      digitalWrite(LED_BUILTIN, LOW);
17      ftduino.output_set(Ftduino::O1, Ftduino::LO);
18      delay(1000);                       
19 }

In Zeile 3 wird die Bibliothek FtduinoSimple.h eingebunden. Sie vereinfacht den Zugriff auf den ftDuino und erweitert C++ um die Abfrage von einfachen Digitalwerten (an/aus) und das Ein- und Ausschalten von Ausgängen.[5]

  • ftduino.output_set(Ftduino::O1, Ftduino::HI);
    Dies schaltet den Eingang 01 des ftDuino ein, …
  • ftduino.output_set(Ftduino::O1, Ftduino::LO);
    … entsprechend aus.


Aufgabe
  1. Hol dir eine zweite Lampe …
  2. und baue eine Ampel, die alle 2 Sekunden von Rot auf Grün schaltet.
  3. Erweitere den obigen Sketch!

Taster + Lampe

In Kapitel 3.2.2 Eingänge findet man einen Sketch, der einen Taster abfragt.

Diesen kann man mit dem Sketch Blink01 aus den Beispielen verbinden:

 1 #include <FtduinoSimple.h>
 2 
 3 void setup() {
 4  pinMode(LED_BUILTIN, OUTPUT);
 5 }
 6 
 7 void loop() {
 8     // lies den Zustand einer Taste an Eingang I1
 9     if(ftduino.input_get(Ftduino::I1)) {
10         // schalte die interne LED und den Ausgang O1 ein (HIGH bzw. HI)
11         digitalWrite(LED_BUILTIN, HIGH);
12         ftduino.output_set(Ftduino::O1, Ftduino::HI);
13 
14         delay(1000);                       
15 
16         // schalte die interne LED und den Ausgang O1 aus (LOW bzw. LO)
17         digitalWrite(LED_BUILTIN, LOW);
18         ftduino.output_set(Ftduino::O1, Ftduino::LO);
19   
20         delay(1000);                       
21     }
22 }


Aufgabe

Logisch, oder?

  1. Wenn man den Taster drückt und wieder loslässt, brennen LED und Lampe nur kurz auf. Überlege Warum?
  2. Ändere den Sketch so, dass ein kurzer Knopfdruck ausreicht, um das Blinklicht dauerhaft einzuschalten.

Roboter oder Auto?

 Gnome-devel.svg


Weblinks

  • Blink(arduino.cc)
  • Erste Schritte (harbaum.github.io)
  • loop() (arduino.cc)
  • pinMode() (harbaum.github.io)
  • 9.1 FtduinoSimple-Bibiliothek (harbaum.github.io)