Die for-Schleife in Arduino-Projekten

Die for-Schleife ist ein grundlegender Bestandteil nahezu jeder Hochsprache, einschließlich C++ und damit auch der Arduino-Sprache. Die Idee einer Schleife, die eine bestimmte Anzahl von Durchläufen durchführt, lässt sich bis in die frühesten Tage des digitalen Computings zurückverfolgen. Mit der for-Schleife kann ein Block von Anweisungen mehrfach ausgeführt werden - eine Funktion, die sich als unerlässlich in der Programmierung erwiesen hat.

Eine interessante Anekdote zur for-Schleife ist, dass sie dazu beigetragen hat, das erste Videospiel zu schaffen! Steve Russell, ein Programmierer am MIT, verwendete Schleifenkonstrukte, um das Spiel "Spacewar!" auf einem PDP-1 Computer im Jahr 1962 zu erstellen. Während die genauen Details seines Codes verloren gegangen sind, ist es wahrscheinlich, dass eine Struktur ähnlich der for-Schleife dazu beigetragen hat, die Bewegung der Raumschiffe und die Animation der Sterne zu steuern. Die for-Schleife bleibt auch heute noch ein grundlegender Baustein in der Programmierung und ist ein unerlässliches Werkzeug für jeden, der mit Arduino arbeitet.

Der PDP-1 (Programmed Data Processor-1) war ein Computer, der von der Firma Digital Equipment Corporation (DEC) in den späten 1950er und frühen 1960er Jahren entwickelt und hergestellt wurde. Er gilt als einer der ersten erfolgreichen Minicomputer und wurde zu einer wegweisenden Plattform für die Computerentwicklung.

Der PDP-1 wurde mit Transistoren und Dioden aufgebaut und verwendete eine Wortlänge von 18 Bit. Er verfügte über eine Taktfrequenz von 100 kHz und konnte bis zu 4096 Worte Speicher adressieren. Die PDP-1 war für ihre Zeit bemerkenswert leistungsfähig und bot eine Reihe von innovativen Funktionen, darunter ein interaktives Benutzerterminal, ein Grafikdisplay und ein Magnetbandspeicher. Der PDP-1 wurde in verschiedenen Bereichen eingesetzt, von wissenschaftlicher Forschung und technischer Simulation bis hin zur Entwicklung von Computerspielen.

Der Sketch

Lass uns die Theorie direkt in die Praxis umsetzen, indem wir die Funktion der for-Schleife anhand der seriellen Schnittstelle veranschaulichen. In diesem Kapitel wird erklärt, wie du einen Arduino-Code erstellst, der die Zahlen von 1 bis 10 über den seriellen Monitor ausgibt. Schließe dazu dein Arduino Uno den Computer an und tippe folgenden Code in der Arduino IDE ein. Wähle das korrekte Board (Arduino Uno) und den Port (USB) unter "Werkzeuge" -> "Board" und "Werkzeuge" -> "Port". Klicke dann auf den Pfeil in der oberen linken Ecke der IDE, um den Code auf das Board zu laden. Im seriellen Monitor solltest du die Zahlen von 1 bis 10 sehen, die jede Sekunde ausgegeben werden.

Struktur der for-Schleife

In Arduino besteht die Struktur einer for-Schleife aus drei Teilen:
1. Initialisierung: Dieser Teil wird zu Beginn der Schleife ausgeführt. Hier wird normalerweise eine Laufvariable initialisiert.

2. Bedingung: Dieser Ausdruck wird vor jeder Iteration ausgewertet. Wenn der Ausdruck wahr ist, wird der Schleifenkörper ausgeführt. Wenn er falsch ist, endet die Schleife.

3. Inkrement: Dieser Ausdruck wird nach jeder Iteration ausgeführt.

Um die for-Schleife zu begreifen, stellen wir uns vor, wir sind Teil eines Autorennens, dessen Ablauf erstaunliche Parallelen zur for-Schleife aufweist:

