Ratgeber · 10 Min. Lesezeit

RGB LED Streifen Arduino: 12 V mit MOSFET ansteuern und mischen

RGB LED Streifen mit Arduino steuern: 12 V 5050 Streifen per IRLZ44N MOSFET, 3 PWM-Kanäle, Farbverlauf, Potentiometer, Netzteil, ESP32- und Pico-Code.

RGB LED Streifen mit Arduino steuern heißt: Du steuerst die roten, grünen und blauen Kanäle eines nicht adressierbaren 12-V-5050-RGB-Streifens mit drei getrennten PWM-Signalen und mischst so jede gewünschte Farbe. Ein Arduino-Pin kann weder die Ströme von mehreren Ampere noch 12 V verkraften, deshalb kommt pro Kanal ein MOSFET dazwischen: Der Arduino schickt nur ein 5-V-Signal an das Gate des MOSFETs, den eigentlichen Strom trägt der MOSFET. So kannst du mehrere Meter Streifen sicher mit einem kleinen Mikrocontroller steuern.

In dieser Anleitung lernst du den Aufbau eines 5050-Streifens, die richtige MOSFET-Wahl, die Schaltung und die Netzteilberechnung kennen. Danach mischst du mit dem Arduino Uno Farben, baust einen weichen Farbverlauf auf Basis von millis() und wählst Farbe und Helligkeit per Potentiometer. Dieselbe Schaltung betreibst du auch mit der LEDC-Einheit des ESP32 und mit MicroPython-PWM auf dem Raspberry Pi Pico. Außerdem erfährst du den Unterschied zum WS2812B, und am Ende findest du Lösungen für die häufigsten Fehler.

Was ist ein RGB LED Streifen und wie funktioniert er?

Bei einem nicht adressierbaren RGB-Streifen steckt in jedem 5050-SMD-Gehäuse je ein roter, grüner und blauer LED-Chip. Der Streifen besteht aus parallel geschalteten 12-V-Segmenten aus drei LEDs und je einem Vorwiderstand pro Farbe; die in Reihe geschalteten LEDs haben je nach Farbe eine Durchlassspannung von insgesamt etwa 6–9 V, den Rest übernimmt der Widerstand. Der Streifen hat vier Anschlüsse: den gemeinsamen Pluspol (+12V) sowie R, G und B. Er ist also gemeinsame Anode: Damit eine Farbe leuchtet, musst du ihre Leitung nach GND ziehen. Der ganze Streifen zeigt immer dieselbe Farbe; einzelne LEDs kannst du nicht unterschiedlich ansteuern. Die Farbe bestimmst du über das PWM-Tastverhältnis jedes Kanals: Sind Rot und Grün voll an, siehst du Gelb, sind alle drei voll an, ein fast weißes Licht.

MerkmalStreifen mit 30 LEDs/mStreifen mit 60 LEDs/m
LED-Typ5050 SMD (5,0 × 5,0 mm, 3 Chips)5050 SMD (5,0 × 5,0 mm, 3 Chips)
Betriebsspannung12 V DC12 V DC
Leistung (volles Weiß)ca. 7,2 W/mca. 14,4 W/m
Strom (volles Weiß)ca. 0,6 A/mca. 1,2 A/m
Strom pro Kanalca. 0,2 A/mca. 0,4 A/m
Schnittabstandalle 3 LEDs (10 cm)alle 3 LEDs (5 cm)
Anschlüsse+12V, R, G, B+12V, R, G, B

Unterschied zwischen RGB-Streifen und WS2812B

Beide Streifen leuchten in RGB, aber die Ansteuerung ist völlig anders. Ein nicht adressierbarer Streifen verhält sich wie eine Lampe: Du änderst die Helligkeit der drei Kanäle und damit die Farbe des gesamten Streifens. Beim WS2812B NeoPixel steckt dagegen in jeder LED ein kleiner Treiberchip, und du schickst über eine einzige Datenleitung jeder LED eine eigene Farbe. Die folgende Tabelle hilft dir bei der Entscheidung:

Merkmal12-V-RGB-Streifen (5050)WS2812B-Streifen
SteuerungGanzer Streifen eine FarbeJede LED eine eigene Farbe
Versorgung12 V (auch 24-V-Versionen)5 V
Kabel4 Adern: +12V, R, G, B3 Adern: 5V, DIN, GND
TreiberschaltungEin MOSFET pro KanalNicht nötig, ein Datenpin genügt
CodeanalogWrite / PWMFastLED oder Adafruit NeoPixel Bibliothek
Strom (60 LEDs/m, volles Weiß)ca. 1,2 A/m (12 V)ca. 3,6 A/m (5 V)
SpannungsabfallBis 5 m meist unkritischBei langen Streifen an mehreren Stellen einspeisen
EffekteFeste Farbe, Farbverlauf, AtmenLauflicht, Regenbogen, Animationen
PreisGünstigTeurer

