Kurz­re­fe­renz

liest den Wert eines ana­lo­gen Pins

int SENSOR = A0; 
int SensorWert; 

void setup()
{
  // bei analogWrite ist kein setup notwendig
} 

void loop() 
{ 
  SensorWert = analogRead(SENSOR); 
}

➨analogRead()/analogWrite()

bringt eine LED mit der Puls­wei­ten­mo­du­la­ti­on an einem digi­ta­len Pin mit unter­schied­li­cher Hel­lig­keit zum Leuchten

int LED = 7; 

void setup()
{
  // bei analogWrite ist kein setup notwendig 
} 

void loop() 
{
  for (int i = 0; i < 255; i += 5) 
  { 
    analogWrite(LED, i);
    delay(200); 
  } 
}

➨analogRead()/analogWrite()

Ein Sen­sor wird einem Inter­rupt zugeordnet.

attachInterrupt(digitalPinToInterrupt(TASTER), LEDSchalten, CHANGE);

Bei Betä­ti­gung des Sen­sors wird der Inter­rupt ausgelöst.
Der nor­ma­le Pro­gramm­ab­lauf wird unter­bro­chen und die fest­ge­leg­te Funk­ti­on (Inter­rupt-Ser­vice-Rou­ti­ne) wird ausgeführt.
Anschlie­ßend wird das Pro­gramm nor­mal fortgesetzt.

➨attach­In­ter­rupt()

Mit Hil­fe von Arrays kön­nen Daten eines ein­heit­li­chen Typs (int, bool oder Strings) im Spei­cher abge­legt und jeder­zeit wie­der her­vor geholt wer­den. Mit den ecki­gen Klam­mern wird die Anzahl der Ele­men­te festgelegt.

Ein­di­men­sio­na­le Arrays

int LED[5] = {3, 4, 5, 6, 7};
bool Status[5] = {1,  0,  1,  0,  1};
String Bauteile[5] = {"Taster", "Potentiometer", "Fernbedienung", "Sensor", "LED"};
char Buchstaben[] = {"aeiou"};

➨ein­di­men­sio­na­le Arrays

Zwei­di­men­sio­na­le Arrays

Im Unter­schied zu ein­di­men­sio­na­len Arrays, die eine bestimm­te Anzahl von Ele­men­te in einer Rei­he haben, kön­nen zwei­di­men­sio­na­le Arrays zwei Dimen­sio­nen haben.Sie sind in Rei­hen und Spal­ten organisiert:

// 4 Reihen, 4 Spalten 
int Zahlen[4] [4] = 
{ 
  {1, 2, 3, 4}, 
  {11, 12, 13, 14}, 
  {21, 22, 23, 24}, 
  {31, 32, 33, 34}
}; 

void setup() 
{ 
  Serial.begin(9600); 

  // auf serielle Verbindung warten
  while (!Serial) {;}

  /*  
    Elemente des Arrays anzeigen    
    i -> Zeilen, j -> Spalten 
    for-Schleife durch die Reihen 
  */
  for ( int i = 0; i < 4; i++ ) 
  {  
    Serial.print("Zeile " + String(i) + ": ");  
 
    // for-Schleife durch die Spalten  
    for (int j = 0; j < 4; j++)  
    {  
      Serial.print(String(Zahlen[i] [j]) + " ");       
    } 
    Serial.println(); 
  } 
}
 
void loop() 
{  
  // bleibt leer, das Programm läuft nur einmal 
} 

➨zwei­di­men­sio­na­le Arrays

const defi­niert eine Varia­ble als Kon­stan­te, die im Lau­fe des Pro­gramms nicht ver­än­dert wer­den kann.

const int LED = 7;
const float Temperatur = 22.5;

Der Ver­such, eine mit defi­ne dekla­rier­te Varia­ble zu ver­än­dern, führt zu einer Fehlermeldung.

➨Defi­ni­ti­on von Variablen

defi­ne defi­niert eine Varia­ble als Kon­stan­te, die im Lau­fe des Pro­gramms nicht ver­än­dert wer­den kann.

# define LED 7
# define Temperatur 22.5

Der Ver­such, eine mit defi­ne dekla­rier­te Varia­ble zu ver­än­dern, führt zu einer Fehlermeldung.

➨Defi­ni­ti­on von Variablen

hält das Pro­gramm für die ange­ge­be­ne Zeit in Mil­li­se­kun­den an

int LED = 7; 
void setup() 
{
  pinMode(GELB, OUTPUT); 
} 

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

➨delay()

