RGB-LED verwenden: Farben mischen mit Arduino, gemeinsame Anode oder Kathode

Eine RGB-LED besteht aus drei einzelnen LEDs in einem Gehäuse: Rot, Grün und Blau. Stellst du die Helligkeit jeder Farbe einzeln ein, bekommst du fast jede gewünschte Farbe – von Gelb über Türkis bis Lila und Orange. Jedes Pixel auf einem Bildschirm funktioniert nach demselben Prinzip. Für Statusleuchten, Stimmungslampen und farbige Benachrichtigungen ist sie eines der spannendsten Arduino-Bauteile.

Wie funktioniert eine RGB-LED?

Lichtfarben mischen sich additiv: Rot und Grün zusammen ergeben für das Auge Gelb, Grün und Blau Türkis, Rot und Blau Lila (Magenta); leuchten alle drei, entsteht Weiß. Der Arduino stellt die Helligkeit jedes Kanals per PWM zwischen 0 und 255 ein. Theoretisch ergeben sich so 256 × 256 × 256 ≈ 16,7 Millionen Kombinationen. PWM schaltet die LED hunderte Male pro Sekunde ein und aus; das Auge sieht dieses Flackern nicht, sondern nur die mittlere Helligkeit.

Gemeinsame Kathode oder gemeinsame Anode?

Das längste der vier Beinchen ist der gemeinsame Anschluss der drei LEDs. Verbindet er ihre Kathoden, ist es eine LED mit gemeinsamer Kathode; verbindet er ihre Anoden, eine mit gemeinsamer Anode. Von außen sehen beide gleich aus, Anschluss und Code sind aber umgekehrt:

Pinreihenfolge und Anschluss am Arduino

Bei gängigen 5-mm-RGB-LEDs ist die Reihenfolge Rot, gemeinsam (längstes), Grün, Blau – sie kann aber je nach Hersteller abweichen, daher testest du am besten jedes Beinchen einzeln. Jede Farbe kommt über einen eigenen Widerstand an einen PWM-Pin. Beim Arduino Uno sind das die mit ~ markierten Pins 3, 5, 6, 9, 10 und 11.

Vorwiderstände berechnen: für jede Farbe einen eigenen

Jede Farbe braucht eine andere Spannung zum Leuchten (Flussspannung): Rot etwa 2,0 V, Grün und Blau 3,0–3,2 V. Für 20 mA an 5 V braucht Rot (5 − 2,0) / 0,020 = 150 Ω, Grün und Blau (5 − 3,2) / 0,020 ≈ 100 Ω. In der Praxis sind 220 Ω für alle drei sicher und trotzdem hell genug; die Farbbalance kannst du im Code ausgleichen. Eigene Werte berechnest du mit dem Rechner LED-Vorwiderstand, die Flussspannungen findest du in der Tabelle LED-Spannungen.

Farben mischen mit dem Arduino

Der folgende Code fasst die drei Kanäle in einer Funktion setColor() zusammen und zeigt nacheinander sieben Farben. Hat deine LED eine gemeinsame Anode, setzt du einfach COMMON_ANODE auf true; die Funktion kehrt die Werte selbst um.

1const int R_PIN = 9;
2const int G_PIN = 10;
3const int B_PIN = 11;
4const bool COMMON_ANODE = false;   // ortak anotsa true yap / set true for common anode
5
6void setColor(int r, int g, int b) {
7  if (COMMON_ANODE) { r = 255 - r; g = 255 - g; b = 255 - b; }
8  analogWrite(R_PIN, r);
9  analogWrite(G_PIN, g);
10  analogWrite(B_PIN, b);
11}
12
13void setup() {
14  pinMode(R_PIN, OUTPUT);
15  pinMode(G_PIN, OUTPUT);
16  pinMode(B_PIN, OUTPUT);
17}
18
19void loop() {
20  setColor(255, 0, 0);     delay(1000);  // kırmızı / red
21  setColor(0, 255, 0);     delay(1000);  // yeşil / green
22  setColor(0, 0, 255);     delay(1000);  // mavi / blue
23  setColor(255, 255, 0);   delay(1000);  // sarı / yellow
24  setColor(0, 255, 255);   delay(1000);  // turkuaz / cyan
25  setColor(255, 0, 255);   delay(1000);  // mor / magenta
26  setColor(255, 255, 255); delay(1000);  // beyaz / white
27}

Sanfter Farbübergang: der Regenbogen-Effekt

Statt zwischen Farben zu springen, senkst du einen Kanal, während du einen anderen erhöhst – so fließt das Licht weich von Rot zu Grün, von Grün zu Blau und zurück zu Rot. Die Schleife unten nutzt dieselbe Funktion setColor(); mit dem delay-Wert stellst du die Geschwindigkeit ein.

