Guide · 9 min di lettura

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.

LED da 5 mm
LED da 5 mm: per l'effetto candela scegli giallo, arancione o bianco caldo; i LED blu e bianco freddo non sembrano una fiamma.

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 LEDTensione diretta (circa)Resistenza (Uno, 5 V)Resistenza (Pico, 3,3 V)Effetto candela
Giallo2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)Ottimo, il classico colore della candela
Arancione / ambra2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)La tonalità più calda e realistica
Bianco caldo3,0–3,2 V150 Ω (~12 mA)Sconsigliato (troppo debole)Luminoso, come una candela LED moderna
Rosso1,8–2,0 V220 Ω (~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

C++ (Arduino IDE)
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

ParametroPredefinitoSe lo abbassiSe lo alzi
FLAME_MIN90La fiamma tremola più a fondo e sembra sul punto di spegnersiLa fiamma si calma e brucia quasi fissa
FLAME_MAX255La candela diventa più fioca, come una luce notturna255 è il massimo; per più luce serve più corrente nel LED
CHANGE_CHANCE8 (%)Una fiamma tranquilla in una stanza senza spifferiTremolio rapido e nervoso, alla lunga stancante
GUST_CHANCE3 (%)Quasi mai uno spifferoUna fiamma che si piega spesso, come con la finestra aperta
SMOOTH41–2: salti bruschi, come una lampadina guasta8 e oltre: oscillazioni lente, a onda
STEP_MS25 msUna fiamma più rapida e vivaceDa 50 ms in su sembra al rallentatore
Durante le regolazioni cambia un parametro alla volta e guarda il LED attraverso un foglio o un vetro satinato invece che direttamente; su un LED nudo il tremolio sembra sempre più brusco di quanto sia. Per la maggior parte delle persone il risultato più naturale si ottiene con FLAME_MIN tra 80 e 110, SMOOTH tra 3 e 5 e CHANGE_CHANCE tra 6 e 10.

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.

CollegamentoArduino Uno / NanoRaspberry Pi Pico
Candela 1 (resistenza verso il piedino lungo del LED)D3GP14
Candela 2D5GP15
Candela 3D6GP16
Candela 4D9GP17
Piedini corti dei LEDGNDGND
Pulsante (altro piedino a GND)D2GP2
Collega le candele solo a pin con PWM: su Uno e Nano sono i pin 3, 5, 6, 9, 10 e 11 (indicati con ~ sulla scheda). Su un altro pin il LED non tremola con analogWrite(); resta spento sotto 128 e acceso al massimo sopra. Collega il pulsante al pin 2, perché lo sketch si risveglia dalla sospensione tramite l'interrupt di questo pin (INT0). Per la piedinatura del Nano guarda la guida pin dell'Arduino Nano.
Arduino Nano
Arduino Nano: lo stesso processore ATmega328P e gli stessi pin PWM dell'Uno, ma abbastanza piccolo da stare nella base di una corona.

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.

C++ (Arduino IDE)
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 codiceFunzione
level[i], target[i]Luminosità e obiettivo propri di ogni candela; le quattro fiamme tremolano in modo indipendente
i >= litCountSpegne 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 1Una EEPROM mai scritta legge 255; al primissimo avvio la corona parte con una candela
ON_TIMEDopo 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 alimentazioneCapacità utilizzabileSerate 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 serateVanno ricaricate 4–5 volte durante l'Avvento
18650 + TP4056 + elevatore a 5 V~1.600 mAh (a 5 V)~4 serateSi ricarica via USB e sta in una scatola
Power bank USB da 10.000 mAh~6.300 mAh (a 5 V)~16 seratePuò spegnersi da solo in sospensione per la bassa corrente
Alimentatore USB 5 V 1 AIllimitataIllimitateLa soluzione più comoda per una corona sul tavolo
Non collegare quattro pile AA alcaline direttamente al pin 5V: le alcaline nuove arrivano in totale fino a 6,4 V e sul pin 5V, che salta il regolatore, questo supera il limite di 5,5 V del processore. Anche una batteria da 9 V non è una buona scelta: ha circa 500 mAh e il regolatore su VIN trasforma in calore la tensione in eccesso. Se vuoi una candela che duri a lungo a batterie, un Arduino Pro Mini senza LED di alimentazione porta la corrente in sospensione a pochi microampere.

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.

MicroPython
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

SintomoCausa probabileSoluzione
Il LED non tremola, è o acceso o spentoIl LED è su un pin senza PWMSposta il LED sul pin 3, 5, 6, 9, 10 o 11
La fiamma sussulta come un neon guastoSMOOTH è troppo piccolo o l'obiettivo cambia a ogni passoPorta SMOOTH a 4–6 e abbassa CHANGE_CHANCE sotto 10
Tutte le candele tremolano uguali nello stesso istanteUna sola variabile level viene scritta su tutti i pinUsa array level e target separati per ogni candela
La scheda non si risveglia dalla sospensioneIl pulsante non è su D2 o l'interrupt non è a livello LOWCollega il pulsante a D2 e usa attachInterrupt(..., LOW)
Lo stesso schema di tremolio a ogni avviorandomSeed non è stato chiamato o A0 è collegato a qualcosaChiama randomSeed(analogRead(A0)) con un pin analogico scollegato
Le batterie finiscono in pochi giorniIl LED di alimentazione e il chip USB del Nano consumano anche in sospensioneUsa un alimentatore o passa a un Pro Mini senza LED di alimentazione
Osserva una candela vera per qualche minuto in una stanza buia e conta quante volte cambia la luminosità, poi regola STEP_MS e CHANGE_CHANCE in base a quello che hai visto. La maggior parte delle fiamme oscilla visibilmente due o tre volte al secondo e si piega davvero solo ogni qualche minuto.

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.

Vedi tutti i progetti
LED lampeggiante
AR-1Principiante

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.

4.6(198)
1242
Due LED lampeggianti alternati
AR-2Principiante

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.

4.6(110)
362
Accendere e spegnere un LED con un pulsante
AR-10Principiante

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.

4.7(103)
177
Utilizzo dei LED RGB
AR-39Principiante
Premium

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.

4.9(73)
100
Transizione cromatica omogenea con LED RGB
AR-40Principiante
Premium

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.

4.8(58)
78
Dissolvenza LED ESP32 con PWM
ES-8Principiante

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.

4.8(36)
55
Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
ES-13Intermedio
Premium

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.

4.5(19)
32
Raspberry Pi Pico PWM LED Fade (Effetto Respiro)
PI-14Principiante

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.

4