Tutorial: Arduino Basics - Teil 1

• Einleitung
• Einrichten der IDE und öffnen eines neuen Sketches
• Kommunikation zwischen Arduino und Computer
• Der erste Schaltplan
• Variablentypen und Anschalten der LED
• Blinkende LED
• If-Then-Else
• Lichtschalter per Taster
• Switch-Case-Funktion
• Hier geht es zu Teil zwei...

Für dieses Tutorial benötigen Sie einige Arduino-Bauteile. Sie finden die folgenden Bauteile auf Amazon oder anderen Händlern:

    1x Rot-, Blau-, Grün-LED
    3x 220-Ohm-Widerstände
    1x 10K-Ohm-Widerstand
    1x Taster
    10x Breadboard-Kabel
    1x Arduino (oder andere) UNO
    1x Lochrasterplatte/Breadboard

Sie können jeden Artikel einzeln oder alle zusammen in einem Paket kaufen. Zum Beispiel enthält das "Miuzei Starter Kit for Arduino" (Link) alle benötigten Teile und mehr, für nur 42,99 € auf Amazon.
Für die Programmierung benötigen Sie die Software "Arduino IDE". Laden Sie die "Arduino IDE" hier herunter. Keine Sorge, diese Software ist absolut kostenlos!

Zunächst einmal die Einrichtung der Software:

1.     Verbinden Sie Ihren Arduino mit Ihrem Computer
2.     Starten Sie die "Arduino IDE".
3.     Gehen Sie zu "Tools" -> "Board" -> und wählen Sie Ihr Arduino Board, in unserem Beispiel "Arduino/Genuino UNO".
4.     Gehen Sie zu "Tools" -> "Port" -> und wählen Sie den Port aus, zum Beispiel "COM6 (Arduino/Genuino UNO)".
5.     Jetzt weiß die Arduino IDE, wie sie Ihren Arduino finden kann.

Nun wenden wir uns der Arduino IDE selbst zu! Öffnen Sie einen neuen Sketch ("Datei" -> "Neu"). In dem neuen Sketch sind bereits zwei Funktionen eingefügt. Bitte löschen Sie diese beiden Funktionen niemals! Aber wozu brauchen wir diese Funktionen?

Die Setup-Funktion:
Diese Funktion wird immer dann aufgerufen, wenn Sie Ihren Arduino starten. Dies geschieht zum einen, wenn Sie einen neuen Sketch auf das Arduino-Board hochladen, oder zum anderen, wenn der Arduino wieder eingeschaltet wird. Letzteres geschieht nicht nur, wenn Sie ihn an einen USB-Port anschließen, sondern auch, wenn Sie ihn an eine andere Stromquelle anschließen. Wir verwenden die Funktion, um neue Variablen oder andere Dinge zu initialisieren.

Die Loop-Funktion:
Diese Funktion wiederholt so schnell wie möglich den gesamten Code, den sie enthält; sie funktioniert also wie ein Repeater. Daher ist die Funktion die Ausgabe aller weiteren Berechnungsschritte nach dem Setup. Zum Beispiel werden immer wieder Messwerte ausgelesen und verarbeitet, oder der Arduino wartet bis zu einer bestimmten Zeit und führt dann eine Funktion aus.

Starten Sie die Arduino IDE, öffnen Sie einen neuen Sketch und verbinden Sie den Arduino mit Ihrem Computer.
Um gesendete Daten vom Arduino lesen zu können, müssen wir den "Serial Monitor" (serielle Anzeige) verwenden. Wir werden diesen immer benutzen, um zu überprüfen, ob unsere Programme richtig funktionieren.
Allerdings müssen der Arduino und der Computer wissen, über welche "Leitung" sie miteinander kommunizieren. Wie bei Discord muss dieselbe Server-/Verbindungsadresse verwendet werden, um miteinander reden zu können. Diese Information geben wir dem Arduino in der Setup-Funktion, die wir im vorherigen Kapitel besprochen haben. Wir schreiben nun die erste Codezeile in die Setup-Funktion:

void setup() {
  Serial.begin(9600);
}

Diese Information besagt: Starten Sie den seriellen Monitor mit der Adresse "9600".
Nach der Initialisierung des seriellen Monitors werden wir eine Meldung senden, dass unser Programm gestartet ist. Wir fahren also mit der Setup-Funktion fort:

void setup() {
	Serial.begin(9600);
	Serial.println("---Programme started---");
}

