# Z-Lab Arduino-Grundkurs Projekt 2: Blinken

In diesem Projekt lassen wir eine LED blinken.

Das gute an diesem Beispiel ist, dass wir hierfür auch wieder nichts brauchen außer den Arduino, einen Computer, das passende Kabel und die Arduino-IDE, die wir ja ohnehin schon installiert haben.

Denn die meisten Arduinos haben eine eingebaute LED, die man programmieren kann.

Zuerst öffnen wir das Projekt 02_Blinken über "Datei" -> "Sketchbook" -> "Z-Lab" -> "Arduino_Grundlagen" -> 02_Blinken:  
![Projekt öffnen](oeffnen.png)

In der Datei 02_Blinken.ino finden wir folgenden Quellcode:

```c
void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}
```

## pinMode

Schauen wir uns das mal genauer an:

```c
void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}
```

Im letzten Projekt haben wir gelernt, dass die setup-Funktion nur einmal ausgeführt wird, wenn der Arduino gestartet wird.  
In dieser setup-Funktion befindet sich nur ein Befehl. Dieser lautet "pinMode".

Die pinMode-Funktion wird nicht wie die setup-Funktion einfach mit Klammern geschrieben sondern in den Klammern stehen noch weitere Zeichen. Diese nennen sich Parameter, Argumente oder Optionen. Gemeint ist damit das gleiche.
Nehmen wir noch mal das Beispiel mit der Wasserflasche im Kühlschrank aus dem letzten Projekt.
Wenn ihr manchmal nicht nur die Wasserflasche aus dem Kühlschrank braucht sondern vielleicht auch mal eine Karotte oder irgendwas anderes dann wäre es doch praktisch, ihr müsstet nicht für alles, was sich im Kühlschrank befindet eine neue Funktion schreiben.  
So wie ihr eure Eltern fragt, ob sie euch die Wasserflasche geben können könnt ihr sie ja auch fragen, ob sie euch eine Karotte geben können.
Wir könnten also sagen, wir machen eine Funktion, die heißt:
```c
void kannstDuMirAusDemKuehlschrankGeben(was)".
```
Dann wäre die Funktion universell einsetzbar und du könntest bei "was" das übergeben, was du gerne aus gem Kühlschrank hättest. Genau das ist ein Parameter.
Eine Funktion kann auch mehrere Parameter haben, das ist bei pinMode der Fall. Wenn du über die Funktion fährst siehst du, was für zwei Parameter erwartet werden:  
![Parameter von pinMode](image-1.png)

Der erste Parameter ist der PIN, den wir konfigurieren wollen, das zweite ist der sog. Modus. Also ob der PIN für eine Eingabe oder eine Ausgabe verwendet werden soll.

Ein PIN ist ein Anschluss am Arduino. Wenn du auf den Arduino schaust dann hat dieser ganz viele Ein- und Ausgänge. Bei manchen steht Analog und bei manchen Digital.  
* Digitale PINs können als Ausgang und als Eingang verwendet werden. Hier können z.B. Sensoren angeschlossen werde, die digitale Signale übertragen, also Temperatursensoren. Oder LEDs, die ein- und ausgeschaltet werden
* Analoge PINs können nur als Eingang verwendet werden. Hier kann z.B. eine Spannung von einem analogen Helligkeitssensor abgelesen werden.

Dann haben wir hier noch etwas neues, das nennt sich "Makro".
Ein Makro ist wie ein Platzhalter, der aber nicht mehr veränderbar ist.
Ein Makro wird einmal definiert und dann bleibt es wie es ist, anders als Variablen (kommen wir in einem späteren Projekt dazu), die später noch veränderbar sind.

Ein Makro, das wir hier haben hat den Namen "LED_BUILTIN".
Dahinter steht eine Zahl, und zwar die PIN, an der die im Arduino eingebaute LED angebracht ist.
Im Falle vom Arduino Uno ist das die 13, das kann aber je nach Arduino abweichen, deshalb gibt es das Makro "LED_BUILDIN" (das heißt so viel wie eingebaute LED). So musst du als Programmierer nicht wissen, wo bei jedem Arduino die eingebaute LED ist. DAs macht dein Programm portabel, weil es so auf mehreren Arduinos läuft ohne angepasst werden zu müssen.  
Der Wert im Makro wird vom Hersteller des Arduinos gepflegt und über die Auswahl des richtigen Arduinos "weiß" die Arduino-IDE, welches Marko sie nehmen soll.