Warum brauche ich einen MOSFET und welchen soll ich nehmen?

Ein Pin des Arduino Uno ist für etwa 20 mA ausgelegt (absolutes Maximum 40 mA), während ein einzelner Kanal eines 5 m langen 60-LEDs/m-Streifens 2 A ziehen kann. Außerdem läuft der Streifen mit 12 V. Ein N-Kanal-MOSFET löst das als Low-Side-Schalter: Drain geht an die Farbleitung des Streifens, Source an GND, und die Spannung am Gate schaltet den MOSFET ein und aus. Wichtig ist ein Logic-Level-MOSFET; Standardtypen wie IRF520 oder IRF540N brauchen etwa 10 V, um voll durchzuschalten, bleiben bei 5 V halb offen und werden heiß. Die Verlustleistung im MOSFET berechnest du mit P = I² × Rds(on): Bei 2 A und 0,025 Ω sind das 2 × 2 × 0,025 = 0,1 W, ein Kühlkörper ist also nicht nötig. Die Grundlagen findest du im Beitrag MOSFET mit Arduino verwenden.

MOSFETGate-SpannungRds(on)Eignung
IRLZ44NLogic-Level, bei 4–5 V voll offen0,025 Ω (bei 5 V)Ideal für Uno und Nano; bei 3,3 V nur für kurze Streifen
IRLB8721Schaltet auch bei 3,3 V gutca. 0,009 Ω (bei 4,5 V)Eine der besten Wahlen für ESP32 und Pico
AO3400 (SMD)Schaltet bei 2,5 Vca. 0,03 Ω (bei 4,5 V)Kleine Platinen, 2–3 A pro Kanal
IRF520 / IRF540NBraucht ca. 10 VBei 5 V hochNicht empfohlen, wird heiß
Schließe den R-, G- oder B-Anschluss des Streifens niemals direkt an einen Arduino-Pin an und verbinde den +12V-Anschluss unter keinen Umständen mit den 5V- oder Signalpins des Arduino. Erreichen 12 V einen Pin, wird der Mikrocontroller sofort zerstört. Ziehe beim Aufbau das Netzteil aus der Steckdose und stecke es erst nach der Kontrolle der Verbindungen wieder ein.

Schaltplan und Anschlusstabelle

Für jeden Farbkanal baust du dieselbe kleine Schaltung dreimal auf. Hältst du den IRLZ44N mit der beschrifteten Seite zu dir, sind die Beinchen von links nach rechts Gate, Drain, Source; die Beinbelegung kannst du auch mit dem Transistor-Tool prüfen. Setze zwischen Gate und Board-Pin einen 220-Ω-Widerstand; er begrenzt den kurzen Stromstoß, wenn die Gate-Kapazität geladen wird. Zwischen Gate und GND kommt zusätzlich ein 10-kΩ-Pull-down-Widerstand; er verhindert, dass der MOSFET beim Einschalten oder Hochladen des Codes, wenn die Pins floaten, von selbst aufgeht und den Streifen zufällig leuchten lässt. Die wichtigste Regel: Der Minuspol des 12-V-Netzteils und GND des Boards müssen unbedingt verbunden sein, sonst fehlt dem Gate-Signal die Referenz. Mehr dazu im Beitrag Gemeinsame Masse (GND).

VerbindungArduino UnoESP32Raspberry Pi Pico
Rot: MOSFET-Gate (über 220 Ω)D9GPIO 25GP11
Grün: MOSFET-Gate (über 220 Ω)D10GPIO 26GP12
Blau: MOSFET-Gate (über 220 Ω)D11GPIO 27GP13
MOSFET-Drain-AnschlüsseR-, G-, B-Anschlüsse des StreifensR-, G-, B-Anschlüsse des StreifensR-, G-, B-Anschlüsse des Streifens
MOSFET-Source-AnschlüsseGNDGNDGND
Potentiometer für den Farbton (Mittelabgriff)A0GPIO 34GP26 (ADC0)
Potentiometer für die Helligkeit (Mittelabgriff)A1Nicht verwendetNicht verwendet
Äußere Potentiometer-Anschlüsse5V und GND3V3 und GND3V3 und GND
Minuspol des 12-V-NetzteilsGNDGNDGND
+12V-Anschluss des StreifensPluspol des NetzteilsPluspol des NetzteilsPluspol des Netzteils

