Candela LED tremolante Arduino: fiamma vera e corona dell'Avvento
Candela LED tremolante con Arduino: fiamma realistica con PWM e casualità smussata, corona dell'Avvento a 4 candele, regolazioni, Nano a batterie e Pico.
In questo progetto di candela LED con Arduino fai tremolare un normale LED come la fiamma di una vera candela usando il PWM e una casualità controllata. Il risultato è una candela che brucia in sicurezza sul tavolo, sul davanzale o nella cameretta, senza fuoco, fuliggine o rischio di cadute. La maggior parte delle candele LED in commercio ripete un unico schema di tremolio; scrivendo il tuo codice decidi tu quanto è calma o vivace la fiamma, in che intervallo si illumina e si affievolisce e quanto spesso si piega per uno "spiffero".
In questa guida trovi prima la logica dell'effetto tremolio e un breve sketch per una candela, poi una tabella che mostra come ogni parametro cambia la fiamma. Poi costruirai una corona dell'Avvento a quattro candele: ogni pressione del pulsante accende una candela in più, la scelta viene salvata nella EEPROM e il circuito va in sospensione dopo 6 ore. Infine vedrai come inserirlo in una scatolina con un Arduino Nano, il calcolo della durata delle batterie e una versione MicroPython per il Raspberry Pi Pico.

