Come utilizzare MQTT con Raspberry Pi ed ESP8266: 8 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

In questo Instructable, spiegherò cos'è il protocollo MQTT e come viene utilizzato per comunicare tra dispositivi. Quindi, come dimostrazione pratica, ti mostrerò come configurare un semplice sistema a due client, in cui un modulo ESP8266 invierà un messaggio a un programma Python quando viene premuto un pulsante. Nello specifico, sto usando un modulo Adafruit HUZZAH per questo progetto, un Raspberry Pi e un computer desktop. Il Raspberry Pi fungerà da broker MQTT e il client Python verrà eseguito da un computer desktop separato (opzionale, poiché potrebbe essere eseguito sul Raspberry Pi).

Per seguire questo Instructable, dovrai avere alcune conoscenze di base sull'elettronica e su come utilizzare il software Arduino. Dovresti anche avere familiarità con l'utilizzo di un'interfaccia a riga di comando (per Raspberry Pi). Si spera che, una volta acquisita la conoscenza di cosa sia MQTT e come utilizzarlo in uno scenario di base, sarai in grado di creare i tuoi progetti IoT!

Parti richieste

• 1 x Raspberry Pi, connesso a una rete locale (che esegue Jessie)
• 1 x Modulo ESP8266 (Adafruit HUZZAH)
• 1 x tagliere
• 3 x cavi jumper (maschio-maschio)
• 1 x pulsante
• 1 x 10k Ohm Resistore (codice colore Marrone-Nero-Arancio)

Ho creato questo Instructable, poiché MQTT mi ha sempre interessato come protocollo e ci sono molti modi diversi in cui potrebbe essere utilizzato. Tuttavia, non riuscivo a capire come codificare i dispositivi per usarlo. Questo perché non sapevo/capivo cosa stesse succedendo per prendere il mio "Hello, World!" dal dispositivo A e inviarlo al dispositivo B. Quindi, ho deciso di scrivere questo Instructable per (si spera) insegnarti come funziona e anche rafforzare la mia comprensione di esso!

Passaggio 1: cos'è MQTT?

MQTT, o MQ Telemetry Transport, è un protocollo di messaggistica che consente a più dispositivi di comunicare tra loro. Attualmente è un protocollo popolare per l'Internet of Things, sebbene sia stato utilizzato per altri scopi, ad esempio Facebook Messenger. È interessante notare che MQTT è stato inventato nel 1999, il che significa che è vecchio quanto me!

MQTT si basa sull'idea che i dispositivi possono pubblicare o sottoscrivere argomenti. Quindi, per esempio. Se il Dispositivo #1 ha registrato la temperatura da uno dei suoi sensori, può pubblicare un messaggio che contiene il valore di temperatura che ha registrato, su un argomento (es. "Temperatura"). Questo messaggio viene inviato a un broker MQTT, che puoi considerare come uno switch/router su una rete locale. Una volta che il broker MQTT ha ricevuto il messaggio, lo invierà a tutti i dispositivi (in questo caso, il dispositivo n. 2) che sono iscritti allo stesso argomento.

In questo progetto, pubblicheremo su un argomento utilizzando un ESP8266 e creeremo uno script Python che si iscriverà a questo stesso argomento, tramite un Raspberry Pi che fungerà da broker MQTT. La cosa grandiosa di MQTT è che è leggero, quindi perfetto per l'esecuzione su piccoli microcontrollori come ESP8266, ma è anche ampiamente disponibile, quindi possiamo eseguirlo anche su uno script Python.

Si spera che alla fine di questo progetto, avrai una comprensione di cosa sia MQTT e come usarlo per i tuoi progetti in futuro.

Passaggio 2: installazione del broker MQTT sul Raspberry Pi

Per configurare il nostro sistema MQTT, abbiamo bisogno di un broker, come spiegato nel passaggio precedente. Per il Raspberry Pi, utilizzeremo il broker MQTT "Mosquitto". Prima di installarlo, è sempre meglio aggiornare il nostro Raspberry Pi.