"println" bedeutet, dass wir den folgenden Text ("---Programm gestartet---") in eine neue Zeile drucken. Ein häufiger Fehler ist die Verwendung eines Apostrophs anstelle der Anführungszeichen. Dies führt dazu, dass eine Zahl zurückgegeben wird und nicht der Text. Würden wir einfach "print" schreiben, dann würde kein Absatz nach dem Text eingefügt, der neue Text würde also einfach an die aktuelle Zeile angehängt werden. Die Ausgabe ohne Absatz ist praktisch, wenn Sie mit mehreren "print"-Befehlen mehrere Informationen in einer Zeile ausgeben wollen. Sie haben vielleicht bemerkt, dass wir nach jeder Anweisung ein Semikolon (";") schreiben. Die Programmiersoftware benötigt dieses Symbol, um zu wissen, wo die Anweisung endet. Dies entspricht einem Punkt am Ende eines Satzes.

Nun ist es an der Zeit, unser Programm zum ersten Mal auszuführen. Doch zuerst müssen wir den seriellen Monitor starten. Gehen Sie dazu auf "Tools" -> "Serial Monitor", unten erscheint eine neue Registerkarte. Stellen Sie sicher, dass im Dropdown-Menü oben rechts auf der Registerkarte "9600 Baud" ausgewählt ist, was der gewählten Kommunikationsfrequenz von Arduino und Computer entspricht.
Jetzt laden wir den Code auf den Arduino hoch. Klicken Sie auf den grünen Rechtspfeil in der oberen linken Ecke der IDE. Die Software prüft nun unseren Code, um zu sehen, ob irgendwelche Fehler aufgetreten sind, dann wird der Code hochgeladen. Unser Arduino zeigt uns in der Arduino-IDE als Fortschrittsbalken mit einem kleinen Licht an, dass der Code hochgeladen wurde.

Wenn der Code kompiliert und ausgeführt wurde, finden wir unsere codierte Nachricht im seriellen Monitor.

Wir werden nun unsere erste Arduino-Schaltung bauen, die wir im nächsten Abschnitt verwenden werden. Zunächst wird aber das Breadboard erklärt.

Jeder Steckplatz auf dem Breadboard steht für einen Pin eines Kabels, einer LED oder eines Widerstandes. In jeder Reihe sind die Spalten (Klemmleisten) a, b, c, d, e und f, g, h, i, j miteinander verbunden, d.h. wenn man an einen dieser Steckplätze eine Spannung anlegt, haben auch alle vier anderen Pins diese Spannung. Ansonsten sind die + und - Spalten (Stromschienen) nicht horizontal (Zeile) sondern vertikal (Spalte) verbunden. Wenn man also eine Spannung an einen der Steckplätze anlegt, haben alle Stifte in der Spalte diese Spannung.
Wir werden die + und - Spalten verwenden, um alle Komponenten mit Spannung zu versorgen.

 

Wir werden nun eine Schaltung mit einer roten LED aufbauen. Die schwarzen Linien repräsentieren die Kabel. Unsere rote LED hat zwei Pins, einen langen und einen kurzen Pin. Bitte platziere den langen Pin in der gleichen Reihe wie den 220-Ohm-Widerstand. Verbinden Sie das andere Ende des 220-Ohm-Widerstandes mit dem digitalen Anschluss 2. Verbinden Sie den anderen Pin der roten LED über die Stromschienen mit der Masse (GND) des Arduino, wie im Bild gezeigt. Wir werden später weitere Verbindungen zur Masse benötigen.

 

Nachdem wir mit dem Bau der kleinen Schaltung fertig sind, kommen wir nun zum Programmieren des dazugehörenden Programm zum Anschalten der LED.
Das Arduino selber weiß sehr wenig über seine Verbindungen mit anderen Bauteilen, deshalb müssen wir ihm per Code beibringen, welcher Port mit was verbunden ist. Zuerst stellen wir alle Informationen über den Port in der Setup-Funktion ein. Zur Bestimmung des Ports wird folgender Code verwendet:

pinMode(redLED, OUTPUT);

