Arduino Code-Referenz

Jedes Arduino-Programm (Sketch genannt) hat eine grundlegende Struktur, die aus drei Hauptteilen besteht: Globale Variablen und Includes, der setup()-Funktion und der loop()-Funktion.

// 1. Includes und globale Variablen
// Hier werden Bibliotheken eingebunden und Variablen deklariert,
// die im gesamten Programm verfügbar sind.
#include <Servo.h> // Beispiel für das Einbinden einer Bibliothek

const int ledPin = 13; // Beispiel für eine globale Variable

// 2. setup() Funktion
// Dieser Code wird nur einmal ausgeführt, wenn das Arduino-Board startet oder zurückgesetzt wird.
// Er wird verwendet, um Pins zu konfigurieren, Bibliotheken zu initialisieren usw.
void setup() {
  pinMode(ledPin, OUTPUT); // Konfiguriert den Pin als Ausgang
  Serial.begin(9600);      // Startet die serielle Kommunikation
}

// 3. loop() Funktion
// Nachdem setup() abgeschlossen ist, wird der Code in der loop() Funktion
// kontinuierlich in einer Schleife wiederholt, solange das Board mit Strom versorgt wird.
// Hier befindet sich die Hauptlogik des Programms.
void loop() {
  digitalWrite(ledPin, HIGH); // Schaltet die LED ein
  delay(1000);
  digitalWrite(ledPin, LOW);  // Schaltet die LED aus
  delay(1000);
}Copy

Das einfachste Beispiel, das eine an einen digitalen Pin angeschlossene LED im Sekundentakt blinken lässt.

// Pin, an den die LED angeschlossen ist
const int ledPin = 13; 

void setup() {
  // Initialisiert den Pin als Ausgang
  pinMode(ledPin, OUTPUT); 
}

void loop() {
  digitalWrite(ledPin, HIGH);   // Schaltet die LED ein
  delay(1000);                  // Wartet 1 Sekunde
  digitalWrite(ledPin, LOW);    // Schaltet die LED aus
  delay(1000);                  // Wartet 1 Sekunde
}Copy

Dieser Code ändert sanft die Farben einer RGB-LED (mit gemeinsamer Kathode), indem er mit PWM (Pulsweitenmodulation) durch Rot-, Grün- und Blautöne wechselt.

// Pins für jede Farbe (müssen PWM unterstützen)
const int redPin = 9;
const int greenPin = 10;
const int bluePin = 11;

void setup() {
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

void loop() {
  // Übergang von Rot zu Grün
  for (int i = 0; i < 255; i++) {
    analogWrite(redPin, 255 - i);
    analogWrite(greenPin, i);
    delay(10);
  }
  // Übergang von Grün zu Blau
  for (int i = 0; i < 255; i++) {
    analogWrite(greenPin, 255 - i);
    analogWrite(bluePin, i);
    delay(10);
  }
  // Übergang von Blau zu Rot
  for (int i = 0; i < 255; i++) {
    analogWrite(bluePin, 255 - i);
    analogWrite(redPin, i);
    delay(10);
  }
}Copy

Liest den analogen Wert eines Potentiometers aus und gibt ihn an den seriellen Monitor aus. Dies zeigt, wie sich die Spannung beim Drehen des Knopfes ändert.

// Pin, an den der mittlere Anschluss des Potentiometers angeschlossen ist
const int potPin = A0; 

void setup() {
  // Initialisiert die serielle Verbindung zur Datenausgabe
  Serial.begin(9600);
}

void loop() {
  // Liest den Wert vom analogen Eingang
  int sensorValue = analogRead(potPin);
  // Gibt den Wert an den seriellen Monitor aus
  Serial.println(sensorValue);
  delay(100); // Kleine Verzögerung zur Stabilisierung
}Copy

Misst die Entfernung zu einem Hindernis mit einem Ultraschallsensor und gibt das Ergebnis in Zentimetern an den seriellen Monitor aus.

const int trigPin = 9;
const int echoPin = 10;

long duration;
int distance;

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  Serial.begin(9600);
}