Du kannst auch ganz einfach prüfen, welche Werte in einem Makro hinterlegt sind, indem du über das Makro fährst:   
![Wert Makro LED_BUILTIN](image-2.png)  
LED_BUILTIN ist mit "13" belegt". Auf PIN 13 befindet sich also die eingebaute LED

![Wert Marko OUTPUT](image-3.png)  
(0x1 ist hexadezimal für 1)

**Und was macht die pinMode jetzt genau?**  
Die Funktion pinMode sagt dem Arduino, ob du einen der digitalen Anschlüsse als Eingang oder Ausgang verwenden willst und welchen.  
Also hängt an PIN 13 jetzt ein Sensor, den du auslesen willst (also als Eingang) oder ein Gerät, mit dem du sprechen willst (eine Signalübertragung) oder eine LED, die nur Strom braucht?  
Mit pinMode(13,1) sagen wir dem Arduino, dass der PIN 13 als Ausgang verwendet werden soll. Wir können den also danach anschalten und damit geht dann auch die LED an.
Die beiden Markos LED_BUILTIN und OUTPUT machen es uns leichter, weil wir uns nicht die Zahlen merken müssen, auf welchem PIN die interne LED angebracht ist und auch nicht, welcher Wert für Output steht.

## digitalWrite

Das nächste, das wir uns anschauen ist:
```c
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  digitalWrite(LED_BUILTIN, LOW);
}
```

Hier haben wir die Funktion digitalWrite(), übersetzt heißt das "Schreibe digital" diese erwartet zwei Parameter:
* Den PIN, auf den "geschrieben" werden soll
* Der Wert, der "geschrieben" werden soll

So sieht das aus, wenn du mit der Maus über die Funktion fährst:  
![digitalWirite Parameter](image-4.png)

Hier steht "HIGH" (wieder ein Makro) für "An" in Form einer 1 und "LOW" für "Aus" in Form einer 0:  
![Marko Wert HIGH](image-5.png)  
*Marko-Wert von HIGH*

![Marko Wert LOW](image-6.png)  
*Marko-Wert von LOW*

Dann gibt es noch eine weitere Funktion in unserem Projekt:

```c
void loop() {
  delay(1000);
}
```

"Delay" ist auch wieder englisch und heißt "verzögere".  
Mit delay lässt sich der nächste Befehl verzögern. Das Programm wartet also, bis die angegebene Zeit abgelaufen ist.
Die Zahl in der Klammer steht dieses Mal direkt drin und ist nicht in einem Makro "versteckt". Das geht natürlich auch immer, macht aber gerade größere Programme aufwändig zu pflegen und zu verändern.  
Die Einheit für die Zahl ist Millisekunden, also tausendstel Sekunden. Wenn hier also 1000 steht dann wartet das Programm mit dem nächsten Befehl für eine Sekunde.

**Also was macht das Programm genau?**
```c
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}
```
Unser Programm schaltet also die eingebaute LED ein, warte eine Sekunden, schalte sie wieder aus und warte dann wieder eine Sekunde.  
Aber warum wartet das Programm am Ende wieder eine Sekunden?  

Weil die loop-Schleife immer wieder wiederholt wird fängt das Programm nach der letzten Zeile wieder an der ersten an. Wäre das zweite delay nicht würde die LED sofort wieder an gehen, es wäre fast nicht sichtbar, dass sie überhaupt aus geht. Wir könnten das delay auch als erste Zeile einsetzen, das spielt keine Rolle, dann würde die LED nach dem Neustart des Arduinos erst nach einer Sekunde an gehen aber ab diesem Moment wäre alles gleich.

## Genug Theorie! Schauen wir, ob's auch klappt!

Jetzt können wir das Programm wieder kompilieren und hochladen. Es reicht sogar aus, wenn du nur auf "Hochladen" drückst, die Arduino-IDE merkt, ob das Programm verändert wurde und kompiliert das Programm dann selbst.

Ob alles funktioniert siehst du, wenn die LED auf dem Arduino regelmäßig im Sekundentakt ein- und ausgeschaltet wird:

![Arduino blinkt](02_Blinken.gif)
