Arduino RGB LED steuern – Tutorial mit Code & Schaltplan

Das brauchst du für dein Arduino RGB LED Projekt

Wichtiger Hinweis: Achte unbedingt darauf, dass du eine RGB-LED mit Common Cathode (gemeinsamer Minuspol) verwendest. Bei Common-Anode-LEDs müsstest du den Code anpassen und die Logik invertieren.

So funktioniert eine RGB-LED – Die Technik dahinter

Das Prinzip der additiven Farbmischung

Eine RGB-LED ist im Grunde ein Dreierpack: Sie enthält drei separate LEDs in einem gemeinsamen Gehäuse – eine rote, eine grüne und eine blaue. Durch das Mischen dieser drei Grundfarben in unterschiedlichen Intensitäten kannst du theoretisch über 16 Millionen verschiedene Farbtöne erzeugen. Das gleiche Prinzip nutzt auch dein Smartphone-Display!

Common Cathode vs. Common Anode – Der entscheidende Unterschied

RGB-LEDs gibt es in zwei Varianten:

Common Cathode (gemeinsame Kathode):

• Der längste Pin ist der gemeinsame Minuspol (GND)
• Die drei Farbpins werden mit positiver Spannung versorgt
• Diese Variante verwende ich in diesem Tutorial

Common Anode (gemeinsame Anode):

• Der längste Pin ist der gemeinsame Pluspol (+5V)
• Die Farbpins werden auf GND gezogen
• Benötigt invertierten Code (255 – Wert)

PWM – So erzeugst du stufenlose Farbverläufe

Der Arduino kann nur digitale Signale ausgeben: Ein (5V) oder Aus (0V). Wie erzeugt er dann unterschiedliche Helligkeiten? Die Antwort heißt PWM (Pulsweitenmodulation).

PWM schaltet den Pin extrem schnell an und aus – so schnell, dass dein Auge nur einen Durchschnittswert wahrnimmt. Mit analogWrite(pin, wert) kannst du Werte von 0 (komplett aus) bis 255 (volle Helligkeit) einstellen.

Beispiel:

• analogWrite(redPin, 255) → Rot leuchtet mit 100%
• analogWrite(redPin, 127) → Rot leuchtet mit ~50%
• analogWrite(redPin, 0) → Rot ist aus

Zwei Wege zum Farbglück

Ich zeige dir in diesem Tutorial zwei verschiedene Ansätze:

Variante 1: Kanalmixer (3 Potentiometer)
Du steuerst jeden Farbkanal einzeln und hast maximale Kontrolle über jede Nuance. Perfekt, wenn du eine ganz bestimmte Farbe einstellen möchtest.

Variante 2: Farbrad (1 Potentiometer)
Du drehst an einem Regler und durchläufst das komplette Farbspektrum wie bei einem Regenbogen. Ideal für sanfte Farbübergänge und elegante Beleuchtungseffekte.

Schaltplan – So verkabelst du die RGB-LED richtig

Variante 1: RGB-Kanalmixer mit drei Potentiometern

Bei dieser Variante steuerst du jeden Farbkanal individuell mit einem eigenen Potentiometer.

Anschluss der RGB-LED:

1. Längster Pin (Common Cathode) → Breadboard GND-Rail
2. Roter Pin → 220Ω Widerstand → Arduino Pin 10 (PWM!)
3. Grüner Pin → 220Ω Widerstand → Arduino Pin 9 (PWM!)
4. Blauer Pin → 220Ω Widerstand → Arduino Pin 11 (PWM!)

Anschluss der Potentiometer:

Potentiometer 1 (für Rot-Kanal):

• Linker Pin → 5V
• Mittlerer Pin (Schleifer) → A0
• Rechter Pin → GND

Potentiometer 2 (für Grün-Kanal):

• Linker Pin → 5V
• Mittlerer Pin (Schleifer) → A1
• Rechter Pin → GND

Potentiometer 3 (für Blau-Kanal):

• Linker Pin → 5V
• Mittlerer Pin (Schleifer) → A2
• Rechter Pin → GND

Wichtige Hinweise:

• Verwende unbedingt PWM-fähige Pins (erkennbar an der ~ Markierung auf dem Arduino Board)
• Die Widerstände schützen die LED vor zu hohem Strom
• Beim Uno sind die PWM-Pins: 3, 5, 6, 9, 10, 11

Variante 2: Farbrad mit einem Potentiometer

Bei dieser Variante bleibt die RGB-LED identisch verkabelt, du benötigst aber nur ein einziges Potentiometer.