1. Start (Initialisierung): Wie Rennfahrer, die ihre Positionen an der Startlinie einnehmen, startet die Zählvariable in der for-Schleife bei einem Anfangswert. Dies symbolisiert den Startschuss des Rennens.

2. Renndistanz (Bedingung): Das Rennen hat eine festgelegte Anzahl von Runden - das ist unsere Bedingung. Die Fahrer fahren solange, bis alle Runden absolviert sind, ähnlich wie die for-Schleife, die solange läuft, bis die Bedingung nicht mehr erfüllt ist.

3. Runden (Iteration): Nach jeder Runde fahren die Fahrer weiter, bis alle Runden absolviert sind. Ähnlich verhält es sich mit der Iteration in der for-Schleife, wo die Zählvariable nach jedem Durchlauf angepasst wird.

4. Boxenstopps (Schleifenkörper): Während jedes Durchlaufs könnte es notwendig sein, bestimmte Aktionen auszuführen, wie Reifenwechsel oder Tanken. Dies entspricht den Befehlen oder Funktionen, die innerhalb der for-Schleife ausgeführt werden.

5. Zieleinlauf (Schleifenende): Sobald alle Runden absolviert sind, endet das Rennen. Dies entspricht dem Ende der for-Schleife, wenn die Bedingung nicht mehr erfüllt ist.

Mit dieser Analogie lässt sich die Funktion der for-Schleife besser visualisieren - sie ist wie ein Autorennen, das eine bestimmte Anzahl von Runden durchläuft, bevor es endet.

Die for-Schleife wird in der Regel dann verwendet, wenn von vornherein bekannt ist, wie oft die Schleife durchlaufen werden soll. In der Regel besitzen for-Schleifen einen Schleifenzähler. Dies ist eine Variable, zu der bei jedem Durchgang ein Wert addiert oder subtrahiert wird (oder die durch andere Rechenoperationen verändert wird). Der Schleifenzähler wird über den ersten Ausdruck initialisiert. Mit dem zweiten Ausdruck wird überprüft, ob die Schleife fortgesetzt oder abgebrochen werden soll. Letzterer Fall tritt ein, wenn dieser den Wert 0 annimmt – also der Ausdruck false (falsch) ist. Der letzte Ausdruck dient schließlich dazu, den Schleifenzähler zu verändern (z.B. hochzählen/mit zählen).

Aufbau und Verkabelung

Der folgende Arduino-Code demonstriert eine einfache Methode, um eine LED zu steuern und sie fünf Mal blinken zu lassen, bevor das Programm für zwei Sekunden pausiert und dann den Vorgang wiederholt. Es handelt sich hierbei um ein grundlegendes Beispiel für die Verwendung von For-Schleifen in Verbindung mit der Elektronik.

Schalte zunächst dein Arduino aus. Verbinde den GND-Pin deines LED-Moduls mit einem GND-Pin des Arduino. Dann verbinde den VCC-Pin des LED-Moduls mit einem 5V-Pin des Arduino. Schließlich verbinde den Signal-Pin des LED-Moduls mit dem Pin auf deinem Arduino, der im Code als LED_PIN definiert ist. Danach kannst du dein Arduino wieder einschalten und den Code laufen lassen. 

#define LED_PIN 13

void setup()
{
  pinMode(LED_PIN, OUTPUT);
}
  
void loop()
{
  for(int i = 0; i < 5; i++) 
  {
    digitalWrite(LED_PIN, HIGH);
    delay(300);
    digitalWrite(LED_PIN, LOW);
    delay(300);
  }
  delay(2000); // Warte zwei Sekunden vor dem nächsten Durchlauf
}
void setup()
{
  Serial.begin(9600);
}
  
void loop()
{
  for(inti = 0; i <= 10; i++) 
  {
    Serial.println(i);
  }
  delay(1000); //Warte 1 Sekunde vor dem nächsten Durchlauf
}