liest den Wert eines digi­ta­len Pins (HIGH/LOW)

int LED = 7; 
int TASTER = 8; 
int TasterStatus; 

void setup() 
{ 
  pinMode(LED, OUTPUT);
  pinMode(TASTER, INPUT_PULLUP); 
} 

void loop() 
{
  TasterStatus = digitalRead(TASTER); 
  if (TasterStatus == LOW) digitalWrite(LED, HIGH); 
}

➨digitalWrite()/digitalRead()

schreibt den Wert eines digi­ta­len Pins (HIGH/LOW)

int LED = 7; 

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

void loop() 
{ 
  digitalWrite(LED, HIGH); 
}

➨digitalWrite()/digitalRead()

Das F-Makro spart Speicherplatz:
Das F-Makro sorgt dafür, dass der Text nicht im SRAM ver­bleibt, er wird viel­mehr im deut­lich grö­ße­ren ➨Flash abge­legt und stellt so Spei­cher­platz für Varia­blen im SRAM zur Verfügung.

Bei­spie­le:

Serial.println(F("Initialisierung abgeschlossen")); 
Serial.println(F("-----------------------------------"));

➨Spei­cher­ma­nage­ment

Sie hat die Form:
Von (Start­wert = Wert; Start­wert klei­ner oder gleich End­wert; Schrittweite)

for (int i = 0; i < 10; i ++)
{
   // Anweisung
}

Begin­ne mit dem Start­wert 0, füh­re die Befeh­le solan­ge aus, bis der Wert 10 erreicht ist.
Die Schritt­wei­te beträgt 1.
In die­se Schlei­fe wer­den nun die Anwei­sun­gen gepackt, die solan­ge aus­ge­führt wer­den, bis i den Wert 10 erreicht hat.

void setup() 
{ 
  Serial.begin(9600); 

  // auf serielle Verbindung warten
  while (!Serial) {;}
} 

void loop() 
{
  for (int i = 0; i < 10; i ++) 
  {
    Serial.println(i);
  } 
}

➨for

trifft je nach der vor­lie­gen­den Bedin­gung eine Ent­schei­dung, wie das Pro­gramm wei­ter­ge­hen soll.

// wenn die Bedingung erfüllt ist ...
if (Bedingung == Zustand)
{
  // Befehl ausführen
}

// sonst
else
{
  // alternativen Befehl ausführen
}

int LED = 7; 
int TASTER = 13; 

void setup() 
{ 
  pinMode(LED, OUTPUT); 
  pinMode(TASTER, INPUT_PULLUP); 
} 

void loop() 
{ 
  int TasterLesen = digitalRead(TASTER); 
  if (TasterLesen == LOW) 
  {
    digitalWrite(LED, HIGH); 
  } 
  else 
  {
    digitalWrite(LED, LOW); 
  }
}

➨if … else

stellt die Posi­ti­on eines Zei­chens inner­halb eines Strings fest

void setup()  
{ 
  Serial.begin(9600); 

  // auf serielle Verbindung warten
  while (!Serial) {;}

  String BeispielString = "Programmieren finde ich toll ;-)";    

  // das t suchen  
  int Suche = BeispielString.indexOf("t"); 
  Serial.print("Position t in " + BeispielString + ": "); 
  Serial.println(Suche); 
}

void loop() 
{
  // bleibt leer, Programm läuft nur einmal
}

➨Strings ver­ar­bei­ten

bestimmt die Anzahl der Zei­chen eines Strings

void setup()
{
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial) {;}

  String BeispielString = "Programmieren finde ich toll ;-)";

  // Länge bestimmen
  int Laenge = BeispielString.length();
  Serial.print("Lu00e4nge des Strings " + BeispielString + ": ");
  Serial.println(String(Laenge) + " Zeichen.");
}

void loop()
{
  // bleibt leer, Programm läuft nur einmal
}

➨Strings ver­ar­bei­ten

über­trägt einen Wer­te­be­reich auf einen anderen.
Über­tra­gung eines ana­lo­gen Sen­sor­wer­tes, der zwi­schen 0 und 1023 lie­gen kann, auf die durch ana­log­Wri­te() mög­li­chen Werte:

int SensorWert = analogRead(SENSOR); 

/*
 map -> Umwandlung des gelesenen Wertes von 0 bis 1023 
 (analoger Sensorwert) auf 0 bis 255 
*/ 
int Helligkeit = map(SensorWert, 0, 1023, 0, 255); 
analogWrite(LED, Helligkeit);

➨map

star­tet den Zeit­neh­mer, die Zeit wird in Mil­li­se­kun­den gemessen.
Aller­dings kann mil­lis() nicht die aktu­el­le Zeit bestimmen.

int TASTER = 7;
int TasterLesen;

float StartZeit;
float VerstricheneZeit;
float Sekunden;

void setup()
{
  pinMode(TASTER, INPUT_PULLUP);
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial) {;}

  StartZeit = millis();
}

void loop()
{
  TasterLesen = digitalRead(TASTER);
  if (TasterLesen == LOW)
  {
    delay(200);
    
    // Zeit berechnen
    float Sekunden;
    VerstricheneZeit = millis() - StartZeit;

    // 1000 ms = 1 s
    Sekunden = VerstricheneZeit / 1000;

    // Sekunden in String umwandeln
    String AnzahlSekunden = String(Sekunden);

    // . durch , ersetzen
    AnzahlSekunden.replace(".", ",");

    // Ausgabe im Seriellen Monitor
    Serial.println(AnzahlSekunden + " Sekunden");
  }
}

➨mil­lis()

ermit­telt den Rest­wert einer Division

int Zahl = 144;

void setup()
{
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial) {;}

  Serial.println("Die Teiler von " + String(Zahl));

  // nur bis zur Hälfte der Zahl prüfen
  for ( int i = 2 ; i <= Zahl / 2 ; i++)
  {
    // wenn kein Rest → Zahl ist teilbar → aktuellen Divisor anzeigen
    if (Zahl % i == 0)
    {
      Serial.println(i);
    }
  }
}

void loop()
{
  // bleibt leer, Programm läuft nur einmal
}

➨modu­lo

setzt das Ver­hal­ten eines Pins

• OUTPUT Pin wird als Aus­ga­be defi­niert z.B eine LED
• INPUT Pin ist ein Ein­gang (z. B. Ein Taster)
• INPUT_PULLUP am Ein­gangs-Pin wird ein 50kΩ Wider­stand akti­viert der Ein­gang hat dann im nicht gedrück­ten Zustand die Eigen­schaft TRUE (bzw. HIGH) und im betä­tig­ten Fall FALSE (bzw. LOW)

int LED =7; 
int TASTER = 8; 

void setup() 
{
  pinMode(LED, OUTPUT); 
  pinMode(TASTER, INPUT_PULLUP); 
}

➨pin­Mo­de()

erzeugt Zufalls­zah­len

void setup() 
{
  Serial.begin(9600); 

  // auf serielle Verbindung warten
  while (!Serial) {;}
  
  // Zufallsgenerator starten 
  randomSeed(analogRead(0));
} 

void loop() 
{
  int Minimum = 1; 
  int Maximum = 7; 
  int Zahl = random(Minimum, Maximum); 
  Serial.print("ZufallszZahl: "); 
  Serial.println(Zahl); 
  delay(1000); 
}

➨ran­dom – Zufalls­zahl bestimmen

war­tet auf die Ein­ga­be im Seri­el­len Monitor.

while(Serial.available() > 0) 
{
  // solange lesen, bis return (n = return) eingegeben wurde 
  String Eingabe = Serial.readStringUntil("n"); 
    
  // das letzte Zeichen ist return = n → soll entfernt werden (-1) 
  Eingabe = Eingabe.substring(0, Eingabe.length() - 1);
  . . . 
}

➨Serial.available/Serial.read()

schreibt Zah­len oder Text in den Seri­el­len Monitor.

void setup() 
{
  Serial.begin(9600); 

  // auf serielle Verbindung warten
  while (!Serial) {;}
  
  // ohne Zeilenumbruch
  Serial.print("Programmieren macht Spaß!"); 
  int Zahl = 87; 
  Serial.println(Zahl);  
  String Text = "Die Zahlen liegen zwischen 81 und 100!"; 

  // mit Zeilenumbruch
  Serial.println(Text);  
}

void loop() 
{ 
  // kein setup notwendig, das Programm läuft nur einmal 
}

➨Serial.print()/Serial.println()

liest ein ein­zel­nes Zei­chen im Seri­el­len Monitor

while (Serial.available() > 0) 
{
  // Eingabe im Seriellen Monitor lesen 
  char Zahl = Serial.read(); 
  Eingabe += Zahl; 

  // Enter/Senden n gedrückt
  if (Zahl == 'n') 
  {
    . . . 
  }
}

➨Serial.available/Serial.read()

liest solan­ge im Seri­el­len Moni­tor, bis das Zei­chen in den Klam­mern erkannt wird

while (Serial.available() > 0) 
{
  // solange lesen, bis return char(13) = return) eingegeben wurde 
  String Eingabe = Serial.readStringUntil(char(13)); 

  // das letzte Zeichen ist return = n → soll entfernt werden (-1) 
  Eingabe = Eingabe.substring(0, Eingabe.length() - 1); 
  . . . 
}

➨Serial.available/Serial.read()

stellt die Län­ge einer Varia­blen (den benö­tig­ten Spei­cher­platz) in Bytes fest.

byte Zahl = 7; 
int Ergebnis = 10; 
float Summe = 5.5; 

void setup() 
{
  Serial.begin(9600); 

  // auf serielle Verbindung warten
  while (!Serial) {;}

  // 1 Byte 
  Serial.println(sizeof(Zahl)); 

  // 2 Byte 
  Serial.println(sizeof(Ergebnis)); 

  // 4 Bytes 
  Serial.println(sizeof(Summe)); 
} 

void loop() 
{
  // bleibt leer, Programm läuft nur einmal 
}

➨sizeof

zeigt den Teil­string von Start bis Ende.

void setup()  
{ 
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial) {;}
 
  String BeispielString = "Programmieren finde ich toll ;-)";    

  // Länge bestimmen
  int Laenge = BeispielString.length(); 
  Serial.print("Lu00e4nge des Strings: "); 
  Serial.println(Laenge);  
 
  // das t suchen  
  int Suche = BeispielString.indexOf("t"); 
  Serial.print("Position t: "); 
  Serial.println(Suche); 

  // String vom Anfang bis zum t 
  BeispielString.substring(0, Suche); 
  Serial.print("String bis zum t: ");  
  Serial.println(BeispielString.substring(0, Suche)); 

  // oder, weil Laenge schon bestimmt wurde:  
  // BeispielString.substring(suche + 1, Laenge); 
  Serial.print("String vom t bis zum Ende: ");      
  Serial.println(BeispielString.substring(Suche, BeispielString.length())); 
} 

void loop() 
{
  // bleibt leer, Programm läuft nur einmal
}

➨<a class="Kurzreferenz" href="Strings verarbeiten

Genau wie if kann switch case Abfra­gen durchführen.

void setup() 
{
  Serial.begin(9600); 

  // auf serielle Verbindung warten
  while (!Serial) {;}

  // Zufallsgenerator starten 
  randomSeed(analogRead(A0)); 
} 

void loop() 
{
  int Zahl = random(1, 3) 
  switch (Zahl) 
  {
    case 1: 
      Serial.print("1"); 
      break; 
    case 2: 
      Serial.print("2");
      break;
    case 3: 
      Serial.print("3"); 
      break;
   } 
}

➨switch … case

Struk­tu­ren (struct) sind eine Samm­lung und Beschrei­bung ver­schie­de­ner Daten. Sie kön­nen belie­bi­ge Daten­ty­pen verwenden.

struct Stadt
{
  int Platz;
  String Name;
  String KFZ_Kennzeichen;
  float Einwohner;
  String Vorwahl;
  int Hoehe;
};
Stadt Berlin =
{
  1,
  "Berlin",
  "B",
  3.64,
  "030",
  30
};

Stadt Hamburg =
{
  2,
  "Hamburg",
  "HH",
  1.84,
  "040",
  6
};

Stadt Muenchen =
{
  3,
  "Mu00fcnchen",
  "M",
  1.84,
  "040",
  6
};

➨struct

tone() schal­tet den Laut­spre­cher ein, noTo­ne() schal­tet ihn aus.

int LAUTSPRECHER = 13; 

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

void loop () 
{
  // tone(Ausgabepin, Frequenz, Zeit_in_Millisekunden) 
  tone(LAUTSPRECHER, 1000, 100);  
  
  // oder Ton ohne Zeitbegrenzung 
  tone(LAUTSPRECHER, 1000); 

  // Lautsprecher ausschalten 
  noTone(LAUTSPRECHER); 
}

➨tone()/noTone()

while erfüllt den glei­chen Zweck wie die for Schleife.
Aller­dings musst du dich selbst um das Hoch­zäh­len der Schlei­fen­va­ria­ble kümmern.

void setup() 
{ 
  Serial.begin(9600); 

  // auf serielle Verbindung warten
  while (!Serial) {;}
} 

void loop() 
{
  int i = 0; 
  while (i < 10)  
  {
    Serial.println(i); i++; 
  }
}

➨while