Kitabı oku: «Mit Arduino die elektronische Welt entdecken», sayfa 4

Kapitel 2:
Arduino: Die Software

Wenn ich von Arduino spreche, dann meine ich damit sowohl das Arduino-Board als auch die Arduino-Software, die man braucht, um den Mikrocontroller steuern zu können. In diesem Kapitel wirst du erfahren, wie du die notwendige Software auf deinem Rechnersystem installierst und worauf du alles achten musst, bis das erste Arduino-Programm korrekt läuft. Ich erkläre, wo du was in der Arduino-Entwicklungsumgebung findest. Außerdem erfährst du in diesem Kapitel auch, was im Hintergrund abläuft, wenn du ein Programm auf deinem Arduino ans Laufen gebracht hast. Außerdem sage ich dir, was an Grundausstattung zu deiner Bastelwerkstatt gehören sollte.

Grundsätzlich gibt es zwei Möglichkeiten, dein Arduino-Board anzusprechen: Entweder nutzt du dafür ein Softwareprogramm, das du auf deinem Computer installierst, es ist die Arduino-Entwicklungsumgebung. Oder du verwendest Arduino Create, das ist ein webbasierter Editor, den du über deinen bevorzugten Browser aufrufen kannst.

Alle notwendigen Schritte zur Installation sowohl der lokal installierbaren als auch der Onlinevariante sind im Download-Verzeichnis meiner Interseite zu finden:

 die Installation der Arduino-Entwicklungsumgebung in der aktuellen Version

 die Einrichtung zur Verwendung von Arduino Create in der aktuellen Version

https://erik-bartmann.de/?Downloads___Arduino

Hinsichtlich des zu installierenden Plug-ins bei der Verwendung des webbasierten Arduino Create handelt es sich nicht um ein Browser-Plug-in, sondern um einen Agenten, der im Hintergrund arbeitet und quasi browserunabhängig seinen Dienst verrichtet. Jeder andere Browser nutzt diesen Agenten und sollte dann darüber eine Verbindung zur Cloud beziehungsweise zum Arduino herstellen können. Dieser Agent wird übrigens nach jedem Neustart des Systems gestartet. Du kannst die Informationen über den Task-Manager einholen, in dem du in den Tab-Reiter Autostart wechselst. Dort ist ein Eintrag mit dem Namen Arduino_Create_Bridge zu sehen:

Abb. 1: Die Konfiguration der Startprogramme unter Windows

Falls du nicht möchtest, dass dieser Agent mit Windows gestartet werden soll, setze den Status auf Deaktiviert.

Arduino-IDE oder Arduino Create?

Wenn du dich für die lokale Installation der Arduino‌-Entwicklungsumgebung‌ entschieden hast, dann befindet sich dein gesamter Code, inklusive der Bibliotheken, auf deinem Rechner. Du hast also alles vor Ort und kannst direkt darauf zugreifen, ohne dass eine Internetverbindung erforderlich ist. Falls es neue Bibliotheken – das sind bereits erstellte Arduino-Programme – oder neue Versionen von bestehenden Bibliotheken gibt, liegt es in deiner Verantwortung, diese auf den neuesten Stand zu bringen oder sie zu installieren. Du erhältst jedoch Informationen über eventuell vorliegende Updates.

Im Gegensatz dazu bietet die Arduino-Create-Plattform die Speicherung deines Codes in der sogenannten Arduino IOT Cloud‌, was einen Speicher darstellt, der sich irgendwo in den Weiten des Internets befindet. Aus diesem Grund ist auch eine ständige Internetverbindung erforderlich, da alles über einen webbasierten Zugriff des Browsers abgewickelt wird. Der Vorteil dieser Variante ist natürlich der weltweite Zugriff auf alle Arduino-Ressourcen, also Code und Bibliotheken. Angebotene Bibliotheken werden auf diese Weise zentral auf einem aktuellen Stand gehalten und es ist nicht erforderlich, sich um eine Aktualisierung zu kümmern. Ich schlage vor, dass du beide Varianten testest und dich für die Version entscheidest, die dir am meisten zusagt. Sowohl mit der Arduino-IDE als auch mit Arduino Create ist ein praktisches Arbeiten möglich. Ich verwende in diesem Buch die Arduino-IDE, weil sie mir persönlich besser gefällt und ich nicht gezwungen sein möchte, immer auf eine bestehende Internetverbindung zurückgreifen zu müssen, obwohl das heutzutage ja fast immer gewährleistet ist. Ich bin kein Freund von Cloud-Lösungen, doch das musst du für dich selbst entscheiden.