Leistungsberechnung: Welches Netzteil brauche ich?

Um das Netzteil zu wählen, berechnest du zuerst den Strom des Streifens bei vollem Weiß: I = Meter × A/m. Ein 5 m langer Streifen mit 60 LEDs/m zieht 5 × 1,2 = 6 A; die Leistung ist P = U × I = 12 × 6 = 72 W. Wähle das Netzteil immer mit etwa 20 % Reserve: In diesem Beispiel passt 12 V 8 A (96 W). Ein 2 m langer Streifen mit 30 LEDs/m zieht 1,2 A, da reicht ein 12-V-2-A-Netzteil. Wähle auch das Kabel passend zum Strom; bei Strömen über 5 A nimmst du statt Jumperkabeln mindestens 0,75 mm² Querschnitt. Willst du das Board aus demselben Netzteil versorgen, akzeptieren die Strombuchse oder der Vin-Pin des Arduino Uno 12 V und arbeiten bei leichter Last problemlos. Bei ESP32-Boards und dem Pico schließt du 12 V dagegen nicht direkt an; der VSYS-Eingang des Pico verträgt höchstens 5,5 V. Am saubersten ist es, die 12 V mit einem LM2596 Step-down-Wandler auf 5 V zu senken und beim ESP32 an den 5V-Pin, beim Pico an VSYS zu legen. Die Rechnungen kannst du mit dem Ohmschen-Gesetz-Rechner prüfen, Details stehen im Beitrag Elektrische Leistung berechnen.

Aufbau Schritt für Schritt

  1. Baue die komplette Schaltung auf, bevor du das Netzteil einsteckst; ändere nichts an den Verbindungen, solange die Schaltung unter Spannung steht.
  2. Löte vier Kabel an die Lötpads des Streifens oder verwende einen fertigen Steckverbinder; verbinde den +12V-Anschluss mit dem Pluspol des Netzteils.
  3. Setze die drei MOSFETs ein und verbinde die Source-Beinchen mit der gemeinsamen GND-Leitung. Breadboard-Schienen eignen sich für etwa 1 A; bei Streifen mit mehreren Ampere legst du den Strompfad mit Lötverbindungen oder Klemmen aus.
  4. Verbinde das Drain-Beinchen jedes MOSFETs mit dem passenden Farbanschluss (R, G, B) des Streifens.
  5. Verbinde die Gate-Beinchen über 220-Ω-Widerstände mit D9, D10 und D11; setze zwischen jedes Gate und GND einen 10-kΩ-Widerstand.
  6. Verbinde den Minuspol des 12-V-Netzteils mit dem GND-Pin des Arduino, damit eine gemeinsame Masse entsteht.
  7. Verbinde den Arduino per USB mit dem Computer, lade den ersten Code hoch und stecke danach das Netzteil ein.
  8. Prüfe, ob jede Farbe einzeln leuchtet; leuchtet eine falsche Farbe, tausche im Code die Pinnummern.

Erster Code: Farben mischen mit dem Arduino

Nach dem Aufbau startest du am sichersten, indem du jeden Kanal einzeln testest. Der folgende Code nutzt die PWM-Pins 9, 10 und 11 des Uno und zeigt mit der Funktion setColor() nacheinander sechs verschiedene Farben. Wenn dich die Funktionsweise von PWM interessiert, lies den Beitrag Was ist PWM?.

C++ (Arduino IDE)
1const int PIN_R = 9;    // kırmızı MOSFET kapısı / red MOSFET gate
2const int PIN_G = 10;   // yeşil MOSFET kapısı / green MOSFET gate
3const int PIN_B = 11;   // mavi MOSFET kapısı / blue MOSFET gate
4
5void setColor(uint8_t r, uint8_t g, uint8_t b) {
6  analogWrite(PIN_R, r);   // 255 = tam parlak, 0 = sönük / 255 = full, 0 = off
7  analogWrite(PIN_G, g);
8  analogWrite(PIN_B, b);
9}
10
11void setup() {
12  pinMode(PIN_R, OUTPUT);
13  pinMode(PIN_G, OUTPUT);
14  pinMode(PIN_B, OUTPUT);
15  setColor(0, 0, 0);       // başlangıçta kapalı / off at start
16}
17
18void loop() {
19  setColor(255, 0, 0);     delay(1000);   // kırmızı / red
20  setColor(0, 255, 0);     delay(1000);   // yeşil / green
21  setColor(0, 0, 255);     delay(1000);   // mavi / blue
22  setColor(255, 120, 0);   delay(1000);   // turuncu / orange
23  setColor(160, 0, 255);   delay(1000);   // mor / purple
24  setColor(255, 255, 255); delay(1000);   // beyaz / white
25}

