Hi,

Du hast gegrübelt und dich vielleicht gefragt, wie auch Du coole Arduino Projekte bauen kannst. In den letzten Wochen hast du dich durch die Online Lektionen vom Arduino Kurs geboxt. Kleine Erfolge haben dir gezeigt, dass es doch eigentlich gar nicht so schwer ist. Vielleicht warst du ja auch schon ein wenig stolz auf die fertigen Schaltungen & Programme. Fakt ist, Du hast durch die Lektionen viel gelernt.

In den nächsten beiden Lektion werden wir daher mal das Wichtigste aus den bisherigen Projekten zusammenfassen. Wir beginnen mit der Arduino Software. Heute bekommst du eine Zusammenfassung aller Befehle und Programmstrukturen die bisher vorkamen. Du kannst diese Lektion super als Nachschlagewerk nutzen um schnell einen Befehl nachzuschauen.

Das nächste Mal betrachten wir die Hardware Seite. Genauer, welche Bauteile haben wir bisher genutzt, welche Grundschaltungen kamen vor und welche Bastler-Tricks sollte man als smarter Maker immer parat haben.

Also los geht’s mit den

Tipps und Tricks zur Arduino Programmierung

 

Sketch Grundstruktur

Jeder Arduino-Sketch ist gleich aufgebaut und besteht aus zwei Hauptblöcken, dem Setup-Block und dem Loop-Block.

Der Setup-Block wird zu Beginn genau einmal durchlaufen. Immer wenn der Reset-Taster am Arduino gedrückt wird, oder die Stromversorgung aus- und wieder eingeschaltet wird, dann springt die Bearbeitung einmalig zu dem Code, der in der Funktion

setup() definiert wird. Hier legst du deine Rahmenbedingungen fest und initialisiert das System. Alles, was zur Vorbereitung der Aufgabe ausgeführt werden muss, gehört hier hinein.

Die Funktion loop() schließlich wird immer wiederholt und enthält die eigentliche Funktion deiner Anwendung. Wenn der Arduino den Code im Loop-Block abgearbeitet hat, springt er wieder zum Beginn des Loop-Blocks, immer wieder in einer Endlosschleife.

Libraries einbinden

Für manche Projekte musst du zusätzliche Programmbibliotheken einbinden. Etwa, wenn du spezielle Hardware ansteuern willst, oder bestimmte Funktionen benötigst, die nicht standardmäßig in der Arduino-Entwicklungsumgebung enthalten sind.

Du kannst auch deine eigenen Bibliotheken schreiben und einbinden. Das hält bei umfangreichen Projekten den Code übersichtlich, außerdem kannst du so deine Entwicklungen veröffentlichen und mit anderen Makern austauschen.

Libraries werden mit der Compiler-Direktive #include<name.h>  ganz zu Anfang des Sketchs eingebunden. Zum Beispiel haben wir zur Ansteuerung des LCD-Display immer die Zeile #include <LiquidCrystal.h>  oben im Sketch stehen.

Du kannst auch neue Bibliotheken zur Arduino-IDE hinzufügen.

Wenn du aus dem Internet eine Bibliothek heruntergeladen hast, dann liegt sie meist in Form eines ZIP-komprimierten Ordners vor. Diesen kannst du über die Arduino-IDE direkt einbinden. Einfach im Menü unter Sketch->Add .ZIP library auswählen.

Die Bibliothek wird entpackt und in den Ordner unter arduino/libraries  kopiert und du kannst sie fortan in deine Sketches einbinden.

 

 Schreiben und Auslesen von Daten

Der beste Sketch nützt nichts, wenn du nicht mit der Außenwelt kommunizieren kannst. Der Arduino muss Daten lesen und schreiben können. Dazu dienen die digitalen und analogen Pins. Alle Pins können sowohl gelesen, als auch geschrieben werden.

Dazu dienen die Funktionen  digitalRead(P) und digitalWrite(P,Wert) für die digitalen Pins und entsprechend analogRead(P)  und analogWrite(P,Wert)  für die analogen Pins. P  steht hier immer für die Nummer des Pins, den du ansprechen willst.

Die Digitalen Pins kennen nur zwei Werte, LOW und HIGH, während du an den Analogen Pins dank A/D-Wandler ganzzahlige Werte von 0 bis 1023 auslesen kannst.

Hier ein Beispiel, in dem wir eine LED mit einem Taster ein- und ausschalten.

LED und Taster sind an digitale Pins angeschlossen und die Pin-Nummern in den Variablen LED und TASTER  gespeichert:

 

Variablen

Variablen gehören zu den wichtigsten Programmierkonzepten. Es sind die Daten deines Sketch. Sie dienen dazu, Werte abzuspeichern, die sich während der Programmlaufzeit verändern. Sie können gelesen und geschrieben werden und du kannst mit ihnen auch rechnen oder sie auf verschiedene Weise abspeichern. Je nachdem ob man ganze Zahlen, reelle Zahlen oder Texte und Zeichenketten speichern möchte, gibt es verschiedene Variablentypen.

