Progetti Raspberry Pi Pico: 20 idee per principianti con codice
20 progetti Raspberry Pi Pico per principianti: LED, interrupt del pulsante, PWM, sensori, OLED e servo, con tabella di linguaggio, componenti e difficoltà.
Cerchi progetti Raspberry Pi Pico e non sai da dove cominciare? Questa lista fa per te: abbiamo raccolto 20 progetti ordinati dal più facile al più difficile, dal semplice LED che lampeggia e dall'interrupt del pulsante all'effetto respiro in PWM, alla lettura dei sensori, al display OLED e al servomotore. In un'unica tabella trovi per ogni progetto il linguaggio consigliato (MicroPython o C/C++), i componenti necessari e la difficoltà, e il progetto più istruttivo di ogni livello ha il suo codice funzionante.
Ci sono tre motivi per cui il Pico è perfetto per iniziare: costa poco, con MicroPython esegui il codice senza aspettare la compilazione e ognuno dei suoi 26 pin GPIO può generare PWM. Se l'hai appena tolto dalla scatola, segui prima i passi di installazione di Cos'è il Raspberry Pi Pico?; qui diamo per scontato che la tua scheda funzioni già in Thonny e che tu sappia far lampeggiare il LED integrato.

Prima di iniziare: il materiale che ti serve
- Scheda: Raspberry Pi Pico, Pico W o Pico 2. Per il progetto wireless (il numero 19) ti serve un Pico W.
- Breadboard e cavetti jumper: per montare i circuiti senza saldare; assicurati che il tuo Pico abbia i pin header saldati.
- LED e resistenze: da 5 a 10 LED e resistenze da 220 Ω e 330 Ω; per scegliere il valore usa il calcolatore della resistenza per LED.
- Ingressi: 2 o 3 pulsanti, un potenziometro da 10 kΩ, una fotoresistenza (LDR) e una resistenza da 10 kΩ.
- Sensori e uscite: HC-SR04, DHT11, PIR HC-SR501, un buzzer passivo, un servo SG90, un OLED SSD1306 da 0,96 pollici e un anello WS2812B da 8 a 12 LED.
- Software: Thonny per MicroPython; l'IDE Arduino con il core RP2040 di Earle Philhower per il C/C++.
MicroPython o C/C++?
Il Pico supporta entrambi i mondi e la maggior parte dei progetti di questa lista si può scrivere in tutti e due i linguaggi. In MicroPython scrivi il codice in Thonny, premi Esegui e vedi il risultato in un secondo; se sbagli, ricevi un messaggio chiaro con il numero di riga. Il C/C++ (IDE Arduino o Pico SDK) richiede la compilazione, ma è da 10 a 100 volte più veloce e ti permette di usare migliaia di librerie scritte per Arduino. Se sei alle prime armi, fai i primi 19 progetti in MicroPython e passa al C/C++ quando ti serve velocità o una libreria già pronta.
| Criterio | MicroPython | C/C++ (IDE Arduino) |
|---|---|---|
| Apprendimento | Facile, bastano le basi di Python | Familiare se conosci Arduino |
| Eseguire il codice | Subito (con Thonny) | Compilazione e caricamento: 10–30 secondi |
| Velocità | Più lento, ma basta per quasi tutti i progetti | Da 10 a 100 volte più veloce |
| Librerie | Moduli integrati come machine, neopixel, dht | Gran parte delle librerie Arduino |
| Ideale per | Imparare, leggere sensori, prove veloci | Tempi precisi, tastiera USB, calcoli pesanti |
20 progetti Raspberry Pi Pico: linguaggio, componenti e difficoltà
| # | Progetto | Linguaggio consigliato | Componenti necessari | Difficoltà |
|---|---|---|---|---|
| 1 | Far lampeggiare il LED integrato (Blink) | MicroPython | Solo il Pico | Facile |
| 2 | LED esterno (GP14) | MicroPython | LED, resistenza da 220 Ω | Facile |
| 3 | Semaforo | MicroPython | LED rosso, giallo e verde, 3 resistenze | Facile |
| 4 | Lampeggiante della polizia | MicroPython | LED rosso e blu, 2 resistenze | Facile |
| 5 | Effetto Supercar (Knight Rider) | MicroPython | 6 LED, 6 resistenze | Facile |
| 6 | Accendere e spegnere un LED con un pulsante | MicroPython | Pulsante, LED, resistenza | Facile |
| 7 | Interrupt del pulsante (IRQ) e antirimbalzo | MicroPython | Pulsante, LED, resistenza | Media |
| 8 | LED che respira in PWM | MicroPython | LED, resistenza | Facile |
| 9 | Ciclo di colori con LED RGB | MicroPython | LED RGB, 3 resistenze | Facile |
| 10 | Melodia con buzzer passivo | MicroPython | Buzzer passivo | Facile |
| 11 | Luminosità del LED con potenziometro | MicroPython | Potenziometro da 10 kΩ, LED | Facile |
| 12 | Sensore di temperatura interno | MicroPython | Solo il Pico | Facile |
| 13 | Luce notturna automatica con LDR | MicroPython | LDR, resistenza da 10 kΩ, LED | Facile |
| 14 | Allarme di movimento con PIR | MicroPython | HC-SR501, buzzer attivo | Facile |
| 15 | Misuratore di distanza con HC-SR04 | MicroPython | HC-SR04, resistenze da 1 kΩ e 2 kΩ | Media |
| 16 | Termometro con display OLED | MicroPython | OLED SSD1306, DHT11 | Media |
| 17 | Controllare un servo con potenziometro | MicroPython | Servo SG90, potenziometro da 10 kΩ | Media |
| 18 | Animazione su anello WS2812B | MicroPython | Anello WS2812B (8–12 LED) | Media |
| 19 | Comandare un LED via Wi-Fi con il Pico W | MicroPython | Pico W, LED | Difficile |
| 20 | Tastiera di macro USB | C/C++ (IDE Arduino) | 3–4 pulsanti | Difficile |
L'ordine non è casuale: ogni progetto aggiunge un gradino a quello che hai imparato nel precedente. I primi sei insegnano uscite e ingressi digitali, dal 7 al 10 interrupt e PWM, dall'11 al 15 sensori analogici e digitali, dal 16 al 18 display, servo e LED pilotati dalla PIO, e gli ultimi due funzioni tipiche del Pico come il Wi-Fi e l'USB. Qui sotto spieghiamo ogni livello con il suo circuito e ti diamo il codice dei progetti più istruttivi.
Livello 1: progetti con LED e pulsante (1–6)
Nel primo progetto fai lampeggiare il LED integrato con Pin(25) (su Pico W e Pico 2 W con Pin("LED")). Nel secondo colleghi un LED esterno a GP14 (pin fisico 19) tramite una resistenza da 220 Ω; la resistenza può stare sul lato della gamba lunga o di quella corta, l'importante è che sia in serie. Il semaforo accende in sequenza i tre LED su GP11, GP12 e GP13, il lampeggiante fa balenare un LED rosso e uno blu a raffiche veloci e l'effetto Supercar fa scorrere una luce avanti e indietro su sei LED da GP9 a GP14. In questi tre progetti, mettere i pin in una lista e scorrerla con un ciclo for dimezza il tuo codice.
Nel sesto progetto il pulsante va su GP2 con l'altro piedino a GND, e si attiva la resistenza di pull-up interna del Pico: rilasciato il pin legge 1, premuto legge 0. Perché ogni pressione cambi lo stato del LED devi salvare lo stato precedente del pulsante in una variabile e contare solo il passaggio da 1 a 0. Perché i pulsanti rimbalzano e come funziona il pull-up lo spieghiamo in Come collegare un pulsante ad Arduino; le stesse regole valgono per il Pico.
Livello 2: interrupt del pulsante, PWM e suono (7–10)
Controllare il pulsante di continuo nel ciclo (polling) va bene per i progetti semplici, ma il tuo codice può perdere delle pressioni mentre fa altro. Con un interrupt (IRQ) il Pico chiama la tua funzione nell'istante in cui il livello del pin cambia. Il codice qui sotto è il progetto 7 completo: ogni pressione cambia lo stato del LED su GP14 e un filtro temporale di 200 ms evita che il rimbalzo meccanico conti come doppia pressione.
1from machine import Pin
2import time
3
4led = Pin(14, Pin.OUT) # GP14 + 220 Ω direnç / GP14 + 220 Ω resistor
5button = Pin(2, Pin.IN, Pin.PULL_UP) # butonun diğer ucu GND / other leg to GND
6last_ms = 0 # son geçerli basış / last valid press
7
8def on_press(pin):
9 global last_ms
10 now = time.ticks_ms()
11 if time.ticks_diff(now, last_ms) > 200: # 200 ms sıçrama filtresi / 200 ms debounce
12 led.toggle()
13 last_ms = now
14
15button.irq(trigger=Pin.IRQ_FALLING, handler=on_press) # basınca 1→0 / press pulls 1→0
16
17while True:
18 time.sleep(1) # ana döngü boşta, iş kesmede / main loop idle, work in the IRQIl progetto otto è l'esempio classico di PWM. Tutti i pin GPIO del Pico possono generare PWM e in MicroPython il duty cycle si imposta con duty_u16() tra 0 e 65535. Se aumenti la luminosità in modo lineare l'occhio non la percepisce come naturale: ai livelli bassi il cambiamento sembra troppo veloce, a quelli alti troppo lento. Il codice qui sotto usa una curva coseno per un ritmo di respiro morbido ed eleva il valore al quadrato per avvicinarsi a come l'occhio percepisce la luce. La teoria è in Cos'è il PWM?
1from machine import Pin, PWM
2import math, time
3
4led = PWM(Pin(14))
5led.freq(1000) # 1 kHz, titreme görünmez / 1 kHz, no visible flicker
6
7while True:
8 for step in range(200):
9 level = (1 - math.cos(step / 200 * 2 * math.pi)) / 2 # 0 → 1 → 0 yumuşak / smooth 0 → 1 → 0
10 led.duty_u16(int(level * level * 65535)) # kare alma göze doğal gelir / squaring looks natural
11 time.sleep_ms(15) # 200 × 15 ms = 3 s bir nefes / one 3 s breathNel progetto nove applichi la stessa idea a tre canali: collega i piedini rosso, verde e blu di un LED RGB a GP11, GP12 e GP13, ognuno con la sua resistenza, e sfasa i tre valori di duty perché i colori sfumino l'uno nell'altro. Con i LED ad anodo comune ricordati di invertire i valori; i dettagli sono in Come usare un LED RGB. Nel progetto dieci cambi invece la frequenza del PWM: collega un buzzer passivo a un pin, scrivi freq(440) e suonerà la nota La; un duty di 32768 (50 per cento) dà il suono più forte e un ciclo su una lista di note ti dà una melodia.
Livello 3: progetti con sensori (11–15)
Gli ingressi analogici del Pico sono GP26, GP27 e GP28 e read_u16() restituisce un valore da 0 a 65535 (il chip misura internamente a 12 bit e MicroPython porta il risultato a 16 bit). Nel progetto undici colleghi il cursore di un potenziometro a GP26 e scrivi la lettura direttamente come duty del LED. Il progetto dodici non richiede componenti: il canale 4 dell'ADC è collegato a un sensore di temperatura dentro il chip e la temperatura si ricava da T = 27 − (V − 0,706) / 0,001721. Poiché misura il chip e non l'ambiente, può sbagliare di qualche grado. Nel progetto tredici costruisci un partitore di tensione con la LDR e una resistenza da 10 kΩ e accendi un LED quando la lettura supera una soglia di buio; il calcolatore del partitore di tensione ti semplifica i conti.
Il sensore PIR HC-SR501 del progetto quattordici si alimenta a 5 V, ma la sua uscita è a 3,3 V e quindi va direttamente su un GPIO; quando rileva un movimento il pin passa a 1 per qualche secondo. Per le sue regolazioni di tempo e sensibilità guarda Sensore di movimento PIR. Il progetto quindici richiede un po' più di attenzione: l'HC-SR04 funziona a 5 V e il suo pin ECHO restituisce un impulso a 5 V. Il codice qui sotto invia un impulso di 10 microsecondi a TRIG, misura la durata dell'eco con time_pulse_us() e calcola la distanza dalla velocità del suono.
1from machine import Pin, time_pulse_us
2import time
3
4trig = Pin(17, Pin.OUT) # GP17 → TRIG
5echo = Pin(16, Pin.IN) # GP16 ← ECHO (1 kΩ + 2 kΩ bölücüyle / through a 1k + 2k divider)
6
7def distance_cm():
8 trig.low()
9 time.sleep_us(2)
10 trig.high()
11 time.sleep_us(10) # 10 µs tetik darbesi / 10 µs trigger pulse
12 trig.low()
13 t = time_pulse_us(echo, 1, 30000) # en çok 30 ms bekle (~5 m) / wait up to 30 ms (~5 m)
14 if t < 0:
15 return None # yankı yok / no echo
16 return t * 0.0343 / 2 # 343 m/s, gidiş-dönüş / round trip
17
18while True:
19 d = distance_cm()
20 print("Mesafe / Distance:", "---" if d is None else "%.1f cm" % d)
21 time.sleep_ms(200)Livello 4: display OLED, servo e NeoPixel (16–18)
Nel progetto sedici mostri su un OLED da 0,96 pollici la temperatura e l'umidità lette da un DHT11. Il modulo dht che serve al DHT11 è già incluso nel firmware MicroPython del Pico; per l'OLED copi sul Pico il driver ssd1306.py. Il display si collega in I2C a GP4 (SDA) e GP5 (SCL). Il codice del display è spiegato in Come usare un display OLED SSD1306, quello del sensore in Sensore di temperatura e umidità DHT11.
Nel progetto diciassette fai ruotare un servo SG90 con un potenziometro. Un servo si aspetta un segnale a 50 Hz e legge l'angolo dalla larghezza dell'impulso: circa 500 microsecondi sono 0 gradi e 2500 microsecondi sono 180 gradi. In MicroPython duty_ns() ti permette di scrivere la larghezza dell'impulso direttamente in nanosecondi, quindi il calcolo è semplicissimo:
1from machine import Pin, PWM, ADC
2import time
3
4servo = PWM(Pin(15)) # GP15 → servo sinyal (turuncu) / signal (orange)
5servo.freq(50) # 50 Hz = 20 ms periyot / 20 ms period
6pot = ADC(26) # GP26 (ADC0) ← potansiyometre orta ucu / pot wiper
7
8def set_angle(angle):
9 pulse_us = 500 + angle * 2000 // 180 # 0° = 500 µs, 180° = 2500 µs
10 servo.duty_ns(pulse_us * 1000)
11
12while True:
13 angle = pot.read_u16() * 180 // 65535 # 0–65535 → 0–180°
14 set_angle(angle)
15 time.sleep_ms(20) # her periyotta bir güncelleme / one update per periodNel progetto diciotto piloti un anello di LED WS2812B con il modulo neopixel integrato in MicroPython. Questi LED richiedono tempi precisi al microsecondo e il Pico li gestisce senza impegnare il processore grazie ai suoi blocchi di I/O programmabili, la PIO. Come usare la PIO e il secondo core lo spieghiamo passo passo in PIO e doppio core del Pico. Un piccolo anello da 8 a 12 LED può essere alimentato da VBUS; le strisce più lunghe richiedono un alimentatore da 5 V separato.
Livello 5: Wi-Fi e tastiera USB con il Pico W (19–20)
Nel progetto diciannove il Pico W si collega alla rete di casa e accende un LED dai pulsanti di una pagina web che apri sul telefono. Con i moduli network e socket di MicroPython scrivi un server web funzionante in 40–50 righe; per la configurazione passo passo vedi Server web Wi-Fi con il Pico W. Nel progetto venti il tuo Pico si presenta al computer come una tastiera: assegna a ogni pulsante una scorciatoia o un testo e avrai il tuo macro pad personale. Qui il C/C++ è la strada più semplice, perché il core Pico per l'IDE Arduino include la libreria Keyboard.
Lo stesso progetto in C/C++: il Pico nell'IDE Arduino
Dopo aver installato dal Gestore schede dell'IDE Arduino il pacchetto Raspberry Pi Pico/RP2040 di Earle Philhower, programmi il Pico con i comandi Arduino che conosci già. Come numero di pin usi il numero GP (14 per GP14), analogWrite() lavora di default nell'intervallo 0–255 e attachInterrupt() funziona su ogni pin. Al primo caricamento potresti dover collegare il Pico tenendo premuto il pulsante BOOTSEL. Il codice qui sotto unisce i progetti 7 e 8: il LED respira, si ferma quando premi il pulsante e riparte alla pressione successiva.
1// Arduino IDE + Raspberry Pi Pico (Earle Philhower çekirdeği / core)
2const int LED_PIN = 14; // GP14 (fiziksel pin 19 / physical pin 19)
3const int BUTTON_PIN = 2; // GP2, diğer ucu GND / other leg to GND
4
5volatile bool breathing = true; // kesmede değişir / changed in the interrupt
6volatile unsigned long lastPress = 0;
7
8void onPress() {
9 unsigned long now = millis();
10 if (now - lastPress > 200) { // 200 ms sıçrama filtresi / 200 ms debounce
11 breathing = !breathing;
12 lastPress = now;
13 }
14}
15
16void setup() {
17 pinMode(LED_PIN, OUTPUT);
18 pinMode(BUTTON_PIN, INPUT_PULLUP);
19 attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onPress, FALLING);
20}
21
22void loop() {
23 if (!breathing) { // butonla durdurulduysa LED sönük / paused by the button
24 analogWrite(LED_PIN, 0);
25 return;
26 }
27 for (int v = 0; v <= 255; v++) { analogWrite(LED_PIN, v); delay(4); } // yavaşça yan / fade in
28 for (int v = 255; v >= 0; v--) { analogWrite(LED_PIN, v); delay(4); } // yavaşça sön / fade out
29}Errori comuni e come risolverli
- Numero di pin sbagliato: nel codice va il numero GP, non il numero del pin fisico. GP14 è il pin 19 della scheda; trovi la piedinatura completa nello strumento Pinout.
- Il LED integrato non si accende sul Pico W: sul Pico W il LED è collegato al chip wireless; scrivi Pin("LED") al posto di Pin(25).
- Il codice non parte quando scolleghi il computer: salva il file sul Pico con il nome main.py; è l'unico file che il Pico avvia da solo all'accensione.
- Il servo trema o il Pico si riavvia: il servo è alimentato dal 3V3 oppure le masse non sono in comune; alimentalo a 5 V e aggiungi un condensatore da 470 µF sull'alimentazione.
- Il valore analogico è sempre 0 o sempre 65535: il sensore è su un pin diverso da GP26–GP28, oppure stai leggendo un piedino esterno del potenziometro invece del cursore.
- duty() degli esempi vecchi dà errore: sul Pico il PWM di MicroPython usa duty_u16() o duty_ns().
- Una pressione viene rilevata più volte: è il rimbalzo meccanico; aggiungi un filtro di 150–200 ms come nel codice con interrupt.
Quando avrai completato questi 20 progetti in ordine, avrai usato ingressi e uscite digitali, interrupt, PWM, ADC, I2C, PIO e Wi-Fi del Pico: quasi tutto quello che serve per progettare i tuoi circuiti. Per sentirti più a tuo agio con MicroPython, Le basi di MicroPython è un ottimo passo successivo. Nell'app BlueGrays puoi provare passo passo progetti con il Pico come il LED integrato, il semaforo, il lampeggiante della polizia, l'effetto Supercar, l'interrupt del pulsante, il LED che respira in PWM e il ciclo di colori RGB, ognuno con il suo schema di collegamento e il suo codice.
Domande frequenti
Cosa si può fare con un Raspberry Pi Pico?
Puoi realizzare effetti luminosi con LED, strumenti di misura con sensori, termometri con display OLED, controlli per servo e motori, tastiere USB e controller per videogiochi, e con un Pico W progetti di domotica comandati dal telefono. Il Pico è un microcontrollore e non un computer, quindi non è adatto a riprodurre video o a far girare programmi desktop.
Il Raspberry Pi Pico va bene per i principianti?
Sì. Con MicroPython usi subito quello che sai di Python ed esegui il codice senza compilare. La cosa principale a cui fare attenzione è che i pin lavorano a 3,3 V, quindi i sensori con uscita a 5 V vanno collegati tramite un partitore di tensione o un traslatore di livello.
Meglio imparare MicroPython o C++ per il Pico?
Se programmazione ed elettronica sono nuove per te, comincia con MicroPython: i messaggi di errore sono comprensibili e provi tutto più in fretta. Passa al C/C++ quando ti servono tempi precisi, più velocità o una libreria che esiste solo per Arduino; il Pico li supporta entrambi.
Il Raspberry Pi Pico può pilotare un servo direttamente?
Per il segnale sì: qualsiasi pin GPIO comanda un servo come l'SG90 con un PWM a 50 Hz. L'alimentazione del servo però deve arrivare da VBUS o da un alimentatore esterno da 5 V e non dal pin 3V3, e le masse vanno collegate insieme.
Che differenza c'è tra Pico e Pico W?
Entrambi usano lo stesso chip RP2040; il Pico W aggiunge un chip Wi-Fi a 2,4 GHz e Bluetooth. Tutti i progetti senza Wi-Fi funzionano su entrambi, e l'unica differenza è che il LED integrato del Pico W si comanda con Pin("LED").
Si può usare il codice Arduino sul Raspberry Pi Pico?
Installando nell'IDE Arduino il pacchetto RP2040 di Earle Philhower, la maggior parte degli sketch funziona con piccole modifiche, usando i numeri GP come numeri di pin. Il codice che usa registri specifici degli AVR o i circuiti che presuppongono una logica a 5 V vanno invece adattati.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Lampeggio LED Integrato Raspberry Pi Pico (Pico e Pico W)
Il progetto d'apertura della serie Raspberry Pi Pico! Facciamo lampeggiare il LED verde integrato del Pico per verificare che la scheda funzioni: il classico primo esperimento in stile "Hello World". Niente componenti esterni, bastano il Pico e un cavo USB. Il codice è scritto in MicroPython, il linguaggio supportato ufficialmente dalla Raspberry Pi Foundation.