Come funziona l'effetto candela LED?
I pin di Arduino possono dare solo 0 V o 5 V; per accendere un LED a metà luminosità il pin viene acceso e spento centinaia di volte al secondo. Questo si chiama PWM (modulazione a larghezza di impulso). Il valore da 0 a 255 di analogWrite(pin, valore) stabilisce per quanta parte di ogni periodo il pin resta acceso: 64 vuol dire circa il 25 percento di luminosità, 191 circa il 75 percento. Su Uno e Nano la frequenza PWM è di circa 980 Hz sui pin 5 e 6 e di circa 490 Hz sui pin 3, 9, 10 e 11; l'occhio non vede questa velocità e percepisce il LED fisso ma attenuato. I dettagli sono nella guida cos'è il PWM.
Il segreto di una fiamma realistica è smussare la casualità. Se scrivi analogWrite(pin, random(0, 256)) ogni 20 millisecondi, il LED sussulta come un neon guasto, perché una vera fiamma non salta mai da zero alla massima luminosità in un istante. Meglio scegliere una luminosità obiettivo a caso e avvicinare un po' la luminosità attuale a quell'obiettivo a ogni passo: livello = livello + (obiettivo − livello) / 4. L'obiettivo cambia ogni tanto e il livello lo segue dolcemente. Aggiungi rari cali profondi, la fiamma che si piega per uno spiffero, e l'occhio la accetta come una candela vera.
Componenti e scelta dei LED
| Colore del LED | Tensione diretta (circa) | Resistenza (Uno, 5 V) | Resistenza (Pico, 3,3 V) | Effetto candela |
|---|---|---|---|---|
| Giallo | 2,0–2,1 V | 220 Ω (~13 mA) | 220 Ω (~6 mA) | Ottimo, il classico colore della candela |
| Arancione / ambra | 2,0–2,1 V | 220 Ω (~13 mA) | 220 Ω (~6 mA) | La tonalità più calda e realistica |
| Bianco caldo | 3,0–3,2 V | 150 Ω (~12 mA) | Sconsigliato (troppo debole) | Luminoso, come una candela LED moderna |
| Rosso | 1,8–2,0 V | 220 Ω (~14 mA) | 220 Ω (~6 mA) | Troppo scuro da solo; bene insieme al giallo |
- Arduino Uno o Nano: L'Uno per le prove sulla scrivania, il Nano per inserirlo in una scatola. Le due schede hanno gli stessi pin e lo stesso codice.
- 4 LED gialli o arancioni e per ognuno la resistenza della tabella. Per altri LED trovi il valore con il calcolatore della resistenza per LED.
- 1 pulsante: Per cambiare il numero di candele e spegnere. Si usa il pull-up interno, quindi non serve un'altra resistenza.
- Breadboard e cavetti jumper, più millefori e stagno per una corona definitiva.
- Alimentazione: Un alimentatore USB, un power bank o un portabatterie. Sceglieremo le batterie con il calcolo più sotto.
- Corpo della candela: Un pezzo di tubo in PVC bianco, una vecchia candela svuotata o un bicchiere di vetro satinato; va bene qualsiasi cosa diffonda la luce del LED.
Una candela: il primo sketch del tremolio
1const byte LED_PIN = 9; // PWM pini, 220 ohm ile LED / PWM pin, LED through 220 ohm
2
3int level = 180; // şu anki parlaklık / current brightness
4int target = 180; // hedef parlaklık / target brightness
5
6void setup() {
7 pinMode(LED_PIN, OUTPUT);
8 randomSeed(analogRead(A0)); // her açılışta farklı titreme / different flicker on every start
9}
10
11void loop() {
12 if (random(100) < 8) { // %8 ihtimalle yeni hedef / 8% chance of a new target
13 target = random(90, 256);
14 if (random(100) < 5) target = 40; // nadir esinti: alev eğilir / rare gust: the flame dips
15 }
16 level += (target - level) / 4; // hedefe yumuşak yaklaş / ease toward the target
17 analogWrite(LED_PIN, level);
18 delay(random(15, 40)); // düzensiz adım / irregular step
19}Collega il LED al pin 9 tramite una resistenza da 220 Ω, il piedino corto a GND, e carica lo sketch. A ogni ciclo c'è l'8 percento di probabilità di scegliere un nuovo obiettivo tra 90 e 255; con il 5 percento di probabilità l'obiettivo scende a 40 per un calo profondo. La riga level += (target − level) / 4 aggiunge un quarto della differenza per una transizione morbida, e la pausa casuale di 15–40 ms rende lo schema ancora più irregolare. La riga randomSeed(analogRead(A0)) usa il rumore del pin A0 scollegato per avviare una sequenza casuale diversa a ogni accensione; senza, la candela tremola sempre allo stesso modo.
Tabella dei parametri del tremolio
| Parametro | Predefinito | Se lo abbassi | Se lo alzi |
|---|---|---|---|
| FLAME_MIN | 90 | La fiamma tremola più a fondo e sembra sul punto di spegnersi | La fiamma si calma e brucia quasi fissa |
| FLAME_MAX | 255 | La candela diventa più fioca, come una luce notturna | 255 è il massimo; per più luce serve più corrente nel LED |
| CHANGE_CHANCE | 8 (%) | Una fiamma tranquilla in una stanza senza spifferi | Tremolio rapido e nervoso, alla lunga stancante |
| GUST_CHANCE | 3 (%) | Quasi mai uno spiffero | Una fiamma che si piega spesso, come con la finestra aperta |
| SMOOTH | 4 | 1–2: salti bruschi, come una lampadina guasta | 8 e oltre: oscillazioni lente, a onda |
| STEP_MS | 25 ms | Una fiamma più rapida e vivace | Da 50 ms in su sembra al rallentatore |
Corona dell'Avvento a quattro candele: collegamenti
La corona dell'Avvento è una tradizione, molto amata soprattutto in Germania, Austria e Svizzera, in cui si accende una candela in più in ciascuna delle quattro domeniche prima di Natale. Nel 2026 le domeniche d'Avvento sono il 29 novembre, il 6 dicembre, il 13 dicembre e il 20 dicembre. Nella nostra corona quattro LED rappresentano le quattro candele; una pressione breve aggiunge una candela accesa (0, 1, 2, 3, 4 e di nuovo 0) e una lunga spegne il circuito. Ogni candela ha il proprio stato di tremolio, quindi le quattro fiamme appaiono indipendenti e naturali.
| Collegamento | Arduino Uno / Nano | Raspberry Pi Pico |
|---|---|---|
| Candela 1 (resistenza verso il piedino lungo del LED) | D3 | GP14 |
| Candela 2 | D5 | GP15 |
| Candela 3 | D6 | GP16 |
| Candela 4 | D9 | GP17 |
| Piedini corti dei LED | GND | GND |
| Pulsante (altro piedino a GND) | D2 | GP2 |

Codice della corona dell'Avvento: una candela in più ogni domenica
Lo sketch usa millis() invece di delay(), così il tremolio non si ferma mai mentre controlla il pulsante e conta il timer. Questo approccio è spiegato nella guida millis e delay a confronto. Ogni 25 ms lo stato delle quattro candele viene aggiornato e le candele non accese restano con PWM a zero. Il numero di candele scelto viene scritto all'indirizzo 0 della EEPROM; anche se stacchi e riattacchi la spina, la corona riparte con lo stesso numero di candele.
1#include <EEPROM.h>
2#include <avr/sleep.h>
3
4const byte CANDLES = 4;
5const byte CANDLE_PINS[CANDLES] = {3, 5, 6, 9}; // PWM pinleri / PWM pins
6const byte BUTTON_PIN = 2; // buton -> GND, INT0 / button -> GND, INT0
7
8// Titreme ayarları / flicker settings
9const int FLAME_MIN = 90; // en kısık alev / dimmest flame
10const int FLAME_MAX = 255; // en parlak alev / brightest flame
11const byte CHANGE_CHANCE = 8; // her adımda yeni hedef olasılığı (%) / chance of a new target per step (%)
12const byte GUST_CHANCE = 3; // esinti olasılığı (%) / chance of a gust (%)
13const byte SMOOTH = 4; // büyüdükçe alev yavaşlar / higher = calmer flame
14const unsigned long STEP_MS = 25; // adım süresi / step time
15const unsigned long ON_TIME = 6UL * 60 * 60 * 1000; // 6 saat sonra uyku / sleep after 6 hours
16
17int level[CANDLES];
18int target[CANDLES];
19byte litCount = 1; // yanan mum sayısı (0-4) / number of lit candles (0-4)
20unsigned long onSince = 0;
21unsigned long lastStep = 0;
22
23void wakeUp() {} // yalnız uyandırmak için / only used to wake the chip
24
25void goToSleep() {
26 for (byte i = 0; i < CANDLES; i++) analogWrite(CANDLE_PINS[i], 0);
27 while (digitalRead(BUTTON_PIN) == LOW) {} // butonun bırakılmasını bekle / wait for release
28 delay(50);
29 set_sleep_mode(SLEEP_MODE_PWR_DOWN);
30 sleep_enable();
31 noInterrupts();
32 attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), wakeUp, LOW);
33 interrupts();
34 sleep_cpu(); // burada uyur / sleeps here
35 sleep_disable(); // butona basınca buradan devam / resumes here on press
36 detachInterrupt(digitalPinToInterrupt(BUTTON_PIN));
37 while (digitalRead(BUTTON_PIN) == LOW) {} // uyandıran basış sayılmasın / ignore the wake-up press
38 delay(50);
39 onSince = millis();
40}
41
42void flicker() {
43 for (byte i = 0; i < CANDLES; i++) {
44 if (i >= litCount) { // bu mum henüz yakılmadı / not lit yet
45 analogWrite(CANDLE_PINS[i], 0);
46 continue;
47 }
48 if (random(100) < CHANGE_CHANCE) {
49 target[i] = random(FLAME_MIN, FLAME_MAX + 1);
50 if (random(100) < GUST_CHANCE) target[i] = FLAME_MIN / 2; // alev eğilir / the flame bends
51 }
52 level[i] += (target[i] - level[i]) / SMOOTH;
53 analogWrite(CANDLE_PINS[i], level[i]);
54 }
55}
56
57void setup() {
58 pinMode(BUTTON_PIN, INPUT_PULLUP);
59 for (byte i = 0; i < CANDLES; i++) {
60 pinMode(CANDLE_PINS[i], OUTPUT);
61 level[i] = target[i] = 200;
62 }
63 randomSeed(analogRead(A0));
64 litCount = EEPROM.read(0); // son seçimi hatırla / remember the last choice
65 if (litCount > CANDLES) litCount = 1; // boş EEPROM 255 okur / empty EEPROM reads 255
66 onSince = millis();
67}
68
69void loop() {
70 if (digitalRead(BUTTON_PIN) == LOW) {
71 unsigned long pressStart = millis();
72 while (digitalRead(BUTTON_PIN) == LOW) {
73 if (millis() - pressStart > 1500) { // uzun basış: kapat / long press: switch off
74 goToSleep();
75 return;
76 }
77 }
78 if (millis() - pressStart > 50) { // kısa basış: bir mum daha / short press: one more candle
79 litCount = (litCount + 1) % (CANDLES + 1);
80 EEPROM.update(0, litCount);
81 onSince = millis();
82 }
83 }
84
85 if (millis() - onSince > ON_TIME) goToSleep(); // zamanlayıcı / auto-off timer
86
87 if (millis() - lastStep >= STEP_MS) {
88 lastStep = millis();
89 flicker();
90 }
91}| Parte del codice | Funzione |
|---|---|
| level[i], target[i] | Luminosità e obiettivo propri di ogni candela; le quattro fiamme tremolano in modo indipendente |
| i >= litCount | Spegne le candele il cui turno non è ancora arrivato; alla 2ª domenica litCount = 2 |
| EEPROM.update(0, litCount) | Non scrive se il valore non è cambiato, preservando la cella della EEPROM |
| se litCount > CANDLES allora 1 | Una EEPROM mai scritta legge 255; al primissimo avvio la corona parte con una candela |
| ON_TIME | Dopo 6 ore spegne le candele e va in sospensione; una corona dimenticata di notte non scarica le batterie |
| goToSleep() | Ferma il processore con SLEEP_MODE_PWR_DOWN; premendo il pulsante l'interrupt INT0 risveglia la scheda |
In sospensione il clock dell'ATmega328P si ferma e il processore scende a pochi microampere. Per risvegliarlo si collega al pin 2 un interrupt a livello LOW; in modalità power-down solo un interrupt a livello può risvegliare il processore, quindi CHANGE o FALLING qui non funzionano. Al risveglio il codice aspetta che il pulsante venga rilasciato, così la pressione che lo sveglia non conta anche come una candela in più. Anche millis() si ferma durante la sospensione, per questo il timer viene azzerato al risveglio.
Dimensioni ridotte con il Nano e calcolo della durata delle batterie
Quanto dura una batteria si calcola con durata (ore) = capacità utilizzabile (mAh) / corrente media (mA). Calcoliamo la corrente della corona: un LED che tremola assorbe in media circa il 70 percento della corrente massima, cioè circa 8–9 mA per un LED da 12 mA. Quattro candele fanno circa 35 mA; aggiungendo i 15–20 mA che consuma da solo un Nano clone, il totale è di circa 50 mA. Una serata di 6 ore consuma 300 mAh. In sospensione il processore non consuma quasi nulla, ma a causa del LED di alimentazione, del chip USB e del regolatore sulla scheda, la maggior parte dei Nano clone consuma comunque qualche mA (di solito intorno a 5 mA); 18 ore di sospensione aggiungono circa 90 mAh. Puoi provare altri scenari con il calcolatore di autonomia della batteria.
| Fonte di alimentazione | Capacità utilizzabile | Serate da 6 ore (≈50 mA) | Nota |
|---|---|---|---|
| 3 × AA alcaline (≈4,5 V, al pin 5V) | ~2.000 mAh | ~5 serate (perdite in sospensione incluse) | Quando le batterie calano, anche i LED si affievoliscono |
| 4 × AA NiMH ricaricabili (≈4,8 V, al pin 5V) | ~1.900 mAh | ~5 serate | Vanno ricaricate 4–5 volte durante l'Avvento |
| 18650 + TP4056 + elevatore a 5 V | ~1.600 mAh (a 5 V) | ~4 serate | Si ricarica via USB e sta in una scatola |
| Power bank USB da 10.000 mAh | ~6.300 mAh (a 5 V) | ~16 serate | Può spegnersi da solo in sospensione per la bassa corrente |
| Alimentatore USB 5 V 1 A | Illimitata | Illimitate | La soluzione più comoda per una corona sul tavolo |
Versione per Raspberry Pi Pico in MicroPython
Sul Pico ogni pin GPIO può dare PWM, quindi le candele vanno su GP14–GP17 e il pulsante su GP2. In MicroPython la luminosità si imposta con duty_u16() da 0 a 65535; il codice mantiene i valori da 0 a 255 della versione Arduino e li moltiplica per 257 per arrivare alla stessa scala (255 × 257 = 65535). Al posto della EEPROM, il numero di candele viene salvato nel file mum.txt del file system del Pico. Se salvi il codice come main.py, la corona si accende appena il Pico riceve alimentazione.
1from machine import Pin, PWM
2import time, random
3
4PINS = (14, 15, 16, 17) # 4 mum: GP14-GP17, 220 ohm / 4 candles, 220 ohm each
5button = Pin(2, Pin.IN, Pin.PULL_UP) # buton -> GND / button -> GND
6
7FLAME_MIN = 90 # 0-255 ölçeğinde / on a 0-255 scale
8FLAME_MAX = 255
9CHANGE_CHANCE = 8 # yeni hedef olasılığı (%) / chance of a new target (%)
10GUST_CHANCE = 3 # esinti olasılığı (%) / chance of a gust (%)
11SMOOTH = 4
12STEP_MS = 25
13
14leds = []
15for p in PINS:
16 pwm = PWM(Pin(p))
17 pwm.freq(1000) # 1 kHz, göz titreşimi görmez / 1 kHz, no visible strobing
18 leds.append(pwm)
19
20level = [200] * len(PINS)
21target = [200] * len(PINS)
22
23try:
24 with open("mum.txt") as f: # son seçimi oku / read the last choice
25 lit = int(f.read())
26except (OSError, ValueError):
27 lit = 1
28
29
30def save(n):
31 with open("mum.txt", "w") as f:
32 f.write(str(n))
33
34
35last_button = 1
36while True:
37 b = button.value()
38 if b == 0 and last_button == 1: # basıldığı an / the moment it is pressed
39 lit = (lit + 1) % (len(PINS) + 1)
40 save(lit)
41 time.sleep_ms(30) # basit debounce / simple debounce
42 last_button = b
43
44 for i, led in enumerate(leds):
45 if i >= lit:
46 led.duty_u16(0)
47 continue
48 if random.randint(0, 99) < CHANGE_CHANCE:
49 target[i] = random.randint(FLAME_MIN, FLAME_MAX)
50 if random.randint(0, 99) < GUST_CHANCE:
51 target[i] = FLAME_MIN // 2
52 level[i] += (target[i] - level[i]) // SMOOTH
53 led.duty_u16(level[i] * 257) # 0-255 -> 0-65535
54 time.sleep_ms(STEP_MS)Dato che il Pico funziona a 3,3 V, i LED bianco caldo (circa 3 V di tensione diretta) si accendono appena; usa LED gialli o arancioni con resistenze da 220 Ω. Questa versione non ha timer né sospensione; se vuoi, conta 6 ore con time.ticks_ms() e poi porta a zero tutti i valori di duty. Abbiamo impostato la frequenza PWM del Pico a 1 kHz; a frequenze più basse possono comparire delle strisce nei video girati con il telefono.
Per un aspetto realistico
- Diffondi la luce: Opacizza la punta del LED con carta vetrata fine o metti un po' di cotone dentro il corpo della candela; si illumina tutto il corpo invece di un solo punto.
- Fiamma a due LED: Metti un LED giallo e uno arancione nella stessa candela, su pin PWM separati, e falli tremolare a velocità diverse: così si muove anche il colore della fiamma. I sei pin PWM dell'Uno bastano per tre candele così.
- Corpo della candela: Usa tubo in PVC bianco da 2–3 cm di diametro, una vera candela svuotata o un bicchiere satinato. Il corpo di una candela vera diffonde la luce nel modo più naturale.
- Base della corona: Decora le quattro candele con rami di abete finto e pigne, nascondi Nano e batterie sotto la base e metti il pulsante in un angolo facile da raggiungere.
- Temperatura di colore: Se usi LED bianco caldo, una pellicola trasparente arancione davanti avvicina la luce al colore di una vera fiamma.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Il LED non tremola, è o acceso o spento | Il LED è su un pin senza PWM | Sposta il LED sul pin 3, 5, 6, 9, 10 o 11 |
| La fiamma sussulta come un neon guasto | SMOOTH è troppo piccolo o l'obiettivo cambia a ogni passo | Porta SMOOTH a 4–6 e abbassa CHANGE_CHANCE sotto 10 |
| Tutte le candele tremolano uguali nello stesso istante | Una sola variabile level viene scritta su tutti i pin | Usa array level e target separati per ogni candela |
| La scheda non si risveglia dalla sospensione | Il pulsante non è su D2 o l'interrupt non è a livello LOW | Collega il pulsante a D2 e usa attachInterrupt(..., LOW) |
| Lo stesso schema di tremolio a ogni avvio | randomSeed non è stato chiamato o A0 è collegato a qualcosa | Chiama randomSeed(analogRead(A0)) con un pin analogico scollegato |
| Le batterie finiscono in pochi giorni | Il LED di alimentazione e il chip USB del Nano consumano anche in sospensione | Usa un alimentatore o passa a un Pro Mini senza LED di alimentazione |
Questa candela LED, fatta con pochi LED, qualche resistenza e un pulsante, riunisce PWM, temporizzazione con millis(), EEPROM, sospensione e calcolo delle batterie in un progetto accogliente. Puoi portare l'effetto candela nei tuoi progetti guardando nell'app BlueGrays gli schemi passo passo e il codice di progetti luminosi di base, come accendere un LED, accendere e spegnere un LED con un pulsante, una dissolvenza di colore con un LED RGB e la regolazione PWM con ESP32 o Pico.
Domande frequenti
Come si fa una candela LED tremolante con Arduino?
Collega il LED con una resistenza da 220 Ω a uno dei pin PWM di Arduino e cambia la sua luminosità in modo casuale ma morbido con analogWrite(). Il risultato migliore si ottiene scegliendo una luminosità obiettivo a caso e avvicinando lentamente la luminosità attuale a ogni passo. Rari cali profondi imitano la fiamma che si piega per uno spiffero.
Quale colore di LED usare per una candela LED?
I LED gialli o arancioni (ambra) sono i più vicini al colore di una vera fiamma. I LED bianco caldo sono più luminosi e ricordano le candele LED moderne, ma restano deboli sulle schede a 3,3 V. I LED blu e bianco freddo non sembrano una fiamma.
Che resistenza serve per collegare un LED ad Arduino?
A 5 V, una resistenza da 220 Ω per un LED giallo o rosso e da 150 Ω per un LED bianco caldo danno circa 12–14 mA, un valore sicuro. Il valore si calcola con (tensione di alimentazione − tensione del LED) / corrente desiderata. Senza resistenza rischi di danneggiare il LED e il pin di Arduino.
Quali pin di Arduino supportano il PWM?
Su Arduino Uno e Nano i pin PWM sono 3, 5, 6, 9, 10 e 11, indicati con ~ sulla scheda. I pin 5 e 6 lavorano a circa 980 Hz, gli altri a circa 490 Hz. Sul Raspberry Pi Pico ogni pin GPIO può dare PWM.
Quanto dura una candela LED con Arduino a batterie?
Una corona a quattro candele con un Nano assorbe circa 50 mA; con tre pile AA da 2.000 mAh, perdite in sospensione comprese, sono circa cinque serate da 6 ore. Un power bank da 10.000 mAh dura circa 16 serate. Per una lunga autonomia si usa un Pro Mini senza LED di alimentazione e la sospensione.
In quali giorni si accendono le candele della corona dell'Avvento?
Sulla corona dell'Avvento si accende una candela in più in ciascuna delle quattro domeniche prima di Natale. Nel 2026 sono il 29 novembre, il 6 dicembre, il 13 dicembre e il 20 dicembre. Premi il pulsante di questo progetto una volta ogni domenica per aumentare il numero di candele accese.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
LED lampeggiante
Il primissimo ciao dell'elettronica: accendere e spegnere un solo LED. L'Arduino accende e spegne il LED a intervalli brevissimi, così la luce lampeggia veloce.

Due LED lampeggianti alternati
Due LED lampeggiano veloci a turno: quando uno si accende l'altro si spegne, come se si passassero una palla. L'Arduino tiene accesa ogni luce per un quinto di secondo e poi passa all'altra.

Accendere e spegnere un LED con un pulsante
Premi il pulsante una volta e la luce si accende, premilo di nuovo e si spegne, proprio come l'interruttore della tua stanza.

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.

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

