Du hast nun deinen Arduino an den Rechner angeschlossen und das erste Mal ein Programm hochgeladen. Nun ist es an der Zeit, die Programme mal näher unter die Lupe zu nehmen. Die Arduino-Umgebung bietet bereits eine Menge an Beispielprogrammen, die du dir angucken kannst.

Jedes Arduinoprogramm besteht zunächst aus zwei Teilen, setup und loop.

• in der setup-Methode steht alles, was nur am Anfang einmal ausgeführt werden soll
• in der loop-Methode steht der Hauptteil des Programms, der (wie der Name sagt) als Schleife theoretisch unendlich lang läuft

Diesen Grundaufbau findest du im Programm BareMinimum, welches du unter Basics findest.

void setup(){
  // einmal
}

void loop(){
  // immer wieder
}

Bevor du loslegst mit senden und empfangen, musst du dem Arduino mitteilen, welche Pins du wofür benutzen willst:

• mit pinMode( n, OUTPUT) legst du fest, dass du an Pin Nummer n Signale senden willst
• mit pinMode( n, INPUT) entsprechend, dass du Signale empfangen willst

Das solltest du nur einmal tun, also gehört das in setup. Senden und empfangen willst du dagegen die ganze Zeit, das tust du also in loop.

Digitale Signale können genau zwei Werte annehmen, HIGH und LOW. Diese stehen dir als Konstanten zur Verfügung.

• HIGH = 1 = an
• LOW = 0 = aus

Lesen und schreiben lassen sich Pins mit den folgenden beiden Methoden:

• mit digitalRead(pin) liest das Signal auf dem Pin, also HIGH oder LOW
• mit digitalWrite(pin, HIGH) schreibt das Signal HIGH (LOW analog)

So liest man zum Beispiel, welcher Wert gerade an Pin 2 anliegt:

wert = digitalRead(2);

Ein einfaches Beispiel zum Schreiben liefert das Programm blink:

void setup(){
  pinMode(13, INPUT);
}

void loop(){
  digitalWrite(13, HIGH); // LED an
  delay(1000); // warte eine Sekunde
  digitalWrite(13, LOW); // LED aus
  delay(1000); // warte eine Sekunde

Während der Wartezeit bleibt das Signal auf den Pins gleich, die LED ist also abwechselnd 1s an und 1s aus.

Ein Beispiel, in dem beide Funktionen genutzt werden findest du unter Digital → Button.

Analoge Signale sind etwas komplexer als digitale Signale. Sie können nicht nur zwischen HIGH und LOW unterscheiden, sondern auch zwischen einer Vielzahl von Werten dazwischen, abhängig von der Spannung. Die Werte sind für Lesen und schreiben unterschiedlich feingranular.

• lesen: Werte zwischen 0 (aus) und 1023 (an), also 1024 Werte / 10 bit Auflösung
• schreiben: Werte zwischen 0 (aus) und 255 (an), also 256 Werte / 8 bit Auflösung

Lesen und schreiben lassen sich Pins mit den folgenden beiden Methoden:

• analogRead(pin) liest das Signal vom Pin, das zwischen 0 und 1023 liegt
• analogWrite(pin, wert) schreibt das Signal wert zwischen 0 und 255 auf den Pin

Die Benutzung ist recht ähnlich zum digitalen Lesen und Schreiben (abgesehen von der Art der Werte). Das große Spektrum an Werten eignet sich besonders, um z.B. statt hartem Blinken einer LED einen weichen Übergang zwischen hell und dunkel zu erhalten. Ein Beispiel dafür findest du unter Analog → Fading.

Wie in allen höheren Programmiersprachen gibt es auch auf dem Arduino einige nützliche Kontrollstrukturen. Die Beispiele hier sind recht knapp gehalten - ausführliche Beispiele findest du unter Control.

Einfach aber nützlich: Du kannst den Arduino eine bestimmte Zeit lang warten lassen:

delay(int);

Die angegebene Zahl sind Millisekunden, und es handelt sich um ganze Zahlen (Datentyp int).

Wenn du etwas abhängig von einer Bedingung ausführen willst, dann kannst du das mit if-Verzweigungen tun:

if(a < b){
  // falls a < b, tu das hier
}
else {
  // ansonsten tu das hier
}

Das Ganze lässt sich bei Bedarf natürlich auch schachteln:

if(a < b){
  // falls a < b tu das hier
  if(c < d){
    // falls a < b  UND c < d, tu das hier
  }
  else {
    // falls a < b UND NICHT c > d, tu das hier
  }
}
else {
  // ansonsten tu das hier
}

usw.

Falls du abhängig vom Wert einer Variablen etwas tun willst, sind switch-Unterscheidungen das Richtige für dich. Hier solltest du alle Fälle, die dir wichtig sind, abhandeln. Für alle anderen Fälle gibt es default.

switch(zahl){
  case 0:
    // falls zahl = 0...
    break;
  case 1:
    // falls zahl = 1...
  case 42:
    // falls zahl = 42...
    break;
  default:
    // falls zahl anders als die angegebenen Zahlen (nicht 0, 1, oder 42)
}

Falls du noch nie programmiert hast, fragst du dich vielleicht, was das break; da soll. Wenn dein Programm schon gemerkt hat, dass die Zahl Null ist, dann ist es überflüssig, darüber hinaus auch noch zu prüfen, ob sie vielleicht auch Eins ist, oder 42.

Wäre das denn so schlimm? Die 2-3 Zeilen auszuführen dauert doch nicht lange.

Nein, lange brauchen sie wirklich nicht in diesem Fall. Aber es wird nicht nur alles angeguckt, sondern auch alles ausgeführt. Das heißt in diesem Beispiel: Da nach case 1 das break fehlt, wird im Fall, dass zahl = 1 ist auch der Code für zahl = 42 ausgeführt. In den meisten Fällen willst du das nicht.

Mit for-Schleifen kannst du ein bestimmtes Stück Code genau so oft ausführen, wie du festlegst. Wenn du es zahl mal willst, schreibst du das einfach folgendermaßen:

for(int i = 0; i < zahl; i++){
  // tue etwas
  delay(i * 1000);
}

Innerhalb der Schleife kannst du auf i zugreifen. Hier wird nach dem Ausführen des Codes i Sekunden lang gewartet (delay wird in Millisekunden gezählt).

Mit while-Schleifen kannst du ein bestimmtes Stück Code so lange immer wieder ausführen, wie eine bestimmte Bedingung gilt. Nehmen wir mal an, du hast

• einen Schalter, der an Pin schalter angebunden ist und Signale liefert (HIGH für gedrückt, LOW sonst)
• eine LED, die an Pin led angebunden ist und Signale empfängt (HIGH für an, LOW für aus)

Du willst, dass die LED immer dann angeschaltet wird, wenn der Schalter gedrückt ist.

// solange der Schalter gedrückt ist...
while(digitalRead(schalter) == HIGH){
  // ... schalte die LED an
  digitalWrite(led, HIGH);
}
// wenn der Schalter nicht mehr gedrückt ist, schalte die LED aus
digitalWrite(led, LOW);