Raspberry Pi Pico W MQTT: sensore e LED con umqtt MicroPython
Come usare MQTT con Raspberry Pi Pico W? Installazione di umqtt, broker gratuito, pubblicare la temperatura, controllare un LED e collegarsi a Home Assistant.
MQTT con Raspberry Pi Pico W è il modo più leggero e diffuso per collegare la scheda a internet, inviare dati dei sensori e ricevere comandi da remoto. Con la libreria umqtt.simple di MicroPython, la Pico W si collega a un broker MQTT con poche righe di codice, pubblica la temperatura misurata su un topic e, iscrivendosi a un altro topic, accende e spegne il LED con i messaggi "ON" e "OFF". Non serve creare un server web, aprire porte sul router o ricordare l'indirizzo IP della scheda: telefono, computer e Home Assistant parlano con la tua scheda attraverso lo stesso broker.
In questa guida imparerai prima la logica e i concetti base di MQTT. Poi installerai la libreria umqtt, ti collegherai a un broker pubblico gratuito, pubblicherai ogni dieci secondi il valore del sensore di temperatura interno della Pico W e controllerai a distanza il LED integrato. Infine renderai il codice capace di riprendersi da solo quando cade il Wi-Fi o il broker, e aggiungerai la scheda a Home Assistant con MQTT Discovery, senza scrivere una riga di YAML.

