Tutorial: Arduino Basics - Teil 2

• Hier geht es zu Teil eins...
• Funktionen
• Ampelschaltung
• Dimmer
• Schleifen-Algorithmen
• Lauflicht - for-Schleife
• Weitere Übungsaufgaben

Im vorherigen Teil haben wir ihnen eine Einführung in die if-then-else Bedingung, die switch-case-Funktion und einige Arduino spezifische Befehle gegeben. Dieses Tutorial soll Anfängern neben dem Arduino auch in das Programmieren in C einführen. Um ihre zukünftige Projekte aufgeräumter und professioneller zu gestalten, wollen wir an dieser Stelle Funktionen vorstellen. Funktionen dienen neben dem Ordnen und der Übersichtlichkeit des Codes auch zur Verringerung des Programmieraufwands, da häufiger bestimmte Algorithmen mehrmals benutzt werden. Statt diese jedes Mal in den Code zu schreiben, können diese in eine Funktion geschrieben werden und aufgerufen werden.
Es existieren zwei Hauptvarianten von Funktionen, zum einen Funktionen die einfach einen Algorithmus ausführen und zum anderen Funktionen, die an den Aufrufer einen Wert zurückgeben. Zusätzlich kann der Aufrufer Funktionen Parameter übergeben. Dadurch kann zum Beispiel die Helligkeit einer LED an die Funktion übergeben werden, welche die Helligkeit der LED anpasst.
Nachfolgend sind beide Funktionstypen in ihrer Grundstruktur aufgeführt:

Funktion ohne Rückgabewert:
void [Name]([Variable type] [Name of the variable]){
//statements
}

Funktion mit Rückgabewert (hier mit einem Integer-Wert):
int [Name]([Variable type] [Name of the variable]){
int value = 0;
//statements
return value;
}

Die Deklaration einer neuen Funktion beginnt mit "void", wenn die Funktion einen Wert zurückgeben soll, geben Sie den Typ einer Variablen an. Diesem folgt der Name der Funktion, z. B. "LightOnOff". Danach können Sie zwischen den Klammern Variablen definieren, die, wenn sie ausgeführt werden, an die Funktion übergeben und in der Funktion verwendet werden können. Wenn Sie einen Wert zurückgeben wollen, beenden Sie die Funktion mit return [Wert / Variable]. Diese Anweisung beendet die Funktion, alle folgenden Zeilen werden nicht ausgeführt!

In den weiteren Abschnitten werden wir alle Algorithmen in separate Funktionen schreiben, die von anderen Funktionen ausgeführt werden. Um eine Funktion auszuführen, schreibst du den Namen und dahinter Klammern, z. B. "LightOnOff()". Wenn der Funktion Parameter mitgegeben werden müssen, fügen Sie diese in die Klammern ein, zum Beispiel: LightOnOff(lightState).

Wir können den Code mit dem Lichtschalter aus Teil 1 des Tutorials mit einer Funktion erweitern:

int redLED = 2;
int button = 5;
boolean buttonstate;  
int lightstate = 0;

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