sudo apt-get update

sudo apt-get upgrade

Una volta fatto, installa mosquitto e poi i pacchetti mosquitto-clients.

sudo apt-get install mosquitto -y

sudo apt-get install mosquitto-clients -y

Al termine dell'installazione di questi due pacchetti, sarà necessario configurare il broker. Il file di configurazione del broker mosquitto si trova in /etc/mosquitto/mosquitto.conf, quindi aprilo con il tuo editor di testo preferito. Se non hai un editor di testo preferito o non sai come usare nessuno degli editor della riga di comando, userò nano in modo che tu possa seguire:

sudo nano /etc/mosquitto/mosquitto.conf

In fondo a questo file, dovresti vedere la riga:

include_dir /etc/mosquitto/conf.d

Elimina questa riga. Aggiungi le seguenti righe in fondo al file.

allow_anonimo falso

file_password /etc/mosquitto/pwfile listener 1883

Digitando quelle righe, abbiamo detto a mosquitto che non vogliamo che nessuno si connetta al nostro broker che non fornisca un nome utente e una password validi (passeremo a impostarli in un secondo) e che vogliamo che mosquitto ascolta i messaggi sulla porta numero 1883.

Se non vuoi che il broker richieda un nome utente e una password, non includere le prime due righe che abbiamo aggiunto (es. allow_anonymous… e password_file…). Se lo hai fatto, passa al riavvio del Raspberry Pi.

Ora chiudi (e salva) quel file. Se stai seguendo l'esempio nano, premi CTRL+X e digita Y quando richiesto.

Poiché abbiamo appena detto a mosquitto che gli utenti che cercano di utilizzare il broker MQTT devono essere autenticati, ora dobbiamo dire a mosquitto quali sono il nome utente e la password! Quindi, digita il seguente comando - sostituendo username con il nome utente che desideri - quindi inserisci la password che desideri quando richiesto (Nota: se, durante la modifica del file di configurazione, hai specificato un percorso file_password diverso, sostituisci il percorso sottostante con il quello che hai usato).

sudo mosquitto_passwd -c /etc/mosquitto/pwfile username

Poiché abbiamo appena modificato il file di configurazione di Mosquitto, dovremmo riavviare il Raspberry Pi.

sudo reboot

Una volta che il Raspberry Pi ha terminato il riavvio, dovresti avere un broker MQTT perfettamente funzionante! Successivamente, proveremo a interagire con esso, utilizzando una serie di dispositivi/metodi diversi!

Passaggio 3: testare il broker

Dopo aver installato mosquitto sul Raspberry Pi, puoi eseguire un rapido test, solo per assicurarti che tutto funzioni correttamente. A questo scopo, ci sono due comandi che possiamo usare sulla riga di comando. mosquitto_pub e mosquitto_sub. In questo passaggio, ti guiderò attraverso l'utilizzo di ciascuno di questi per testare il nostro broker.

Per testare il broker, dovrai aprire due finestre della riga di comando. Se stai usando Putty o un altro client SSH, è semplice come aprire un'altra finestra SSH e accedere come al solito. Se accedi al tuo Pi da un terminale UNIX, è esattamente lo stesso. Se stai utilizzando direttamente il Raspberry Pi, dovrai aprire due finestre di terminale in modalità GUI (il comando startxpuò essere utilizzato per avviare la GUI).

Ora che hai aperto due finestre, possiamo iniziare il test. In uno dei due terminali, digita il seguente comando, sostituendo nome utente e password con quelli impostati nel passaggio precedente.

mosquitto_sub -d -u nome utente -P password -t test

Se hai deciso di non impostare un nome utente e una password nel passaggio precedente, d'ora in poi ignora i flag -u e -P nei comandi. Quindi, ad esempio, il comando mosquitto_sub ora sarebbe:

mosquitto_sub -d -t test