Hier gibt es einen wichtigen Unterschied: Schließt du eine einzelne RGB-LED mit gemeinsamer Anode direkt an einen Pin an, ist die Logik invertiert (255 schaltet aus). In der MOSFET-Schaltung dagegen schaltet analogWrite(pin, 255) den MOSFET voll durch und die Farbe leuchtet mit voller Helligkeit; 0 schaltet sie aus. Beim Uno hängen die Pins 9 und 10 an Timer1 und Pin 11 an Timer2, alle drei laufen mit etwa 490 Hz; bei dieser Frequenz nimmt das Auge kein Flackern wahr. Allerdings nutzt tone() den Timer2 und stört damit das PWM an Pin 11, und die Servo-Bibliothek deaktiviert das PWM an Pin 9 und 10. Planst du in deinem Projekt einen Buzzer oder Servo ein, wähle die Pins entsprechend. Außerdem sind die Farben des Streifens nicht gleich hell; wirkt Weiß bläulich, kannst du den Blaukanal auf etwa 200 absenken, um es auszugleichen.

Langsamer Farbverlauf: Farbrad mit millis()

Damit der Streifen weich durch alle Farben wandert, nutzt man die Farbrad-Logik: Ein Farbton zwischen 0 und 767 wird in drei Bereiche geteilt. In den ersten 256 Schritten nimmt Rot ab und Grün zu, in den nächsten 256 geht es von Grün zu Blau, im letzten Abschnitt von Blau zu Rot. Da die Summe zweier Kanäle in jedem Schritt 255 beträgt, gehen die Farben nahtlos ineinander über. Weil wir im Code statt delay() die Funktion millis() verwenden, kannst du in loop() nebenbei andere Dinge tun, etwa Taster lesen oder Sensoren messen. Unser Auge nimmt Helligkeit nicht linear wahr: Kleine Änderungen bei niedrigen Werten fallen stark auf, bei hohen Werten kaum. Deshalb skaliert die Funktion gamma8() im Code den Wert mit seinem Quadrat (v × v / 255) und lässt Übergänge bei gedimmtem Licht natürlicher wirken. Erhöhst du STEP_MS, wird der volle Durchlauf länger; mit 15 ms dauert ein Durchlauf etwa 11,5 Sekunden.

C++ (Arduino IDE)
1const int PIN_R = 9;    // kırmızı / red
2const int PIN_G = 10;   // yeşil / green
3const int PIN_B = 11;   // mavi / blue
4
5const unsigned long STEP_MS = 15;   // 768 x 15 ms = yaklaşık 11,5 s / about 11.5 s per cycle
6unsigned long lastStep = 0;
7int hue = 0;                        // renk tonu 0-767 / hue 0-767
8
9uint8_t gamma8(uint8_t v) {
10  return (uint16_t)v * v / 255;     // basit gama düzeltmesi / simple gamma correction
11}
12
13void setColor(uint8_t r, uint8_t g, uint8_t b) {
14  analogWrite(PIN_R, gamma8(r));
15  analogWrite(PIN_G, gamma8(g));
16  analogWrite(PIN_B, gamma8(b));
17}
18
19void wheel(int h) {
20  uint8_t p = h % 256;
21  if (h < 256)      setColor(255 - p, p, 0);   // kırmızı -> yeşil / red -> green
22  else if (h < 512) setColor(0, 255 - p, p);   // yeşil -> mavi / green -> blue
23  else              setColor(p, 0, 255 - p);   // mavi -> kırmızı / blue -> red
24}
25
26void setup() {
27  pinMode(PIN_R, OUTPUT);
28  pinMode(PIN_G, OUTPUT);
29  pinMode(PIN_B, OUTPUT);
30}
31
32void loop() {
33  if (millis() - lastStep >= STEP_MS) {
34    lastStep = millis();
35    wheel(hue);
36    hue = (hue + 1) % 768;
37  }
38  // burada buton ya da sensör okuyabilirsin / you can read buttons or sensors here
39}

Farbe und Helligkeit per Potentiometer wählen