Anschluss der RGB-LED:

• Identisch wie bei Variante 1

Anschluss des Potentiometers:

• Linker Pin → 5V
• Mittlerer Pin (Schleifer) → A0
• Rechter Pin → GND

Der Arduino-Code für deine RGB-LED

Code 1: RGB-Kanalmixer – Volle Kontrolle über alle Kanäle

Mit diesem Code liest du drei Potentiometer aus und steuerst damit die drei Farbkanäle völlig unabhängig voneinander. Drehe an den Reglern und mische deine Wunschfarbe!

int redPin = 10;
int greenPin = 9;
int bluePin = 11;

int potPin1 = A0;
int potPin2 = A1;
int potPin3 = A2;

void setup() {
  
}

void loop() {
  analogWrite(redPin, analogRead(potPin1)/4);
  analogWrite(greenPin, analogRead(potPin2)/4);
  analogWrite(bluePin, analogRead(potPin3)/4);
}

So funktioniert der Code:

• Pin-Definitionen: Die ersten Zeilen legen fest, welche Pins verwendet werden
• analogRead(potPin): Liest den Potentiometer-Wert aus (Bereich: 0-1023)
• Division durch 4: Wandelt den Bereich 0-1023 in 0-255 um (PWM-Bereich von analogWrite())
• analogWrite(pin, wert): Setzt die Helligkeit des jeweiligen Farbkanals

Die Funktion setup() ist leer, weil die PWM-Pins automatisch als Ausgänge konfiguriert werden.

Was passiert beim Drehen:

• Potentiometer 1 links → Rot aus / rechts → Rot voll
• Potentiometer 2 links → Grün aus / rechts → Grün voll
• Potentiometer 3 links → Blau aus / rechts → Blau voll

Code 2: Farbrad – Das komplette Spektrum mit einem Regler

Dieser Code ist deutlich komplexer, erzeugt aber einen wunderschönen, nahtlosen Farbverlauf durch das gesamte Farbspektrum – gesteuert mit nur einem Potentiometer!

int redPin = 10;
int greenPin = 9;
int bluePin = 11;

int potPin1 = A0;

void setup() {
  Serial.begin(115200);
}

void loop() {
  int phase = round(analogRead(potPin1) / 171);   
  int frame = analogRead(potPin1) % 171;          
  frame = map(frame, 0, 171, 0, 255);
  Serial.print(phase);
  Serial.print("\t");
  Serial.println(frame);

  if (phase == 0) {
    analogWrite(redPin, 255);
    analogWrite(greenPin, frame);
    analogWrite(bluePin, 0);
  } else if (phase == 1) {
    analogWrite(redPin, 255-frame);
    analogWrite(greenPin, 255);
    analogWrite(bluePin, 0);
  } else if (phase == 2) {
    analogWrite(redPin, 0);
    analogWrite(greenPin, 255);
    analogWrite(bluePin, frame);
  } else if (phase == 3) {
    analogWrite(redPin, 0);
    analogWrite(greenPin, 255-frame);
    analogWrite(bluePin, 255);
  } else if (phase == 4) {
    analogWrite(redPin, frame);
    analogWrite(greenPin, 0);
    analogWrite(bluePin, 255);
  } else if (phase == 5) {
    analogWrite(redPin, 255);
    analogWrite(greenPin, 0);
    analogWrite(bluePin, 255-frame);
  }
}

Die Mathematik hinter dem Farbrad:

1. Phasen-Berechnung: Der Potentiometer-Bereich (0-1023) wird in 6 Phasen unterteilt (1024 / 171 ≈ 6)
2. Frame-Berechnung: Innerhalb jeder Phase gibt es 171 Zwischenschritte, die mit map() auf 0-255 gestreckt werden
3. Farbübergänge: Jede Phase repräsentiert einen Übergang im Farbkreis:
   • Phase 0: Rot → Gelb (Grün wird hochgefahren)
   • Phase 1: Gelb → Grün (Rot wird runtergefahren)
   • Phase 2: Grün → Cyan (Blau wird hochgefahren)
   • Phase 3: Cyan → Blau (Grün wird runtergefahren)
   • Phase 4: Blau → Magenta (Rot wird hochgefahren)
   • Phase 5: Magenta → Rot (Blau wird runtergefahren)
4. Serial-Ausgabe: Die Debug-Ausgaben zeigen dir die aktuelle Phase und Frame-Position im Serial Monitor (Tools → Serial Monitor, 115200 Baud)

Ergebnis: Wenn du am Potentiometer drehst, durchläuft die LED sanft das gesamte Farbspektrum wie ein Regenbogen!