In der Setup-Funktion initialisiert Serial.begin(9600) die serielle Kommunikation zwischen dem Arduino und dem Computer. Die Baudrate von 9600 bestimmt die Übertragungsgeschwindigkeit der Daten. In der Loop-Funktion führt eine for-Schleife den Befehl Serial.println(i) zehn Mal aus, wobei i bei jedem Durchgang um eins erhöht wird, beginnend bei 0. Dies führt dazu, dass die Zahlen von 0 bis 10 nacheinander auf dem seriellen Monitor ausgegeben werden. Nach jedem Durchlauf der for-Schleife wartet das Programm eine Sekunde (delay(1000)) bevor es den nächsten Durchlauf beginnt. Dieser Vorgang wiederholt sich unendlich, solange der Arduino mit Strom versorgt wird.

Insgesamt bietet dieser Code ein gutes Beispiel dafür, wie for-Schleifen verwendet werden können, um wiederholende Aufgaben effizient zu kodieren und dabei den Code übersichtlich und gut lesbar zu halten.

Dieser Arduino-Code lässt eine LED, die an Pin 13 angeschlossen ist, fünf Mal blinken und pausiert dann für zwei Sekunden vor dem nächsten Durchlauf. Am Anfang des Codes wird mit #define LED_PIN 13 der Pin, an den die LED angeschlossen ist, definiert. Die setup() Funktion setzt den LED-Pin als Ausgangspin mittels pinMode(LED_PIN, OUTPUT). In der loop() Funktion wird dann eine for-Schleife eingesetzt, um das Blinken der LED zu steuern. Die LED wird eingeschaltet (digitalWrite(LED_PIN, HIGH)), dann wartet das Programm für 300 Millisekunden, die LED wird ausgeschaltet (digitalWrite(LED_PIN, LOW)), und das Programm wartet erneut für 300 Millisekunden. Dieser Zyklus wird fünf Mal wiederholt, wie in der Bedingung der for-Schleife angegeben. Nachdem die LED fünf Mal geblinkt hat, pausiert das Programm für zwei Sekunden (delay(2000)) bevor der nächste Durchlauf beginnt. Dieser Vorgang wiederholt sich unendlich, solange der Arduino mit Strom versorgt wird.

Eine LED dimmen

Lass uns abschließend eine LED hoch und runter dimmen, um die Funktionalität der for-Schleife zu demonstrieren. Der folgende Arduino-Code steuert die Helligkeit einer LED, die an Pin 9 (ein PWM-fähiger Pin) angeschlossen ist. Dadurch wird ein Atmungseffekt erzeugt, bei dem die LED langsam aufleuchtet und dann allmählich wieder abdunkelt.

const int ledPin = 9; //Pin, an dem die LED angeschlossen ist
int brightness = 0; //Variable zur Steuerung der Helligkeit

void setup() 
{
  pinMode(ledPin, OUTPUT); //Pin als Ausgang festlegen
}

void loop() 
{
  //Erhöhe die Helligkeit von 0 bis 255
  for (brightness = 0; brightness <= 255; brightness++) 
  {
    analogWrite(ledPin, brightness); // Helligkeit an den Pin senden
    delay(10); // Eine kurze Verzögerung, um den Effekt sichtbar zu machen
  }
  
  // Verringere die Helligkeit von 255 bis 0
  for (brightness = 255; brightness >= 0; brightness--) 
  {
    analogWrite(ledPin, brightness); //Helligkeit an den Pin senden
    delay(10); //Eine kurze Verzögerung, um den Effekt sichtbar zu machen
  }
}

In diesem Arduino-Code wird die Helligkeit einer LED, die an Pin 9 angeschlossen ist, gesteuert, um einen Atmungseffekt zu erzeugen. Wir werden nun die einzelnen Teile dieses Codes erläutern.