Für die manuelle Farbwahl reichen zwei Potentiometer: Das Poti an A0 bestimmt den Farbton (0–767), das an A1 die Gesamthelligkeit (0–255). Da analogRead() Werte von 0 bis 1023 liefert, skalieren wir sie mit map() auf den gewünschten Bereich. Die Helligkeit wird angewendet, indem jeder Kanalwert mit bri / 255 multipliziert wird; so bleibt der Farbton erhalten, während das Licht gedimmt wird. R, G und B lassen sich zwar auch direkt mit drei Potentiometern einstellen, aber das Farbrad mit nur einem Regler ist viel intuitiver und erreicht alle gesättigten Farben außer Weiß.

C++ (Arduino IDE)
1const int PIN_R = 9;
2const int PIN_G = 10;
3const int PIN_B = 11;
4const int POT_HUE = A0;   // renk tonu / hue
5const int POT_BRI = A1;   // parlaklık / brightness
6
7void setup() {
8  pinMode(PIN_R, OUTPUT);
9  pinMode(PIN_G, OUTPUT);
10  pinMode(PIN_B, OUTPUT);
11}
12
13void loop() {
14  int hue = map(analogRead(POT_HUE), 0, 1023, 0, 767);
15  int bri = map(analogRead(POT_BRI), 0, 1023, 0, 255);
16
17  uint8_t r, g, b;
18  uint8_t p = hue % 256;
19  if (hue < 256)      { r = 255 - p; g = p;       b = 0; }       // kırmızı -> yeşil / red -> green
20  else if (hue < 512) { r = 0;       g = 255 - p; b = p; }       // yeşil -> mavi / green -> blue
21  else                { r = p;       g = 0;       b = 255 - p; } // mavi -> kırmızı / blue -> red
22
23  analogWrite(PIN_R, (uint16_t)r * bri / 255);   // parlaklığı uygula / apply brightness
24  analogWrite(PIN_G, (uint16_t)g * bri / 255);
25  analogWrite(PIN_B, (uint16_t)b * bri / 255);
26  delay(20);
27}

RGB-Streifen mit dem ESP32 steuern (LEDC)

Beim ESP32 wird für PWM die Hardware-Einheit LEDC genutzt; Frequenz und Auflösung legst du selbst fest. 5 kHz und 8 Bit ergeben ein flimmerfreies Licht und den gewohnten Bereich von 0–255. Beim Arduino-Core 3.x verwendest du ledcAttach(pin, frequenz, auflösung) und ledcWrite(pin, wert); bei 2.x richtest du zuerst mit ledcSetup() einen Kanal ein, bindest ihn mit ledcAttachPin() an den Pin und schreibst mit ledcWrite() auf den Kanal. Der folgende Code unterstützt beide Versionen per #if. Da die ESP32-Pins 3,3 V liefern, ist ein MOSFET mit niedriger Gate-Spannung wie der IRLB8721 aus der Tabelle wichtig. Das Potentiometer haben wir an GPIO 34 angeschlossen, einen ADC1-Pin, der auch bei aktivem WLAN problemlos funktioniert; der ADC hat 12 Bit, die Werte liegen also zwischen 0 und 4095, und zur Rauschminderung wird über acht Messungen gemittelt. Grundlagen zum Board findest du im Beitrag Was ist der ESP32?.