Was befindet sich wo?

Nach dem Starten der Arduino-Entwicklungsumgebung, die du auf deinem Computer installiert hast, öffnet sich ein Fenster, das aussieht wie in Abbildung 2. Die Arduino-Entwicklungsumgebung ist in einzelne Bereiche unterteilt. Es gibt einen Ein- und einen Ausgabebereich, Steuerelemente, Informationen über die Verbindungsparameter und einiges mehr. Schauen wir uns das im Detail an.

Der Editor‌

Der Bereich, in dem du deinen Programmiercode eintippst, wird Editor genannt. Er beherrscht das sogenannte Syntax-Highlighting‌, was besagt, dass erkannte Schlüsselwörter der Programmiersprache meist farbig dargestellt werden.

Statusinformationen‌

Unterhalb des Editors befindet sich ein schmaler Bereich, der Statusinformationen anzeigt. Das können Hinweise darüber sein, was gerade passiert oder Meldungen der letzten ausgeführten Aktion. Du kannst in Abbildung 2 erkennen, dass ich gerade einen Sketch erfolgreich auf das Arduino-Board hochgeladen hatte.

Abb. 2: Die Bereiche der Arduino-Entwicklungsumgebun‌g

Compiler-Meldungen‌

Wenn der Compiler, also das interne Arduino-Programm, das deinen Programmcode in eine Maschinensprache übersetzt, die der Mikrocontroller versteht, seine Arbeit zur Übersetzung des Quellcodes verrichtet, erscheinen im Bereich, der schwarz hinterlegt ist, die Meldungen über den Fortschritt oder aufgetretene Probleme und abschließend auch Hinweise über den Speicherverbrauch. Damit der Compiler etwas gesprächiger wird, kann über den Menüpunkt Datei | Voreinstellungen der Redefluss angepasst werden.

Standardmäßig ist hier der Punkt Keine ausgewählt.

COM-Verbindung‌

Am unteren Rand der Entwicklungsumgebung sehen wir die Verbindungsinformationen, also welches Board sich an welchem COM-Port befindet. Das kann bei Verbindungsproblemen und zur Fehlersuche sehr hilfreich sein.

Tabulatoren‌

Im Bereich der Tabulatoren‌ befindet sich die Umschaltmöglichkeit zwischen Quellcodes desselben Sketches. Das wird dann interessant, wenn wir später eigene Bibliotheken und Klassen programmieren. Es kann jedoch immer nur ein einzelner Sketch je Entwicklungsumgebung verarbeitet werden. Mehrere unterschiedliche Sketches können nicht in einer einzigen Instanz der Entwicklungsumgebung Platz finden. Das Prinzip gleicht nicht den Tabulatoren innerhalb eines Browsers, der darüber mehrere unterschiedliche und eigenständige Verbindungen verwaltet.

Serial-Monitor‌

Über das Lupensymbol (es sieht jedenfalls so aus) kann der Serial-Monitor geöffnet werden, der auf die serielle Schnittstelle zugreift, um dann Informationen anzuzeigen oder auch zu versenden.

Menüleiste‌

Über die Menüleiste können die unterschiedlichsten Anpassungen zur Verwaltung der Anwendung vorgenommen werden, wie man das auch von anderen Programmen kennt.

Symbolleiste‌

In der Symbolleiste befinden sich einige wichtige Schaltflächen, die mit Aktionen hinterlegt sind, die immer wieder benötigt werden, beispielsweise das Übersetzen (Kompilieren) des Quellcodes, das Hochladen des übersetzten Codes zum Mikrocontroller oder das Laden und Speichern von Sketches.

Der Anschluss des Arduino‌-Boards

