Progetti Raspberry Pi Pico W: 15 idee con Wi-Fi e Bluetooth
15 progetti Raspberry Pi Pico W: web server, MQTT, orologio NTP, meteo, Telegram e BLE. Codice MicroPython, limiti di memoria e tabella Pico W o ESP32.
Se cerchi progetti con Raspberry Pi Pico W, questo elenco raccoglie 15 progetti realistici per usare il Wi-Fi e il Bluetooth della scheda dal più facile al più difficile: un web server che accende un LED dal telefono, un orologio NTP che prende l'ora da internet, una stazione che pubblica i dati dei sensori via MQTT, un allarme che invia un messaggio Telegram quando si apre una porta e un sensore di temperatura BLE che leggi con il telefono sono solo alcuni. Tutti funzionano con lo stesso codice sul Pico W e sul nuovo Pico 2 W.
Abbiamo raccolto in una tabella i componenti, il tipo di connessione e la difficoltà di ogni progetto, e per i cinque più importanti c'è il codice MicroPython completo. Poi trovi i limiti di memoria del Pico W in MicroPython, gli errori più comuni e una tabella di confronto che indica quali progetti riescono meglio con un Pico W e quali con un ESP32. Se è la prima volta che usi la scheda, dai prima un'occhiata a cos'è il Raspberry Pi Pico.