C++ (Arduino IDE)
1const int PIN_R = 25;       // kırmızı MOSFET kapısı / red MOSFET gate
2const int PIN_G = 26;       // yeşil / green
3const int PIN_B = 27;       // mavi / blue
4const int POT_HUE = 34;     // ADC1, yalnız giriş / ADC1, input only
5const int PWM_FREQ = 5000;  // 5 kHz, titreşimsiz / flicker-free
6const int PWM_RES = 8;      // 8 bit: 0-255
7
8void setColor(uint8_t r, uint8_t g, uint8_t b) {
9#if ESP_ARDUINO_VERSION_MAJOR >= 3
10  ledcWrite(PIN_R, r);      // core 3.x: pine yaz / write to pin
11  ledcWrite(PIN_G, g);
12  ledcWrite(PIN_B, b);
13#else
14  ledcWrite(0, r);          // core 2.x: kanala yaz / write to channel
15  ledcWrite(1, g);
16  ledcWrite(2, b);
17#endif
18}
19
20void setup() {
21#if ESP_ARDUINO_VERSION_MAJOR >= 3
22  ledcAttach(PIN_R, PWM_FREQ, PWM_RES);
23  ledcAttach(PIN_G, PWM_FREQ, PWM_RES);
24  ledcAttach(PIN_B, PWM_FREQ, PWM_RES);
25#else
26  ledcSetup(0, PWM_FREQ, PWM_RES);
27  ledcSetup(1, PWM_FREQ, PWM_RES);
28  ledcSetup(2, PWM_FREQ, PWM_RES);
29  ledcAttachPin(PIN_R, 0);
30  ledcAttachPin(PIN_G, 1);
31  ledcAttachPin(PIN_B, 2);
32#endif
33  analogReadResolution(12);  // 0-4095
34  setColor(0, 0, 0);
35}
36
37void loop() {
38  long sum = 0;
39  for (int i = 0; i < 8; i++) {
40    sum += analogRead(POT_HUE);   // 8 okumayı topla / sum 8 readings
41  }
42  int hue = map(sum / 8, 0, 4095, 0, 767);
43  uint8_t p = hue % 256;
44  if (hue < 256)      setColor(255 - p, p, 0);   // kırmızı -> yeşil / red -> green
45  else if (hue < 512) setColor(0, 255 - p, p);   // yeşil -> mavi / green -> blue
46  else                setColor(p, 0, 255 - p);   // mavi -> kırmızı / blue -> red
47  delay(20);
48}

MicroPython-Code für den Raspberry Pi Pico

Auf dem Pico kann jeder GPIO-Pin PWM erzeugen, und duty_u16() nimmt Werte von 0 bis 65535. Im Code rechnen wir die Farbwerte von 0–255 mit dem Faktor 257 in diesen Bereich um (255 × 257 = 65535). Das Potentiometer hängt an GP26 (ADC0); read_u16() liefert ebenfalls 0–65535 und lässt sich leicht in einen Farbton umrechnen. GP12 und GP13 teilen sich dasselbe PWM-Slice (Slice 6); da wir beiden dieselbe Frequenz geben, gibt es kein Problem, aber versuchst du, unterschiedliche Frequenzen einzustellen, wirkt die letzte Einstellung auf beide. Da der Pico mit 3,3 V arbeitet, gilt auch hier die MOSFET-Empfehlung für den ESP32. Zur Einrichtung kannst du den Beitrag Was ist der Raspberry Pi Pico? lesen.

MicroPython
1from machine import Pin, PWM, ADC
2import time
3
4pins = (11, 12, 13)                      # R, G, B MOSFET kapıları / gates
5leds = []
6for p in pins:
7    pwm = PWM(Pin(p))
8    pwm.freq(1000)                       # 1 kHz PWM
9    pwm.duty_u16(0)                      # başlangıçta kapalı / off at start
10    leds.append(pwm)
11
12pot = ADC(26)                            # GP26 = ADC0
13
14def set_color(r, g, b):
15    # 0-255 değerini 0-65535'e çevir / convert 0-255 to 0-65535
16    leds[0].duty_u16(r * 257)
17    leds[1].duty_u16(g * 257)
18    leds[2].duty_u16(b * 257)
19
20def wheel(hue):
21    p = hue % 256
22    if hue < 256:
23        return 255 - p, p, 0             # kırmızı -> yeşil / red -> green
24    elif hue < 512:
25        return 0, 255 - p, p             # yeşil -> mavi / green -> blue
26    return p, 0, 255 - p                 # mavi -> kırmızı / blue -> red
27
28while True:
29    hue = pot.read_u16() * 767 // 65535  # 0-767 ton / hue
30    set_color(*wheel(hue))
31    time.sleep_ms(20)

Projektideen mit dem RGB LED Streifen

  • Musikreaktive Ambientebeleuchtung: Ändere mit einem Soundsensor Farbe und Helligkeit des Streifens im Rhythmus der Musik; Details im Beitrag Musikreaktive LED.
  • Fernbediente TV-Hintergrundbeleuchtung: Ändere mit einem IR-Empfänger und einer Fernbedienung Farbe und Helligkeit vom Sofa aus.
  • Treppenlicht mit Bewegungsmelder: Erkennt ein PIR-Sensor jemanden, blendest du den Streifen langsam ein und nach einer Weile wieder aus.
  • Automatisches Nachtlicht: Wird es dunkel, lässt ein LDR einen warmen Orangeton mit gedimmter Helligkeit leuchten.
  • Steuerung per Handy: Richte mit dem ESP32 einen Webserver ein und nutze eine Farbauswahl im Browser.
  • Sonnenaufgangswecker: Blende den Streifen 20 Minuten vor der Weckzeit langsam von dunklem Rot zu Weiß auf.

