Striscia LED RGB con Arduino: Controllo a 12 V con MOSFET
Come controllare una striscia LED RGB 12 V con Arduino: MOSFET IRLZ44N, PWM a tre canali, dissolvenza dei colori, potenziometro, alimentatore e codice ESP32 e Pico.
Controllare una striscia LED RGB con Arduino significa pilotare i canali rosso, verde e blu di una striscia 5050 non indirizzabile da 12 V con tre segnali PWM separati, per ottenere il colore che vuoi. I pin di Arduino non reggono né i 12 V né gli ampere assorbiti dalla striscia, quindi serve un MOSFET per ogni canale: Arduino manda solo un segnale a 5 V al gate del MOSFET, e la corrente vera passa attraverso quest'ultimo. Così puoi controllare metri di striscia con un piccolo microcontrollore in modo sicuro.
In questa guida vedrai come è fatta la striscia 5050, come scegliere il MOSFET giusto, come fare i collegamenti e come calcolare l'alimentatore. Poi miscelerai i colori con Arduino Uno, creerai una dissolvenza fluida basata su millis() e sceglierai colore e luminosità con i potenziometri; infine userai lo stesso circuito con l'unità LEDC dell'ESP32 e con il PWM MicroPython di Raspberry Pi Pico. Troverai anche la differenza rispetto ai WS2812B e, alla fine, le soluzioni agli errori più comuni.
Cos'è una striscia LED RGB e come funziona?
In una striscia RGB non indirizzabile, ogni package SMD 5050 contiene tre chip LED separati: rosso, verde e blu. La striscia è formata da segmenti a 12 V collegati in parallelo, ciascuno con tre LED e una resistenza di limitazione per colore; la tensione diretta totale di tre LED in serie è di circa 6–9 V a seconda del colore, e il resto lo assorbe la resistenza. La striscia ha quattro terminali: il positivo comune (+12V) e R, G, B. Quindi è ad anodo comune: per accendere un colore devi collegare la sua linea a GND. Tutta la striscia mostra sempre lo stesso colore; non puoi accendere i singoli LED con colori diversi. Il colore dipende dal duty cycle PWM di ogni canale: rosso e verde al massimo danno il giallo, tutti e tre al massimo una luce vicina al bianco.
| Caratteristica | Striscia da 30 LED/m | Striscia da 60 LED/m |
|---|---|---|
| Tipo di LED | SMD 5050 (5,0 × 5,0 mm, 3 chip) | SMD 5050 (5,0 × 5,0 mm, 3 chip) |
| Tensione di lavoro | 12 V DC | 12 V DC |
| Potenza (bianco pieno) | Circa 7,2 W/m | Circa 14,4 W/m |
| Corrente (bianco pieno) | Circa 0,6 A/m | Circa 1,2 A/m |
| Corrente per canale | Circa 0,2 A/m | Circa 0,4 A/m |
| Punto di taglio | Ogni 3 LED (10 cm) | Ogni 3 LED (5 cm) |
| Terminali | +12V, R, G, B | +12V, R, G, B |
Differenza tra striscia RGB e WS2812B
Entrambe le strisce emettono luce RGB, ma la logica di controllo è del tutto diversa. La striscia non indirizzabile è come una lampada: regoli il colore dell'intera striscia cambiando la luminosità dei tre canali. Nella striscia WS2812B NeoPixel, invece, ogni LED ha un piccolo chip driver e con un'unica linea dati puoi inviare un colore diverso a ciascun LED. La tabella qui sotto ti aiuta a scegliere:
| Caratteristica | Striscia RGB 12 V (5050) | Striscia WS2812B |
|---|---|---|
| Controllo | Tutta la striscia di un colore | Ogni LED di un colore diverso |
| Alimentazione | 12 V (esistono anche versioni a 24 V) | 5 V |
| Cavi | 4 fili: +12V, R, G, B | 3 fili: 5V, DIN, GND |
| Circuito di pilotaggio | Un MOSFET per canale | Non serve, basta un pin dati |
| Codice | analogWrite / PWM | Libreria FastLED o Adafruit NeoPixel |
| Corrente (60 LED/m, bianco pieno) | Circa 1,2 A/m (12 V) | Circa 3,6 A/m (5 V) |
| Caduta di tensione | Di solito nessun problema fino a 5 m | Sulle strisce lunghe serve alimentare in più punti |
| Effetti | Colore fisso, dissolvenza, respiro | Luce scorrevole, arcobaleno, animazioni |
| Prezzo | Economica | Più cara |
Perché serve un MOSFET e quale scegliere?
Un pin di Arduino Uno è progettato per erogare circa 20 mA (limite assoluto 40 mA), mentre un solo canale di una striscia da 5 metri a 60 LED/m può assorbire 2 A. Inoltre la striscia funziona a 12 V. Un MOSFET a canale N risolve il problema come interruttore low-side: il Drain va alla linea del colore della striscia, il Source a GND e la tensione applicata al Gate accende e spegne il MOSFET. Il punto cruciale è scegliere un MOSFET logic level: i MOSFET standard come IRF520 o IRF540N vogliono circa 10 V per aprirsi del tutto, a 5 V restano semiaperti e si scaldano. La potenza dissipata nel MOSFET si calcola con P = I² × Rds(on): con 2 A e 0,025 Ω fa 2 × 2 × 0,025 = 0,1 W, quindi non serve il dissipatore. Per le basi leggi Usare i MOSFET con Arduino.
| MOSFET | Tensione di gate | Rds(on) | Idoneità |
|---|---|---|---|
| IRLZ44N | Logic level, completamente aperto a 4–5 V | 0,025 Ω (a 5 V) | Ideale per Uno e Nano; a 3,3 V solo per strisce corte |
| IRLB8721 | Si apre bene anche a 3,3 V | Circa 0,009 Ω (a 4,5 V) | Una delle scelte migliori per ESP32 e Pico |
| AO3400 (SMD) | Si apre a 2,5 V | Circa 0,03 Ω (a 4,5 V) | Schede piccole, 2–3 A per canale |
| IRF520 / IRF540N | Richiede circa 10 V | Alta a 5 V | Sconsigliati, si scaldano |
Schema del circuito e tabella dei collegamenti
Per ogni canale di colore costruisci tre volte lo stesso piccolo circuito. Se tieni l'IRLZ44N con il lato scritto rivolto verso di te, i piedini da sinistra a destra sono Gate, Drain, Source; puoi controllare l'ordine anche con lo strumento per transistor. Tra il Gate e il pin della scheda metti una resistenza da 220 Ω: limita la corrente improvvisa assorbita dal pin mentre si carica la capacità del gate. Tra il Gate e GND aggiungi anche una resistenza pull-down da 10 kΩ: quando la scheda si accende o si carica il codice e i pin sono flottanti, evita che il MOSFET si apra da solo e accenda la striscia a caso. La regola più importante: il negativo dell'alimentatore a 12 V e il GND della scheda devono essere uniti, altrimenti il segnale di gate non ha riferimento. Ne parliamo in dettaglio nell'articolo sulla massa comune (GND).
| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Gate MOSFET rosso (tramite 220 Ω) | D9 | GPIO 25 | GP11 |
| Gate MOSFET verde (tramite 220 Ω) | D10 | GPIO 26 | GP12 |
| Gate MOSFET blu (tramite 220 Ω) | D11 | GPIO 27 | GP13 |
| Drain dei MOSFET | Terminali R, G, B della striscia | Terminali R, G, B della striscia | Terminali R, G, B della striscia |
| Source dei MOSFET | GND | GND | GND |
| Potenziometro del colore (centrale) | A0 | GPIO 34 | GP26 (ADC0) |
| Potenziometro della luminosità (centrale) | A1 | Non usato | Non usato |
| Estremi dei potenziometri | 5V e GND | 3V3 e GND | 3V3 e GND |
| Negativo dell'alimentatore a 12 V | GND | GND | GND |
| Terminale +12V della striscia | Positivo dell'alimentatore | Positivo dell'alimentatore | Positivo dell'alimentatore |
Calcolo della potenza: quale alimentatore scegliere?
Per scegliere l'alimentatore, calcola prima la corrente della striscia a bianco pieno: I = metri × A/m. Una striscia da 5 metri a 60 LED/m assorbe 5 × 1,2 = 6 A; la potenza è P = V × I = 12 × 6 = 72 W. Scegli sempre un alimentatore con circa il 20% di margine: in questo esempio va bene un 12 V 8 A (96 W). Una striscia da 2 metri a 30 LED/m assorbe 1,2 A, quindi basta un alimentatore 12 V 2 A. Scegli anche il cavo in base alla corrente: sopra i 5 A usa un cavo da almeno 0,75 mm² al posto dei jumper. Se vuoi alimentare la scheda dallo stesso alimentatore, il jack di alimentazione o il pin Vin di Arduino Uno accettano 12 V e con carichi leggeri funzionano senza problemi. Sulle schede ESP32 e sul Pico, invece, non collegare i 12 V direttamente: l'ingresso VSYS del Pico accetta al massimo 5,5 V. Per queste schede la soluzione più pulita è abbassare i 12 V a 5 V con un regolatore step-down LM2596 e darli al pin 5V sull'ESP32 e al pin VSYS sul Pico. Puoi verificare i calcoli con la calcolatrice della legge di Ohm; per approfondire leggi il calcolo della potenza elettrica.
Montaggio passo dopo passo
- Monta tutto il circuito prima di collegare l'alimentatore alla presa; non cambiare i collegamenti con il circuito sotto tensione.
- Salda quattro cavi ai pad della striscia oppure usa un connettore già pronto; collega il +12V al positivo dell'alimentatore.
- Posiziona i tre MOSFET e collega i piedini Source alla linea GND comune. Le linee della breadboard vanno bene per circa 1 A; con strisce da diversi ampere realizza il percorso della corrente con saldature o morsetti.
- Collega il Drain di ogni MOSFET al terminale del colore corrispondente della striscia (R, G, B).
- Collega i Gate a D9, D10 e D11 tramite resistenze da 220 Ω e aggiungi una resistenza da 10 kΩ tra ogni Gate e GND.
- Collega il negativo dell'alimentatore a 12 V al pin GND di Arduino per creare la massa comune.
- Collega Arduino al computer via USB, carica il primo codice e poi collega l'alimentatore.
- Verifica che ogni colore si accenda da solo; se si accende il colore sbagliato, scambia i numeri dei pin nel codice.
Primo codice: miscelare i colori con Arduino
Dopo aver montato il circuito, il modo più sicuro per iniziare è provare un canale alla volta. Il codice qui sotto usa i pin PWM 9, 10 e 11 di Uno e mostra in sequenza sei colori diversi con la funzione setColor(). Se vuoi capire la logica del PWM, leggi Cos'è il PWM.
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}C'è una differenza importante: se colleghi direttamente a un pin un singolo LED RGB ad anodo comune, la logica è invertita (255 spegne), ma in un circuito con MOSFET analogWrite(pin, 255) apre completamente il MOSFET e accende il colore alla massima luminosità, mentre 0 lo spegne. Su Uno i pin 9 e 10 sono legati al Timer1 e il pin 11 al Timer2, e tutti lavorano a circa 490 Hz; a questa frequenza l'occhio non nota lo sfarfallio. Però la funzione tone() usa il Timer2 e rovina il PWM del pin 11, mentre la libreria Servo disattiva il PWM sui pin 9 e 10. Se nel progetto hai un buzzer o un servo, pianifica i pin di conseguenza. Inoltre i colori della striscia non hanno la stessa luminosità: se il bianco appare bluastro, puoi bilanciarlo abbassando il canale blu intorno a 200.
Dissolvenza lenta dei colori: ruota dei colori con millis()
Perché la striscia percorra dolcemente tutti i colori si usa la logica della ruota dei colori: un valore di tonalità da 0 a 767 viene diviso in tre zone. Nei primi 256 passi il rosso cala e il verde sale, nei 256 successivi si passa dal verde al blu e nell'ultima parte dal blu al rosso. Poiché la somma dei due canali a ogni passo è 255, i colori scorrono l'uno nell'altro senza stacchi. Nel codice usiamo millis() al posto di delay(), quindi dentro loop() puoi anche leggere pulsanti o misurare sensori. Il nostro occhio non percepisce la luminosità in modo lineare: piccole variazioni a valori bassi sono molto evidenti, mentre a valori alti si notano a fatica. Per questo la funzione gamma8() nel codice scala il valore con il suo quadrato (v × v / 255) e rende più naturali le transizioni a luce bassa. Se aumenti STEP_MS il giro completo dura di più; con 15 ms un giro dura circa 11,5 secondi.
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}Scegliere colore e luminosità con i potenziometri
Per scegliere il colore a mano bastano due potenziometri: quello su A0 determina la tonalità (0–767), quello su A1 la luminosità generale (0–255). Poiché analogRead() restituisce valori da 0 a 1023, li scaliamo con map() nell'intervallo che ci serve. La luminosità si applica moltiplicando il valore di ogni canale per bri / 255; così la tonalità resta invariata mentre la luce si attenua. È possibile regolare direttamente R, G e B con tre potenziometri, ma la ruota dei colori con una sola manopola è molto più intuitiva e ti permette di raggiungere tutti i colori saturi, tranne il bianco.
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}Controllare la striscia RGB con ESP32 (LEDC)
Sull'ESP32 per il PWM si usa l'unità hardware LEDC; frequenza e risoluzione le scegli tu. 5 kHz e 8 bit danno una luce senza sfarfallio e il consueto intervallo 0–255. Con l'Arduino core 3.x si usano ledcAttach(pin, frequenza, risoluzione) e ledcWrite(pin, valore), mentre con la 2.x si configura prima un canale con ledcSetup(), lo si collega al pin con ledcAttachPin() e ledcWrite() scrive sul canale; il codice qui sotto supporta entrambe le versioni con #if. Poiché i pin dell'ESP32 danno 3,3 V, è importante scegliere un MOSFET con bassa tensione di gate come l'IRLB8721 della tabella. Abbiamo collegato il potenziometro al GPIO 34, un pin ADC1 che funziona senza problemi anche con il Wi-Fi attivo; l'ADC è a 12 bit, quindi i valori vanno da 0 a 4095, e per ridurre il rumore si fa la media di otto letture. Per le basi della scheda leggi Cos'è l'ESP32.
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}Codice MicroPython con Raspberry Pi Pico
Sul Pico ogni pin GPIO può generare PWM e duty_u16() accetta valori da 0 a 65535. Nel codice portiamo i valori colore 0–255 in questo intervallo moltiplicandoli per 257 (255 × 257 = 65535). Il potenziometro è collegato a GP26 (ADC0); read_u16() restituisce 0–65535, quindi si converte facilmente in tonalità. GP12 e GP13 condividono lo stesso slice PWM (slice 6); dando a entrambi la stessa frequenza non ci sono problemi, ma se provi a impostare frequenze diverse l'ultima impostazione influisce su entrambi. Poiché il Pico lavora a 3,3 V, il consiglio sui MOSFET dato per l'ESP32 vale anche qui. Per l'installazione leggi Cos'è Raspberry Pi Pico.
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)Idee di progetto con la striscia LED RGB
- Atmosfera sensibile alla musica: con un sensore audio cambia colore e luminosità della striscia a ritmo di musica; i dettagli sono nell'articolo sui LED sensibili alla musica.
- Retroilluminazione TV con telecomando: con un ricevitore IR e telecomando cambi colore e luminosità dal divano.
- Luce per scale con rilevamento di movimento: quando il sensore PIR rileva qualcuno, accendi lentamente la striscia e dopo un po' spegnila.
- Luce notturna automatica: quando l'ambiente si fa buio, un LDR accende un caldo arancione a bassa luminosità.
- Controllo da smartphone: con l'ESP32 crea un web server e usa il selettore di colore dal browser.
- Sveglia alba: 20 minuti prima dell'orario di risveglio, accendi lentamente la striscia dal rosso scuro al bianco.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| La striscia non si accende affatto | Manca la massa comune oppure il +12V non è collegato | Collega il negativo dell'alimentatore al GND della scheda e controlla il terminale +12V della striscia |
| Un colore resta sempre acceso qualunque cosa dica il codice | Drain e Source del MOSFET sono invertiti oppure il MOSFET è bruciato | Controlla l'ordine dei piedini (G-D-S) e, se serve, sostituisci il MOSFET |
| All'accensione la striscia lampeggia da sola | Manca la resistenza pull-down sul Gate | Aggiungi 10 kΩ tra ogni Gate e GND |
| Il MOSFET si scalda molto | MOSFET non logic level o tensione di gate insufficiente a 3,3 V | Usa un MOSFET logic level come IRLZ44N o IRLB8721 |
| Colori scambiati (si accende il verde al posto del rosso) | Etichette della striscia o ordine dei cavi diversi | Scambia i valori di PIN_R, PIN_G, PIN_B nel codice |
| La fine della striscia è giallastra e tenue | Caduta di tensione sulla striscia lunga | Alimenta le strisce oltre 5 m da entrambe le estremità e usa un cavo più spesso |
| La scheda si resetta o si riavvia | Alimentatore insufficiente, la tensione crolla | Usa un alimentatore più potente e alimenta la scheda con un regolatore separato |
| Sfarfallio o righe in camera | Frequenza PWM bassa | Su ESP32 e Pico porta la frequenza a 1–5 kHz |
La striscia RGB non indirizzabile con tre MOSFET e tre pin PWM è il modo più pratico per dare alla tua stanza, alla tua scrivania o al tuo progetto uno strato di luce potente ed economico. Se vuoi controllare ogni LED separatamente, il passo successivo possono essere i WS2812B. Nell'app BlueGrays trovi passo dopo passo, con schema del circuito e codice, i progetti di miscelazione colori con LED RGB, dissolvenza dei colori, lampada mixer di colori con ESP32 e ciclo di colori RGB con Pico.
Domande frequenti
Si può collegare una striscia LED RGB direttamente ad Arduino?
No. Una striscia a 12 V può assorbire più di un ampere per metro, mentre un pin di Arduino eroga circa 20 mA e lavora a 5 V. Devi pilotare la striscia con un MOSFET logic level per ogni canale colore; Arduino manda solo il segnale PWM al gate del MOSFET.
Quale MOSFET si usa per una striscia LED da 12 V?
Per Arduino Uno e Nano a 5 V l'IRLZ44N è una scelta diffusa e adatta. Sulle schede a 3,3 V come ESP32 e Raspberry Pi Pico funzionano meglio MOSFET che si aprono del tutto con bassa tensione di gate, come IRLB8721 o AO3400. IRF520 e IRF540N non si aprono completamente a 5 V e quindi si scaldano.
Quanti ampere assorbe una striscia LED RGB da 5 metri?
Una striscia 5050 da 60 LED/m assorbe circa 1,2 A per metro a bianco pieno; 5 metri fanno circa 6 A e 72 W. Con una striscia da 30 LED/m questi valori si dimezzano. Scegli l'alimentatore con il 20% di margine: per 6 A va bene un 12 V 8 A.
Qual è la differenza tra striscia LED RGB e WS2812B?
Nella striscia RGB non indirizzabile tutti i LED mostrano lo stesso colore nello stesso momento e si pilota con tre MOSFET. Nei WS2812B ogni LED ha il proprio chip driver e da un solo pin dati si invia un colore diverso a ciascun LED. I WS2812B sono ideali per gli effetti scorrevoli, la striscia RGB per un'illuminazione uniforme economica e potente.
Dove si può tagliare una striscia LED RGB?
Le strisce a 12 V funzionano a segmenti di tre LED e si possono tagliare solo sui segni di taglio sui pad di rame; l'intervallo è 5 cm a 60 LED/m e 10 cm a 30 LED/m. Se tagli altrove, quel segmento non si accende. Il pezzo tagliato lo ricolleghi saldando i cavi ai pad o con un connettore a incastro.
Posso alimentare Arduino con l'alimentatore a 12 V della striscia?
Puoi alimentare Arduino Uno a 12 V dal jack di alimentazione o dal pin Vin; il regolatore sulla scheda lo regge con carichi leggeri. Sulle schede ESP32 e su Raspberry Pi Pico devi invece abbassare i 12 V a 5 V con uno step-down come l'LM2596. In ogni caso il negativo dell'alimentatore deve essere collegato al GND della scheda.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Utilizzo dei LED RGB
Dentro un solo LED si nascondono tre colori: il LED RGB si accende rosso, poi verde, poi blu, ogni colore acceso per mezzo secondo e spento per mezzo secondo, e poi il giro ricomincia.