Il comando mosquitto_sub sottoscriverà un argomento e visualizzerà tutti i messaggi inviati all'argomento specificato nella finestra del terminale. Qui, -d significa modalità di debug, quindi tutti i messaggi e le attività verranno visualizzati sullo schermo. -u e -P dovrebbero essere autoesplicativi. Infine, -t è il nome dell'argomento a cui vogliamo iscriverci, in questo caso "test".

Successivamente, nell'altra finestra del terminale, proveremo a pubblicare un messaggio nell'argomento "test". Digita quanto segue, ricordandoti ancora di cambiare username e password:

mosquitto_pub -d -u nome utente -P password -t test -m "Hello, World!"

Quando premi invio, dovresti vedere il tuo messaggio "Hello, World!" appaiono nella prima finestra di terminale che abbiamo usato (per iscriverci). In questo caso, sei pronto per iniziare a lavorare su ESP8266!

Passaggio 4: configurazione di ESP8266 (Adafruit HUZZAH)

Questo passaggio è specifico per Adafruit HUZZAH (dato che è quello che sto usando per completare questo progetto). Se stai utilizzando un dispositivo Arduino/ESP8266 diverso, potresti voler saltare questo passaggio. Tuttavia, ti consiglierei di leggerlo velocemente, nel caso ci siano informazioni qui che potrebbero essere rilevanti per te.

Per questo progetto, programmerò HUZZAH con il software Arduino. Quindi, se non lo hai già fatto, assicurati di installare il software Arduino (più recente di 1.6.4). Potete scaricarlo qui.

Una volta installato il software Arduino, aprilo e vai su File->Preferenze. Qui dovresti vedere (vicino alla parte inferiore della finestra) una casella di testo con l'etichetta: "Ulteriori URL di Board Manager". In questa casella di testo, copia e incolla il seguente collegamento:

arduino.esp8266.com/stable/package_esp8266com_index.json

Fare clic su OK per salvare le modifiche. Ora apri Board Manager (Strumenti->Board->Board Manager) e cerca ESP8266. Installa il pacchetto esp8266 by ESP8266 Community. Riavvia il software Arduino.

Ora, prima di poter programmare la scheda, dobbiamo selezionare alcune opzioni diverse. Nell'opzione del menu Strumenti, seleziona Adafruit HUZZAH ESP8266 per la scheda, 80 MHz per la frequenza della CPU (puoi usare 160 MHz se desideri overclockarlo, ma per ora userò 80 MHz), 4 M (3 M SPIFFS) per la dimensione del flash e 115200 per la velocità di caricamento. Inoltre, assicurati di selezionare la porta COM che stai utilizzando (questo dipenderà dalla tua configurazione).

Prima di poter caricare qualsiasi codice, devi assicurarti che HUZZAH sia in modalità bootloader. Per abilitare ciò, tieni premuto il pulsante sulla scheda contrassegnato con GPIO0 e, mentre questo è premuto, tieni premuto anche il pulsante Reset. Quindi, rilascia il pulsante Ripristina, quindi GPIO0. Se l'hai fatto correttamente, il LED rosso che si è acceso quando hai premuto GPIO0 ora dovrebbe essere debolmente acceso.

Per caricare il codice sul microcontrollore, assicurati prima che HUZZAH sia in modalità bootloader, quindi fai semplicemente clic sul pulsante di caricamento nell'IDE di Arduino.

In caso di problemi con la configurazione di HUZZAH, è possibile trovare ulteriori informazioni nel tutorial di Adafruit.

Passaggio 5: programmazione dell'ESP8266

Ora inizieremo a programmare ESP8266, ma prima di poter iniziare, dovrai installare le seguenti librerie nel gestore della libreria Arduino (Sketch->Include Libraries->Manage Libraries)

• Rimbalzo2
• PubSubClient