Häufige Fehler und ihre Lösungen

SymptomMögliche UrsacheLösung
Der Streifen leuchtet gar nichtKeine gemeinsame Masse oder +12V-Anschluss nicht verbundenMinuspol des Netzteils mit GND des Boards verbinden, +12V-Anschluss des Streifens prüfen
Eine Farbe leuchtet dauerhaft, egal was der Code sagtDrain und Source des MOSFETs vertauscht oder MOSFET defektBeinbelegung (G-D-S) prüfen, ggf. MOSFET tauschen
Der Streifen blinkt beim Einschalten von selbstKein Gate-Pull-down-Widerstand10 kΩ zwischen jedes Gate und GND setzen
MOSFET wird sehr heißKein Logic-Level-MOSFET oder zu niedrige Gate-Spannung bei 3,3 VLogic-Level-MOSFET wie IRLZ44N oder IRLB8721 verwenden
Farben vertauscht (Grün statt Rot)Beschriftung des Streifens oder Kabelreihenfolge andersIm Code die Werte von PIN_R, PIN_G, PIN_B tauschen
Das Streifenende wirkt gelblich und blassSpannungsabfall bei langem StreifenStreifen über 5 m an beiden Enden einspeisen, dickes Kabel verwenden
Board setzt sich zurück oder startet neuNetzteil zu schwach, Spannung bricht einStärkeres Netzteil verwenden, Board über einen eigenen Regler versorgen
Flackern oder Streifen auf KameraaufnahmenZu niedrige PWM-FrequenzBeim ESP32 und Pico die Frequenz auf 1–5 kHz erhöhen

Ein nicht adressierbarer RGB-Streifen mit drei MOSFETs und drei PWM-Pins ist der praktischste Weg, deinem Zimmer, Schreibtisch oder Projekt eine kräftige, günstige Lichtebene zu geben. Willst du jede LED einzeln steuern, ist der nächste Schritt vielleicht der WS2812B. In der BlueGrays-App findest du Projekte wie Farbmischen mit RGB-LED, weiche Farbverläufe, eine ESP32-Farbmisch-Lampe und den Pico-RGB-Farbwechsel Schritt für Schritt mit Schaltplan und Code.

Häufige Fragen

Kann ich einen RGB LED Streifen direkt an den Arduino anschließen?

Nein. Ein 12-V-Streifen kann pro Meter mehr als ein Ampere ziehen, ein Arduino-Pin liefert dagegen nur etwa 20 mA und arbeitet mit 5 V. Du musst den Streifen pro Farbkanal über einen Logic-Level-MOSFET ansteuern; der Arduino schickt nur das PWM-Signal an das Gate des MOSFETs.

Welchen MOSFET brauche ich für einen 12-V-LED-Streifen?

Für den 5-V-Arduino Uno und Nano ist der IRLZ44N eine verbreitete und passende Wahl. Bei 3,3-V-Boards wie dem ESP32 und dem Raspberry Pi Pico liefern MOSFETs wie der IRLB8721 oder AO3400, die schon bei niedriger Gate-Spannung voll durchschalten, bessere Ergebnisse. IRF520 und IRF540N schalten bei 5 V nicht voll durch und werden deshalb heiß.

Wie viel Ampere zieht ein 5 m RGB LED Streifen?

Ein 5050-Streifen mit 60 LEDs/m zieht bei vollem Weiß etwa 1,2 A pro Meter; 5 Meter ergeben rund 6 A und 72 W. Bei 30 LEDs/m halbieren sich diese Werte. Wähle das Netzteil mit 20 % Reserve; für 6 A passt ein 12-V-8-A-Netzteil.

Was ist der Unterschied zwischen RGB-Streifen und WS2812B?

Beim nicht adressierbaren RGB-Streifen zeigen alle LEDs gleichzeitig dieselbe Farbe, und er wird mit drei MOSFETs angesteuert. Beim WS2812B hat jede LED einen eigenen Treiberchip, und über einen einzigen Datenpin bekommt jede LED eine eigene Farbe. Der WS2812B eignet sich für Lauflichteffekte, der RGB-Streifen für günstige, kräftige Flächenbeleuchtung.

Wo darf ich einen RGB LED Streifen schneiden?

12-V-Streifen bestehen aus Segmenten mit drei LEDs und dürfen nur an den Schnittmarkierungen auf den Kupferpads durchtrennt werden; der Abstand beträgt bei 60 LEDs/m 5 cm, bei 30 LEDs/m 10 cm. Schneidest du woanders, leuchtet dieses Segment nicht. Das abgeschnittene Stück kannst du durch Anlöten von Kabeln oder mit einem Klemmverbinder wieder anschließen.