Transizione cromatica omogenea con LED RGB
Un solo LED RGB passa lentamente dal rosso al verde, dal verde al blu e torna al rosso, in un giro di arcobaleno che non si ferma mai.

Controllo LED RGB ESP32
Generazione illimitata di colori con un singolo LED RGB invece di 3 LED separati. La transizione arcobaleno avviene impostando i valori R/G/B con analogWrite() come in Arduino. La teoria dei colori (come rosso+verde=giallo) viene vista in pratica.

Lampada con miscelatore di colori ESP32 (3 potenziometri + LED RGB + OLED)
Una lampada mixer di colori smart: gira 3 potenziometri sull'ESP32 e mescola il colore che vuoi! Mentre ruoti i potenziometri rosso, verde e blu, il LED RGB a catodo comune cambia colore all'istante. Il display OLED SSD1306 mostra in tempo reale il valore 0-255 di ogni colore, barre di riempimento e il codice colore web HEX (come #FF8040).

Raspberry Pi Pico LED RGB Ciclo di Colori (PWM a 3 Canali)
Un LED, milioni di colori! Un LED RGB contiene 3 LED: rosso, verde e blu. Con un canale PWM del Pico per ciascuno, i colori si mescolano: rosso + verde = giallo, verde + blu = ciano, tutti e tre = bianco. Il LED scorre 8 colori. Impara più canali PWM, funzioni (def), miscelazione RGB, conversione da 8 a 16 bit (x257) e catodo comune vs anodo comune.

Dissolvenza LED ESP32 con PWM
Modificare la luminosità del LED in modo fluido da 0 a max, da max a 0. Controlliamo il PWM con analogWrite() come in Arduino - la stessa sintassi con ESP32 Arduino Core 3.0+ funziona senza problemi. La definizione del pin + pinMode + analogWrite è sufficiente.

Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
In questo progetto controlliamo in modo analogico la luminosità di un LED tramite un potenziometro. Il pin ADC dell'ESP32 legge la tensione tra 0 e 3,3 V dal potenziometro; il valore viene convertito in un segnale PWM (Pulse Width Modulation) e inviato al LED. Ruotando il potenziometro, il LED si accende e si spegne gradualmente. Con Arduino Core 3.0+ si usa direttamente analogWrite(); su ESP32-S2/S3 la risoluzione dell'ADC è fissata a 12 bit.

Raspberry Pi Pico PWM LED Fade (Effetto Respiro)
Il LED non lampeggia più — respira! Con il PWM (modulazione di larghezza d'impulso) del Raspberry Pi Pico, la luminosità sale e scende lentamente. Impara la classe machine.PWM, duty_u16() (luminosità a 16 bit 0–65535), la frequenza PWM, i cicli range() e l'uscita quasi analogica. Base per miscelazione colori RGB, controllo motori, servo e buzzer.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