Häufige Probleme und ihre Lösungen

LED leuchtet gar nicht

Mögliche Ursachen:

• ✗ Falsche LED-Variante: Hast du versehentlich eine Common-Anode-LED verwendet?
• ✗ LED falsch herum: Der längste Pin muss an GND (bei Common Cathode)
• ✗ Keine PWM-Pins verwendet: Nutze nur Pins mit ~ Symbol (3, 5, 6, 9, 10, 11)
• ✗ Widerstände vergessen oder falsch angeschlossen

Lösung:
Überprüfe systematisch die Verkabelung und miss mit einem Multimeter die Spannungen.

LED leuchtet, aber in falschen Farben

Mögliche Ursachen:

• ✗ Pin-Zuordnung im Code stimmt nicht mit der physischen Verkabelung überein
• ✗ Farbpins der LED vertauscht

Lösung:
Teste jeden Kanal einzeln: Setze im Code z.B. analogWrite(redPin, 255) und die anderen auf 0. So findest du heraus, welcher Pin welche Farbe steuert.

Potentiometer zeigt keine Wirkung

Mögliche Ursachen:

• ✗ Mittlerer Pin (Schleifer) nicht mit dem analogen Eingang verbunden
• ✗ Potentiometer nicht mit 5V und GND verbunden
• ✗ Falscher analoger Pin im Code definiert

Lösung:
Öffne den Serial Monitor und gib den Potentiometer-Wert mit Serial.println(analogRead(A0)) aus. Du solltest Werte zwischen 0 und 1023 sehen.

Farben flackern oder sind instabil

Mögliche Ursachen:

• ✗ Wackelkontakte im Breadboard
• ✗ Zu lange oder zu dünne Kabel
• ✗ Stromversorgung zu schwach

Lösung:
Stecke alle Verbindungen fest, verwende kürzere Kabel und versorge den Arduino über USB oder ein stabiles Netzteil.

Fazit – Dein Einstieg in die RGB-Welt

Herzlichen Glückwunsch! Du hast erfolgreich gelernt, wie du eine Arduino RGB LED auf zwei völlig unterschiedliche Arten ansteuerst. Lass uns kurz zusammenfassen, was du erreicht hast:

✅ Kanalmixer beherrscht: Du kannst mit drei Potentiometern präzise jede gewünschte Farbe mischen – perfekt für Stimmungsbeleuchtung oder Signalisierung.

✅ Farbrad implementiert: Du hast einen eleganten Farbdurchlauf programmiert, der mit nur einem Regler das gesamte Spektrum durchläuft.

✅ PWM verstanden: Du weißt jetzt, wie der Arduino mit Pulsweitenmodulation stufenlose Helligkeiten erzeugt.

✅ Schaltungsaufbau gemeistert: Von der Materialliste über den Schaltplan bis zur fertigen Hardware – du kannst selbstständig Arduino-Projekte umsetzen.

Erweitere dein Projekt – Nächste Schritte

Die Grundlagen sitzen? Dann probiere diese Erweiterungen:

🎨 Automatische Farbwechsel:
Programmiere zeitgesteuerte Farbübergänge ohne Potentiometer. Nutze millis() für sanfte Animationen.

🎵 Sound-to-Light:
Kombiniere die LED mit einem Mikrofon-Modul und lass die Farben im Takt der Musik tanzen.

💡 RGB-LED-Streifen:
Steige um auf WS2812B-LED-Strips und steuere hunderte LEDs gleichzeitig mit der FastLED-Bibliothek.

📱 Smartphone-Steuerung:
Erweitere das Projekt mit einem Bluetooth-Modul (HC-05) oder ESP32 mit WiFi und steuere die Farben per App.

🕹️ Speicherfunktion:
Nutze EEPROM, um deine Lieblingsfarben dauerhaft zu speichern und per Tastendruck abzurufen.

🌈 Multi-LED-Setup:
Vervielfache die Schaltung und erstelle komplexe Lichtinstallationen mit mehreren RGB-LEDs.

Mein Tipp für dich

Experimentiere mit den Werten im Code! Ändere die Phasenberechnung im Farbrad-Code oder füge Verzögerungen mit delay() hinzu. Die besten Lernerfolge erzielst du, wenn du aktiv herumtüftelst und eigene Ideen umsetzt.

Viel Spaß beim Experimentieren mit deiner Arduino RGB LED – und vergiss nicht, deine Projekte zu dokumentieren und mit der Community zu teilen! 🎨✨