Guide · 10 min di lettura

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.

Scheda microcontrollore Raspberry Pi Pico
La famiglia Raspberry Pi Pico: i modelli W hanno all'estremità della scheda il chip wireless CYW43439 con la sua antenna, mentre la piedinatura resta la stessa.

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

CaratteristicaPico WPico 2 W
ProcessoreRP2040, 2 × Cortex-M0+, 133 MHzRP2350, 2 × Cortex-M33 (o RISC-V), 150 MHz
RAM264 KB520 KB
Flash2 MB4 MB
WirelessCYW43439: Wi-Fi 4 a 2,4 GHz, Bluetooth 5.2CYW43439: Wi-Fi 4 a 2,4 GHz, Bluetooth 5.2
GPIO / ADC26 GPIO, 3 ingressi analogici (12 bit)26 GPIO, 3 ingressi analogici (12 bit)
LED integratoPin("LED")Pin("LED")
Firmware MicroPythonRPI_PICO_WRPI_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.
ModuloA cosa serve?Incluso?
networkConnessione Wi-Fi, access point, scansione retiSì (nel firmware W)
socket / asyncioWeb server, UDP, attività in paralleloSì
requestsRichieste HTTP e HTTPS, JSONSì
ntptimeOra da internetSì
bluetoothBLE a basso livelloSì
aiobleBLE semplice: servizi, caratteristiche, advertisingDipende dalla versione; altrimenti mip.install("aioble")
umqtt.simpleClient MQTTDipende 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.

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

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

Dato che password del Wi-Fi e token sono scritti nel codice, cancella quelle righe prima di condividere il file. Un modo più ordinato è tenere le credenziali in un file separato secrets.py e lasciare fuori solo quel file quando condividi. Inoltre non mettere metallo, batterie o grovigli di cavi sopra o sotto la zona dell'antenna (l'estremità opposta alla USB); il segnale si indebolisce parecchio.

15 progetti con Raspberry Pi Pico W: tabella

#ProgettoConnessioneComponenti extraDifficoltà
1Collegarsi al Wi-Fi e mostrare lo stato con il LED integratoWi-FiNessunoFacile
2Web server che controlla un LED e un relè dal telefonoWi-Fi, HTTPLED, modulo relèFacile
3Pannello della temperatura aggiornato in tempo reale nel browserWi-Fi, HTTP + JSONSensore interno o DHT22Media
4Orologio NTP che prende l'ora da internet (con OLED)Wi-Fi, NTPOLED da 0,96"Facile
5Modalità access point (AP) per il controllo senza routerWi-Fi APNessunoMedia
6Scanner di reti Wi-Fi e misuratore di segnaleWi-FiOLED (facoltativo)Facile
7Pubblicare i dati dei sensori via MQTTWi-Fi, MQTTSensore internoMedia
8Sensore che entra in Home Assistant via MQTTWi-Fi, MQTTDHT22Media
9Display meteoWi-Fi, HTTPS + JSONOLEDMedia
10Avviso Telegram quando si apre una portaWi-Fi, HTTPSReed switch o PIRMedia
11Messaggi tra due Pico W via UDPWi-Fi, UDPSecondo Pico W, pulsante, LEDMedia
12Registrazione dati e grafici su ThingSpeakWi-Fi, HTTPQualsiasi sensoreFacile
13Sensore di temperatura BLE letto dal telefonoBLENessunoMedia
14Telecomando BLE per un LED o un servo dal telefonoBLE (servizio UART)LED o servoDifficile
15Tastiera Bluetooth e telecomando per presentazioniBLE HID (Arduino IDE)2 pulsantiDifficile

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.

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

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

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

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

RisorsaPico WPico 2 WNota
RAM totale264 KB520 KBUna parte la usano firmware e Wi-Fi
Memoria libera all'avvio (gc.mem_free)Circa 150–190 KBCirca 400 KB o piùVaria con la versione; misurala sulla tua scheda
Flash / file system2 MB / circa 850 KB4 MB / oltre 2 MBQui stanno codice, HTML e file di log
Una connessione HTTPS30–50 KB temporanei30–50 KB temporaneiLiberala con r.close() quando hai finito
Wi-Fi e BLE insiemeFunziona, la memoria diventa ancora più strettaVa tranquilloProva prima ciascuno da solo, poi uniscili
Tre regole evitano i problemi di memoria: chiudi ogni risposta di requests con r.close() quando hai finito, chiama import gc; gc.collect() prima dei cicli grandi e invia le pagine HTML lunghe a pezzi invece che come un'unica stringa enorme. Aggiungere print(gc.mem_free()) nei punti chiave ti mostra anche quanta memoria usa ogni riga. Quando unisci più progetti (per esempio web server, MQTT e lettura dei sensori insieme), scrivi ogni lavoro come un'attività asyncio separata; usando await asyncio.sleep() invece di lunghi time.sleep(), le altre continuano mentre una attende una risposta dalla rete.

Pico W o ESP32? Quale progetto con quale scheda?

Tipo di progettoPico WESP32Consiglio
Web server semplice, controllo di LED e relèNessun problemaNessun problemaEntrambi; Pico W se stai imparando MicroPython
Sensore MQTT e Home AssistantFunziona beneBenissimo, senza codice con ESPHomeESP32
Fotocamera e trasmissione di immaginiNon disponibilePossibile con l'ESP32-CAMESP32
Sensore che dura mesi a batteriaIn MicroPython la corrente in sospensione resta altaMicroampere con il deep sleepESP32
Audio Bluetooth Classic (altoparlante A2DP)Supporto limitatoSupportato dall'ESP32 classicoESP32
Tastiera BLE, telecomandoFacile con arduino-picoFacile con le librerieEntrambi
WS2812B, temporizzazione precisa, protocolli propriPotentissimo con il PIOBuono con l'RMTPico W
Misura analogica3 canali, ADC lineare a 12 bitMolti canali ma non lineare; ADC2 inutilizzabile con Wi-Fi attivoPico 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.

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 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
Connessione Wi-Fi STA con ESP32 (con display LCD)
ES-25Avanzato

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.

4.4(21)
38
ESP32: ora reale da Internet tramite NTP
ES-26Avanzato
Premium

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.

4.5(13)
22
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

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

4.8(16)
26