Pico W e Pico 2 W: che differenza c'è?
Il Pico W è il Pico classico con l'aggiunta di un chip wireless Infineon CYW43439: offre Wi-Fi a 2,4 GHz (802.11n) e Bluetooth 5.2 (Classic e BLE). Il Pico 2 W unisce lo stesso chip al processore RP2350, più potente; la RAM raddoppia e la flash sale a 4 MB. Piedinatura, dimensioni e gran parte del codice MicroPython sono uguali sulle due schede. Poiché il chip wireless usa alcuni pin interni, il LED integrato non è più su GP25 ma sul chip wireless e si controlla con Pin("LED").
| Caratteristica | Pico W | Pico 2 W |
|---|---|---|
| Processore | RP2040, 2 × Cortex-M0+, 133 MHz | RP2350, 2 × Cortex-M33 (o RISC-V), 150 MHz |
| RAM | 264 KB | 520 KB |
| Flash | 2 MB | 4 MB |
| Wireless | CYW43439: Wi-Fi 4 a 2,4 GHz, Bluetooth 5.2 | CYW43439: Wi-Fi 4 a 2,4 GHz, Bluetooth 5.2 |
| GPIO / ADC | 26 GPIO, 3 ingressi analogici (12 bit) | 26 GPIO, 3 ingressi analogici (12 bit) |
| LED integrato | Pin("LED") | Pin("LED") |
| Firmware MicroPython | RPI_PICO_W | RPI_PICO2_W |
Prima di iniziare: MicroPython e librerie
- Carica il firmware giusto: Usa il file UF2 di MicroPython chiamato RPI_PICO_W per il Pico W e RPI_PICO2_W per il Pico 2 W. Il firmware del Pico normale non ha il modulo network e il codice Wi-Fi fallisce con "no module named network".
- Usa Thonny: In Thonny scegli in basso a destra "MicroPython (Raspberry Pi Pico)"; esegue il codice, copia i file sulla scheda e sincronizza il suo orologio con il computer. Per i comandi base di MicroPython guarda la guida basi di MicroPython.
- Installa i pacchetti extra con mip: Dopo esserti collegato al Wi-Fi, scrivi nella Shell import mip; mip.install("umqtt.simple") o mip.install("aioble") per scaricare il pacchetto direttamente sulla scheda. Il menu Strumenti > Gestisci pacchetti di Thonny fa la stessa cosa.
- Solo 2,4 GHz: Il Pico W non si collega alle reti a 5 GHz; se il router trasmette le due bande con lo stesso nome, la connessione può dare problemi.
- Alimentazione: Quando il Wi-Fi trasmette, la corrente di picco può superare i 100 mA. Usa un buon cavo USB e un alimentatore da almeno 500 mA.
| Modulo | A cosa serve? | Incluso? |
|---|---|---|
| network | Connessione Wi-Fi, access point, scansione reti | Sì (nel firmware W) |
| socket / asyncio | Web server, UDP, attività in parallelo | Sì |
| requests | Richieste HTTP e HTTPS, JSON | Sì |
| ntptime | Ora da internet | Sì |
| bluetooth | BLE a basso livello | Sì |
| aioble | BLE semplice: servizi, caratteristiche, advertising | Dipende dalla versione; altrimenti mip.install("aioble") |
| umqtt.simple | Client MQTT | Dipende dalla versione; altrimenti mip.install("umqtt.simple") |
Il codice di connessione Wi-Fi da usare in ogni progetto
Salva il file qui sotto sul Pico W da Thonny con il nome wifi.py. Così in tutti gli altri progetti ti basterà scrivere import wifi e wifi.connect(). Il LED integrato lampeggia durante la connessione e resta acceso quando è collegato; è il modo più semplice per vedere lo stato della connessione quando la scheda non è attaccata al computer.
1# wifi.py: Pico W'ye bu adla kaydet / save it to the Pico W with this name
2import network, time
3from machine import Pin
4
5SSID = "AgAdi" # Wi-Fi adın (2,4 GHz) / your Wi-Fi name (2.4 GHz)
6PASSWORD = "Sifre123" # Wi-Fi şifren / your Wi-Fi password
7led = Pin("LED", Pin.OUT) # Pico W ve Pico 2 W dahili LED / onboard LED
8
9
10def connect(timeout=20):
11 network.country("TR") # ülke kodu: kanal ve güç sınırları / country code
12 wlan = network.WLAN(network.STA_IF)
13 wlan.active(True)
14 if not wlan.isconnected():
15 wlan.connect(SSID, PASSWORD)
16 for _ in range(timeout * 2):
17 if wlan.status() < 0 or wlan.status() == 3:
18 break
19 led.toggle() # bağlanırken yanıp söner / blinks while connecting
20 time.sleep(0.5)
21 if wlan.status() != 3:
22 led.off()
23 raise RuntimeError("Wi-Fi hatasi / error: %d" % wlan.status())
24 led.on() # bağlandı / connected
25 print("IP:", wlan.ifconfig()[0], "RSSI:", wlan.status("rssi"), "dBm")
26 return wlanwlan.status() indica a che punto è la connessione: 3 vuol dire collegato con indirizzo IP, 1 in connessione, −2 rete non trovata, −3 password errata e −1 fallito per altri motivi. Appena il codice vede un valore sotto 0 smette di aspettare e segnala chiaramente l'errore. Il RSSI è la potenza del segnale: −50 dBm è ottimo, −70 dBm accettabile, −80 dBm o meno è una connessione soggetta a cadute. La riga network.country("TR") imposta canali e potenza del chip secondo le regole del paese; in Italia scrivi "IT", in Svizzera "CH".
15 progetti con Raspberry Pi Pico W: tabella
| # | Progetto | Connessione | Componenti extra | Difficoltà |
|---|---|---|---|---|
| 1 | Collegarsi al Wi-Fi e mostrare lo stato con il LED integrato | Wi-Fi | Nessuno | Facile |
| 2 | Web server che controlla un LED e un relè dal telefono | Wi-Fi, HTTP | LED, modulo relè | Facile |
| 3 | Pannello della temperatura aggiornato in tempo reale nel browser | Wi-Fi, HTTP + JSON | Sensore interno o DHT22 | Media |
| 4 | Orologio NTP che prende l'ora da internet (con OLED) | Wi-Fi, NTP | OLED da 0,96" | Facile |
| 5 | Modalità access point (AP) per il controllo senza router | Wi-Fi AP | Nessuno | Media |
| 6 | Scanner di reti Wi-Fi e misuratore di segnale | Wi-Fi | OLED (facoltativo) | Facile |
| 7 | Pubblicare i dati dei sensori via MQTT | Wi-Fi, MQTT | Sensore interno | Media |
| 8 | Sensore che entra in Home Assistant via MQTT | Wi-Fi, MQTT | DHT22 | Media |
| 9 | Display meteo | Wi-Fi, HTTPS + JSON | OLED | Media |
| 10 | Avviso Telegram quando si apre una porta | Wi-Fi, HTTPS | Reed switch o PIR | Media |
| 11 | Messaggi tra due Pico W via UDP | Wi-Fi, UDP | Secondo Pico W, pulsante, LED | Media |
| 12 | Registrazione dati e grafici su ThingSpeak | Wi-Fi, HTTP | Qualsiasi sensore | Facile |
| 13 | Sensore di temperatura BLE letto dal telefono | BLE | Nessuno | Media |
| 14 | Telecomando BLE per un LED o un servo dal telefono | BLE (servizio UART) | LED o servo | Difficile |
| 15 | Tastiera Bluetooth e telecomando per presentazioni | BLE HID (Arduino IDE) | 2 pulsanti | Difficile |
Livello 1: progetti Wi-Fi e web (1–6)
Il primo progetto è proprio il wifi.py qui sopra; il LED che lampeggia durante la connessione e resta acceso a connessione riuscita è un indicatore piccolo ma molto comodo. Nel secondo il Pico W diventa un web server: quando apri il suo indirizzo IP sul telefono, i pulsanti ACCENDI e SPEGNI della pagina inviano /on o /off nell'indirizzo; il codice lo legge e commuta il LED o il relè. Un esempio completo con i socket e il collegamento del relè sono nella guida web server con Pico W. Nel terzo la pagina non si ricarica: un piccolo JavaScript nel browser chiede JSON a /data ogni due secondi e il Pico W legge il sensore di temperatura interno (ADC4) o un DHT22 e lo serve lì. Così la pagina si aggiorna in tempo reale senza sfarfallare.
Il quarto progetto è un orologio da scrivania che prende l'ora da internet. ntptime.settime() imposta l'orologio interno della scheda in UTC; in Italia devi aggiungere un'ora d'inverno e due d'estate, calcolando il cambio dell'ora nel codice. Nel quinto il Pico W non si collega a un router ma crea la propria rete: colleghi il telefono alla rete "PicoW" creata con network.WLAN(network.AP_IF) e apri la pagina di controllo all'indirizzo 192.168.4.1; utilissimo in giardino o a scuola, dovunque manchi un router. Il sesto usa wlan.scan() per elencare le reti vicine con canale e potenza del segnale; porta il Pico W in vari angoli della casa e decidi in base al RSSI dove mettere un sensore.
1import time, ntptime
2import wifi
3
4UTC_OFFSET = 3 * 3600 # Türkiye UTC+3; kendi saat dilimin / your own time zone
5wifi.connect()
6ntptime.settime() # dahili saati UTC'ye ayarla / set the internal clock to UTC
7
8while True:
9 t = time.localtime(time.time() + UTC_OFFSET)
10 print("%02d:%02d:%02d %02d.%02d.%04d" % (t[3], t[4], t[5], t[2], t[1], t[0]))
11 if t[4] == 0 and t[5] == 0: # her saat başı yeniden eşitle / resync every hour
12 try:
13 ntptime.settime()
14 except OSError:
15 pass
16 time.sleep(1)Livello 2: servizi internet: MQTT, meteo, Telegram (7–12)
MQTT è il modo di comunicare più diffuso tra dispositivi IoT: il Pico W invia la sua misura a un argomento (topic) su un server broker, e il telefono, il computer o Home Assistant iscritti a quell'argomento ricevono il messaggio all'istante. Non serve conoscere l'IP della scheda né aprire porte sul router. Nel settimo progetto pubblichiamo il sensore di temperatura interno ogni dieci secondi; nell'ottavo un sensore DHT22 che invia un messaggio MQTT Discovery con la stessa logica compare da solo in Home Assistant. La configurazione lato Home Assistant è spiegata nella guida ESP32, MQTT e Home Assistant e vale allo stesso modo per il Pico W.
1import time
2from machine import ADC
3from umqtt.simple import MQTTClient
4import wifi
5
6BROKER = "test.mosquitto.org" # kendi broker'ın / your own broker
7TOPIC = b"bluegrays/picow/sicaklik"
8sensor = ADC(4) # dahili sıcaklık sensörü / internal temperature sensor
9
10
11def read_temp():
12 volts = sensor.read_u16() * 3.3 / 65535
13 return 27 - (volts - 0.706) / 0.001721
14
15
16wifi.connect()
17client = MQTTClient("picow-bluegrays", BROKER, keepalive=60)
18client.connect()
19
20while True:
21 msg = "%.1f" % read_temp()
22 client.publish(TOPIC, msg.encode()) # her 10 sn yayınla / publish every 10 s
23 print("gonderildi / sent:", msg)
24 time.sleep(10)Il nono progetto è un display meteo: il Pico W usa requests per inviare una richiesta HTTPS a un servizio meteo gratuito che non richiede chiave, prende dalla risposta JSON la temperatura e il codice meteo e li scrive sull'OLED. Qui la memoria conta: per tenere piccola la risposta, chiedi solo i campi che ti servono. Il decimo è tra i più utili in casa: quando un reed switch sulla porta si apre, il Pico W ti manda subito un messaggio sul telefono tramite un bot Telegram. I passaggi per creare il bot e ottenere token e chat ID sono nella guida bot Telegram con ESP32; alla fine della stessa guida c'è anche una versione per Pico W più completa che accetta comandi.
1import time, requests
2from machine import Pin
3import wifi
4
5TOKEN = "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # BotFather token'ı / token from BotFather
6CHAT_ID = 123456789 # kendi Telegram ID'n / your Telegram ID
7URL = "https://api.telegram.org/bot%s/sendMessage" % TOKEN
8door = Pin(15, Pin.IN, Pin.PULL_UP) # reed röle -> GND; kapı açılınca 1 / reed switch, 1 when open
9
10
11def send(text):
12 try:
13 r = requests.post(URL, json={"chat_id": CHAT_ID, "text": text})
14 r.close() # belleği geri ver / free the memory
15 except OSError as e:
16 print("gonderilemedi / failed:", e)
17
18
19wifi.connect()
20last = door.value()
21while True:
22 now = door.value()
23 if now != last:
24 send("Kapi acildi / door opened" if now else "Kapi kapandi / door closed")
25 last = now
26 time.sleep_ms(100)Nell'undicesimo progetto due Pico W sulla stessa rete si scambiano pacchetti UDP: premi il pulsante di uno e si accende il LED dell'altro. UDP funziona senza stabilire una connessione, quindi è velocissimo e si scrive in poche righe, ma non garantisce che il pacchetto arrivi; per i comandi importanti conviene attendere una breve risposta "ricevuto" dall'altra parte. Nel dodicesimo le misure vengono inviate ogni 20 secondi con una richiesta HTTP a un servizio IoT gratuito come ThingSpeak; il servizio salva i dati e disegna grafici pronti nel browser. Ricorda che i piani gratuiti limitano la frequenza di invio.
Livello 3: progetti Bluetooth (13–15)
In MicroPython il Bluetooth del Pico W si usa come BLE (Bluetooth Low Energy). Un dispositivo BLE offre uno o più servizi e ogni servizio contiene caratteristiche che si possono leggere o che inviano notifiche. Nel tredicesimo progetto usiamo il servizio standard Environmental Sensing (0x181A) e la caratteristica Temperature (0x2A6E), così app BLE generiche come nRF Connect mostrano il valore direttamente in °C. Il codice si basa sul pacchetto aioble; se la tua scheda non ce l'ha, installalo prima con mip. I concetti BLE sono spiegati nel dettaglio nella guida ESP32, Bluetooth e BLE.
1import asyncio, struct, bluetooth, aioble
2from machine import ADC
3
4ENV_SENSE = bluetooth.UUID(0x181A) # Environmental Sensing servisi / service
5TEMP_CHAR = bluetooth.UUID(0x2A6E) # Temperature karakteristiği / characteristic
6sensor = ADC(4)
7
8service = aioble.Service(ENV_SENSE)
9temp_char = aioble.Characteristic(service, TEMP_CHAR, read=True, notify=True)
10aioble.register_services(service)
11
12
13def read_temp():
14 volts = sensor.read_u16() * 3.3 / 65535
15 return 27 - (volts - 0.706) / 0.001721
16
17
18async def measure():
19 while True:
20 t = int(read_temp() * 100) # 0,01 °C birimi / unit of 0.01 °C
21 temp_char.write(struct.pack("<h", t), send_update=True)
22 await asyncio.sleep(2)
23
24
25async def advertise():
26 while True:
27 async with await aioble.advertise(
28 250_000, name="PicoW-Temp", services=[ENV_SENSE], appearance=768
29 ) as connection:
30 print("baglandi / connected:", connection.device)
31 await connection.disconnected(timeout_ms=None)
32
33
34async def main():
35 await asyncio.gather(measure(), advertise())
36
37
38asyncio.run(main())Nel quattordicesimo progetto il Pico W imita uno schema BLE molto diffuso chiamato Nordic UART Service (NUS); testi come "on", "off" o "90" inviati da un'app terminale BLE sul telefono accendono il LED o ruotano il servo sul Pico W. Il quindicesimo si scrive nell'IDE di Arduino: la libreria KeyboardBLE del core Raspberry Pi Pico/RP2040 di Earle Philhower fa vedere il Pico W a computer e telefoni come una tastiera Bluetooth. Dopo aver attivato lo stack Bluetooth dal menu Strumenti, con due pulsanti puoi costruire un telecomando che passa alla slide successiva e precedente nelle presentazioni.
Limiti di memoria e stabilità
La memoria che MicroPython può usare su un Pico W è solo una parte dei 264 KB di RAM della scheda; firmware, driver Wi-Fi e buffer di rete occupano il resto. Per i progetti semplici basta e avanza, ma quando si sommano richieste HTTPS, grandi risposte JSON e lunghe pagine HTML può comparire un MemoryError. Ogni connessione HTTPS riserva temporaneamente 30–50 KB per la crittografia, e una risposta JSON da 20 KB occupa memoria due volte, prima come testo e poi come dizionario. La RAM doppia del Pico 2 W allenta molto questo limite.
| Risorsa | Pico W | Pico 2 W | Nota |
|---|---|---|---|
| RAM totale | 264 KB | 520 KB | Una parte la usano firmware e Wi-Fi |
| Memoria libera all'avvio (gc.mem_free) | Circa 150–190 KB | Circa 400 KB o più | Varia con la versione; misurala sulla tua scheda |
| Flash / file system | 2 MB / circa 850 KB | 4 MB / oltre 2 MB | Qui stanno codice, HTML e file di log |
| Una connessione HTTPS | 30–50 KB temporanei | 30–50 KB temporanei | Liberala con r.close() quando hai finito |
| Wi-Fi e BLE insieme | Funziona, la memoria diventa ancora più stretta | Va tranquillo | Prova prima ciascuno da solo, poi uniscili |
Pico W o ESP32? Quale progetto con quale scheda?
| Tipo di progetto | Pico W | ESP32 | Consiglio |
|---|---|---|---|
| Web server semplice, controllo di LED e relè | Nessun problema | Nessun problema | Entrambi; Pico W se stai imparando MicroPython |
| Sensore MQTT e Home Assistant | Funziona bene | Benissimo, senza codice con ESPHome | ESP32 |
| Fotocamera e trasmissione di immagini | Non disponibile | Possibile con l'ESP32-CAM | ESP32 |
| Sensore che dura mesi a batteria | In MicroPython la corrente in sospensione resta alta | Microampere con il deep sleep | ESP32 |
| Audio Bluetooth Classic (altoparlante A2DP) | Supporto limitato | Supportato dall'ESP32 classico | ESP32 |
| Tastiera BLE, telecomando | Facile con arduino-pico | Facile con le librerie | Entrambi |
| WS2812B, temporizzazione precisa, protocolli propri | Potentissimo con il PIO | Buono con l'RMT | Pico W |
| Misura analogica | 3 canali, ADC lineare a 12 bit | Molti canali ma non lineare; ADC2 inutilizzabile con Wi-Fi attivo | Pico W se bastano pochi canali |
In breve, il Pico W è ottimo per imparare MicroPython, per lavori hardware che richiedono temporizzazione precisa e per progetti di rete semplici; è ben documentato, stabile e facilissimo da programmare con Thonny. Se ti servono una fotocamera, una lunga autonomia a batteria, audio Bluetooth o un ecosistema pronto come ESPHome, l'ESP32 è la scelta migliore. Se vuoi confrontare le versioni ESP32 di progetti come un orologio via internet, un web server o un display meteo, la guida orologio NTP con ESP32 è un buon punto di partenza.
Errori comuni e soluzioni
- ImportError: no module named 'network': Sulla scheda c'è il firmware del Pico normale. Carica il file UF2 RPI_PICO_W o RPI_PICO2_W.
- Il LED integrato non si accende: È stato usato Pin(25). Su Pico W e Pico 2 W la forma corretta è Pin("LED", Pin.OUT).
- wlan.status() restituisce −2: Rete non trovata; controlla il nome della rete rispettando maiuscole e minuscole e verifica che la banda a 2,4 GHz sia attiva.
- OSError: [Errno 98] EADDRINUSE: La porta 80 è ancora occupata dopo il riavvio del web server. Fai un soft reset con Ctrl+D o usa SO_REUSEADDR sul socket.
- MemoryError: Un JSON o un HTML troppo grande ha riempito la memoria. Riduci le risposte, usa r.close() e gc.collect() e, se serve, passa a un Pico 2 W.
- Il codice funziona dal computer ma non con un alimentatore: Il file non è stato salvato come main.py o il codice si affida all'orologio impostato da Thonny. Chiama il file main.py e imposta tu l'ora con ntptime.
Completati questi 15 progetti, avrai usato con il Pico W Wi-Fi, HTTP, NTP, MQTT, UDP e BLE e avrai le basi per progettare i tuoi dispositivi IoT. Nell'app BlueGrays puoi guardare schemi passo passo e codice di progetti base con Pico, come accendere un LED, un semaforo, la dissolvenza PWM di un LED e un ciclo di colori RGB, e di progetti ESP32 come la connessione Wi-Fi, un orologio NTP e un web server, per completare ogni progetto anche dal lato hardware.
Domande frequenti
Cosa si può fare con un Raspberry Pi Pico W?
Con un Pico W puoi creare web server controllati dal telefono, orologi NTP che prendono l'ora da internet, sensori che inviano dati via MQTT, allarmi con avvisi Telegram e dispositivi che dialogano con il telefono via BLE. Grazie ai 26 pin GPIO è facile aggiungere sensori, relè, display e LED. Il codice si scrive in MicroPython o con l'IDE di Arduino.
Che differenza c'è tra Pico W e Pico 2 W?
Entrambi usano lo stesso chip Wi-Fi e Bluetooth CYW43439. Il Pico 2 W ha il processore RP2350, più veloce, il doppio della RAM (520 KB) e 4 MB di flash. La piedinatura è identica e la maggior parte del codice MicroPython funziona senza modifiche.
Il Pico W si collega a una rete Wi-Fi a 5 GHz?
No, Pico W e Pico 2 W si collegano solo a reti a 2,4 GHz. Se il router trasmette le due bande con lo stesso nome la connessione può non riuscire; di solito aiuta dare un nome proprio alla banda a 2,4 GHz o provare con l'hotspot a 2,4 GHz del telefono.
Perché il LED integrato del Pico W non si accende con Pin(25)?
Sul Pico W il GP25 è usato come linea di selezione del chip wireless e il LED integrato è stato spostato su quel chip. La forma corretta è Pin("LED", Pin.OUT). Funziona allo stesso modo sul Pico classico, sul Pico W e sul Pico 2 W.
MicroPython supporta il Bluetooth del Pico W?
Sì, MicroPython supporta il BLE sul Pico W. Il modulo bluetooth a basso livello è incluso nel firmware e, per un uso più semplice, il pacchetto aioble si installa con mip. Funzioni come l'audio Bluetooth Classic invece non sono supportate in MicroPython.
Per un progetto IoT è meglio un Pico W o un ESP32?
Per imparare MicroPython, per progetti di rete semplici e per lavori che richiedono temporizzazione precisa il Pico W è un'ottima scelta. Se servono una fotocamera, mesi di autonomia a batteria, audio Bluetooth o un ecosistema pronto come ESPHome, l'ESP32 è più adatto. Entrambi gestiscono senza problemi semplici progetti di web server e MQTT.
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 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.

Connessione Wi-Fi STA con ESP32 (con display LCD)
In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

ESP32: ora reale da Internet tramite NTP
L'ESP32 si collega al Wi-Fi e ottiene l'ora esatta dai server NTP (Network Time Protocol) con precisione al millisecondo. Con configTzTime() si applica in automatico il fuso orario turco (TRT, UTC+3) e, nei paesi con l'ora legale, il cambio (DST) è gestito da una stringa POSIX TZ. L'ora viene stampata sul Serial Monitor e su un display LCD I2C opzionale.

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).
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

