Decorazione natalizia Raspberry Pi Pico: stella e anello WS2812B
Crea una decorazione natalizia Raspberry Pi Pico: anello WS2812B da 24 LED, effetti rotazione, scintillio e neve in MicroPython, touch TTP223 e Pico W.
In questo progetto di decorazione natalizia con Raspberry Pi Pico usi un Pico e un anello WS2812B da 24 LED per creare una stella di Natale luminosa che gira, scintilla e fa nevicare, pronta da appendere all'albero. Scrivi il codice con il modulo neopixel integrato in MicroPython, passi da un effetto all'altro con un sensore touch TTP223 e alimenti la stella senza fili con un power bank USB. Quasi niente saldature, costo basso e alla fine una decorazione da riusare ogni anno.
In questa guida trovi come funziona l'anello, il collegamento corretto al Pico, un primo codice di prova, i piccoli trucchi matematici dietro ciascuno dei cinque effetti, una tabella di effetti e luminosità, un programma completo che ricorda l'ultima modalità scelta e il calcolo di quante ore dura con un power bank. Nell'ultima parte renderai la stessa decorazione controllabile dal browser del telefono con un Pico W.

Perché un Pico e un anello WS2812B?
Il WS2812B è un LED indirizzabile che racchiude chip rosso, verde e blu e un minuscolo integrato driver nello stesso package 5050. Il Pico invia in sequenza sulla linea dati informazioni di colore da 24 bit; il primo LED prende la sua parte e passa il resto al successivo. Così un solo pin GPIO può accendere ciascuno dei 24 LED con il suo colore. La forma ad anello entra perfettamente in una stella o in una pallina. Dato che il modulo neopixel è già incluso nel firmware MicroPython del Pico, inizi a programmare senza scaricare librerie; per le basi del WS2812B guarda la guida LED WS2812B NeoPixel.
| Caratteristica | Valore |
|---|---|
| Numero di LED | 24 × WS2812B (5050 SMD) |
| Diametro esterno | Circa 6,5–8,5 cm (dipende dal produttore) |
| Alimentazione | 5 V (circa 3,5–5,3 V) |
| Corrente | Fino a ~20 mA per canale colore e per LED; ~60 mA per LED in bianco pieno |
| Corrente a riposo | Circa 0,5–1 mA per LED anche con i LED spenti |
| Dati | Una linea, 800 kHz; aggiornare 24 LED richiede circa 0,7 ms |
| Pin | DI (ingresso dati), DO (uscita dati), 5V, GND |
Materiali
- Raspberry Pi Pico (un Pico W o Pico 2 W se vuoi scegliere i colori dal telefono) e un cavo micro USB che trasmetta dati.
- Anello WS2812B da 24 LED: vanno bene anche anelli da 12 o 16 LED; basta cambiare il valore N nel codice.
- Modulo sensore touch TTP223: Per cambiare modalità. Puoi usare al suo posto un normale pulsante.
- Resistenza da 330 Ω (per la linea dati) e, facoltativo, un condensatore elettrolitico da 100–470 µF.
- Power bank USB: 5.000–10.000 mAh bastano. Se l'albero è vicino a una presa, va bene anche un alimentatore USB.
- Corpo della decorazione: Una stella di cartone, gommapiuma o stampata in 3D; carta da lucido o gommapiuma bianca sottile per ammorbidire la luce.
Tabella dei collegamenti
| Collegamento | Pin del Pico | Pin fisico | Nota |
|---|---|---|---|
| DI dell'anello (ingresso dati) | GP0 | 1 | Resistenza da 330 Ω in mezzo |
| 5V dell'anello | VBUS | 40 | 5 V dalla USB |
| GND dell'anello | GND | 38 | Qui va anche il piedino negativo del condensatore |
| TTP223 VCC | 3V3(OUT) | 36 | Funziona a 3,3 V |
| TTP223 I/O | GP15 | 20 | HIGH al tocco (A e B aperti) |
| TTP223 GND | GND | 23 | Va bene qualsiasi pin GND |