Accensione di un LED esterno con Raspberry Pi Pico (breadboard)
Il passo successivo al LED integrato del Pico: collegare un LED esterno sulla breadboard e controllarlo dal pin GP14. Impari a usare qualsiasi pin GPIO del Pico come uscita, la polarità del LED (gamba lunga = anodo/+, gamba corta = catodo/–) e perché una resistenza di limitazione della corrente (220Ω) è indispensabile. Senza di essa nel LED passa troppa corrente e può bruciarsi.

Simulatore Semaforo Raspberry Pi Pico (3 LED Sequenziali)
Simuliamo un vero semaforo con LED rosso, giallo e verde. Verde 4 sec "vai", giallo 1,5 sec "preparati", rosso 3 sec "fermati" e rosso+giallo 1 sec "partenza" (pattern europeo). Impara la definizione di funzione, la logica della macchina a stati e la sincronizzazione multi-GPIO. Circuito semplice: 3 LED su GP11/GP12/GP13.

Raspberry Pi Pico Effetto Lampeggiante Polizia (Rosso + Blu Stroboscopio)
Simuliamo il lampeggiante di un'auto della polizia con un Raspberry Pi Pico nella sua forma più semplice! I LED rosso e blu si alternano (flip-flop): mentre il rosso è acceso il blu è spento, e ogni 0,3 secondi si scambiano, all'infinito. Il codice scrive i due passi direttamente in un unico ciclo while True; la velocità si regola con la costante WAIT_MS.

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.

Raspberry Pi Pico Pulsante Debounce: IRQ vs Software Polling
Una pressione e il codice conta 3-4? È contact bounce! Confronta 2 metodi di conteggio in Serial: polling RAW (cattura bounce, conta male) vs IRQ + software debounce (preciso). Impara fisica del bounce, software debounce, Pin.irq() interrupt, IRQ_FALLING trigger, ISR handler, sicurezza delle variabili globali ISR.

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

