Guide · 9 min di lettura

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.

Anello LED RGB WS2812B da 24 LED
Anello WS2812B da 24 LED: ogni LED ha il proprio driver interno, quindi si possono mostrare 24 colori diversi insieme con una sola linea dati.

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.

CaratteristicaValore
Numero di LED24 × WS2812B (5050 SMD)
Diametro esternoCirca 6,5–8,5 cm (dipende dal produttore)
Alimentazione5 V (circa 3,5–5,3 V)
CorrenteFino a ~20 mA per canale colore e per LED; ~60 mA per LED in bianco pieno
Corrente a riposoCirca 0,5–1 mA per LED anche con i LED spenti
DatiUna linea, 800 kHz; aggiornare 24 LED richiede circa 0,7 ms
PinDI (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

CollegamentoPin del PicoPin fisicoNota
DI dell'anello (ingresso dati)GP01Resistenza da 330 Ω in mezzo
5V dell'anelloVBUS405 V dalla USB
GND dell'anelloGND38Qui va anche il piedino negativo del condensatore
TTP223 VCC3V3(OUT)36Funziona a 3,3 V
TTP223 I/OGP1520HIGH al tocco (A e B aperti)
TTP223 GNDGND23Va bene qualsiasi pin GND
Non alimentare l'anello dal pin 3V3(OUT): il regolatore a 3,3 V del Pico fornisce al massimo 300 mA e questo limite si supera appena qualche LED va in bianco pieno. Alimenta l'anello da VBUS (5 V della USB). A 5 V l'ingresso dati del WS2812B richiede in teoria circa 3,5 V, mentre il Pico invia 3,3 V; con un filo dati corto (sotto i 10 cm) la maggior parte degli anelli funziona senza problemi. Se il primo LED sfarfalla o i colori escono a caso, accorcia il filo dati, metti la resistenza da 330 Ω vicino all'ingresso dell'anello o aggiungi un traslatore di livello come il 74AHCT125.
Modulo sensore touch capacitivo TTP223
Sensore touch TTP223: il pin I/O va a HIGH quando avvicini il dito. Rileva anche attraverso cartone o plastica sottili, quindi si può nascondere dentro la decorazione.

Prima prova: accendere l'anello con il modulo neopixel

MicroPython
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àEffettoColoriDurata fotogrammaCorrente circa (luminosità 0,2, anello + Pico)
0Cometa rotanteUn giro rosso, un giro verde40 ms~65 mA
1Scintillio doratoLuce di base calda + scintille dorate casuali60 ms~70 mA
2NevicataSfondo blu notte, fiocchi bianchi40 ms~110 mA
3Stella che respiraGiallo oro che si accende e si spegne piano30 ms~125 mA
4Arcobaleno rotanteTutta la ruota dei colori30 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.

MicroPython
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 codiceFunzione
bufTiene 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 / heldMisura 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.

Perché l'effetto neve risulti giusto, monta l'anello con il LED numero 0 (di solito quello più vicino alla piazzola DI) in alto. Per trovarlo, scrivi solo np[0] = (40, 0, 0) nel codice di prova ed eseguilo; il LED che si accende deve stare in cima. Se hai montato l'anello capovolto, basta girare la decorazione invece di cambiare il codice.

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à arcobalenoPower bank 5.000 mAhPower 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
Alcuni power bank si spengono da soli quando la corrente scende sotto circa 50–100 mA, perché credono che il dispositivo sia carico. Di solito è per questo che la decorazione si spegne dopo pochi minuti al livello soffuso. Scegli un power bank con modalità a bassa corrente o porta il livello minimo da 0,08 a 0,12, così la corrente resta sopra la soglia di spegnimento.

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.

MicroPython
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

SintomoCausa probabileSoluzione
Nessun LED si accendeDati sulla piazzola DO o GND non in comuneCollega i dati a DI e unisci il GND dell'anello a quello del Pico
Il primo LED sfarfalla, colori casualiIl segnale dati a 3,3 V è al limite o il filo è lungoAccorcia 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 rispondeIl TTP223 si è calibrato con un dito appoggiato all'accensioneTogli la mano e ricollega la USB del Pico; non toccare il sensore all'avvio
Il Pico non avvia l'effetto all'accensioneIl file non è stato salvato come main.pyIn Thonny: Salva con nome > Raspberry Pi Pico > main.py
La decorazione si spegne dopo pochi minutiIl power bank si spegne a bassa correnteUsa un power bank con modalità a bassa corrente o alza la luminosità minima
Per aggiungere un effetto nuovo, scrivi una funzione, aggiungila alla lista EFFECTS e metti un valore in più nelle liste FRAME_MS e NAMES. Ad esempio, un effetto "colori di Natale" che porta lentamente tutto l'anello dal rosso al verde si scrive in cinque righe passando a wheel() solo tonalità tra 0 e 85.

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.

Vedi tutti i progetti
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
Raspberry Pi Pico LED RGB Ciclo di Colori (PWM a 3 Canali)
PI-15Principiante

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.

6
Raspberry Pi Pico LED Sequenziale (6 LED)
PI-7Principiante

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Ω.

5.0(1)
9
Raspberry Pi Pico Knight Rider LED Scanner (6 LED Avanti-Indietro)
PI-8Principiante

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.

5.0(1)
14
Utilizzo della striscia LED WS2812B
AR-69Intermedio
Premium

Utilizzo della striscia LED WS2812B

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

4.8(54)
70
LED in sequenza con WS2812B
AR-71Intermedio
Premium

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.

4.8(58)
75
WS2812B Animazione 1
AR-75Intermedio
Premium

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.

4.9(69)
89
Controllo della striscia LED NeoPixel WS2812B con ESP32
ES-24Intermedio
Premium

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.

4.9(19)
30