Guide · 11 min di lettura

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.

Scheda microcontrollore Raspberry Pi Pico
Raspberry Pi Pico: chip RP2040, 26 GPIO, 3 ingressi analogici e PWM su ogni pin. Tutti i progetti di questa lista funzionano su Pico, Pico W e Pico 2.

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.

CriterioMicroPythonC/C++ (IDE Arduino)
ApprendimentoFacile, bastano le basi di PythonFamiliare se conosci Arduino
Eseguire il codiceSubito (con Thonny)Compilazione e caricamento: 10–30 secondi
VelocitàPiù lento, ma basta per quasi tutti i progettiDa 10 a 100 volte più veloce
LibrerieModuli integrati come machine, neopixel, dhtGran parte delle librerie Arduino
Ideale perImparare, leggere sensori, prove velociTempi precisi, tastiera USB, calcoli pesanti

20 progetti Raspberry Pi Pico: linguaggio, componenti e difficoltà

#ProgettoLinguaggio consigliatoComponenti necessariDifficoltà
1Far lampeggiare il LED integrato (Blink)MicroPythonSolo il PicoFacile
2LED esterno (GP14)MicroPythonLED, resistenza da 220 ΩFacile
3SemaforoMicroPythonLED rosso, giallo e verde, 3 resistenzeFacile
4Lampeggiante della poliziaMicroPythonLED rosso e blu, 2 resistenzeFacile
5Effetto Supercar (Knight Rider)MicroPython6 LED, 6 resistenzeFacile
6Accendere e spegnere un LED con un pulsanteMicroPythonPulsante, LED, resistenzaFacile
7Interrupt del pulsante (IRQ) e antirimbalzoMicroPythonPulsante, LED, resistenzaMedia
8LED che respira in PWMMicroPythonLED, resistenzaFacile
9Ciclo di colori con LED RGBMicroPythonLED RGB, 3 resistenzeFacile
10Melodia con buzzer passivoMicroPythonBuzzer passivoFacile
11Luminosità del LED con potenziometroMicroPythonPotenziometro da 10 kΩ, LEDFacile
12Sensore di temperatura internoMicroPythonSolo il PicoFacile
13Luce notturna automatica con LDRMicroPythonLDR, resistenza da 10 kΩ, LEDFacile
14Allarme di movimento con PIRMicroPythonHC-SR501, buzzer attivoFacile
15Misuratore di distanza con HC-SR04MicroPythonHC-SR04, resistenze da 1 kΩ e 2 kΩMedia
16Termometro con display OLEDMicroPythonOLED SSD1306, DHT11Media
17Controllare un servo con potenziometroMicroPythonServo SG90, potenziometro da 10 kΩMedia
18Animazione su anello WS2812BMicroPythonAnello WS2812B (8–12 LED)Media
19Comandare un LED via Wi-Fi con il Pico WMicroPythonPico W, LEDDifficile
20Tastiera di macro USBC/C++ (IDE Arduino)3–4 pulsantiDifficile

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.

MicroPython
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 IRQ
Tieni corta la funzione di interrupt: niente lunghe serie di print, niente time.sleep e niente creazione di grandi liste al suo interno. La via più pulita è cambiare solo una variabile flag nell'interrupt e fare il lavoro vero nel ciclo principale. Per confrontare i tempi usa sempre time.ticks_diff(); dà il risultato giusto anche quando il contatore ricomincia da capo.

Il 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?

MicroPython
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 breath

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

MicroPython
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)
Non collegare direttamente il pin ECHO dell'HC-SR04 al Pico: i suoi pin non tollerano i 5 V. Metti una resistenza da 1 kΩ tra ECHO e GP16 e una da 2 kΩ tra GP16 e GND; così l'impulso a 5 V scende a circa 3,3 V. Se usi le versioni a 3,3 V, l'HC-SR04P o l'RCWL-1601, il partitore non serve.

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:

MicroPython
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 period
Non alimentare il servo dal pin 3V3 del Pico. Un SG90 in movimento può assorbire picchi di oltre 500 mA, che fanno ripartire il Pico o tremare il servo. Collega il filo rosso del servo ai 5 V dell'USB (VBUS, pin fisico 40) o a un alimentatore esterno da 5 V e il filo marrone a GND; con un alimentatore esterno unisci sempre le due masse. I dettagli sono in Cos'è un servomotore?

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

C++ (Arduino IDE)
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 vuoi far funzionare un progetto lontano dal computer, alimenta il Pico con un caricatore USB da telefono oppure porta da 1,8 a 5,5 V sul pin VSYS (per esempio 3 pile AA o una singola cella agli ioni di litio). Ricordati di salvare prima il codice come main.py.

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.

Vedi tutti i progetti
Lampeggio LED Integrato Raspberry Pi Pico (Pico e Pico W)
PI-1Principiante

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.

5.0(1)
10
Accensione di un LED esterno con Raspberry Pi Pico (breadboard)
PI-2Principiante

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.

4.5(2)
7
Simulatore Semaforo Raspberry Pi Pico (3 LED Sequenziali)
PI-4Principiante

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.

4.0(1)
12
Raspberry Pi Pico Effetto Lampeggiante Polizia (Rosso + Blu Stroboscopio)
PI-5Principiante

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.

4.7(3)
10
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
Raspberry Pi Pico Pulsante Debounce: IRQ vs Software Polling
PI-13Intermedio
Premium

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.

12
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