Die "pinMode"-Funktion hat zwei Parameter, erstens die Pin-Nummer und zweitens den Typ des Pins, der entweder INPUT oder OUTPUT sein kann. Ein INPUT Pin dient als Empfänger von Daten, beispielsweise von einem Temperatursensor. Ein OUTPUT-Pin funktioniert als Sender der Daten an ein Bauteil sendet, zum Beispiel an eine LED in Form von Strom an oder Strom aus.
Wir werden mit einem neuen Sketch beginnen, daher erstellen wir einen neuen Sketch in der Arduino IDE. Wenn wir den vorherigen Code in der IDE ausführen würde, bekämen wir einen Fehler ausgeworfen, dass die Variable "redLED" unbekannt sei. Deshalb müssen wir die Variable noch definieren. Dafür gibt es zwei Möglichkeiten, entweder definieren wir die Variable global, das heißt dass alle Funktionen diese kennen, oder lokal, was meint dass nur die dazugehörige Funktion diese kennt. Um eine Variable global zu definieren, schreiben wir diese oberhalb der Setup-Funktion, an den Anfang unseres Sketches. Wenn wir eine Variable lokal definieren wollen, dann muss diese in eine Funktion geschrieben werden, zum Beispiel innerhalb der loop-Funktion. Um eine Variable zu definieren, muss folgendes Schema eingehalten werden: [Variablentyp] [Variablenname] = [Wert]; Für unsere Variable "redLED" definieren wir diese global, also am Anfang des Sketches, als eine Integer-Variable mit dem Wert 2, da wir Pin 2 mit der LED verbunden haben. Unser Sketch, sieht also wie folgt aus:

int redLED = 2;

void setup(){
	pinMode(redLED, OUTPUT);
}

void loop(){

}

Bevor wir mit dem Sketch fortfahren, stellen wir nun die häufigsten Variablentypen mit Beispielen und ihren Abkürzungen vor.

Der letzte fehlende Teil für unser Programm zum Anschalten der LED ist der Befehl den Strom an Pin 2 anzuschalten. Da alle Pins ohne ein 'A' vor der Zahl digitale Pins sind, benutzen wir den Befehl "digitalWrite". Der Befehl benötigt zwei Parameter, erstens die Pinnummer und zweitens den Zustand (LOW - kein Strom, oder HIGH - Strom an). Um die LED nun anzuschalten, fügen wir nach der pinMode Zeile noch den digitalWrite-Befehl hinzu. Der Code ist nun vollständig und wir können diesen Compilieren und Hochladen. Nicht vergessen das Arduino mit dem Computer zu verbinden. Der fertige Code sieht wie folgt aus:

int redLED = 2;

void setup(){
	pinMode(redLED, OUTPUT);
	digitalWrite(redLED,HIGH);
}

void loop(){

}

Wir können bisher die LED per Code einschalten, was sie dann auch bis in alle Ewigkeit bleibt. Für etwas mehr Show und zur Einführung des Delay-Befehls, wollen wir nun die LED zum Blinken bekommen. Dazu nutzen wir die loop-Funktion, welche immer wieder den in ihr enthaltenen Code ausführt. Würden wir aber zwei Zeilen bestehend aus dem digitalWrite-Befehl zuerst mit Zustand HIGH und danach dem Zustand LOW in die loop-Funktion schreiben, so würden wir durch die hohe Ausführungsgeschwindigkeit (im Millisekundenbereich) kein Blinken erkennen. Wir müssen zwischen der Zustandsänderung Zeit verstreichen lassen. Dazu dient der Delay-Befehl, welcher alle Prozesse für die eingestellte Zeit anhält. Achtung,  durch den Delay-befehl alle Prozesse des Sketches angehalten werden. Will man aber nur einen unterbrechen, geht dies nicht mit dem Delay-Befehl. Da wir aber nur die eine LED blinken lassen wollen, müssen wir dies nicht beachten. Der Wartezeit muss in Millisekunden übergeben werden. Eine Sekunde entspricht 1000 Millisekunden. In unserem Fall werden wir eine halbe Sekunde in jedem Zustand ausharren, also 500 Millisekunden. Wir passen unseren Sketch auf folgenden Code an und laden diesen auch gleich auf das Arduino hoch. Die LED sollte nun blinken. Pass gerne die Wartezeit an, um zu sehen was passiert.

int redLED = 2;

void setup(){
	pinMode(redLED, OUTPUT);
	digitalWrite(redLED,HIGH);
}

void loop(){
	digitalWrite(redLED,HIGH);
	delay(500);
	digitalWrite(redLED,LOW);
	delay(500);
}