Prima prova: accendere l'anello con il modulo neopixel
1from machine import Pin
2import neopixel, time
3
4N = 24 # halkadaki LED sayısı / LEDs on the ring
5np = neopixel.NeoPixel(Pin(0), N) # DIN -> 330 ohm -> GP0
6
7for i in range(N):
8 np[i] = (40, 0, 0) if i % 2 == 0 else (0, 40, 0) # kırmızı-yeşil sıra / red-green pattern
9 np.write() # renkleri halkaya gönder / send colours to the ring
10 time.sleep_ms(50)Quando esegui il codice in Thonny, i LED dell'anello devono accendersi uno alla volta in rosso e verde. Abbiamo tenuto apposta i valori di colore a 40: 255 abbaglia e consuma corrente inutile durante la prova. La riga np[i] = (r, g, b) imposta in memoria il colore del LED numero i, ma sull'anello non cambia ancora nulla; i colori vengono inviati solo quando chiami np.write(). In realtà il WS2812B si aspetta i colori nell'ordine verde, rosso, blu (GRB); il modulo neopixel se ne occupa per te, quindi scrivi sempre (rosso, verde, blu). Se l'anello non si accende affatto, forse hai collegato i dati al lato sbagliato: devono andare alla piazzola DI o IN, mentre DO o OUT va all'anello successivo.
Tabella di effetti e luminosità
| Modalità | Effetto | Colori | Durata fotogramma | Corrente circa (luminosità 0,2, anello + Pico) |
|---|---|---|---|---|
| 0 | Cometa rotante | Un giro rosso, un giro verde | 40 ms | ~65 mA |
| 1 | Scintillio dorato | Luce di base calda + scintille dorate casuali | 60 ms | ~70 mA |
| 2 | Nevicata | Sfondo blu notte, fiocchi bianchi | 40 ms | ~110 mA |
| 3 | Stella che respira | Giallo oro che si accende e si spegne piano | 30 ms | ~125 mA |
| 4 | Arcobaleno rotante | Tutta la ruota dei colori | 30 ms | ~145 mA |
Ecco come stimare a grandi linee la corrente: ogni canale colore assorbe circa 20 mA al valore massimo (255) e proporzionalmente meno con valori più bassi. Un LED assorbe quindi circa 20 mA × (r + g + b) / 255; a questo aggiungi circa 1 mA di corrente a riposo per LED e i 20–25 mA del Pico. Il codice ha tre livelli di luminosità: 0,08 (soffusa, per la notte), 0,2 (predefinita) e 0,4 (con la luce del giorno). Oltre 0,4 affatichi la vista e accorci in fretta l'autonomia.
Codice completo: cinque effetti e cambio modalità con il TTP223
Salva il programma qui sotto sul Pico come main.py da Thonny, così la decorazione parte da sola appena la colleghi al power bank. Un tocco breve sul TTP223 passa all'effetto successivo, un tocco più lungo di 0,7 secondi cambia il livello di luminosità. La scelta viene scritta nel file susu.txt e la decorazione riparte con lo stesso effetto alla prossima accensione.
1from machine import Pin
2import neopixel, time, random, math
3
4N = 24 # halkadaki LED sayısı / LEDs on the ring
5np = neopixel.NeoPixel(Pin(0), N) # DIN -> 330 ohm -> GP0
6touch = Pin(15, Pin.IN) # TTP223 I/O (A ve B açık / A and B open)
7
8LEVELS = (0.08, 0.2, 0.4) # parlaklık kademeleri / brightness steps
9FRAME_MS = (40, 60, 40, 30, 30) # her efektin kare süresi / frame time of each effect
10NAMES = ("donen", "parilti", "kar", "nefes", "gokkusagi")
11LONG_MS = 700 # uzun dokunuş / long touch
12
13buf = [[0, 0, 0] for _ in range(N)] # ham renkler 0-255 / raw colours 0-255
14flakes = [] # kar taneleri / snowflakes
15step = 0
16
17
18def load():
19 try:
20 with open("susu.txt") as f:
21 m, b = f.read().split(",")
22 return int(m) % len(NAMES), int(b) % len(LEVELS)
23 except (OSError, ValueError):
24 return 0, 1
25
26
27def save():
28 with open("susu.txt", "w") as f:
29 f.write("%d,%d" % (mode, level))
30
31
32def show():
33 k = LEVELS[level]
34 for i in range(N):
35 r, g, b = buf[i]
36 np[i] = (int(r * k), int(g * k), int(b * k))
37 np.write()
38
39
40def fade(f):
41 for c in buf:
42 c[0] = int(c[0] * f)
43 c[1] = int(c[1] * f)
44 c[2] = int(c[2] * f)
45
46
47def wheel(h): # 0-255 renk tekerleği / 0-255 colour wheel
48 h %= 256
49 if h < 85:
50 return [255 - h * 3, h * 3, 0]
51 if h < 170:
52 h -= 85
53 return [0, 255 - h * 3, h * 3]
54 h -= 170
55 return [h * 3, 0, 255 - h * 3]
56
57
58def spinning(): # dönen kuyruklu yıldız / spinning comet
59 fade(0.7)
60 head = step % N
61 buf[head] = [255, 0, 0] if (step // N) % 2 == 0 else [0, 255, 0]
62
63
64def twinkle(): # altın parıltı / golden sparkle
65 fade(0.88)
66 for c in buf: # sıcak taban ışığı / warm base glow
67 c[0] = max(c[0], 30)
68 c[1] = max(c[1], 10)
69 if random.randint(0, 99) < 35:
70 buf[random.randint(0, N - 1)] = [255, 170, 40]
71
72
73def snow(): # tepeden iki yana akan kar / snow falling down both sides
74 for c in buf:
75 c[0], c[1], c[2] = 0, 0, 25 # gece mavisi / night blue
76 for j in range(len(flakes)): # her tane bir LED aşağı / each flake moves one LED down
77 flakes[j] += 1
78 while flakes and flakes[0] > N // 2:
79 flakes.pop(0) # en alta ulaşan silinir / remove flakes at the bottom
80 if random.randint(0, 99) < 20:
81 flakes.append(0) # tepede yeni tane / new flake at the top
82 for k in flakes:
83 buf[k % N] = [230, 230, 255]
84 buf[(N - k) % N] = [230, 230, 255]
85
86
87def breathe(): # yıldız nefesi / breathing star
88 v = (1 - math.cos(step * 2 * math.pi / 100)) / 2
89 for i in range(N):
90 buf[i] = [int(255 * v), int(150 * v), int(20 * v)]
91
92
93def rainbow(): # dönen gökkuşağı / rotating rainbow
94 for i in range(N):
95 buf[i] = wheel(i * 256 // N + step * 3)
96
97
98EFFECTS = (spinning, twinkle, snow, breathe, rainbow)
99mode, level = load()
100touch_start = None
101
102while True:
103 if touch.value() and touch_start is None:
104 touch_start = time.ticks_ms() # dokunuş başladı / touch started
105 elif not touch.value() and touch_start is not None:
106 held = time.ticks_diff(time.ticks_ms(), touch_start)
107 touch_start = None
108 if held >= LONG_MS:
109 level = (level + 1) % len(LEVELS) # uzun: parlaklık / long: brightness
110 else:
111 mode = (mode + 1) % len(NAMES) # kısa: sonraki efekt / short: next effect
112 flakes = [] # karı sıfırla / reset the snow
113 save()
114 print("efekt / effect:", NAMES[mode], "parlaklik / brightness:", LEVELS[level])
115
116 EFFECTS[mode]()
117 show()
118 step += 1
119 time.sleep_ms(FRAME_MS[mode])| Parte del codice | Funzione |
|---|---|
| buf | Tiene i colori grezzi dei 24 LED tra 0 e 255; gli effetti scrivono sempre qui |
| show() | Moltiplica i colori grezzi per la luminosità scelta e li invia all'anello; la luminosità si applica in un solo punto |
| fade(f) | Attenua ogni LED del fattore f; 0,7 lascia una scia corta, 0,88 una lunga |
| wheel(h) | Trasforma un numero da 0 a 255 in un colore con passaggi tra rosso, verde e blu |
| touch_start / held | Misura quanto dura il tocco; il limite di 700 ms separa tocco breve e lungo |
| load() / save() | Scrive modalità e luminosità nel file system del Pico e le rilegge all'avvio |
Come funzionano gli effetti?
La cometa rotante attenua tutto l'anello del 30 percento a ogni fotogramma e accende il LED successivo alla massima luminosità. Poiché i LED precedenti si spengono un po' di più a ogni fotogramma, dietro la testa si forma da sola una scia morbida: 0,7 × 0,7 × 0,7 ≈ 0,34, quindi un LED tre fotogrammi indietro è a un terzo della luminosità iniziale. Ogni volta che la testa completa un giro passa dal rosso al verde o viceversa. Lo scintillio dorato attenua l'anello più lentamente ma non lascia scendere nessun LED sotto una luce di base calda; a ogni fotogramma, con il 35 percento di probabilità, un LED a caso si accende d'oro e si spegne piano.
La nevicata considera il LED in cima all'anello (numero 0) come il cielo e quello in basso (numero 12) come il suolo. Un nuovo fiocco nasce in alto e scende di un LED per fotogramma; lo stesso fiocco viene mostrato a specchio sui due lati dell'anello, così la neve sembra scendere da entrambi i lati insieme. La stella che respira porta dolcemente la luminosità tra zero e uno con la formula (1 − cos(2π × passo / 100)) / 2; con fotogrammi da 30 ms un respiro dura circa 3 secondi. L'arcobaleno assegna a ogni LED una tonalità distribuita in modo uniforme sulla ruota dei colori e sposta tutte le tonalità un po' a ogni fotogramma.
Funzionamento con power bank e autonomia
La capacità scritta su un power bank è quella delle sue celle a 3,7 V. Dato che l'uscita è a 5 V e il convertitore lavora con un rendimento di circa l'85 percento, la capacità davvero utilizzabile è capacità × 3,7 / 5 × 0,85; un power bank da 10.000 mAh fornisce circa 6.300 mAh a 5 V. L'autonomia si calcola con capacità utilizzabile / corrente media. Puoi provare altri valori con il calcolatore di autonomia della batteria.
| Luminosità | Corrente totale in modalità arcobaleno | Power bank 5.000 mAh | Power bank 10.000 mAh |
|---|---|---|---|
| 0,08 (soffusa) | ~85 mA | ~37 ore | ~74 ore |
| 0,2 (predefinita) | ~145 mA | ~22 ore | ~43 ore |
| 0,4 (intensa) | ~240 mA | ~13 ore | ~26 ore |
Scegliere il colore dal telefono con un Pico W
Se usi un Pico W o un Pico 2 W, puoi aggiungere una piccola pagina web alla decorazione. Il programma qui sotto si collega al Wi-Fi di casa, scrive un indirizzo IP nella Shell e, quando apri quell'indirizzo sul telefono, compaiono un selettore di colore e un elenco di effetti. Il colore scelto appare subito sull'anello in modalità fissa, scintillio o arcobaleno. Luci e server web funzionano insieme grazie ad asyncio; nessuno dei due aspetta l'altro. Le basi del server web sono spiegate nel dettaglio nella guida server web con Pico W.
1import network, asyncio, neopixel, random, time
2from machine import Pin
3
4SSID = "AgAdi" # Wi-Fi adın (2,4 GHz) / your Wi-Fi name (2.4 GHz)
5PASSWORD = "Sifre123" # Wi-Fi şifren / your Wi-Fi password
6N = 24
7np = neopixel.NeoPixel(Pin(0), N) # DIN -> 330 ohm -> GP0
8BRIGHT = 0.2 # genel parlaklık / overall brightness
9
10color = [255, 120, 20] # telefondan seçilen renk / colour picked on the phone
11mode = 1 # 0 sabit, 1 parıltı, 2 gökkuşağı / 0 solid, 1 sparkle, 2 rainbow
12
13PAGE = """<!DOCTYPE html><html><head><meta charset="utf-8">
14<meta name="viewport" content="width=device-width, initial-scale=1"><title>Noel Susu</title></head>
15<body style="font-family:sans-serif;text-align:center">
16<h2>Noel Susu / Ornament</h2>
17<form action="/" method="get">
18<p><input type="color" name="c" value="#ff7814" style="width:120px;height:80px"></p>
19<p><select name="m"><option value="0">Sabit / Solid</option><option value="1" selected>Parilti / Sparkle</option>
20<option value="2">Gokkusagi / Rainbow</option></select></p>
21<p><button style="font-size:22px">Uygula / Apply</button></p>
22</form></body></html>"""
23
24
25def connect():
26 wlan = network.WLAN(network.STA_IF)
27 wlan.active(True)
28 wlan.connect(SSID, PASSWORD)
29 for _ in range(20):
30 if wlan.isconnected():
31 break
32 time.sleep(1)
33 print("Telefonda ac / open on the phone: http://" + wlan.ifconfig()[0])
34
35
36def parse(query):
37 global mode
38 for part in query.split("&"):
39 if part.startswith("c=") and len(part) >= 8:
40 hexcode = part[-6:] # "%23ff7814" -> "ff7814"
41 color[0] = int(hexcode[0:2], 16)
42 color[1] = int(hexcode[2:4], 16)
43 color[2] = int(hexcode[4:6], 16)
44 elif part.startswith("m=") and part[2:].isdigit():
45 mode = int(part[2:]) % 3
46
47
48async def handle(reader, writer):
49 line = await reader.readline() # "GET /?c=%23ff7814&m=1 HTTP/1.1"
50 while True: # başlıkları atla / skip the headers
51 h = await reader.readline()
52 if not h or h == b"\r\n":
53 break
54 try:
55 path = line.decode().split(" ")[1]
56 if "?" in path:
57 parse(path.split("?", 1)[1])
58 except (IndexError, ValueError):
59 pass
60 writer.write(b"HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n")
61 writer.write(PAGE.encode())
62 await writer.drain()
63 writer.close()
64 await writer.wait_closed()
65
66
67def wheel(h):
68 h %= 256
69 if h < 85:
70 return (255 - h * 3, h * 3, 0)
71 if h < 170:
72 h -= 85
73 return (0, 255 - h * 3, h * 3)
74 h -= 170
75 return (h * 3, 0, 255 - h * 3)
76
77
78async def lights():
79 step = 0
80 while True:
81 for i in range(N):
82 if mode == 0:
83 c = color
84 elif mode == 1: # rastgele LED'ler parlar / random LEDs flare
85 k = 1.0 if random.randint(0, 99) < 8 else 0.25
86 c = [int(x * k) for x in color]
87 else:
88 c = wheel(i * 256 // N + step * 3)
89 np[i] = (int(c[0] * BRIGHT), int(c[1] * BRIGHT), int(c[2] * BRIGHT))
90 np.write()
91 step += 1
92 await asyncio.sleep_ms(60 if mode == 1 else 30)
93
94
95async def main():
96 connect()
97 await asyncio.start_server(handle, "0.0.0.0", 80)
98 await lights() # ışıklar sonsuza kadar döner / lights run forever
99
100
101asyncio.run(main())Quando il browser invia il modulo, l'indirizzo è simile a /?c=%23ff7814&m=1: %23 è il simbolo # all'inizio del codice colore. La funzione parse() prende gli ultimi sei caratteri e li divide in tre numeri esadecimali a due cifre, cioè i valori di rosso, verde e blu. Telefono e Pico devono essere sulla stessa rete; il Pico W si collega solo a reti a 2,4 GHz. Se non vuoi che riceva un IP diverso a ogni avvio, riserva al Pico un IP fisso nelle impostazioni del router.
Montaggio della decorazione e consigli estetici
- Ammorbidisci la luce: Metti carta da lucido o gommapiuma bianca a 1–2 cm davanti all'anello. I LED non sembrano più punti separati ma un'unica stella luminosa.
- Mettila in una stella: Ritaglia due stelle di cartone, incolla l'anello in mezzo, lascia Pico e power bank ai piedi dell'albero e fai passare i tre fili (5V, GND, dati) tra i rami con un cavo verde.
- Nascondi il sensore touch: Fissa il TTP223 con il nastro sul retro della decorazione. Il sensore rileva anche attraverso 1–2 mm di cartone o plastica.
- Più decorazioni: Collega il DO del primo anello al DI del secondo e imposta N a 48 per gestire due decorazioni con un solo pin; raddoppia il calcolo dei consumi.
- Attenzione al calore: A luminosità 0,2 l'anello non si intiepidisce nemmeno, ma se resterà acceso per ore a 0,4 in una scatola chiusa, fai dei piccoli fori di ventilazione.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Nessun LED si accende | Dati sulla piazzola DO o GND non in comune | Collega i dati a DI e unisci il GND dell'anello a quello del Pico |
| Il primo LED sfarfalla, colori casuali | Il segnale dati a 3,3 V è al limite o il filo è lungo | Accorcia il filo dati, aggiungi la resistenza da 330 Ω, usa un traslatore di livello se serve |
| Colori sbagliati (verde invece di rosso) | L'anello usa un altro ordine dei colori (es. RGB invece di GRB) | Aggiungi np.ORDER = (0, 1, 2, 3) dopo la riga np = neopixel.NeoPixel(...) e riprova |
| Il sensore touch non risponde | Il TTP223 si è calibrato con un dito appoggiato all'accensione | Togli la mano e ricollega la USB del Pico; non toccare il sensore all'avvio |
| Il Pico non avvia l'effetto all'accensione | Il file non è stato salvato come main.py | In Thonny: Salva con nome > Raspberry Pi Pico > main.py |
| La decorazione si spegne dopo pochi minuti | Il power bank si spegne a bassa corrente | Usa un power bank con modalità a bassa corrente o alza la luminosità minima |
Questa decorazione natalizia fatta con un Pico, un anello da 24 LED e un sensore touch insegna in un solo progetto i LED indirizzabili, il controllo della luminosità senza PWM, il salvataggio delle impostazioni su file e il calcolo dell'autonomia. Per aggiungere nuovi effetti, guarda nell'app BlueGrays gli schemi passo passo e il codice di progetti luminosi di base con il Pico, come la dissolvenza di un LED, un ciclo di colori RGB e i LED in sequenza, oltre a progetti con WS2812B come un lampeggiante della polizia e delle animazioni.
Domande frequenti
Un Raspberry Pi Pico può pilotare direttamente i LED WS2812B?
Sì. Il modulo neopixel di MicroPython è già presente sul Pico e gestisce da solo la temporizzazione precisa del WS2812B. La linea dati può andare a qualsiasi pin GP; i LED invece vanno alimentati a 5 V da VBUS, non dal pin a 3,3 V del Pico.
Quanta corrente assorbe un anello WS2812B da 24 LED?
Ogni LED assorbe circa 60 mA in bianco pieno, quindi il caso peggiore per 24 LED è circa 1,44 A. Con effetti reali a luminosità 0,2 si scende a circa 60–150 mA. Limitare la luminosità nel codice allunga l'autonomia e non affatica la linea USB.
Il segnale dati a 3,3 V del Pico basta per il WS2812B?
In teoria il WS2812B con alimentazione a 5 V chiede un livello dati di circa 3,5 V, ma con un filo corto la maggior parte degli anelli funziona bene a 3,3 V. Se il primo LED sfarfalla, accorcia il filo e metti la resistenza da 330 Ω vicino all'anello. La soluzione sicura è un traslatore di livello come il 74AHCT125.
Quante ore dura una decorazione con Pico su un power bank?
Un power bank da 10.000 mAh fornisce circa 6.300 mAh a 5 V. Alla luminosità predefinita di 0,2 la decorazione assorbe circa 145 mA, cioè oltre 40 ore di funzionamento. Dimezzare la luminosità quasi raddoppia la durata.
Come faccio a far partire il codice MicroPython all'accensione del Pico?
Basta salvare il codice sul Raspberry Pi Pico come main.py da Thonny. A ogni accensione il Pico esegue prima boot.py e poi main.py. Per fermare il codice premi Stop in Thonny o usa Ctrl+C.
Si possono controllare le luci di Natale dal telefono con un Pico W?
Sì. Il Pico W si collega al Wi-Fi di casa e può far girare un piccolo server web; aprendo il suo indirizzo IP nel browser del telefono compaiono un selettore di colore e i pulsanti degli effetti. Grazie ad asyncio, effetti luminosi e server web funzionano contemporaneamente.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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.

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.

Raspberry Pi Pico LED Sequenziale (6 LED)
La classica animazione delle "luci che camminano" con il Pico, in versione a 6 LED! Sei LED si accendono uno dopo l'altro da sinistra a destra, come se la luce camminasse lungo la fila. Impari le liste Python (LED_PINS = [14, 13, 12, 11, 10, 9]), la list comprehension, il controllo dei pin con un ciclo for ed enumerate(). Sei LED sui pin GP9-GP14, ognuno con una resistenza di limitazione da 220Ω.

Raspberry Pi Pico Knight Rider LED Scanner (6 LED Avanti-Indietro)
Effetto scanner LED "Knight Rider" classico con Pico! 6 LED vanno da sinistra a destra, poi da destra a sinistra, all'infinito. Impara reversed() e due cicli for separati per pattern avanti-indietro.

Utilizzo della striscia LED WS2812B
Conosci una striscia LED intelligente in cui puoi colorare ogni singola luce per conto suo.

LED in sequenza con WS2812B
Su una striscia di dieci LED, un puntino di luce verde avanza dall'inizio alla fine un LED alla volta, poi torna all'inizio; resta su ogni LED per un terzo di secondo.

WS2812B Animazione 1
Su una striscia di 56 LED tutti i colori dell'arcobaleno si mettono in fila uno accanto all'altro e scorrono senza fermarsi mai, come se un fiume di luce scivolasse lungo la striscia.

Controllo della striscia LED NeoPixel WS2812B con ESP32
I LED indirizzabili WS2812B (NeoPixel) sono LED RGB intelligenti collegabili in catena e controllati da un solo pin dati. Pilotiamo una striscia WS2812B da 8 LED con la libreria Adafruit_NeoPixel e creiamo un arcobaleno fluido. La logica a 3,3 V dell'ESP32 va bene con quasi tutti i WS2812B; in caso di instabilità mostriamo la soluzione con una resistenza in serie da 470Ω e un condensatore da 1000µF. L'animazione sposta la tonalità nello spazio HSV.
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