void loop(){
	buttonstate = digitalRead(button);
	if(buttonstate == true){
		//GEÄNDERT:
		LightOnOff(lightstate);
    }

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

void LightOnOff(int lightstate){
	switch(lightstate){
        case 0:
            digitalWrite(redLED,HIGH);
            lightstate = true;
			break;
        case 1:
            digitalWrite(redLED,LOW);
            lightstate = false;
			break;
    }
}

Ampelschaltung

Wir werden mit einem neuen Projekt beginnen. Bei unserem neuen Projekt werden wir zwei LEDs (rot/grün) so programmieren, sodass diese wie eine Fußgängerampel funktionieren. Wenn Sie jetzt denken, dass wir dieses Projekt schon einmal ganz ähnlich hatten, keine Sorge, wir werden einige zusätzliche Funktionen hinzufügen. Dafür wird der Schaltplan um eine grüne LED erweitert.

Das Projekt Ampelschaltung soll Ihnen als Übung dienen. Versuchen Sie doch einmal einen Code mit nachfolgenden Voraussetzungen zu erzeugen, sodass auf den Tastendruck die Ampel von Rot auf Grün und andersrum schaltet:

• Alle Bauteile (rote und grüne LED und der Button) haben eine eigene Variable.
• Die Variable TrafficLightState speichert den aktuellen Status der Ampel.
• Der aktuelle Status des Tasters wird in der loop-Funktion ausgelesen und in die globale Variable buttonState gespeichert.
• In der Funktion checkButtonState mit den Übergabeparametern (btnState und trafficState) wird ausgelesen, ob der Taster gedrückt wurde und entsprechen des aktuellen TrafficLightStates dieser angepasst.
• Die Funktion TurnLightsOnOff mit dem Übergabe Parameter trafficState werden die LEDs entsprechend dem übergebenen TrafficLightState an. bzw. ausgeschaltet.

Sofern der Code bei Ihnen funktioniert, herzlichen Glückwunsch, es gibt mehrere Wege, deshalb ist unsere Lösung nur eine Möglichkeit:

int redLED = 2;
int greenLED = 3;
int button = 5;
boolean buttonState = false;
int TrafficLightState = 0;


void setup() {
  TrafficLightState = 0;
  pinMode(redLED,OUTPUT);  
  pinMode(greenLED,OUTPUT); 
  pinMode(button,INPUT);
}

void loop() {
  buttonState = digitalRead(button);
  checkButtonState(buttonState,TrafficLightState);
}

void checkButtonState(boolean btnState, int trafficState){
  if(btnState == true && trafficState == 0){
    TrafficLightState = 1;
    turnonofflights(TrafficLightState);
    delay(500);
  }
  else 
    if(btnState == true && trafficState == 1){
      TrafficLightState = 0;
      turnonofflights(TrafficLightState);
      delay(500);
  }
}

void turnonofflights(int trafficState){
  if(trafficState == 0){
    digitalWrite(redLED,HIGH);
    digitalWrite(greenLED,LOW);
  }
  else if(trafficState == 1){
    digitalWrite(redLED,LOW);  
    digitalWrite(greenLED,HIGH);
  }
}

Wir werden die Schaltung ein wenig verändern, da nicht alle Pins zum Dimmen von LEDs geeignet sind. Ändern Sie Pin Nummer zwei (rote LED) auf neun und drei (grüne LED) auf zehn.
Bitte öffnen Sie einen neuen Sketch, denn wir werden die Ampelfunktionen in diesem Tutorial nicht weiter verwenden. Am Ende des Tutorials finden Sie aber einige Übungen, in denen Sie die Ampelschaltung um den Dimmer beim Wechsel von Rot auf Grün erweitern. Der Schaltplan bleibt derselbe.
Zum Glück ist es nicht sehr schwierig, eine LED zu dimmen. Wir müssen nur zwei Dinge lernen. Erstens, dass nur die digitalen Pins unseres Arduinos mit diesem Tilde-Symbol (~) in der Lage sind, verschiedene Spannungen auszugeben. Zweitens, dass wir jetzt die Funktion analogWrite() verwenden müssen, weil die Funktion digitalWrite() nur HIGH- oder LOW-Signale senden kann.
Der analogWrite()-Befehl ist ähnlich wie der digitalWrite()-Befehl. Zuerst geben Sie den Pin an und dann den Wert der Spannung (im Bereich 0-255, aber nur ganzzahlige Werte). Sie können auch HIGH (=255) oder LOW (=0) verwenden. Wenn Sie zum Beispiel die rote LED um 50% dimmen wollen, schreiben Sie: analogWrite(redLED, 127).
Im folgenden Code dimmen wir die rote LED in Endlosschleifen von 100% in 25%-Schritten herunter.

int redLED = 9;

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

void loop() {
  analogWrite(redLED,HIGH); //100% - OR analogWrite(redLED,255);
  delay(500);
  analogWrite(redLED, 192); //75%
  delay(500);
  analogWrite(redLED, 127); //50%
  delay(500);  
  analogWrite(redLED, 64);  //25%
  delay(500);
}

Nach ein paar Beispielen kommt nun der letzte Teil der Theorie in diesem Tutorial: Schleifen. Schleifen-Algorithmen werden benötigt, um definierte Algorithmen mit immer anderen Werten erneut auszuführen. Zum Beispiel, um eine Liste Punkt für Punkt auf einen bestimmten Wert zu überprüfen. Es gibt zum einen die for-Schleife und zum anderen die while-Schleife. Die for-Schleife erhöht eine Variable um einen bestimmten Wert und führt dann den in ihr beinhalteten Code aus. Die while-Schleife hingegen wiederholt solange den in ihr beinhalteten Code, bis die definierte Abbruchbedingung eintritt.

Die Struktur der for-Schleife:
for (Initialisierung der Variablen und setzen erste Grenze; Laufzeitbedingung (solange die Bedingung erfüllt ist, wird die for-Schleife ausgeführt); Erhöhungsschritte) {
//Anweisung(en);
}

Beispiel zur kontinuierlichen Erhöhung der LED-Helligkeit:

for(int i = 0; i <= 255; i++){
	analogWrite(redLED, i);
}

In diesem Beispiel erhöhen wir die Steuervariable i immer um einen (i++ ist die Abkürzung für i = i + 1) und setzen die Variable als den roten LED-Strom (Helligkeit).
Sie können also einen Wert erhöhen oder verringern und jeden Wert durch den Algorithmus jagen. Sie können auch andere Funktionen aus der for-Schleife heraus starten. Es gibt viele Möglichkeiten, diese for-Schleife zu verwenden.

Die while-Schleife hat folgenden Aufbau:
while(Abbruchbedingung){
//Anweisung(en)
}

Als Beispiel wird solange eine zufällige Zahl zwischen 0 und 9 erzeugt, bis diese den Wert 2 hat, dann bricht die while-Schleife ab.

int number;
while (number != 2){
	number = random(10);
}

(!= bedeutet ungleich)

Man kann eine while-Schleife auch wie eine for-Schleife aufbauen, dann muss auch hier eine Variable die erhöht wird eingeführt werden und die Abbruchbedingung lautet wie die Laufzeitbedingung der for-Schleife. Die for-Schleife aus dem vorherigen Beispiel sieht dann wie folgt aus:

int i;
while (i<=255){
  analogWrite(redLED,i);
  i++;
}

Allerdings empfiehlt sich für das kontinuierliche Heraufsetzen eines Wertes immer die for-Schleife. Bei der while-Schleife gibt es zu dem noch zu beachten, dass die Abbruchbedingung erfüllbar sein muss, da das Programm sonst in dieser steckenbleibt!

Lauflicht - for-Schleife

Wir wollen nun die for-Schleife praktisch anwenden. Dazu werden wir ein Lauflicht, welches seine Helligkeit verändert, programmieren. Dazu Erweitern wir unseren Schaltplan um eine blaue LED, damit das Lauflicht etwas mehr Farbe bekommt. Versuchen Sie sich ruhig einmal selbst an dem Programmieren eines solchen Lauflichts bevor sie folgenden Code einfach kopieren. Sie bekommen das hin!

 

int redLED = 9;
int greenLED = 10;
int blueLED = 11;

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

void loop(){
	for(int i = 0; i <= 255; i++){
		analogWrite(redLED, i);		//SCHALTET DIE ROTE LED EIN
		delay(100);					//WARTEN FÜR 100 ms
		analogWrite(redLED, 0);     //SCHALTET DIE ROTE LED AUS                    
		analogWrite(greenLED,i);	//GLEICHES FÜR DIE GRÜNE LED
		delay(100);
		analogWrite(greenLED, 0);                           
		analogWrite(blueLED, i);	//GLEICHES FÜR DIE BLAUE LED
		delay(100);
		analogWrite(blueLED, 0);                           
	}                       
}

Als Übung können Sie die vorherigen Sketches erweitern oder den Aufbau mit den LEDs für neue Aufgaben benutzen:

• Die Ampel dimmt die LED hoch und runter, wenn die Ampel schaltet
• Der Chaser geht auf Knopfdruck für 10 Sekunden an
• Programmieren Sie das Blaulicht eines Polizeiautos