1// setColor() ve pin tanımları yukarıdaki gibi / setColor() and pins as above
2void loop() {
3  for (int i = 0; i < 256; i++) { setColor(255 - i, i, 0); delay(8); }  // kırmızı → yeşil / red → green
4  for (int i = 0; i < 256; i++) { setColor(0, 255 - i, i); delay(8); }  // yeşil → mavi / green → blue
5  for (int i = 0; i < 256; i++) { setColor(i, 0, 255 - i); delay(8); }  // mavi → kırmızı / blue → red
6}

Farben mit Potentiometern wählen

Schließt du drei Potentiometer an A0, A1 und A2 an, wird jedes zum Drehknopf für einen Farbkanal. analogRead() liefert einen Wert von 0 bis 1023; geteilt durch 4 ergibt das den Bereich 0–255, den PWM erwartet. Wie man ein Potentiometer anschließt, erklärt Was ist ein Potentiometer?

1// A0, A1, A2'de üç potansiyometre; setColor() yukarıdaki gibi
2// three pots on A0, A1, A2; setColor() as above
3void loop() {
4  int r = analogRead(A0) / 4;   // 0–1023 → 0–255
5  int g = analogRead(A1) / 4;
6  int b = analogRead(A2) / 4;
7  setColor(r, g, b);
8}

RGB-LED mit ESP32 und Raspberry Pi Pico

Am ESP32 funktioniert analogWrite() mit dem aktuellen Arduino-Core (3.x) an jedem Ausgangspin, der Code oben läuft also mit angepassten Pinnummern unverändert. Achten musst du nur auf die Spannung: Die Pins liefern 3,3 V, deshalb leuchten Grün und Blau, deren Flussspannung nahe 3 V liegt, schwächer. Nimm bei 3,3 V kleine Widerstände wie 47–100 Ω oder treibe die LED für viel Helligkeit über einen Transistor mit 5 V. Am Pico nimmt die PWM-Klasse von MicroPython Werte von 0 bis 65535:

1from machine import Pin, PWM
2import time
3
4pins = [PWM(Pin(n)) for n in (11, 12, 13)]   # GP11 R, GP12 G, GP13 B
5for p in pins:
6    p.freq(1000)
7
8def set_color(r, g, b):                       # 0–255
9    for p, v in zip(pins, (r, g, b)):
10        p.duty_u16(v * 257)                   # 0–65535 (ortak anotta 65535 - v * 257)
11
12while True:
13    set_color(255, 0, 0); time.sleep(1)       # kırmızı / red
14    set_color(0, 255, 0); time.sleep(1)       # yeşil / green
15    set_color(0, 0, 255); time.sleep(1)       # mavi / blue

Normale RGB-LED oder adressierbare LED (WS2812B)?

Für ein oder zwei farbige Lichter ist die normale RGB-LED die einfachste und günstigste Lösung. Willst du Dutzende LEDs einzeln einfärben, reichen die 6 PWM-Pins des Uno nicht; dann wechselst du zu WS2812B-Streifen, die Hunderte LEDs über eine einzige Leitung steuern.

Projektideen mit RGB-LED

• Stimmungslampe: den Regenbogen-Übergang in ein mattes Glas setzen und so ein sanftes Nachtlicht bauen.
• Temperaturanzeige: mit einem DHT11 kombinieren – blau bei Kälte, grün bei angenehmer Temperatur, rot bei Hitze.
• Farbmischer: mit drei Potentiometern jede Farbe von Hand einstellen.
• Farbe per Handy wählen: mit einem ESP32 die Lampenfarbe über einen Farbwähler auf einer Webseite ändern.
• Benachrichtigungslicht: bei neuer E-Mail oder Nachricht in einer bestimmten Farbe blinken.
• Farben per Tastenfeld: je nach eingegebener Zahl eine andere Farbe zeigen.

Typische Fehler und ihre Lösungen

• Die Farben verhalten sich umgekehrt: Du steuerst eine LED mit gemeinsamer Anode wie eine mit gemeinsamer Kathode an; setze COMMON_ANODE auf true.
• Eine Farbe leuchtet nie: Die Pinreihenfolge ist vielleicht anders als erwartet; teste jedes Beinchen einzeln mit Widerstand.
• Übergänge sind stufig, ohne Zwischentöne: Die LED hängt an einem Pin ohne PWM; beim Uno können diese Pins nur ganz an oder aus sein.
• Farben spinnen, während ein Buzzer spielt: Beim Uno nutzt tone() Timer2 und stört PWM an den Pins 3 und 11; leg die RGB-LED auf Pins wie 5, 6, 9 und 10.
• Ohne Widerstände: Zu viel Strom beschädigt mit der Zeit LED und Arduino-Pin.
• Sehr dunkel am ESP32: Bei 3,3 V sind Grün und Blau am Limit; kleinere Widerstände oder einen Transistor verwenden.

Wenn du die LED-Grundlagen verstehen willst und wissen möchtest, warum sie Widerstände brauchen, lies Was ist eine LED? und Was ist ein Widerstand? In der BlueGrays-App findest du Projekte mit RGB-Farbübergang, tastengesteuerter Lampe und Farbmischer samt Schaltplänen und Code.