void loop() {
  // Setzt den trigPin zurück
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Sendet einen Ultraschallimpuls
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  // Liest die Zeit des zurückkehrenden Echos
  duration = pulseIn(echoPin, HIGH);
  
  // Berechnet die Entfernung
  distance = duration * 0.034 / 2;
  
  // Gibt das Ergebnis aus
  Serial.print("Entfernung: ");
  Serial.print(distance);
  Serial.println(" cm");
  delay(500);
}Copy

Steuert einen Gleichstrommotor mit einem L298N-Treiber: Vorwärts-, Rückwärtslauf, Stopp und Geschwindigkeitsregelung.

// Pins zur Motorsteuerung
const int enA = 9; // PWM für Geschwindigkeit
const int in1 = 8;
const int in2 = 7;

void setup() {
  pinMode(enA, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
}

void loop() {
  // Vorwärtsdrehung bei maximaler Geschwindigkeit
  digitalWrite(in1, HIGH);
  digitalWrite(in2, LOW);
  analogWrite(enA, 255);
  delay(2000);
  
  // Rückwärtsdrehung bei halber Geschwindigkeit
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
  analogWrite(enA, 128);
  delay(2000);

  // Motor anhalten
  digitalWrite(in1, LOW);
  digitalWrite(in2, LOW);
  delay(2000);
}Copy

Dreht die Welle eines Servomotors sanft von 0 auf 180 Grad und zurück. Erfordert die Einbindung der Bibliothek Servo.h.

#include <Servo.h>

Servo myServo; // Erstellt ein Servo-Objekt
int pos = 0;   // Variable zum Speichern der Position

void setup() {
  myServo.attach(9); // Verbindet den Servo mit Pin 9
}

void loop() {
  // Drehung von 0 auf 180 Grad
  for (pos = 0; pos <= 180; pos += 1) { 
    myServo.write(pos); // Stellt den Winkel ein
    delay(15);
  }
  // Drehung von 180 auf 0 Grad
  for (pos = 180; pos >= 0; pos -= 1) { 
    myServo.write(pos);
    delay(15);
  }
}Copy

Liest einen Tastendruck ohne Verwendung von delay() aus und ignoriert dabei das "Prellen" der Kontakte – falsche Signale beim Drücken und Loslassen.

const int buttonPin = 2;
const int ledPin = 13;

int ledState = HIGH;
int buttonState;
int lastButtonState = LOW;

unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, ledState);
}

void loop() {
  int reading = digitalRead(buttonPin);

  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }

  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != buttonState) {
      buttonState = reading;
      if (buttonState == HIGH) {
        ledState = !ledState;
      }
    }
  }

  digitalWrite(ledPin, ledState);
  lastButtonState = reading;
}Copy

Spielt eine einfache Melodie mit einem passiven Summer unter Verwendung der Funktion tone().

// Pin, an den der Summer angeschlossen ist
const int buzzerPin = 8;

// Noten der Melodie (Frequenz in Hz)
// c4=262, d4=294, e4=330, f4=349, g4=392, a4=440, b4=494
int melody[] = {262, 294, 330, 349, 392, 440, 494, 523};
int noteDuration = 500; // Dauer jeder Note

void setup() {
  // Nichts im Setup erforderlich
}

void loop() {
  // Spielt die Melodie ab
  for (int thisNote = 0; thisNote < 8; thisNote++) {
    tone(buzzerPin, melody[thisNote], noteDuration);
    // Pause zwischen den Noten
    delay(noteDuration + 50);
  }
  noTone(buzzerPin); // Schaltet den Ton aus
  delay(2000); // Pause vor der Wiederholung
}Copy

Steuert einen adressierbaren LED-Streifen (z. B. WS2812B). Dieser Code erzeugt einen "Regenbogen"-Effekt. Die Installation der 'Adafruit NeoPixel'-Bibliothek ist erforderlich.

#include <Adafruit_NeoPixel.h>

#define LED_PIN    6  // Steuer-Pin des Streifens
#define LED_COUNT 16  // Anzahl der LEDs im Streifen

// Erstellt ein Streifen-Objekt
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  strip.begin();           // Initialisiert den Streifen
  strip.show();            // Schaltet alle LEDs aus
  strip.setBrightness(50); // Stellt die Helligkeit ein (0-255)
}

void loop() {
  rainbow(20); // Startet den Regenbogen-Effekt
}

void rainbow(int wait) {
  for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256) {
    for(int i=0; iCopy