Guide · 10 min di lettura

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.

Scheda microcontrollore Raspberry Pi Pico
Scheda Raspberry Pi Pico. Per MQTT serve la versione W con chip wireless (Pico W o Pico 2 W); non serve alcun modulo Wi-Fi aggiuntivo.

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.

ConcettoSignificatoEsempio
BrokerIl server che riceve i messaggi e li distribuisce agli iscrittiMosquitto, HiveMQ, EMQX
ClientOgni dispositivo o app che si collega al brokerPico W, telefono, Home Assistant
TopicL'indirizzo del messaggio, separato da /bluegrays/picow/sicaklik
PublishInviare un messaggio a un topicInvia il valore "23.4"
SubscribeAscoltare i messaggi di un topicbluegrays/picow/led
QoSGaranzia di consegna: 0 al massimo una volta, 1 almeno una volta, 2 esattamente una voltaumqtt.simple supporta 0 e 1
RetainIl broker conserva l'ultimo messaggio e lo invia subito ai nuovi iscrittiUltimo stato del LED
Last Will (LWT)Messaggio che il broker pubblica se il dispositivo si disconnette in modo imprevisto"offline"
KeepaliveOgni quanti secondi al massimo il client deve inviare un pacchetto60

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è.
ComponenteCollegamento alla Pico WNota
LED integratoPin("LED")È pilotato dal chip wireless, non è GP25
Sensore di temperatura internoADC(4)Nessun cavo; misura la temperatura del chip stesso
LED esternoGP15 → 220 Ω → anodo LED, catodo → GNDNel codice Pin(15, Pin.OUT)
Pin dati DHT22GP16 (VCC → 3V3, GND → GND)Si legge con il modulo dht di MicroPython
IN del modulo relèGP14Scegli un modulo attivabile a 3,3 V
Pin riservati al chip wirelessGPIO23, 24, 25, 29Non escono dalla scheda, non si possono usare per altro
Sulla Pico normale il LED integrato è collegato a GP25, ma sulla Pico W GP25 è usato dalla linea di comunicazione del chip wireless. Se su questa scheda scrivi Pin(25), il LED non si accende e rischi di disturbare la comunicazione Wi-Fi. Per il LED integrato usa sempre Pin("LED", Pin.OUT). Se colleghi un LED esterno, scegli la resistenza per 3,3 V con il calcolatore della resistenza per LED.

Installare la libreria umqtt

  1. 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.
  2. 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.
  3. Se ricevi un ImportError, collega la scheda al Wi-Fi con il codice qui sotto e scarica la libreria direttamente da internet con mip.
  4. In alternativa, in Thonny vai su Strumenti > Gestisci pacchetti, cerca micropython-umqtt.simple e installalo.
  5. Dopo l'installazione dovresti vedere il file /lib/umqtt/simple.py nel file system della Pico.
Python
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ı / optional
umqtt.robust è un piccolo strato costruito sopra umqtt.simple: se la connessione cade durante una pubblicazione o l'attesa di messaggi, prova a riconnettersi automaticamente. Però, con una sessione pulita (clean session), non rinnova da solo le sottoscrizioni. In questa guida scriviamo noi la riconnessione: così possiamo controllare anche i casi in cui cade il Wi-Fi e rifare le sottoscrizioni ogni volta.

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

BrokerIndirizzoPortaNota
Broker pubblico HiveMQbroker.hivemq.com1883 (TCP)Senza registrazione, aperto a tutti
Server di test Eclipse Mosquittotest.mosquitto.org1883 (senza cifratura), 8883 (TLS)Senza registrazione, aperto a tutti
Broker pubblico EMQXbroker.emqx.io1883 (TCP), 8883 (TLS)Senza registrazione, aperto a tutti
Add-on Mosquitto di Home AssistantIndirizzo IP locale di Home Assistant1883Servono utente e password
Il tuo server MosquittoIndirizzo IP del tuo Raspberry Pi o computer1883Controllo totale, funziona in rete locale
I broker pubblici sono aperti a tutti: chiunque può iscriversi al tuo topic o inviarvi messaggi. Aggiungi al nome del topic un prefisso personale (per esempio le tue iniziali e qualche cifra casuale), non inviare password o dati personali e non controllare dispositivi reali come serrature o prese tramite un broker pubblico.

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.

MicroPython
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 codiceCosa fa
CLIENT_IDCon 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_stateInvece 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

  1. In Home Assistant, da Impostazioni > Componenti aggiuntivi, installa e avvia l'add-on Mosquitto broker.
  2. 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.
  3. In Impostazioni > Dispositivi e servizi configura l'integrazione MQTT rilevata.
  4. 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.
  5. Aggiungi al codice la funzione ha_discovery() qui sotto e chiamala come ha_discovery(c) in mqtt_connect(), dopo la riga subscribe().
  6. In pochi secondi nell'elenco dei dispositivi compare un nuovo dispositivo chiamato "Pico W", con il sensore di temperatura e l'interruttore del LED.
MicroPython
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

SintomoCausa probabileSoluzione
ImportError: no module named 'umqtt'La libreria non è nel firmwaremip.install("umqtt.simple") o il gestore pacchetti di Thonny
Il Wi-Fi non si collegaRete a 5 GHz, password errata o segnale deboleUsa una rete a 2,4 GHz, stampa wlan.status(), avvicina la scheda al router
OSError durante connect()Indirizzo del broker non risolto o rete assenteControlla prima wlan.isconnected(), scrivi correttamente nome del broker e porta
MQTTException: 4 o 5Utente o password errati, nessuna autorizzazioneControlla utente e password di Home Assistant
La connessione cade dopo circa 90 secondiNessun pacchetto inviato entro il keepalivePubblica con regolarità o aggiungi client.ping()
I messaggi non arrivano maicheck_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 falsoTopic e messaggio arrivano come bytes e li confronti con strUsa costanti bytes come b"ON"
Due schede si scollegano a vicendaStesso CLIENT_IDGenera un ID univoco con machine.unique_id()
Durante il debug testa la catena un pezzo alla volta: nella shell wlan.isconnected() restituisce True? Il messaggio che pubblichi da MQTT Explorer arriva alla Pico? La pubblicazione della Pico arriva a MQTT Explorer? Con questi tre passaggi capisci in pochi minuti se il problema è nel Wi-Fi, nel broker o nel codice. Per i consigli generali sul Wi-Fi, la lista di controllo dell'articolo ESP32 non si collega al Wi-Fi vale in larga parte anche per la Pico W.

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.

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
Raspberry Pi Pico LED Controllato da Pulsante (Push)
PI-9Principiante
Premium

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.

11
Raspberry Pi Pico Pulsante Toggle LED
PI-10Principiante

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.

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