Kurzreferenz

liest den Wert eines analo­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 Pul­sweit­en­mod­u­la­tion an einem dig­i­tal­en Pin mit unter­schiedlich­er Hel­ligkeit zum Leucht­en

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 zuge­ord­net.

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

Bei Betä­ti­gung des Sen­sors wird der Inter­rupt aus­gelöst.
Der nor­male Pro­gram­ma­blauf wird unter­brochen und die fest­gelegte Funk­tion (Inter­rupt-Ser­vice-Rou­tine) wird aus­ge­führt.
Anschließend wird das Pro­gramm nor­mal fort­ge­set­zt.

⇒attach­In­ter­rupt()

Mit Hil­fe von Arrays kön­nen Dat­en eines ein­heitlichen Typs (int, bool oder Strings) im Spe­ich­er abgelegt und jed­erzeit wieder her­vor geholt wer­den. Mit den eck­i­gen Klam­mern wird die Anzahl der Ele­mente fest­gelegt.

Eindi­men­sion­ale 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"};

⇒eindi­men­sion­ale Arrays

Zwei­di­men­sion­ale Arrays

Im Unter­schied zu eindi­men­sion­alen Arrays, die eine bes­timmte Anzahl von Ele­mente in ein­er Rei­he haben, kön­nen zwei­di­men­sion­ale Arrays zwei Dimen­sio­nen haben.Sie sind in Rei­hen und Spal­ten organ­isiert:

// 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­sion­ale Arrays

con­st definiert eine Vari­able als Kon­stante, die im Laufe des Pro­gramms nicht verän­dert wer­den kann.

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

Der Ver­such, eine mit define deklar­i­erte Vari­able zu verän­dern, führt zu ein­er Fehler­mel­dung.

⇒Def­i­n­i­tion von Vari­ablen

define definiert eine Vari­able als Kon­stante, die im Laufe des Pro­gramms nicht verän­dert wer­den kann.

#define LED 7
#define Temperatur 22.5

Der Ver­such, eine mit define deklar­i­erte Vari­able zu verän­dern, führt zu ein­er Fehler­mel­dung.

⇒Def­i­n­i­tion von Vari­ablen

hält das Pro­gramm für die angegebene Zeit in Mil­lisekun­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 dig­i­tal­en 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 dig­i­tal­en Pins (HIGH/LOW)

int LED = 7; 

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

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

⇒digitalWrite()/digitalRead()

Das F‑Makro spart Spe­icher­platz:
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 Ver­fü­gung.

Beispiele:

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

⇒Spe­icher­man­age­ment

Sie hat die Form:
Von (Startwert = Wert; Startwert klein­er oder gle­ich Endw­ert; Schrit­tweite)

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

Beginne mit dem Startwert 0, führe die Befehle solange aus, bis der Wert 10 erre­icht ist.
Die Schrit­tweite beträgt 1.
In diese Schleife wer­den nun die Anweisun­gen gepackt, die solange aus­ge­führt wer­den, bis i den Wert 10 erre­icht 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­liegen­den Bedin­gung eine Entschei­dung, wie das Pro­gramm weit­erge­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­tion eines Zeichens 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­beit­en

bes­timmt die Anzahl der Zeichen 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­beit­en

überträgt einen Wer­te­bere­ich auf einen anderen.
Über­tra­gung eines analo­gen Sen­sor­w­ertes, der zwis­chen 0 und 1023 liegen kann, auf die durch analog­Write() möglichen 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

startet den Zeit­nehmer, die Zeit wird in Mil­lisekun­den gemessen.
Allerd­ings kann mil­lis() nicht die aktuelle Zeit bes­tim­men.

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 ein­er Divi­sion

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
}

⇒mod­u­lo

set­zt das Ver­hal­ten eines Pins

• OUTPUT Pin wird als Aus­gabe definiert 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 aktiviert der Ein­gang hat dann im nicht gedrück­ten Zus­tand die Eigen­schaft TRUE (bzw. HIGH) und im betätigten Fall FALSE (bzw. LOW)

int LED =7; 
int TASTER = 8; 

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

⇒pin­Mode()

erzeugt Zufall­szahlen

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 – Zufall­szahl bes­tim­men

wartet auf die Eingabe im Seriellen Mon­i­tor.

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 Zahlen oder Text in den Seriellen Mon­i­tor.

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 einzelnes Zeichen im Seriellen Mon­i­tor

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 solange im Seriellen Mon­i­tor, bis das Zeichen in den Klam­mern erkan­nt 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änge ein­er Vari­ablen (den benötigten Spe­icher­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 
}

⇒size­of

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
}

⇒Strings ver­ar­beit­en

Genau wie if kann switch case Abfra­gen durch­fü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­turen (struct) sind eine Samm­lung und Beschrei­bung ver­schieden­er Dat­en. Sie kön­nen beliebige Daten­typen ver­wen­den.

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­sprech­er ein, noTone() 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 gle­ichen Zweck wie die for Schleife.
Allerd­ings musst du dich selb­st um das Hochzählen der Schleifen­vari­able küm­mern.

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

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

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

⇒while