Cos'è MQTT e come funziona?
MQTT (Message Queuing Telemetry Transport) è un protocollo di messaggistica publish/subscribe pensato per dispositivi con poca banda e poca potenza di calcolo. Al centro del sistema c'è un server chiamato broker. I dispositivi non si collegano direttamente tra loro: ognuno apre una connessione TCP verso il broker (porta 1883 senza cifratura, 8883 con TLS). Quando un dispositivo pubblica un messaggio su un topic come "bluegrays/picow/sicaklik", il broker lo inoltra a tutti gli iscritti a quel topic. Così la Pico W non deve sapere chi leggerà il messaggio: un'app sul telefono, un data logger e Home Assistant possono ricevere lo stesso dato contemporaneamente. L'intestazione fissa di un pacchetto MQTT è di soli 2 byte, quindi consuma molti meno dati ed energia delle richieste HTTP.
| Concetto | Significato | Esempio |
|---|---|---|
| Broker | Il server che riceve i messaggi e li distribuisce agli iscritti | Mosquitto, HiveMQ, EMQX |
| Client | Ogni dispositivo o app che si collega al broker | Pico W, telefono, Home Assistant |
| Topic | L'indirizzo del messaggio, separato da / | bluegrays/picow/sicaklik |
| Publish | Inviare un messaggio a un topic | Invia il valore "23.4" |
| Subscribe | Ascoltare i messaggi di un topic | bluegrays/picow/led |
| QoS | Garanzia di consegna: 0 al massimo una volta, 1 almeno una volta, 2 esattamente una volta | umqtt.simple supporta 0 e 1 |
| Retain | Il broker conserva l'ultimo messaggio e lo invia subito ai nuovi iscritti | Ultimo stato del LED |
| Last Will (LWT) | Messaggio che il broker pubblica se il dispositivo si disconnette in modo imprevisto | "offline" |
| Keepalive | Ogni quanti secondi al massimo il client deve inviare un pacchetto | 60 |
I topic si comportano come percorsi di cartelle e distinguono maiuscole e minuscole. Quando ti iscrivi puoi usare due caratteri jolly: + sostituisce un solo livello ("casa/+/temperatura" intercetta sia "casa/salotto/temperatura" sia "casa/cucina/temperatura"), mentre # copre tutti i livelli restanti e va usato solo alla fine ("casa/#"). In pubblicazione i caratteri jolly non si possono usare. Evitare spazi e caratteri accentati nei nomi dei topic riduce il rischio di problemi tra client diversi.
Cosa serve e collegamenti della Pico W
- Raspberry Pi Pico W o Pico 2 W: con la Pico normale, senza chip wireless, non si può usare MQTT.
- Firmware MicroPython: il file .uf2 preparato per la versione W. I passaggi di installazione sono nell'articolo Cos'è Raspberry Pi Pico?.
- Thonny o un altro editor MicroPython e un cavo micro USB che trasmetta dati.
- Rete Wi-Fi a 2,4 GHz: la Pico W non si collega alle reti a 5 GHz.
- Un client MQTT: per i test, MQTT Explorer sul computer o un'app MQTT panel sul telefono.
- Facoltativo: LED esterno e resistenza da 220 Ω, un sensore esterno come DHT22 o BME280, un modulo relè.
| Componente | Collegamento alla Pico W | Nota |
|---|---|---|
| LED integrato | Pin("LED") | È pilotato dal chip wireless, non è GP25 |
| Sensore di temperatura interno | ADC(4) | Nessun cavo; misura la temperatura del chip stesso |
| LED esterno | GP15 → 220 Ω → anodo LED, catodo → GND | Nel codice Pin(15, Pin.OUT) |
| Pin dati DHT22 | GP16 (VCC → 3V3, GND → GND) | Si legge con il modulo dht di MicroPython |
| IN del modulo relè | GP14 | Scegli un modulo attivabile a 3,3 V |
| Pin riservati al chip wireless | GPIO23, 24, 25, 29 | Non escono dalla scheda, non si possono usare per altro |
Installare la libreria umqtt
- Collega la scheda al computer tenendo premuto il tasto BOOTSEL e copia il file .uf2 di MicroPython specifico per la versione W nell'unità RPI-RP2 che compare.
- In Thonny scegli in basso a destra l'interprete MicroPython (Raspberry Pi Pico) e scrivi nella shell from umqtt.simple import MQTTClient. Se non ricevi errori, la libreria è già nel firmware e non serve installarla.
- Se ricevi un ImportError, collega la scheda al Wi-Fi con il codice qui sotto e scarica la libreria direttamente da internet con mip.
- In alternativa, in Thonny vai su Strumenti > Gestisci pacchetti, cerca micropython-umqtt.simple e installalo.
- Dopo l'installazione dovresti vedere il file /lib/umqtt/simple.py nel file system della Pico.
1import network
2import time
3import mip
4
5wlan = network.WLAN(network.STA_IF)
6wlan.active(True)
7wlan.connect("WIFI_ADIN", "WIFI_SIFREN") # kendi ağ bilgilerin / your network credentials
8
9while not wlan.isconnected():
10 print("Baglaniyor... / Connecting...")
11 time.sleep(1)
12
13print("IP:", wlan.ifconfig()[0])
14mip.install("umqtt.simple") # /lib/umqtt/simple.py olarak kurulur / installed as /lib/umqtt/simple.py
15mip.install("umqtt.robust") # isteğe bağlı / optionalScegliere un broker MQTT gratuito
Per iniziare non devi installare un tuo server. Molte aziende gestiscono broker pubblici a scopo di test: non chiedono utente e password e in pochi minuti puoi collegare la scheda e inviare il primo messaggio. Per un progetto duraturo, la soluzione più solida è installare Mosquitto su un Raspberry Pi di casa, su un vecchio computer o su Home Assistant: i dati restano in casa e, anche se internet cade, i dispositivi della rete locale continuano a scambiarsi messaggi.
| Broker | Indirizzo | Porta | Nota |
|---|---|---|---|
| Broker pubblico HiveMQ | broker.hivemq.com | 1883 (TCP) | Senza registrazione, aperto a tutti |
| Server di test Eclipse Mosquitto | test.mosquitto.org | 1883 (senza cifratura), 8883 (TLS) | Senza registrazione, aperto a tutti |
| Broker pubblico EMQX | broker.emqx.io | 1883 (TCP), 8883 (TLS) | Senza registrazione, aperto a tutti |
| Add-on Mosquitto di Home Assistant | Indirizzo IP locale di Home Assistant | 1883 | Servono utente e password |
| Il tuo server Mosquitto | Indirizzo IP del tuo Raspberry Pi o computer | 1883 | Controllo totale, funziona in rete locale |
Passo dopo passo: pubblicare la temperatura e iscriversi al LED
Il programma qui sotto fa quattro cose insieme: si collega alla rete Wi-Fi, si collega al broker con un ID client univoco, si iscrive al topic bluegrays/picow/led e pubblica ogni dieci secondi il valore del sensore di temperatura interno sul topic bluegrays/picow/sicaklik. Se sul topic del LED arriva "ON" il LED si accende, con "OFF" si spegne e il nuovo stato viene comunicato su un topic separato con il flag retain. Se salvi il file sulla Pico con il nome main.py in Thonny, il programma parte da solo a ogni accensione.
1import network
2import time
3import machine
4import binascii
5from machine import Pin, ADC
6from umqtt.simple import MQTTClient
7
8SSID = "WIFI_ADIN" # Wi-Fi ağ adın / your Wi-Fi name
9PASSWORD = "WIFI_SIFREN" # Wi-Fi şifren / your Wi-Fi password
10BROKER = "broker.hivemq.com" # ücretsiz genel broker / free public broker
11PORT = 1883
12MQTT_USER = None # Home Assistant için kullanıcı / user for Home Assistant
13MQTT_PASS = None # Home Assistant için şifre / password for Home Assistant
14
15CLIENT_ID = b"picow-" + binascii.hexlify(machine.unique_id()) # benzersiz kimlik / unique client id
16TOPIC_TEMP = b"bluegrays/picow/sicaklik"
17TOPIC_LED = b"bluegrays/picow/led"
18TOPIC_LED_STATE = b"bluegrays/picow/led/durum"
19TOPIC_STATUS = b"bluegrays/picow/durum"
20PUBLISH_MS = 10000 # 10 saniyede bir yayınla / publish every 10 s
21
22led = Pin("LED", Pin.OUT) # Pico W dahili LED / Pico W onboard LED
23sensor = ADC(4) # dahili sıcaklık sensörü / internal temperature sensor
24wlan = network.WLAN(network.STA_IF)
25client = None
26pending_state = None # bildirilecek LED durumu / LED state to report
27
28
29def read_temp():
30 voltage = sensor.read_u16() * 3.3 / 65535
31 return 27 - (voltage - 0.706) / 0.001721
32
33
34def wifi_connect():
35 wlan.active(True)
36 if wlan.isconnected():
37 return
38 wlan.connect(SSID, PASSWORD)
39 for _ in range(20): # en fazla 20 saniye bekle / wait up to 20 s
40 if wlan.isconnected():
41 print("IP:", wlan.ifconfig()[0])
42 return
43 time.sleep(1)
44 raise OSError("Wi-Fi baglanamadi / Wi-Fi failed")
45
46
47def on_message(topic, msg):
48 global pending_state
49 print("Mesaj / Message:", topic, msg)
50 if topic == TOPIC_LED:
51 if msg == b"ON":
52 led.on()
53 pending_state = b"ON"
54 elif msg == b"OFF":
55 led.off()
56 pending_state = b"OFF"
57
58
59def mqtt_connect():
60 c = MQTTClient(CLIENT_ID, BROKER, port=PORT, user=MQTT_USER,
61 password=MQTT_PASS, keepalive=60)
62 c.set_callback(on_message)
63 c.set_last_will(TOPIC_STATUS, b"offline", retain=True) # koparsa broker yayınlar / broker sends it on drop
64 try:
65 c.connect()
66 except Exception:
67 try:
68 c.sock.close() # yarım kalan soketi kapat / close the half-open socket
69 except Exception:
70 pass
71 raise
72 c.subscribe(TOPIC_LED)
73 c.publish(TOPIC_STATUS, b"online", retain=True)
74 return c
75
76
77def reconnect():
78 global client
79 delay = 2
80 while True:
81 if client:
82 try:
83 client.sock.close()
84 except Exception:
85 pass
86 try:
87 wifi_connect()
88 client = mqtt_connect()
89 print("MQTT bagli / connected")
90 return
91 except Exception as e:
92 print("Tekrar denenecek / retrying:", e)
93 time.sleep(delay)
94 delay = min(delay * 2, 60) # üstel bekleme / exponential backoff
95
96
97reconnect()
98last_pub = time.ticks_add(time.ticks_ms(), -PUBLISH_MS) # ilk yayın hemen / first publish right away
99
100while True:
101 try:
102 client.check_msg() # gelen mesaj var mı? / any incoming message?
103 if pending_state:
104 client.publish(TOPIC_LED_STATE, pending_state, retain=True)
105 pending_state = None
106 if time.ticks_diff(time.ticks_ms(), last_pub) >= PUBLISH_MS:
107 last_pub = time.ticks_ms()
108 temp = "{:.1f}".format(read_temp())
109 client.publish(TOPIC_TEMP, temp.encode())
110 print("Yayinlandi / Published:", temp)
111 except Exception as e:
112 print("Baglanti koptu / Connection lost:", e)
113 reconnect()
114 time.sleep_ms(100)| Parte del codice | Cosa fa |
|---|---|
| CLIENT_ID | Con machine.unique_id() crea un ID specifico per ogni scheda; due dispositivi con lo stesso ID si scollegano a vicenda dal broker |
| read_temp() | Converte il valore di ADC(4) in tensione e poi in gradi Celsius con la formula 27 - (V - 0,706) / 0,001721 |
| set_last_will() | Fa scrivere al broker "offline" sul topic di stato se la connessione cade in modo imprevisto; va chiamata prima di connect() |
| subscribe() | Inizia ad ascoltare il topic del LED; va richiamata a ogni nuova connessione |
| check_msg() | Se c'è un messaggio in arrivo chiama la funzione on_message, altrimenti ritorna subito senza attendere |
| pending_state | Invece di pubblicare dentro la callback, salva lo stato in una variabile e la pubblicazione la fa il ciclo principale |
| ticks_diff() | Misura i dieci secondi senza bloccarsi con sleep, così i comandi del LED vengono elaborati senza ritardi |
| reconnect() | Riprova Wi-Fi e MQTT a intervalli di 2, 4, 8 … fino a 60 secondi |
Dopo aver avviato il programma, collegati allo stesso broker con MQTT Explorer sul computer e iscriviti al topic bluegrays/picow/#. Dovresti vedere arrivare la temperatura ogni dieci secondi e "online" sul topic di stato. Per provare il LED, pubblica ON in maiuscolo sul topic bluegrays/picow/led: il LED verde sulla scheda si accende subito e il messaggio ricevuto viene stampato nella shell di Thonny. Se hai gli strumenti client di Mosquitto, puoi fare la stessa cosa da riga di comando con mosquitto_pub -h broker.hivemq.com -t bluegrays/picow/led -m ON. Poiché il sensore interno misura la temperatura del chip, può leggere qualche grado in più o in meno rispetto alla stanza; per una misura ambientale reale collega un sensore esterno come DHT11/DHT22 o BME280 e modifica di conseguenza la funzione read_temp().
Ripristinare automaticamente la connessione persa
Il nemico numero uno di un dispositivo IoT che lavora in casa sono le cadute di connessione: il router si riavvia, il segnale Wi-Fi si indebolisce o il broker va in manutenzione. In questi casi umqtt.simple non si riprende da solo: alla successiva chiamata di publish() o check_msg() lancia un OSError. Il blocco try/except del programma intercetta l'errore e chiama reconnect(). La funzione chiude prima il vecchio socket, si riconnette al Wi-Fi se è caduto, poi ristabilisce da zero la connessione MQTT e la sottoscrizione. Dopo ogni tentativo fallito l'attesa raddoppia (2, 4, 8, 16, 32, 60 secondi): si chiama backoff esponenziale e ti evita di sommergere il broker con decine di tentativi al secondo.
Anche il valore di keepalive è importante. Nel codice abbiamo impostato 60 secondi; secondo le regole MQTT, se per 1,5 volte questo tempo (cioè 90 secondi) non arriva alcun pacchetto dal client, il broker chiude la connessione. Pubblicando ogni dieci secondi non ci sono problemi. Se invece porti l'intervallo di pubblicazione a, per esempio, cinque minuti, devi aggiungere chiamate periodiche a client.ping(): umqtt.simple non invia il pacchetto di ping in automatico. Grazie al messaggio Last Will, anche se stacchi l'alimentazione della scheda, allo scadere del keepalive il broker scrive "offline" sul topic di stato e Home Assistant mostra il dispositivo come "non disponibile".
- Tieni le credenziali Wi-Fi e la password del broker in un file secrets.py separato; quando condividi il codice, non condividere quel file.
- Per maggiore stabilità attiva un watchdog con machine.WDT(timeout=8000) e chiama regolarmente wdt.feed() nel ciclo principale: se il programma si blocca, la scheda si riavvia. In questo caso tieni le attese dentro reconnect() sotto gli 8 secondi o alimenta il watchdog durante l'attesa.
- Pubblica la misura a intervalli e non a ogni ciclo; per ridurre le oscillazioni istantanee fai la media di alcune misure (filtraggio dei dati dei sensori).
- Usa retain per i topic in cui conta l'ultimo valore, come lo stato del LED; non inviare messaggi retain ai topic dei comandi, altrimenti a ogni riconnessione la scheda riapplica il vecchio comando.
- Se la connessione cade spesso, prova a disattivare il risparmio energetico del chip wireless con wlan.config(pm=0xa11140): riduce la latenza ma aumenta il consumo di corrente.
Collegare la Pico W a Home Assistant
- In Home Assistant, da Impostazioni > Componenti aggiuntivi, installa e avvia l'add-on Mosquitto broker.
- In Impostazioni > Persone crea un utente separato per la Pico W (per esempio "pico"); nella connessione MQTT si useranno nome utente e password di questo utente.
- In Impostazioni > Dispositivi e servizi configura l'integrazione MQTT rilevata.
- Sostituisci il valore di BROKER nel codice con l'indirizzo IP locale di Home Assistant (per esempio 192.168.1.50) e scrivi nome utente e password nelle variabili MQTT_USER e MQTT_PASS.
- Aggiungi al codice la funzione ha_discovery() qui sotto e chiamala come ha_discovery(c) in mqtt_connect(), dopo la riga subscribe().
- In pochi secondi nell'elenco dei dispositivi compare un nuovo dispositivo chiamato "Pico W", con il sensore di temperatura e l'interruttore del LED.
1import json
2import binascii
3import machine
4
5DEVICE_ID = "picow_" + binascii.hexlify(machine.unique_id()).decode()
6DEVICE = {
7 "identifiers": [DEVICE_ID],
8 "name": "Pico W",
9 "manufacturer": "Raspberry Pi",
10 "model": "Pico W",
11}
12
13
14def ha_discovery(c):
15 temp_cfg = {
16 "name": "Sicaklik",
17 "unique_id": DEVICE_ID + "_temp",
18 "state_topic": "bluegrays/picow/sicaklik",
19 "unit_of_measurement": "°C",
20 "device_class": "temperature",
21 "availability_topic": "bluegrays/picow/durum",
22 "device": DEVICE,
23 }
24 led_cfg = {
25 "name": "LED",
26 "unique_id": DEVICE_ID + "_led",
27 "command_topic": "bluegrays/picow/led",
28 "state_topic": "bluegrays/picow/led/durum",
29 "payload_on": "ON",
30 "payload_off": "OFF",
31 "availability_topic": "bluegrays/picow/durum",
32 "device": DEVICE,
33 }
34 base = DEVICE_ID.encode()
35 # JSON'u bytes olarak gönder (°C çok baytlıdır) / send JSON as bytes (°C is multi-byte)
36 c.publish(b"homeassistant/sensor/" + base + b"/temp/config",
37 json.dumps(temp_cfg).encode(), retain=True)
38 c.publish(b"homeassistant/switch/" + base + b"/led/config",
39 json.dumps(led_cfg).encode(), retain=True)
40
41# mqtt_connect() içinde subscribe() satırından sonra çağır / call after subscribe() in mqtt_connect()
42# ha_discovery(c)Home Assistant per impostazione predefinita ascolta i topic che iniziano con il prefisso homeassistant/. Quando la Pico W invia a questi topic una configurazione JSON con il flag retain, Home Assistant crea automaticamente le entità: la configurazione sensor mostra la temperatura come valore con grafico, quella switch aggiunge all'interfaccia un interruttore on/off. Quando tocchi l'interruttore, Home Assistant pubblica "ON" o "OFF" sul command_topic, la scheda cambia il LED e scrive il nuovo stato sullo state_topic, così l'interruttore mostra sempre lo stato reale. Il campo availability_topic usa il messaggio Last Will per mostrare le entità in grigio quando la scheda è spenta. Per vedere la stessa struttura sul lato ESP32, leggi l'articolo ESP32, MQTT e Home Assistant.
Idee di progetti con Pico W e MQTT
- Pannello di temperatura e umidità: metti una Pico W e un DHT22 in ogni stanza e controlla tutta la casa su un solo schermo con topic come casa/salotto/temperatura.
- Lampada controllata a distanza: al posto del LED pilota un modulo relè e accendi o spegni la lampada da Home Assistant.
- Avviso per l'irrigazione: pubblica il valore del sensore di umidità del terreno e, quando la terra è asciutta, invia una notifica al telefono con un'automazione.
- Allarme di movimento: quando il sensore PIR scatta, pubblica un messaggio sul topic casa/corridoio/movimento.
- Termometro per acquario: misura la temperatura dell'acqua con un DS18B20 e, superata la soglia, invia un messaggio di avviso con retain.
- Confronto con l'interfaccia web: controlla lo stesso LED anche con un server web su Pico W per vedere la differenza tra i due metodi.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| ImportError: no module named 'umqtt' | La libreria non è nel firmware | mip.install("umqtt.simple") o il gestore pacchetti di Thonny |
| Il Wi-Fi non si collega | Rete a 5 GHz, password errata o segnale debole | Usa una rete a 2,4 GHz, stampa wlan.status(), avvicina la scheda al router |
| OSError durante connect() | Indirizzo del broker non risolto o rete assente | Controlla prima wlan.isconnected(), scrivi correttamente nome del broker e porta |
| MQTTException: 4 o 5 | Utente o password errati, nessuna autorizzazione | Controlla utente e password di Home Assistant |
| La connessione cade dopo circa 90 secondi | Nessun pacchetto inviato entro il keepalive | Pubblica con regolarità o aggiungi client.ping() |
| I messaggi non arrivano mai | check_msg() non è chiamata nel ciclo o hai dimenticato set_callback() | Chiama set_callback() prima di subscribe() e usa check_msg() nel ciclo |
| Il confronto risulta sempre falso | Topic e messaggio arrivano come bytes e li confronti con str | Usa costanti bytes come b"ON" |
| Due schede si scollegano a vicenda | Stesso CLIENT_ID | Genera un ID univoco con machine.unique_id() |
Una volta configurato MQTT, ogni nuovo sensore o uscita che aggiungi alla scheda è semplicemente un nuovo topic; l'infrastruttura resta la stessa. Prima fai funzionare il programma di questa guida con il LED integrato e il sensore di temperatura, poi amplialo con relè e sensori esterni. Se vuoi consolidare i passaggi base di MicroPython come LED, pulsante e PWM, nei progetti Raspberry Pi Pico dell'app BlueGrays trovi lo schema del circuito e il codice di ogni passaggio.
Domande frequenti
Si può usare MQTT con un Raspberry Pi Pico normale?
No, la Pico normale non ha Wi-Fi né Ethernet e non può collegarsi direttamente a un broker. Per MQTT devi usare la Pico W o la Pico 2 W, con chip wireless. La Pico normale può andare in rete solo con un modulo Wi-Fi o Ethernet esterno, ma l'installazione diventa molto più complessa.
Qual è la differenza tra umqtt.simple e umqtt.robust?
umqtt.simple è un client piccolissimo che svolge le operazioni MQTT di base (connessione, pubblicazione, sottoscrizione) e lancia un errore quando la connessione cade. umqtt.robust è costruito sopra di esso e prova a riconnettersi automaticamente in caso di errore. Tuttavia non rinnova da solo le sottoscrizioni, quindi dopo la riconnessione devi chiamare subscribe() tu.
Qual è il miglior broker MQTT gratuito?
Per le prove, broker.hivemq.com, test.mosquitto.org e broker.emqx.io sono broker pubblici che non richiedono registrazione e usano la porta 1883. Poiché sono aperti a tutti, invia solo dati di test. Per un'installazione duratura e sicura, la migliore opzione gratuita è installare Mosquitto su un Raspberry Pi di casa o su Home Assistant.
Come si aggiunge la Pico W a Home Assistant?
Installa in Home Assistant l'add-on Mosquitto broker e l'integrazione MQTT, e crea un utente dedicato alla Pico W. Collega la scheda all'indirizzo IP di Home Assistant con quell'utente e pubblica con retain una configurazione di discovery sui topic che iniziano con homeassistant/. Home Assistant crea automaticamente il sensore e l'interruttore.
Perché la connessione MQTT della Pico W si interrompe?
La causa più frequente è che non viene inviato alcun pacchetto entro il keepalive: umqtt.simple non invia il ping in automatico, quindi servono client.ping() regolari o pubblicazioni periodiche. Anche un segnale Wi-Fi debole, il riavvio del router e un secondo dispositivo con lo stesso ID client causano disconnessioni. Scrivere il codice in modo da intercettare gli OSError e riconnettersi risolve tutti questi casi.
Si può usare TLS (8883) con MQTT sulla Pico W?
Sì. Con il parametro ssl di umqtt.simple puoi stabilire una connessione cifrata sulla porta 8883; nelle versioni recenti di MicroPython a questo parametro si passa un contesto creato con ssl.SSLContext. L'handshake TLS sull'RP2040 può richiedere qualche secondo e aumenta l'uso di RAM. I broker cloud come HiveMQ Cloud di solito rendono obbligatoria la connessione TLS.
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.

Raspberry Pi Pico LED Controllato da Pulsante (Push)
Primo progetto di input con Pico — lettura pulsante! LED si accende mentre il pulsante è premuto. Impara Pin.IN, Pin.PULL_UP e button.value(). GP14 LED, GP2 pulsante con PULL_UP interno. Premuto = 0, rilasciato = 1 — standard.

Raspberry Pi Pico Pulsante Toggle LED
Pulsante + LED — livello successivo! A differenza del progetto pulsante di base, non serve tenere premuto. Premi e rilascia → LED acceso. Premi di nuovo → LED spento (toggle). Stesso circuito, grande differenza di codice. Impara edge detection, state tracking e debounce.

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.

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

