Arduino Grundlagen Teil 4: Eine LED blinken lassen!

Eine LED blinken lassen Arduino Grundlagen Teil 5

Wie fangen wir jetzt mit einem Arduino an? Was müssen wir dabei beachten? Können wir einfach so eine LED blinken lassen?

Normalerweise ist das erste Programm immer ein „Hello World“ Programm. Damit ist gemeint, dass das Programm in einem Fenster (oder irgendwo anders) den Text „Hello World“ ausgibt. Bei einem Arduino macht man das aber eher nicht. Warum? Ganz einfach, ein Arduino hat nicht direkt ein Display, worüber man den Text ausgeben kann. Eine andere Möglichkeit wäre die Ausgabe über ein Terminal (auch Konsole genannt). Hierfür bräuchten wir eine serielle Schnittstelle, die etwas umfangreicher ausfallen kann und nicht unbedingt für den allerersten Schritt geeignet ist. Aber keine Sorge, auch um ein Display und die serielle Schnittstelle kümmern wir uns noch.

Dein erstes Programm: eine LED blinken lassen

Das erste Programm bei einem Arduino ist eine LED blinken zu lassen. Können wir also „einfach“ eine LED anschließen? Nein, leider nicht. Warum man das nicht machen sollte schauen wir uns gleich noch an. Es gibt aber zum Glück eine einfachere Möglichkeit, mit der wir jetzt beginnen wollen.

Auf Arduinos gibt es eine LED am Pin 13, die fest auf dem Board verlötet ist. Der Pin 13 ist ein digitaler Ausgang. Dieser Ausgang kann mit einem High-Signal (auch 1 genannt) oder einem Low-Signal (auch als 0 bezeichnet) beschrieben/angesteuert werden.

Bei High leuchtet die LED, bei Low ist sie aus.

So viel zur Theorie. Jetzt brauchen wir also ein Programm, welches die LED an- und ausschaltet.
Das kleine Programm sieht wie folgt aus:

// Das Setup
void setup() {
  pinMode(13, OUTPUT);       // Den digitalen Pin 13 (D13) als Ausgang deklarieren.
}

// Die Haupt-Schleife (Main-Loop)
void loop() {
  digitalWrite(13, HIGH);    // Den Ausgang D13 HIGH setzen.
  delay(1000);               // 1 Sekunde warten.
  digitalWrite(13, LOW);     // Den Ausgang D13 LOW setzen.
  delay(1000);               // 1 Sekunde warten.
}

Listing 1: Das erste Programm

Du kannst das Programm einfach kopieren und in der Arduino IDE einfügen. Über den Upload-Button kann das Programm auf den Arduino gespielt werden. Das dauert einen kleinen Moment, aber nach erfolgreichem Upload sollte die LED im Sekundentakt blinken.

Da wir ja nicht nur anwenden sondern auch verstehen wollen was da genau passiert, nehmen wir das kleine Programm nun auseinander.

Grundlegender Aufbau eines Arduino Programms

Ein Arduino Programm besteht mindestens aus zwei Teilen. Dem Setup und der Loop (Schleife). Der erste Teil ist immer das Setup, welches einmalig beim Starten/Anschalten des Arduinos aufgerufen wird.

// Das Setup
void setup() {
  pinMode(13, OUTPUT);       // Den digitalen Pin 13 (D13) als Ausgang deklarieren.
}

Listing 2: Das Setup

Das Setup beginnt mit der Zeile:

void setup(){

Das Setup

setup() ist eine fest vorgegebene Funktion bei der Arduino-Programmierung. Dass es eine Funktion ist, erkennt man an den beiden Klammern (). Gleich werden wir einer Funktion noch Werte beim Aufruf übergeben. Diese Übergabe erfolgt innerhalb der beiden Klammern.

void steht bei einer Funktion dafür, dass diese Funktion keine Werte zurückgibt. Was damit gemeint ist, behandeln wir an späterer Stelle ebenfalls genauer.

Die Setup-Funktion reicht von der geöffneten geschweiften Klammer { bis zur geschlossenen geschweiften Klammer } in Zeile 4. Im Setup können das erste Mal im Ablauf eines Arduino Programms Dinge berechnet bzw. ausgeführt werden. Vor dem Aufruf vom Setup können zwar ebenfalls einige Sachen gemacht werden, z.B. Deklaration von Variablen, aber direkt irgendetwas berechnen/ausführen oder einen Ausgang schalten funktioniert erst im Setup.

Danach kommt unsere erste richtige Befehls-Zeile:

pinMode(13, OUTPUT);         // Den digitalen Pin 13 (D13) als Ausgang deklarieren.

Mittels pinMode(13,OUTPUT); legen wir fest, dass der digitale Ausgang 13 (zukünftig kürzen wir bei digitalen Ausgängen die Schreibweise einfach mit D13, D10 usw. ab) ein Ausgang sein soll. Der Pin D13 wird also als Ausgang initialisiert. Auch hier haben wir wieder zwei Klammern (). Wie wir bereits gelernt haben, muss es sich bei pinMode() also um eine Funktion handeln.

Funktionen beim Aufruf Werte übergeben

Ich weiß nicht, ob es Dir aufgefallen ist, aber wir haben jetzt einer Funktion beim Aufruf zwei „Werte“ übergeben. Der erste Wert war der Pin D13 und der zweite Wert OUTPUT, also dass D13 ein Ausgang sein soll. Die Werte-Übergabe ist also auch recht einfach.

Am Ende einer jeden Befehlszeile steht dann noch ein Semikolon ; und schon ist unsere erste Befehlszeile geschafft.

Kommentare einfügen

Hinter dem Semikolon sind zwei //. Sie werden benötigt, wenn man einen Kommentar in den Quelltext schreiben möchte. Kommentare sind für das eigentliche Programm komplett egal, sie dienen lediglich uns, damit wir später noch wissen, was wir an welcher Stelle gemacht haben. Gleichzeitig sind sie auch anderen Leuten hilfreich, die sich unseren Code anschauen wollen. Wie heißt es so schön: „Die beste Dokumentation ist ein gut kommentierter Quelltext!“

Gewöhn Dir möglichst früh an, Deine Quellcodes/Programme zu kommentieren. Wenn Du später eigene (erst Recht) größere Programme schreibst, weißt Du nach einem halben Jahr nicht mehr, was welche Funktion oder Zeile genau macht bzw. wofür sie da ist. Bisher ging es zumindest allen Leuten so, die ich kenne, mich eingeschlossen.

Die Main-Loop

Der zweite Teil eines Arduino Programms ist die Loop – auch Main-Loop, Main Funktion, Hauptschleife genannt. Da wir später noch mit anderen Schleifen arbeiten, einigen wir uns hier am besten auf die Bezeichnung Main-Loop.

// Die Main-Loop (Haupt-Schleife)
void loop() {
  digitalWrite(13, HIGH);    // Den Ausgang D13 HIGH setzen.
  delay(1000);               // 1 Sekunde warten.
  digitalWrite(13, LOW);     // Den Ausgang D13 LOW setzen.
  delay(1000);               // 1 Sekunde warten.
}

Listing 3: Die Main-Loop

Dieser Teil des Arduino-Programms wird immer wieder von neuem aufgerufen. Das heißt die Schleife läuft so lange durch, bis der Arduino ausgeschaltet oder „absichtlich“ gestoppt wird. Die Main-Loop ist ebenfalls eine Funktion. Sie reicht von der öffnenden geschweiften Klammer { bis zur schließenden geschweiften Klammer }.

Was passiert in unserem Beispiel in der Main-Loop?

Die erste Zeile lautet:

digitalWrite(13, HIGH); // Den Ausgang D13 HIGH setzen.

Wir sehen hier direkt wieder zwei Klammern (). Was sagt uns das? Stimmt genau, digitalWrite() muss auch wieder eine Funktion sein. Jetzt haben wir schon die vierte Funktion kennen gelernt! Auch dieser Funktion übergeben wir zwei Werte. 13 ist der Pin D13 von eben, dem wir gesagt haben, dass er ein Ausgang sein soll. HIGH setzt den Ausgang auf das High-Signal und schaltet ihn damit an. Wie dieses Signal aussieht, bzw. was es genau ist, schauen wir uns in einem anderen Teil an.

Jetzt kommt unsere fünfte Funktion:

delay(1000);            // 1 Sekunde warten.

delay() steht für eine Verzögerung. Wir können damit den weiteren Ablauf des Programms verzögern bzw. unterbrechen. In dieser Zeit wird also nichts gemacht. Es wird einfach gewartet, bis die Zeit abgelaufen ist. Okay, um korrekt zu sein zählt der µC die Zeit weiter und vergleicht sie mit dem Wert den wir angegeben haben. Aber unser selbst geschriebenes Programm macht in dieser Zeit nichts. Die Zeit wird in Millisekunden (ms) angegeben.Durch delay(1000) wartet unser Programm also 1 Sekunde und macht dann mit der Zeile

digitalWrite(13, LOW);  // Den Ausgang D13 LOW setzen.

weiter. Der einzige Unterschied zum vorangegangenen digitalWrite() ist hier das LOW. Die Übergabe des Wertes LOW an die digitalWrite()-Funktion schaltet unseren Ausgang D13 also wieder aus. Die LED würde als aufhören zu leuchten. Danach warten wir durch erneuten Aufruf von

delay(1000);            // 1 Sekunde warten.

wieder 1 Sekunde und schon ist unser Programm quasi fertig. Es muss nur noch die Main-Loop durch die schließende geschweifte Klammer } beendet werden.