Sehen wir uns nun den Anschluss des Arduino-Boards mit dem Computer genauer an. Der Arduino Uno besitzt auf dem Board den folgenden USB-Anschluss:

Abb. 3: Die USB-Buchse des Arduino

Auf Computerseite wird ein Standardanschluss Typ-A benötigt. Ein entsprechendes Kabel ist überall erhältlich, ich habe davon ganze Kisten voll. Ist die Verbindung hergestellt worden, so übernimmt dieser USB-Anschluss zwei Aufgaben:

 Es wird das Arduino-Board mit Spannung versorgt.

 Es ermöglicht die Kommunikation zwischen Computer und Board.

Detaillierte Informationen über die verschiedenen USB-Anschlüsse sind unter der folgenden Internetadresse zu finden:

http://de.wikipedia.org/wiki/Universal_Serial_Bus

Wird ein fabrikneues Arduino-Board mit Spannung versorgt, blinkt die auf dem Board befindliche LED (gekennzeichnet mit L) im Sekundentakt.

Abb. 4: Die Onboard-LED L

Das passiert, weil immer ein Basic-Sketch vorinstalliert ist. Wir können die erfolgreiche Kommunikation mit dem Arduino-Board mithilfe dieses Sketches überprüfen, denn die IDE verfügt von Haus aus über zahlreiche vorinstallierte Sketches.

Wir testen die Kommunikation zwischen Computer und Arduino

Wenn das Arduino-Board von der IDE erkannt wurde, wollen wir im nächsten Schritt die Kommunikation zwischen Rechner und Arduino testen. Wenn ich von Kommunikation rede, dann meine ich im Moment die Übertragung eines Sketches (wir erinnern uns: Im Arduino-Umfeld wird ein Programm Sketch genannt) – zum Mikrocontroller-Board. Am besten laden wir uns den Blink-Sketch in die IDE und passen die Blinkrate etwas an. Dann kompilieren und übertragen wir den Sketch zum Arduino und sehen, was passiert. Hier die einzelnen Schritte, wobei ich voraussetze, dass die Installation erfolgreich war und der Arduino von der IDE nach deren Start erkannt wurde.

Schritt 1: Beispiel-Sketch laden

Über den Menüpunkt Datei | Beispiele | 01.Basics | Blink wird der Sketch in die IDE geladen und stellt sich wie folgt dar, wobei ich alle führenden Kommentarzeilen mit Zusatzinformationen weggelassen habe:

void setup() { pinMode(13, OUTPUT); } void loop() { digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level) delay(1000); // wait for a second digitalWrite(13, LOW); // turn the LED off by making the voltage LOW delay(1000); // wait for a second }

Was die einzelnen Codezeilen im Detail bewirken, werden wir noch ausführlich im Bastelprojekt 1 besprechen. Die aktuelle Aufgabe ist jedoch die Ansteuerung einer auf dem Board befindlichen Leuchtdiode, die im Sekundentakt blinken soll. Jetzt wollen wir erst einmal sehen, ob der Sketch von der IDE zum Arduino-Board übertragen wird. Ich erwähnte schon, dass ein fabrikneues Board über einen fertig hochgeladenen Blink-Sketch verfügt und wir wollen diesen Sketch jetzt so anpassen, dass die LED mit der Bezeichnung L anfängt zu blinken. Dazu müssen die beiden Codezeilen, in denen sich der delay-Befehl befindet, leicht modifiziert werden.

Schritt 2: Den Beispiel-Sketch modifizieren

Im Moment befindet sich ein Wert innerhalb des runden Klammerpaares, der festlegt, wie lange die Verarbeitung an dieser Stelle pausieren soll. Der Wert 1000 gibt die Wartezeit in Millisekunden (ms) an, wobei 1000 ms = 1 Sekunde ist. Demnach wird beim Erreichen des delay-Befehls für eine Sekunde gewartet, bevor es mit dem Befehl in der nächsten Zeile weitergeht. Wenn wir jetzt den Wert von 1000 auf 100 ändern, erreichen wir damit eine zehnmal höhere Blinkrate. Die beiden Zeilen, in denen der Befehl vorkommt, müssen wie folgt angepasst werden:

delay(100);

Nun kann der modifizierte Sketch – fast – auf den Arduino übertragen werden. Ich sage fast, weil es im Folgenden noch eine Kleinigkeit zu beachten gilt.

Schritt 3: Das richtige Board und den richtigen COM-Port auswählen

Da von Arduino – und ich rede jetzt von der Firma und nicht von dem Board – etliche unterschiedliche Boards entwickelt wurden, müssen wir der Entwicklungsumgebung mitteilen, um welches Board es sich denn handelt, das wir verwenden. Des Weiteren ist die Angabe des korrekten COM-Ports wichtig. Diese beiden Unterschritte werden über die folgenden Menüpunkte erledigt:

 Werkzeuge | Board und

 Werkzeuge | Port

In meinem speziellen Fall also Arduino Uno und COM5.

Schritt 4: Den Sketch‌ kompilieren und hochladen

Kommen wir zu einem Schritt in der Programmierung, der sich kompilieren nennt. Doch eins nach dem anderen. Um ein Computerprogramm in einer für den Menschen mehr oder weniger lesbaren Form abzubilden, wurden die sogenannten Hochsprachen‌ wie C/C++, Java und C# – um nur einige wenige zu nennen – entwickelt. Die Befehle aus dem vorliegenden Sketch sind allesamt auf Englisch, was für fast alle anderen Programmiersprachen ebenfalls gilt. Jeder einzelne Befehl beschreibt in mehr oder weniger deutlicher Weise, welche Funktion dahinter verborgen ist. Unser delay-Befehl bedeutet übersetzt Verzögerung oder Aufschub und darunter kann sich sicherlich jeder etwas vorstellen. Ein Mikrocontroller kann damit jedoch zunächst nicht das Geringste anfangen und deshalb müssen wir ihm auf die Sprünge helfen. Warum? Nun, ein Mikrocontroller und jede andere CPU kann lediglich Befehle in Form der ganz persönlichen Muttersprache, auch Maschinensprache‌ oder Native Language‌ genannt, verstehen und diese ist für jeden Mikrocontroller-Typen meist anders definiert. Somit wird eine Übersetzungsinstanz benötigt, die unsere Hochsprache, beim Arduino ist das C++, in eine für den Mikrocontroller verständliche Maschinensprache übersetzt. Diese Arbeit übernimmt ein sogenannter Compiler‌.

Was ist ein Compiler?

Ein Compiler ist ein Übersetzungsprogramm, das den Quellcode einer Hochsprache wie zum Beispiel C++ in eine Sprache übersetzt, die der jeweilige Prozessor beziehungsweise Mikrocontroller versteht.

Die Arduino-Entwicklungsumgebung besitzt – wie oben bereits erwähnt – mehrere kleine Symbole mit dahinter verborgenen Aktionen. In der folgenden Liste sind die beiden wichtigsten Symbole und deren Funktion zu sehen. Natürlich sind die anderen auch wichtig, doch diese hier sind eben essentiell wichtig:

Tabelle 1: Ein paar wichtige Icons für den Anfang
Symbol	Funktion
	Überprüfung des Quellcodes durch Kompilierung
	Übertragung zum Mikrocontroller starten, wenn Kompilierung erfolgreich war

Das erste Symbol überprüft den Quellcode‌ – so nennt sich der Text im Editor einer Entwicklungsumgebung – auf Richtigkeit. Was bedeutet aber Richtigkeit? Nun, jede Sprache verfügt über eine gewisse Grammatik. Wird bei der Kommunikation nicht korrekt auf diese Regeln zurückgegriffen, versteht der andere Kommunikationsteilnehmer die Absicht des Sprechenden nicht. Ebenso verhält es sich bei der Programmierung. Werden die Befehle nicht genau so geschrieben beziehungsweise formuliert, wie der Compiler sie versteht, kommt es unweigerlich zu einem (Syntax-) Fehler und der Compiler bricht seinen Übersetzungsvorgang mit einer entsprechenden Fehlermeldung ab. In der folgenden Abbildung 5 ist der Ablauf nach Anklicken des Überprüfen-Symbols zu sehen:

Zu Beginn startet die Kompilierung mit der Anzeige des Fortschritts über den grünen Balken. Ist kein syntaktischer Fehler gefunden worden, wird dieser Vorgang mit der Meldung beendet, dass die Kompilierung abgeschlossen ist. Ein Upload des Maschinencodes zum Mikrocontroller des Arduino Uno erfolgt dabei nicht. Wurde jedoch ein Fehler im Sketch-Code gefunden, so bricht der Vorgang des Kompilierens mit einer entsprechenden Fehlermeldung ab.

Das zweite Symbol analysiert ebenfalls den Quellcode‌ und es werden die gleichen Prozeduren wie beim Überprüfen durchgeführt. Jedoch erfolgt hier nach einer fehlerfreien Kompilierung das Hochladen des Maschinencodes zum Mikrocontroller des Arduino Uno. Auf der nachfolgenden Abbildung 6 ist der Ablauf zu sehen:

Abb. 5: Der Ablauf nach Anklicken des Überprüfen-Symbols

Abb. 6: Der Ablauf nach Anklicken des Hochladen-Symbols

Zu Beginn startet die Kompilierung mit der Anzeige des Fortschritts über den grünen Balken. Ist kein syntaktischer Fehler gefunden worden, wird der Prozess des Hochladens zum Mikrocontroller gestartet, der ebenfalls eine Fortschrittsanzeige auf einem grünen Balken bietet. Nach erfolgreichem Hochladen erscheint die Meldung, dass das Hochladen abgeschlossen wurde. Bei einem Fehler im Sketch-Code bricht der Vorgang des Kompilierens mit einer entsprechenden Fehlermeldung ab, wie das auch bei der Überprüfung der Fall war.

Es kann auch ohne Umweg über das vorherige Kompilieren sofort das Hochladen gewählt werden, weil eine vorherige Kompilierung dort ebenfalls ausgeführt wird. Während des Uploads – so wird das Hochladen im Englischen genannt – leuchten einige LEDs, die sich auf dem Arduino-Board befinden. Schauen wir genauer hin:

Abb. 7: Drei wichtige LEDs auf dem Arduino

Links neben dem Arduino‌-Schriftzug finden wir drei LEDs. Eine davon ist unsere LED mit der Bezeichnung L, die den Zustand am digitalen Pin 13 widerspiegelt. Etwas darunter sehen wir zwei weitere LEDs mit den Bezeichnungen TX (Senden) und RX (Empfangen). Es handelt sich um die Statusanzeigen der seriellen Schnittstelle, über die das Arduino-Board mit dem Computer verbunden ist. Und beim gerade angesprochenen Upload werden die Maschinensprachinformationen über diese Schnittstelle versendet‌. Das Board quittiert diesen Vorgang mit einem unregelmäßigen Blinken der beiden genannten LEDs. Wurde der Upload beendet – aus welchen Gründen auch immer – erlöschen die beiden LEDs wieder. Somit haben wir eine sehr gute optische Kontrolle über den Upload-Vorgang. Nach dem erfolgreichen Upload blinkt die LED L in kurzen Zeitabständen und wir können sicher sein, dass unser modifizierter Sketch funktioniert hat. Auf der rechten Seite der Abbildung sehen wir eine weitere LED mit der Bezeichnung ON. Sie leuchtet, wenn das Board mit Spannung versorgt wurde.

Der Maschinencode des Arduino

Der folgende Abschnitt hat zwar nicht unmittelbar etwas mit der Programmierung des Arduino-Boards zu tun, aber es ist wichtig, dass du die Schritte verstehst, die im Hintergrund ablaufen. Ich habe ja schon ein wenig über die Entwicklungsumgebung, den Compiler und die Programmiersprachen C/C++ erzählt. Wie läuft die Kompilierung ab und was wird eigentlich zum Mikrocontroller des Arduino-Boards übertragen?

Abb. 8: Was passiert im Hintergrund bei der Übertragung des Sketches zum Arduino-Board?

Wir können den Ablauf in einzelne logische Schritte unterteilen: