Programmiren in der Arduino-IDE



Grundlegende Struktur
void setup() Wird einmal zu Beginn ausgeführt.
void loop() Wird danach endlos wiederholt.
delay(ms) Programm pausiert für bestimmte Zeit in ms. 
// Dieses Programm lässt die LED an Pin 13 blinken
                      
void setup() {
  pinMode(13, OUTPUT);  // Pin 13 als Ausgang definieren (z.B. LED)
}

void loop() {
   digitalWrite(13, HIGH);  // LED einschalten
   delay(500);              // 500 ms warten
   digitalWrite(13, LOW);   // LED ausschalten
   delay(500);              // 500 ms warten
 }


Variablen und Datentypen
int Ganze Zahl float Kommazahl
bool Wahrheitswert String Zeichenkette (Text) 
// Variablen deklarieren

int counter;               // Erstellt eine Variable "counter" (Ganzzahl)
counter = 1;               // Speichert den Wert 1
counter = counter + 5;     // Erhöht "counter" um 5 → jetzt 6

float spannung = 3.3;      // Kommazahl speichern
bool aktiviert = true;     // Wahrheitswert speichern (true oder false)
String name = "Arduino";   // Text speichern (Großes S bei String ist wichtig)

void setup() {
  // Code
}

void loop() {
  // Code
}


Eingabe und Ausgabe
pinMode(Pin, Modus) Setzt Pin als INPUT oder OUTPUT.
digitalWrite(Pin, Wert) Setzt digitalen Pin auf HIGH oder LOW.
digitalRead(Pin) Liest digitalen Pin (HIGH/LOW).
analogRead(Pin) Liest analogen Wert (0–1023).
analogWrite(Pin, Wert) Gibt PWM-Signal (0–255) aus. 
// Eingabe- und Ausgabefunktionen

int ledPin = 13;             
int tasterPin = 2;           
int sensorPin = A0;          
int pwmLedPin = 9;           

void setup() {
  pinMode(ledPin, OUTPUT);     
  pinMode(tasterPin, INPUT);   
  pinMode(pwmLedPin, OUTPUT);  
}

void loop() {
  digitalWrite(ledPin, HIGH);               
  int tasterZustand = digitalRead(tasterPin); 
  int sensorWert = analogRead(sensorPin);     
  int pwmWert = sensorWert / 4;             // Wert auf 0–255 reduzieren
  analogWrite(pwmLedPin, pwmWert);          // PWM-Wert an LED ausgeben
  delay(20);                                 
}


Bedingte Anweisung und Verzweigung
if (Bedingung) Führt Anweisungen aus, wenn die Bedingung wahr ist.
else Führt alternativ Anweisungen aus, wenn die Bedingung falsch ist.
else if (weitere Bedingung) Prüft eine zusätzliche Bedingung.
==, !=, >, >=, <, <= Vergleichsoperatoren gleich, ungleich, größer (gleich), kleiner (gleich)
&& und || Logische Operatoren und, oder 
// Taster schaltet LED ein oder aus
       
int ledPin = 8;             // LED an Pin 8
int tasterPin = 7;           // Taster an Pin 7
int tasterZustand = 0;       // Variable für Tasterzustand
       
void setup() {
   pinMode(ledPin, OUTPUT);     // LED ist Ausgang
   pinMode(tasterPin, INPUT);   // Taster ist Eingang
}
       
void loop() {
   tasterZustand = digitalRead(tasterPin);  // Taster lesen
       
   if (tasterZustand == HIGH) {             // Wenn gedrückt
      digitalWrite(ledPin, HIGH);           // LED an
   } else {                                 // Wenn nicht gedrückt
      digitalWrite(ledPin, LOW);            // LED aus
   }
}


Wiederholungen
for (Initialisierung; Bedingung; Aktualisierung) while (Bedingung)
Wiederholt Anweisungen eine bestimmte
Anzahl Mal. 		Wiederholt Anweisungen, solange die
Bedingung wahr ist. 
// LED mit einer for-Schleife heller und dunkler dimmen
         
int ledPin = 9;  // LED an PWM-Pin 9
       
void setup() {
   pinMode(ledPin, OUTPUT);  // Pin als Ausgang setzen
}
       
void loop() {
   for (int h = 0; h <= 255; h++) {     // von 0 bis 255 (heller)
      analogWrite(ledPin, h);           // Helligkeit setzen
      delay(5);                         // kurze Pause
}
       
   for (int h = 255; h >= 0; h--) {     // von 255 zurück auf 0 (dunkler)
      analogWrite(ledPin, h);           // Helligkeit setzen
      delay(5);                         // kurze Pause
   }
}
 
// LED blinkt, solange der Taster gedrückt wird (mit while-Schleife)

int ledPin = 13;       // LED an Pin 13
int tasterPin = 2;     // Taster an Pin 2
       
void setup() {
   pinMode(ledPin, OUTPUT);     // LED ist Ausgang
   pinMode(tasterPin, INPUT);   // Taster ist Eingang
}
       
void loop() {
   while (digitalRead(tasterPin) == HIGH) {  // Solange Taster gedrückt
         digitalWrite(ledPin, HIGH);         // LED an
         delay(200);                         // Wartezeit
         digitalWrite(ledPin, LOW);          // LED aus
         delay(200);                         // Wartezeit
      }
}


Serielle Kommunikation
Serial.begin(baudrate) Startet die serielle Verbindung mit dem Computer.
Serial.print(Daten) Gibt Daten ohne Zeilenumbruch aus.
Serial.println(Daten) Gibt Daten mit Zeilenumbruch aus. 
// Sensorwert über serielle Konsole ausgeben

int sensorPin = A0;      // Sensor an analogem Pin A0
int sensorWert = 0;      // Variable zum Speichern des Werts
       
void setup() {
   Serial.begin(9600);    // Serielle Verbindung starten
}
       
void loop() {
   sensorWert = analogRead(sensorPin);    // Sensorwert lesen
   Serial.print("Sensor: ");              // Text ausgeben
   Serial.println(sensorWert);            // Wert mit Zeilenumbruch ausgeben
   delay(500);                            // kurze Pause
}


Eigene Funktionen
Datentyp Funktionsname(Parameter) Definiert eine eigene Funktion. 
int addiere(int a, int b) {      // Funktion mit zwei Parametern
   return a + b;                 // Gibt Summe zurück
}
       
void setup() {
   int ergebnis = addiere(3, 5);  // Ergebnis: 8
}
       
void loop() {
         // Code
}


Zufallszahlen
randomSeed(Wert) Initialisiert den Zufallsgenerator.
random(Max) Gibt Zufallszahl zwischen 0 und Max–1.
random(Min, Max) Gibt Zufallszahl zwischen Min und Max–1. 
// Zufallszahlen mit Delay ausgeben

void setup() {
   randomSeed(analogRead(A0));     // Zufall initialisieren
   Serial.begin(9600);             // Serielle Ausgabe starten
}
       
void loop() {
   int zahl = random(1, 7);        // Zufallszahl 1–6
   Serial.println(zahl);           // Zahl ausgeben
   delay(1000);                    // 1 Sekunde warten
}