Im Sketch definierst du eine Variable, indem du zunächst den Typ angibst und dann einen frei wählbaren Namen für die Variable, den sogenannten Bezeichner.

Int/Long

Der häufigste Typ sind Integer-Variablen, die einfach ganze Zahlen aufnehmen können.

Natürlich kannst du damit auch rechnen:

Bei der Weltzeituhr mussten wir an einer Stelle den Typ Long verwenden, um einen Überlauf zu verhindern.

Long-Variablen verhalten sich wie Int, benötigen aber doppelt so viel Speicherplatz, sie belegen 4 Byte anstatt 2 im Speicher. Daher können damit größere Werte dargestellt werden.

 

String

String-Variablen speichern Zeichenketten ab. Die Zeichenketten werden in Anführungszeichen eingeschlossen, damit der Compiler weiß, was dazugehört und was nicht. Das kommt zum Beispiel vor bei Ausgabetexten für Fehlermeldungen oder Statusangaben.

string Status = "Alles ok";

 

Man kann mit ihnen auch in gewisser Weise „rechnen“, aber anders als mit Zahlen.

Wir haben dies auch beim Projekt mit der Weltzeituhr gemacht.

Der Ausdruck Minuten+':'+Sekunden  setzt die Zeichenketten einfach hintereinander zusammen. So kann man durch „Addition“ von Strings Meldungen und Texte aus einzelnen Textbausteinen zusammensetzen.

 

Float/Double

Im Projekt mit der Wetterstation haben wir Temperaturen ausgelesen, die nicht unbedingt immer ganzzahlig sein müssen.

Für nicht ganzahlige Variablen gibt es die Datentypen Float und  Double. Dabei ist Double wieder die Variante, die doppelt so viel Speicherplatz belegt, in diesem Fall 8 Bytes statt 4 wie ein Float-Wert, Double-Variablen haben beim Rechnen die doppelte Genauigkeit.

 

Boolean

Ein Binärwert, der nur true oder false annehmen kann. Streng genommen braucht man diesen Typ gar nicht, weil man auch eine int-Variable nehmen kann und mit 0 und 1 arbeiten kann.

Es ist aber eleganter und weniger fehleranfällig, wenn du eine Variable hast, die tatsächlich nur zwei Zustände annehmen kann. Etwa, ob ein bestimmter Taster gedrückt ist oder nicht.

 

Arrays

Arrays sind eigentlich keine eigenen Variablentypen, sondern Listen von mehreren Variablen, die mit einem Index versehen sind. So kann man größere Datenmengen einfach abspeichern. Deshalb können aller der bisher behandelten Datentypen auch als Array auftreten.

 

Serieller Monitor

Der Arduino kann Daten über die USB-Schnittstelle an den angeschlossenen Rechner senden. Um sie sichtbar zu machen,  gibt es in der Entwicklungsumgebung einen sogenannten Monitor.

Mit dem Serial -Objekt kannst du über die USB-Schnittstelle Daten an den angeschlossenen PC senden. Das Monitorfenster zeigt ankommende Zeichen in Echtzeit an.

 

Den Monitor öffnest du in der Arduino-Entwicklungsumgebung unter Werkzeuge, oder mit der Tastenkombination  Strg-Umschalt-M. Probiere es aus und du wirst sehen, wie im Sekundentakt die Ausgabe in das Fenster auf dem Bildschirm geschickt wird.

screen_serieller_Mon_Aufruf

 

Abfrage

Wir haben zwei Techniken zur Abfrage und Fallunterscheidung kennengelernt. Wenn du dich zwischen zwei Alternativen entscheiden musst, ist die if-Konstruktion die Richtige.

 

if

Die if-Abfrage haben wir ja in den Projekten ausgiebig verwendet. Sie ist die Standard-Abfragetechnik, wenn der Arduino Entscheidungen treffen muss:

 

Falls du aus mehreren Optionen genau eine auswählen möchtest, geht das aber am besten mit case und switch:

case

Das, was hinter  switch  in Klammern steht wird bei jedem Block, der mit  case  beginnt abgefragt. Nur wenn es übereinstimmt, dann wird der Anweisungsblock hinter  case  ausgeführt. Wenn nicht, geht es einfach mit dem nächsten case weiter. Aber auch nach einer Übereinstimmung geht es beim nächsten case  weiter. Auf diese Weise kannst du auch mehrere Bedingungen gleichzeitig abfragen. Willst du also, dass nur ein case -Block ausgeführt wird, dann musst du ihn mit der Anweisung break;  beenden. Die sorgt nämlich dafür, dass der ganze switch-Block verlassen wird. Schließlich gibt es dann noch die Anweisung hinter  default: , die nur ausgeführt wird, wenn keine der case Abfragen geklappt hat.