Una volta installate queste librerie, sarai in grado di eseguire il codice che ho incluso in questo Instructable (MQTT_Publish.zip). Mi sono assicurato di commentarlo in modo che tu possa capire cosa sta facendo ogni sezione e, si spera, questo dovrebbe consentirti di adattarlo alle tue esigenze.

Ricorda di modificare le costanti nella parte superiore del codice in modo che il tuo ESP8266 possa connettersi alla tua rete WiFi e al tuo broker MQTT (il Raspberry Pi).

Se hai deciso di non impostare un nome utente e una password per il broker MQTT, scarica invece il file MQTT_PublishNoPassword.zip.

Passaggio 6: installazione del client Python (paho-mqtt)

Per fortuna, questo passaggio è molto semplice! Per installare il client mosquitto python, è sufficiente digitare quanto segue nella riga di comando (Linux/Mac) o anche nel prompt dei comandi (Windows).

pip install paho-mqtt

Nota: il prompt dei comandi di Windows potrebbe avere un problema nell'esecuzione del comando pip se non hai specificato che desideri installare pip e python aggiunto alla variabile PATH quando hai installato Python. Esistono diversi modi per risolvere questo problema, ma penso che reinstallare Python sia il modo più semplice. In caso di dubbio, dai un google!

Passaggio 7: client Python - Iscrizione

In questo passaggio, configureremo lo script Python (sul Raspberry Pi stesso o su un altro computer connesso alla rete) per gestire tutti i messaggi inviati (pubblicati) da ESP8266 all'argomento MQTT.

Ho incluso il codice Python di seguito (PythonMQTT_Subscribe.py), che è stato commentato per aiutarti a capire cosa sta succedendo, ma qui spiegherò anche alcune delle caratteristiche principali.

Se non hai impostato un nome utente e una password per la connessione MQTT in precedenza, scarica invece il file PythonMQTT_SubscribeNoPassword.py.

Passaggio 8: comunicazione tra dispositivi ESP8266

Se desideri configurare una rete IoT, ad esempio, potresti voler comunicare tra i dispositivi ESP8266. Per fortuna, questo non è molto più complesso del codice che abbiamo scritto prima, tuttavia, ci sono un paio di cambiamenti notevoli.

Affinché un ESP invii dati a un altro, il primo ESP dovrà pubblicare sull'argomento e il secondo ESP dovrà iscriversi a quell'argomento. Questa configurazione consentirà una conversazione unidirezionale - da ESP(1) a ESP(2). Se vogliamo che ESP(2) parli con ESP(1), possiamo creare un nuovo argomento, al quale ESP(2) pubblicherà e ESP(1) si abbonerà. Per fortuna, possiamo avere più abbonati sullo stesso argomento, quindi se vuoi inviare dati a un certo numero di sistemi, avrai bisogno di un solo argomento (a cui sono abbonati tutti, tranne il dispositivo che sta inviando i dati, poiché ciò sarà essere editoriale).

Se hai bisogno di aiuto per capire cosa deve fare ogni dispositivo, pensa al sistema come a una stanza di persone. Se ESP(1) sta pubblicando, puoi immaginare questo dispositivo come un "altoparlante" e tutti i dispositivi che si iscrivono all'argomento sono "ascoltatori" in questo esempio.

Ho incluso un codice di esempio di seguito, che dimostra come un ESP8266 può iscriversi a un argomento e ascoltare determinati messaggi - 1 e 0. Se viene ricevuto 1, il LED di bordo (per HUZZAH - GPIO 0) è acceso. Se viene ricevuto 0, questo LED è spento.

Se vuoi elaborare dati più complessi, questo dovrebbe essere fatto nella funzione ReceivedMessage (vedi codice).

Per i tuoi progetti, se devi inviare e ricevere dati, puoi incorporare la funzione di pubblicazione dell'esempio precedente nel codice incluso in questo passaggio. Questo dovrebbe essere gestito nella funzione principale di Arduino loop().

Ricorda di modificare le variabili nella parte superiore del codice per adattarle alla tua rete!