Was macht jetzt unser Programm in Kurzfassung?

Wir haben also ein Programm erstellt, welches in der Setup-Funktion dem Pin D13 sagt, dass er ein Ausgang sein soll. Danach schalten wir in der Main-Loop den Ausgang D13 an, warten 1 Sekunde, schalten den Ausgang D13 aus und warten wieder 1 Sekunde. Da am Ausgang D13, wie bereits gesagt, eine LED angeschlossen ist, wird diese LED folglich im Sekundentakt an und ausgeschaltet werden. Wir haben also einen kleinen Blinker programmiert.

Der Sketch bzw. das Programm muss nur noch, wie hier >> Ein Programm auf einen Arduino laden kurz erläutert, auf den Arduino gespielt werden.

Was haben wir gelernt?

  • Den grundlegenden Aufbau eines Arduino-Programms
  • Das Setup und den Main-Loop
  • Was Funktionen sind
  • Wie Funktionen beim Aufruf Werte übergeben werden
  • Was Kommentare sind
  • Wie ein Programm kompiliert wird

Arduino Grundlagen Kurs im Überblick:

>> Teil 1: Der Arduino im Detail
>> Teil 2: Die Bauteile des Arduino
>>Teil 3: Ein Programm auf einen Arduino laden
>> Teil 4: Eine LED blinken lassen!
>> Teil 5: Eine externe LED blinken lassen
>> Teil 6: Die LED Schaltung im Detail
>> Teil 7: Mehrere LEDs ansteuern & blinken lassen
>> Teil 8: Eine LED dimmen
>> Teil 9: Mehrere LEDs dimmen
>> Teil 10: Taster an Arduino anschließen
>> Teil 11: Serielle Schnittstelle
>> Teil 12: Softwareserial Library

Kommentar hinterlassen zu "Arduino Grundlagen Teil 4: Eine LED blinken lassen!"

Hinterlasse einen Kommentar

E-Mail Adresse wird nicht veröffentlicht.


*


*