Erinnerst du dich an die Weltzeituhr? Dort haben wir genau diese Konstruktion schon benutzt.

Ein Beispiel für eine Schaltung mit drei Tasten, die ein Benutzer bedienen kann, sähe in etwa folgendermaßen aus:

 

 

Schleifen

Oft müssen beim Programmieren Anweisungen wiederholt werden. Dazu haben wir meist die Schleife mit For verwendet, die einen Anweisungsblock so oft wiederholt, wie in der for-Anweisung angegeben wird:

for

Die For-Schleife ist immer dann angebracht, wenn du genau vorher weißt, wie viele Wiederholungen benötigt werden. Zum Beispiel, wenn du alle Elemente eines Arrays abfragen willst. Die Grenzen und die Schrittweite der Zählvariablen kannst du dabei frei festlegen, wie diese Beispiele zeigen:

 

do while

Manchmal ist zu Beginn einer Schleife nicht bekannt, wie oft sie durchlaufen werden muss. Stattdessen hast du eine Bedingung, die erfüllt sein muss, damit die Schleife abbricht.

Nehmen wir zum Beispiel an, du hast bei einer Motorsteuerung einen Temperatursensor ausgelesen und festgestellt, dass der Arduino zu warm wird. Jetzt soll eine Sicherungsfunktion den Motor ausschalten und dann warten, bis die Temperatur unter 30 Grad gefallen ist. Jetzt checken wir jede Sekunde die Temperatur, aber wie oft wir das tun müssen ist vorher nicht bekannt.

Das kannst du mit der do…while Schleife lösen:

Nach dem Schlüsselwort do kommt ein Anweisungsblock, danach folgt while(BEDINGIUNG).

Nach jeder Ausführung des Anweisungsblocks überprüft der Arduino, ob die Bedingung noch wahr ist. Sobald die Bedingung nicht mehr zutrifft, bricht die Bearbeitung der Schleife ab.

Eigene Funktionen und Prozeduren definieren

Kleine in sich abgeschlossene Aufgaben, die immer wiederkehren eignen sich, um sie als Funktion abzukapseln.

Das hat viele Vorteile: Der Code ist übersichtlicher und kürzer, außerdem kannst du die Funktionen an anderer Stelle wiederverwenden. Wichtige Funktionen kannst du zum Beispiel sammeln und eine Library daraus machen, die du bei Bedarf einbindest (siehe oben).

 

Den Namen der Funktion kannst du frei wählen. typ gibt den Datentyp des Rückgabewerts an, wenn du die Funktion verwenden willst, um etwas auszurechnen. Zum Beispiel so:

Damit könntest du an jeder Stelle im Code mit A2=quadrat(A); eine Zahl quadrieren.

Einen Rückgabewert benötigst du nicht immer. Wenn du einfach eine Folge von Anweisungen auslagern willst, dann teilst du dies dem Compiler durch den Rückgabetyp void mit.

Wir haben das auch schon öfters verwendet, zum Beispiel, um bei der Weltzeituhr mit Alarmfunktion den Weckton abzuspielen.

Das Abspielen haben wir in eine Funktion alarm() gepackt, die an passender Stelle nur aufgerufen werden muss.

 

 Systemvariablen und Funktionen

Zum Schluss kommt noch eine Liste der eingebauten Variablen und Funktionen, die wir bisher verwendet haben:

millis()

Gibt die Anzahl an Millisekunden zurück, die seit dem letzten Einschalten oder Reset vergangen sind.

PORTD

Gibt als Dezimalzahl die Binärzahl, die der digitale Belegung an den Pins 0 bis 15 entspricht.

tone(Frequenz)

Gibt einen Ton mit  Rechteck-Wellenform wieder. Beendet wird er mit notone()

sizeof(Variable)

Gibt den Speicherbedarf einer Variablen in Bytes zurück. Wir haben das benutzt, um bei einem Int-Array unbekannter Länge die Grenzen für die for-Schleife zu bestimmen, die automatisch alle Elemente abgrast.

delay(T) und  delayMicroseconds(t)

Die beiden Delays sind wichtige Werkzeuge für das Timing zeitkritischer Aufgaben. Beide Befehle tun eigentlich nichts. Das heißt, der Arduino stoppt die aktuelle Abarbeitung und wartet für den angegebenen Zeitraum. Bei delay wird die Zeit in Millisekunden angegeben, bei delayMicroseconds hingegen wie der Name schon sagt in Mikrosekunden.

 

Soweit erstmal die Zusammenfassung der Arduino-Programmierung. Bei der Entwicklung eigener Programme  kannst du immer wieder hierher zurückkehren als kleines Nachschlagewerk.

Beim nächsten Mal schauen wir uns an, was wir bisher an Hardware und Schaltungstricks kennengelernt haben.

Soweit zur Arduino Software . . . bis bald zur nächsten Lektion!

 

Die ultimative Arduino Software Zusammenfassung.
Markiert in:        

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.