Nun kommen wir zur wichtigsten Befehlskette überhaupt: der if-then-else Bedingung. Diese klärt was passieren soll, wenn ein Zustand wahr ist oder wenn nicht, was stattdessen zu tun ist. Grundlegend, aber wichtig für jedes Programm, denn ein Computer kann nicht selbständig entscheiden. Wir müssen für ihn die Regeln definieren.
Die Basis der if-then-else-Bedingung (in jeder Programmiersprache immer gleich) ist die if-Bedingung selbst:

If (Bedingung){
//mehrere Anweisungen, die ausgeführt werden, wenn die Bedingung als Wahr ausgewertet wird
}

Nach dem "if" müssen wir eine Bedingung festlegen, die der Arduino/Computer überprüfen kann, wenn der Algorithmus ausgeführt wird. Nach den geschweiften Klammern können Sie Ihren Code dafür schreiben, was passieren soll, wenn die Bedingung wahr ist. Eine Bedingung kann zum Beispiel sein, ist die LED ausgeschlatet, dann soll sie eingeschaltet werden.
Wenn die Bedingung falsch ist, tut der Algorithmus in diesem Fall nichts. Wenn wir wollen, dass der Computer etwas anderes tut, müssen wir den else-Algorithmus hinzufügen:

If (condition){
//mehrere Anweisungen, die ausgeführt werden, wenn die Bedingung als Wahr ausgewertet wird
}
else{
//mehrere Anweisungen, die ausgeführt werden, wenn die Bedingung als falsch ausgewertet wird
}

Nachfolgend ist ein Beispielcode aufgeführt, der überprüft ob die Variable größer oder kleiner 100 ist. Da der Wert zuvor auf 50 gesetzt wurde, wird "Kleiner" im Seriellen Monitor ausgegeben.

int value = 50;

if(value<100){
	Serial.println("Kleiner");               
}else{
 	Serial.println("Größer");              
}              

Es ist sogar möglich, mehr als eine if-then-else-Bedingung miteinander zu kombinieren. Der folgende Beispielcode prüft zusätzlich zum vorherigen Beispiel, ob der Wert gleich 100 ist. Das Ergebnis wäre aber immer noch dasselbe, da 50 immer noch kleiner 100 ist.

int value = 50;

if(value<100){
	Serial.println("Kleiner");               
}else{
    if(value == 100){
         Serial.println("Gleich");      
    }else{           
 	     Serial.println("Größer");              
    }           
}              

Lichtschalter per Taster

Wir müssen unsere Schaltung vor dem nächsten Schritt um einen Taster erweitern. Wir wollen nämlich programmieren, dass unsere rote LED leuchtet, wenn man die Taste drückt. Dazu brauchen wir einen 10k-Ohm Widerstand, einen Taster und fünf Kabel. Im Bild ist zu sehen, wie der Taster platziert und durch Kabel und Widerstand mit dem Arduino verbunden wird.

Nachdem nun die Hardware angepasst wurde, müssen wir die Software anpassen. Dazu bringen wir dem Arduino erst einmal bei, dass nun ein Taster mit ihm verbunden ist. Wir erinnern uns, dass die pinMode-Funktion den Typ des Pins kennen muss. Ein Taster ist eindeutig ein INPUT, da er seinen Zustand (gedrückt - nicht gedrückt) an das Arduino übermittelt.

int redLED = 2;
int button = 5;	//NEUE ZEILE

void setup(){
	pinMode(redLED, OUTPUT);
	pinMode(button,INPUT);		//NEUE ZEILE
	//LÖSCHEN DIESER ZEILE: digitalWrite(redLED,HIGH);
}

void loop(){
	digitalWrite(redLED,HIGH);
	delay(500);
	digitalWrite(redLED,LOW);
	delay(500);
}

Nachdem wir den Taster über die Setup-Funktion dem Arduino vertraut gemacht haben, wollen wir nun seinen Zustand abfragen und verwenden. Dazu definieren wir global eine weitere Variable des Typs Boolean mit dem Namen "buttonstate", der wir keinen inertialen Wert zuweisen. Als zweites fügen wir als erste Zeile in der loop-Funktion eine Abfrage des Zustands des Tasters mit Hilfe der Funktion "digitalRead" ein. Die Funktion digitalRead benötigt nur einen Parameter und zwar die Pinnummer. Sie gibt dann den am Pin anliegenden Wert aus. Würden wir diesen Wert in eine Integer-Variable speichern, würde eine Zahl dort stehen. Da der Taster aber nur an oder aus kennt, können wir seinen Zustand auch gleich in die zuvor definierte Boolean-Variable speichern, welche einem die Abfrage ob der Wert LOW (einem Wert von Null) oder HIGH entspricht abnimmt. Haben wir nun den Zustand abgefragt, werten wir diesen in einer if-then-else Bedingung aus. Ist der Taster gedrückt, die Variable Buttonstate wahr bzw. gleich eins, dann soll die LED angeschaltet werden, ansonsten wird sie ausgeschaltet. Dies ergibt den folgenden Code:

int redLED = 2;
int button = 5;
boolean buttonstate;  //NEUE ZEILE

void setup(){
	pinMode(redLED, OUTPUT);
	pinMode(button,INPUT);		
}

void loop(){
	//VERÄNDERT:
	buttonstate = digitalRead(button);
	if(buttonstate == true){
	    digitalWrite(redLED,HIGH);
    }else{
		digitalWrite(redLED,LOW);
	}
}

Soll man den Button nicht gedrückt halten müssen, damit die LED leuchtet, muss noch eine weitere Variable hinzugefügt werden. Diese speichert den aktuellen Zustand der LED und ändert entsprechend dessen den Zustand bei einem Tasterdruck. Wir definieren somit die Boolean-Variable "lightstate" mit dem Inertialwert false (hier stehend für ausgeschlatet) und passen die Loop-Funktion an. Dabei ist wichtig, dass wenn der Zustand der LED sich ändert auch die Variable lightstate angepasst wird. Es kann sein, dass für ein besseres Handling es sich empfiehlt einen Delay von 200 ms am Ende in die loop-Funktion einzubauen.

int redLED = 2;
int button = 5;
boolean buttonstate;  
boolean lightstate = false;    //NEUE ZEILE

void setup(){
	pinMode(redLED, OUTPUT);
	pinMode(button,INPUT);		
}

void loop(){
	buttonstate = digitalRead(button);
	//VERÄNDERT:
	if(buttonstate == true){
		if(lightstate == false){
	    	digitalWrite(redLED,HIGH);
			lightstate = true;
		}else{
			digitalWrite(redLED,LOW);
			lightstate = false;
		}
    }

	delay(200); //VIELLEICHT NICHT BENÖTIGT
}

Als letzte Theorie in Teil 1 vom Arduino Basics Tutorial beschäftigen wir uns mit der switch-case-Funktion. Diese macht es für uns viel einfacher eine Variable auf ihren Wert zu überprüfen, wenn diese mehr als zwei Werte annehmen kann. Ansonsten müssten wir sehr viele if-then-else Bedingungen benutzen. Die switch-case Funktion hat eine einfache Struktur:

switch(Variable) {
case Wert: //etwas passiert
break;
case anderer Wert: //etwas anderes passiert
break;
//...
}

Die switch()-Anweisung ist der Anfang und ruft die Variable auf, deren Wert mit verschiedenen Werten verglichen werden soll. Jeder Vergleich beginnt mit "case". Danach schreibt man den Wert (es dürfen nur Integer oder String/Char verwendet werden) und dann einen Doppelpunkt. Nun können Sie alle Anweisungen aneinanderreihen, die ausgeführt werden sollen, wenn die Variable gleich dem Wert ist. Wenn Sie die Anweisungen für einen Fall abschließen, beenden Sie sie mit "break;", was die switch-Funktion stoppt und den Code nach dieser ausführt.
Als Beispiel verändern wir den vorherigen Code (der einzige Unterschied neben der switch-case-Funktion ist, dass wir den Typ der lightState-Variable von Boolean auf Integer geändert haben, also true = 1 und false = 0):

int redLED = 2;
int button = 5;
boolean buttonstate;  
int lightstate = 0;    //VERÄNDERT

void setup(){
	pinMode(redLED, OUTPUT);
	pinMode(button,INPUT);		
}

void loop(){
	buttonstate = digitalRead(button);
	if(buttonstate == true){
		//VERÄNDERT:
		switch(lightstate){
        case 0:
            digitalWrite(redLED,HIGH);
            lightstate = true;
			break;
        case 1:
            digitalWrite(redLED,LOW);
            lightstate = false;
			break;
        }
    }

	delay(200); //VIELLEICHT NICHT BENÖTIGT
}