Zunächst deklarieren wir mit const int ledPin = 9; eine Konstante namens ledPin und weisen ihr den Wert 9 zu. Dies repräsentiert den physischen Pin am Arduino-Board, an dem die LED angeschlossen ist. Im folgenden Schritt wird mit pinMode(ledPin, OUTPUT); innerhalb der setup()-Funktion ledPin als Ausgangspin definiert. Das bedeutet, dass wir an diesem Pin eine Spannung anlegen werden, um die LED zu steuern. Die setup()-Funktion wird einmal beim Start ausgeführt.

Der Hauptteil des Codes beginnt mit der for-Schleife for (int brightness = 0; brightness <= 255; brightness++). Hierbei wird eine Variable namens brightness von 0 bis 255 erhöht. Die Zahl 255 repräsentiert die maximale Helligkeit für die Funktion analogWrite(), die wir gleich verwenden werden.

In der folgenden Codezeile analogWrite(ledPin, brightness); wird die Helligkeit der LED auf den aktuellen Wert von brightness gesetzt. Dadurch, dass brightness langsam von 0 auf 255 erhöht wird, wird die LED langsam heller.

Um den Übergang für das menschliche Auge sichtbar zu machen, wird mit delay(5); das Programm für 5 Millisekunden pausiert. Dies verlangsamt das Aufhellen der LED.

Abschließend haben wir eine zweite for-Schleife, die genauso wie die erste funktioniert, jedoch in umgekehrter Reihenfolge. Sie startet brightness bei 255 und verringert den Wert bis 0, was dazu führt, dass die LED langsam abdunkelt.

Zusammengefasst erzeugt dieser Code einen Atmungseffekt bei der LED, indem er die Helligkeit langsam von 0 auf 255 erhöht und dann wieder auf 0 verringert. Dieser Vorgang wiederholt sich in einer Endlosschleife, solange der Arduino mit Strom versorgt wird.

Die for-Schleife kann in Situationen, in denen die Anzahl der Durchläufe im Voraus nicht bekannt ist, weniger geeignet sein. In solchen Fällen sind while- oder do-while-Schleifen oft eine bessere Wahl.

Die for-Schleife wird in Arduino-Projekten auf vielfältige Weise eingesetzt, von der Steuerung von LEDs und Motoren über die Verarbeitung von Sensorinformationen bis hin zur Kommunikation über Netzwerke.

Achtung!

Ist die Bedingung ungünstig formuliert, besteht die Gefahr, dass die Schleife unaufhaltsam weiterläuft. Es wird dann von der Endlosschleife gesprochen. Eine Endlosschleife ist eine Schleife, die niemals endet und somit unendlich läuft. Dies kann passieren, wenn die Bedingung für das Beenden der Schleife nie erfüllt wird. Ein Beispiel für eine Endlosschleife in der Programmierung könnte sein: 

void setup() 
{
  // Kein Setup benötigt
}

void loop() {
  // Diese for-Schleife wird unendlich oft ausgeführt
  for (int i = 0; i >= 0; i++) {
    // Hier könnten Befehle stehen, die immer wieder ausgeführt werden
  }
}

In diesem Code wird die Variable i auf 0 gesetzt und danach immer um 1 erhöht. Die Bedingung für die Schleife ist, dass i größer oder gleich 0 ist. Da i immer erhöht wird und nie kleiner als 0 wird, ist die Bedingung immer wahr, und die Schleife läuft unendlich oft. Es ist wichtig zu beachten, dass dies zu unerwarteten Ergebnissen führen kann, da i schließlich so groß wird, dass es den maximalen Wert für eine int-Variable überschreitet und zu einem Überlauf führt, wodurch i zu einem negativen Wert wird.

Eine Endlosschleife kann zu verschiedenen Problemen führen, wie einer übermäßigen Prozessor-Auslastung, einer übermäßigen Speichernutzung oder im schlimmsten Fall zum Einfrieren oder Absturz des Systems.

Es ist daher sehr wichtig, beim Schreiben von Schleifen vorsichtig zu sein und sicherzustellen, dass die Bedingungen für den Austritt aus der Schleife korrekt formuliert sind und unter den gegebenen Umständen erreicht werden können.