MQTT: Guida Pratica per IoT e Radiosonde

MQTT (Message Queuing Telemetry Transport) è un protocollo di messaggistica leggero, pensato per ambienti con larghezza di banda ridotta, alta latenza o dispositivi con poca RAM — esattamente il tipo di scenario che si incontra nell'IoT e con microcontrollori come l'ESP32.

Il modello di comunicazione è publish/subscribe: i client non si parlano direttamente ma attraverso un intermediario chiamato broker. Chi ha dati da condividere li pubblica su un topic (una stringa gerarchica); chi vuole riceverli si sottoscrive a quel topic.

Vantaggi principali rispetto a HTTP per l'IoT:

• Overhead minimo: header fisso di soli 2 byte, ideale per connessioni lente o instabili.
• Disaccoppiamento: publisher e subscriber non devono essere online allo stesso momento (con QoS 1/2).
• Fan-out nativo: un singolo messaggio raggiunge tutti i subscriber interessati senza duplicare la trasmissione.
• Wildcard sui topic: + (un livello) e # (tutto il sotto-albero) permettono sottoscrizioni flessibili.
• QoS configurabile: 0 (at-most-once), 1 (at-least-once), 2 (exactly-once).

Prima di iniziare, assicurati di avere:

• Un sistema Linux (Debian/Ubuntu o derivati) oppure un Raspberry Pi per il broker.
• Accesso root o sudo sulla macchina dove installerai il broker.
• Il LilyGo LoRa32 già flashato con il firmware rdz_ttgo_sonde e connesso alla tua rete WiFi locale.
• Conoscenza base della riga di comando Linux.
• Opzionale: Node-RED o Home Assistant per visualizzare i dati.

Mosquitto è il broker MQTT open-source più diffuso, leggero e facile da configurare. È la scelta ideale per un laboratorio casalingo o un Raspberry Pi.

# Aggiorna i repository e installa broker + client CLI
sudo apt update && sudo apt install -y mosquitto mosquitto-clients

# Abilita e avvia il servizio
sudo systemctl enable --now mosquitto

Di default Mosquitto su Debian/Ubuntu accetta connessioni solo da localhost. Per consentire ai dispositivi della rete locale (come il LilyGo) di connettersi, crea un file di configurazione personalizzato:

sudo nano /etc/mosquitto/conf.d/local.conf

# Ascolta su tutte le interfacce, porta standard
listener 1883

# Permetti connessioni anonime (solo in LAN fidata!)
allow_anonymous true

# Abilita i log (utile per il debug)
log_dest file /var/log/mosquitto/mosquitto.log
log_type all

# Riavvia per applicare la configurazione
sudo systemctl restart mosquitto

Prima di coinvolgere qualsiasi dispositivo hardware, verifica che il broker funzioni usando i client CLI inclusi nel pacchetto mosquitto-clients.

Apri due terminali. Nel primo, sottoscrivi a un topic di test:

mosquitto_sub -h localhost -t "test/hello" -v

Nel secondo terminale, pubblica un messaggio:

mosquitto_pub -h localhost -t "test/hello" -m "Ciao MQTT!"

Nel primo terminale dovresti vedere immediatamente:

test/hello Ciao MQTT!

Prova ora le wildcard — sottoscrivi a tutti i sensori in una struttura gerarchica:

# '#' cattura TUTTO ciò che parte da 'casa/'
mosquitto_sub -h localhost -t "casa/#" -v

# '+' sostituisce un singolo livello (es. qualsiasi stanza)
mosquitto_sub -h localhost -t "casa/+/temperatura" -v

MQTT si adatta a qualsiasi scenario dove dispositivi eterogenei devono scambiarsi dati in modo asincrono. Ecco una struttura di topic consigliata e alcuni pattern comuni.

Convenzione per i topic: usa una gerarchia descrittiva come:

# Schema consigliato
{progetto}/{luogo}/{dispositivo}/{metrica}

# Esempi concreti
casa/soggiorno/esp32-01/temperatura
casa/giardino/sensore-pioggia/stato
impianto/pannelli/inverter/potenza_w
stazione-meteo/roof/bmp280/pressione_hpa

Esempio: ESP32 che pubblica temperatura con MicroPython:

import network, time, json
from umqtt.simple import MQTTClient

BROKER = "192.168.1.100"   # IP del tuo server Mosquitto
CLIENT_ID = "esp32-soggiorno"
TOPIC = b"casa/soggiorno/esp32-01/temperatura"

client = MQTTClient(CLIENT_ID, BROKER)
client.connect()

while True:
    temp = leggi_sensore()   # funzione che legge il tuo DHT22, ecc.
    payload = json.dumps({"value": temp, "unit": "C"})
    client.publish(TOPIC, payload)
    time.sleep(30)

Retained messages — mantieni sempre l'ultimo valore disponibile per i nuovi subscriber:

# Il flag -r pubblica con retain=true
# Ogni nuovo subscriber riceverà subito l'ultimo valore
mosquitto_pub -h localhost -t "casa/soggiorno/luce/stato" \
    -m '{"stato":"on","brightness":80}' -r

Last Will and Testament (LWT) — il broker pubblica un messaggio automatico se il client si disconnette inaspettatamente:

# --will-topic / --will-payload configurano il messaggio di "morte"
mosquitto_sub -h localhost -t "casa/#" \
    --will-topic "casa/esp32-01/status" \
    --will-payload "offline" \
    --will-retain -v

Il firmware rdz_ttgo_sonde per LilyGo LoRa32 supporta MQTT come output nativo. Una volta abilitato, il ricevitore pubblica automaticamente i dati di ogni radiosonde decodificata (posizione GPS, temperatura, umidità, altitudine, RSSI) su un topic del tuo broker.

Accedi all'interfaccia web del dispositivo (l'IP è mostrato sul display) e vai su Config → Data feed. Compila i seguenti campi:

MQTT Active (needs reboot)  = 1
MQTT client ID              = lilygolora-sonde
MQTT server hostname        = 192.168.1.100   # IP del tuo broker
MQTT Port                   = 1883
MQTT Username               =                # vuoto se allow_anonymous true
MQTT Password               = 
MQTT Prefix                 = sonde/         # prefisso dei topic

Salva e riavvia il dispositivo. Dopo il reboot, sottoscrivi al topic per vedere i dati in arrivo:

# '#' cattura tutto ciò che pubblica il LilyGo sotto il prefisso sonde/
mosquitto_sub -h 192.168.1.100 -t "sonde/#" -v

Quando viene decodificata una radiosonde, riceverai un payload JSON simile a questo:

{
  "lat":   45.4654,
  "lon":   9.1865,
  "alt":   12540.3,
  "vs":    5.2,       // velocità verticale m/s
  "hs":    8.5,       // velocità orizzontale m/s
  "dir":   282.9,     // direzione gradi
  "type":  "RS41",
  "id":    "V1620877",
  "frame": 6507,
  "temp":  -42.1,
  "hum":   14.3,
  "rssi":  -87
}

Home Assistant con l'add-on Mosquitto broker integrato o con un broker esterno può ricevere e visualizzare i dati delle radiosonde come sensori nella dashboard.

Aggiungi i sensori MQTT in configuration.yaml (o tramite l'editor UI):

mqtt:
  sensor:
    - name: "Radiosonde Altitudine"
      state_topic: "sonde/lilygolora-sonde"
      value_template: "{{ value_json.alt | round(0) }}"
      unit_of_measurement: "m"
      icon: "mdi:weather-windy"

    - name: "Radiosonde Temperatura"
      state_topic: "sonde/lilygolora-sonde"
      value_template: "{{ value_json.temp }}"
      unit_of_measurement: "°C"
      device_class: "temperature"

    - name: "Radiosonde ID"
      state_topic: "sonde/lilygolora-sonde"
      value_template: "{{ value_json.id }}"

    - name: "Radiosonde RSSI"
      state_topic: "sonde/lilygolora-sonde"
      value_template: "{{ value_json.rssi }}"
      unit_of_measurement: "dBm"
      icon: "mdi:signal"

Se usi Home Assistant con Mosquitto add-on integrato, configura rdz_ttgo_sonde con:

MQTT server hostname  = homeassistant.local   # o IP di HA
MQTT Port             = 1883
MQTT Username         = homeassistant          # utente Mosquitto HA
MQTT Password         = la-tua-password

Node-RED è un ambiente di programmazione visuale che permette di creare flussi di elaborazione dati senza scrivere molto codice. È ideale per loggare, trasformare e visualizzare i messaggi MQTT delle radiosonde.

Installa Node-RED (se non già presente):

bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)
sudo systemctl enable --now nodered

Un flusso Node-RED minimo per ricevere e loggare i dati delle sonde:

[
  {
    "id": "mqtt-in-sonde",
    "type": "mqtt in",
    "topic": "sonde/#",
    "broker": "192.168.1.100",
    "datatype": "json"
  },
  {
    "id": "parse-sonde",
    "type": "function",
    "func": "msg.payload = { id: msg.payload.id, alt: msg.payload.alt, temp: msg.payload.temp }; return msg;"
  },
  {
    "id": "debug-out",
    "type": "debug",
    "complete": "payload"
  }
]

Con i nodi node-red-dashboard puoi aggiungere gauge, grafici temporali e mappe per vedere la traiettoria della sonde in tempo reale.

Comandi utili per diagnosticare problemi di connessione o messaggi mancanti:

# Verifica che il broker sia attivo e in ascolto
sudo systemctl status mosquitto

# Controlla i log del broker in tempo reale
sudo tail -f /var/log/mosquitto/mosquitto.log

# Verifica che la porta 1883 sia aperta
ss -tlnp | grep 1883

# Testa la raggiungibilità dal LilyGo (dalla macchina broker)
# (sostituisci con l'IP del LilyGo mostrato sul display)
ping 192.168.1.XXX

# Sniffa TUTTI i messaggi sul broker (utile per debug)
mosquitto_sub -h localhost -t "#" -v

Se il LilyGo non si connette al broker, controlla in ordine:

• Il LilyGo è connesso alla stessa rete WiFi del broker? L'IP è visibile sul display.
• Il firewall del server blocca la porta 1883? (sudo ufw allow 1883/tcp)
• L'hostname o IP del broker è corretto nella config di rdz_ttgo_sonde?
• Il Client ID è univoco? Due client con lo stesso ID si disconnettono a vicenda.