Kann ich den Arduino aus dem 12-V-Netzteil des Streifens versorgen?

Den Arduino Uno kannst du über die Strombuchse oder den Vin-Pin mit 12 V versorgen; der Regler auf dem Board schafft das bei leichter Last. Bei ESP32-Boards und dem Raspberry Pi Pico musst du die 12 V mit einem Step-down-Wandler wie dem LM2596 auf 5 V senken. In jedem Fall muss der Minuspol des Netzteils mit GND des Boards verbunden sein.

Alle Projekte ansehen
RGB-LED verwenden
AR-39Anfänger
Premium

RGB-LED verwenden

In einer einzigen LED stecken drei Farben: Die RGB-LED leuchtet erst rot, dann grün, dann blau, jede Farbe eine halbe Sekunde an und eine halbe Sekunde aus, und dann geht es von vorne los.

4.9(73)
100
Sanfte Farbübergänge mit RGB-Led
AR-40Anfänger
Premium

Sanfte Farbübergänge mit RGB-Led

Eine einzige RGB-LED wandert langsam von Rot zu Grün, von Grün zu Blau und wieder zurück zu Rot, eine Regenbogenschleife ohne Ende.

4.8(58)
78
ESP32 RGB-LED-Steuerung
ES-9Anfänger

ESP32 RGB-LED-Steuerung

Unbegrenzte Farberzeugung mit einer einzigen RGB-LED anstelle von 3 separaten LEDs. Wie in Arduino machen wir Regenbogenübergänge, indem wir R/G/B-Werte mit analogWrite() setzen. Die Farbtheorie (z. B. Rot+Grün=Gelb) wird praktisch umgesetzt.

4.6(29)
52
ESP32-Farbmischerlampe (3 Potentiometer + RGB-LED + OLED)
ES-36Fortgeschritten
Premium

ESP32-Farbmischerlampe (3 Potentiometer + RGB-LED + OLED)

Eine smarte Farbmischer-Lampe: Dreh an 3 Potentiometern am ESP32 und misch dir jede Farbe! Während du die Potis für Rot, Grün und Blau drehst, wechselt die RGB-LED mit gemeinsamer Kathode sofort die Farbe. Das SSD1306-OLED zeigt live für jede Farbe den Wert von 0-255, Füllbalken und den HEX-Webfarbcode (etwa #FF8040).

4.7(6)
10
Raspberry Pi Pico RGB-LED Farbwechsel (3-Kanal-PWM)
PI-15Anfänger

Raspberry Pi Pico RGB-LED Farbwechsel (3-Kanal-PWM)

Eine LED, Millionen Farben! Eine RGB-LED enthält 3 LEDs: Rot, Grün und Blau. Mit je einem PWM-Kanal des Pico mischst du Farben: Rot + Grün = Gelb, Grün + Blau = Cyan, alle drei = Weiß. Die LED wechselt durch 8 Farben. Lerne mehrere PWM-Kanäle, Funktionen (def), RGB-Farbmischung, 8-Bit → 16-Bit-Umrechnung (x257) und gemeinsame Kathode vs. Anode.

6
ESP32 LED-Überblendung mit PWM
ES-8Anfänger

ESP32 LED-Überblendung mit PWM

Ändern Sie die Helligkeit der LED stufenlos von 0 bis max, von max bis 0. Wir steuern PWM mit analogWrite() wie in Arduino - die gleiche Syntax mit ESP32 Arduino Core 3.0+ funktioniert reibungslos. Pin-Definition + pinMode + analogWrite ist genug.

4.8(36)
55
ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
ES-13Mittel
Premium

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)

In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.

4.5(19)
32
Raspberry Pi Pico PWM LED Fade (Atem-Effekt)
PI-14Anfänger

Raspberry Pi Pico PWM LED Fade (Atem-Effekt)

Die LED blinkt nicht mehr nur — sie atmet! Mit der PWM (Pulsweitenmodulation) des Raspberry Pi Pico steigt die Helligkeit langsam an und fällt wieder ab. Lerne die machine.PWM-Klasse, duty_u16() (16-Bit-Helligkeit 0–65535), PWM-Frequenz, range()-Schleifen und analogähnliche Ausgabe. Grundlage für RGB-Farbmischung, Motorsteuerung, Servos und Buzzer.

4