Hur man använder MQTT med Raspberry Pi och ESP8266: 8 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:44

I den här instruktionsboken kommer jag att förklara vad MQTT -protokollet är och hur det används för att kommunicera mellan enheter. Sedan ska jag som en praktisk demonstration visa dig hur du installerar ett enkelt två -klientsystem, där en ESP8266 -modul skickar ett meddelande till ett Python -program när en knapp trycks in. Specifikt använder jag en Adafruit HUZZAH -modul för detta projekt, en Raspberry Pi och en stationär dator. Raspberry Pi kommer att fungera som MQTT -mäklare, och Python -klienten kommer att köras från en separat stationär dator (valfritt, eftersom detta kan köras på Raspberry Pi).

För att följa denna instruktionsbok måste du ha en grundläggande kunskap om elektronik och hur du använder Arduino -programvaran. Du bör också vara bekant med att använda ett kommandoradsgränssnitt (för Raspberry Pi). Förhoppningsvis, när du har fått kunskapen om vad MQTT är och hur du använder det i ett grundscenario, kommer du att kunna skapa dina egna IoT -projekt!

Obligatoriska delar

• 1 x Raspberry Pi, ansluten till ett lokalt nätverk (kör Jessie)
• 1 x ESP8266 -modul (Adafruit HUZZAH)
• 1 x brödbräda
• 3 x bygelkablar (man-till-hane)
• 1 x tryckknapp
• 1 x 10k Ohm motstånd (brun-svart-orange färgkod)

Jag har skapat denna Instructable, eftersom MQTT alltid har intresserat mig som ett protokoll och det finns många olika sätt det kan användas. Jag kunde dock inte få koll på hur jag skulle koda enheter för att använda den. Detta berodde på att jag inte visste/förstod vad som faktiskt hände för att ta min "Hej, värld!" från enhet A och skicka den till enhet B. Därför bestämde jag mig för att skriva den här instruktionsboken för att (förhoppningsvis) lära dig hur den fungerar och för att förstärka min egen förståelse av den!

Steg 1: Vad är MQTT?

MQTT, eller MQ Telemetry Transport, är ett meddelandeprotokoll som gör att flera enheter kan prata med varandra. För närvarande är det ett populärt protokoll för sakernas internet, även om det har använts för andra ändamål - till exempel Facebook Messenger. Intressant nog uppfanns MQTT 1999 - vilket betyder att den är lika gammal som jag!

MQTT bygger på tanken att enheter kan publicera eller prenumerera på ämnen. Så, till exempel. Om enhet #1 har registrerat temperaturen från en av dess sensorer kan den publicera ett meddelande som innehåller temperaturvärdet som det spelade in till ett ämne (t.ex. "Temperatur"). Detta meddelande skickas till en MQTT -mäklare, som du kan tänka dig som en switch/router på ett lokalt nätverk. När MQTT -mäklaren har tagit emot meddelandet skickar den det till alla enheter (i detta fall enhet nr 2) som prenumererar på samma ämne.

I det här projektet kommer vi att publicera ett ämne med hjälp av en ESP8266 och skapa ett Python -skript som prenumererar på samma ämne via en Raspberry Pi som fungerar som MQTT -mäklare. Det fina med MQTT är att det är lätt, så det är perfekt för att köra på små mikrokontroller som en ESP8266, men det är också allmänt tillgängligt - så att vi kan köra det på ett Python -skript också.

Förhoppningsvis kommer du i slutet av detta projekt att ha en förståelse för vad MQTT är och hur du kan använda det för dina egna projekt i framtiden.

Steg 2: Installera MQTT -mäklaren på Raspberry Pi

För att konfigurera vårt MQTT -system behöver vi en mäklare, som förklarades i föregående steg. För Raspberry Pi kommer vi att använda "Mosquitto" MQTT -mäklare. Innan vi installerar detta är det alltid bäst att uppdatera vår Raspberry Pi.

sudo apt-get uppdatering

sudo apt-get uppgradering

När du har gjort detta installerar du mygg och sedan myggklientpaketen.

sudo apt -get install mygg -y

sudo apt-get install mosquitto-clients -y

När du har installerat dessa två paket kommer vi att behöva konfigurera mäklaren. Myggmäklarens konfigurationsfil finns på /etc/mosquitto/mosquitto.conf, så öppna detta med din favorittextredigerare. Om du inte har en favorittextredigerare eller inte vet hur du använder någon av kommandoradsredigerarna använder jag nano så att du kan följa med:

sudo nano /etc/mosquitto/mosquitto.conf

Längst ner i den här filen ska du se raden:

include_dir /etc/mosquitto/conf.d

Ta bort den här raden. Lägg till följande rader längst ner i filen.

allow_anonymous false

password_file/etc/mosquitto/pwfile listener 1883

Genom att skriva dessa rader har vi sagt till myggan att vi inte vill att någon ska ansluta till vår mäklare som inte tillhandahåller ett giltigt användarnamn och lösenord (vi sätter igång dessa om en sekund) och att vi vill att myggan ska lyssna efter meddelanden på portnummer 1883.

Om du inte vill att mäklaren kräver ett användarnamn och lösenord, inkludera inte de två första raderna som vi har lagt till (dvs. allow_anonymous … och password_file …). Om du har gjort detta, hoppa sedan till omstart av Raspberry Pi.

Stäng nu (och spara) den filen. Om du följer nano -exemplet, tryck på CTRL+X och skriv Y när du uppmanas.

Eftersom vi just har sagt till myggan att användare som försöker använda MQTT -mäklaren måste autentiseras, måste vi nu berätta för myggan vad användarnamnet och lösenordet är! Så skriv följande kommando - ersätt användarnamn med det användarnamn du vill ha - ange sedan det lösenord du vill ha när du uppmanas (Obs: om du redigerade konfigurationsfilen, angav en annan lösenord_fil -sökväg, ersätt sökvägen nedan med en du använde).

sudo mosquitto_passwd -c/etc/mosquitto/pwfile användarnamn

Eftersom vi just har ändrat myggkonfigurationsfilen bör vi starta om Raspberry Pi.

sudo starta om

När Raspberry Pi har startat om bör du ha en fullt fungerande MQTT -mäklare! Därefter ska vi försöka interagera med det, med hjälp av ett antal olika enheter/metoder!

Steg 3: Testa mäklaren

När du har installerat mygga på Raspberry Pi kan du göra ett snabbt test - bara för att se till att allt fungerar korrekt. För detta ändamål finns det två kommandon som vi kan använda på kommandoraden. mygg_pub och mygg_sub. I det här steget kommer jag att guida dig genom att använda var och en av dessa för att testa vår mäklare.

För att testa mäklaren måste du öppna två kommandoradsfönster. Om du använder Putty eller en annan SSH -klient är det lika enkelt som att öppna ett annat SSH -fönster och logga in som vanligt. Om du kommer åt din Pi från en UNIX -terminal är detta exakt samma sak. Om du använder Raspberry Pi direkt måste du öppna två terminalfönster i GUI -läget (kommandot startxcan användas för att starta GUI).

Nu när du har öppnat två fönster kan vi komma igång med testningen. I en av de två terminalerna skriver du följande kommando och ersätter användarnamn och lösenord med dem du konfigurerade i föregående steg.

mosquitto_sub -d -u användarnamn -P lösenord -t test

Om du bestämde dig för att inte ange ett användarnamn och lösenord i föregående steg, ignorera från och med nu flaggorna -u och -P i kommandona. Så som ett exempel skulle kommandot mosquitto_sub nu vara:

mygg_sub -d -t test

Kommandot mosquitto_sub prenumererar på ett ämne och visar alla meddelanden som skickas till det angivna ämnet i terminalfönstret. Här betyder -d felsökningsläge, så alla meddelanden och aktivitet kommer att matas ut på skärmen. -u och -P ska vara självförklarande. Slutligen är -t namnet på ämnet vi vill prenumerera på - i det här fallet "test".

Därefter, i det andra terminalfönstret, ska vi försöka publicera ett meddelande till ämnet "test". Skriv följande, kom ihåg igen för att ändra användarnamn och lösenord:

mosquitto_pub -d -u användarnamn -P lösenord -t test -m "Hej, värld!"

När du trycker på enter ska du se ditt meddelande "Hej, värld!" visas i det första terminalfönstret vi använde (för att prenumerera). Om så är fallet är du redo att börja arbeta med ESP8266!

Steg 4: Konfigurera ESP8266 (Adafruit HUZZAH)

Detta steg är specifikt för Adafruit HUZZAH (eftersom det är vad jag använder för att slutföra detta projekt). Om du använder en annan Arduino / ESP8266 -enhet kanske du vill hoppa över det här steget. Jag skulle dock råda dig att skumma läsa den, om det finns någon information här som kan vara relevant för dig.

För detta projekt kommer jag att programmera HUZZAH med Arduino -programvaran. Så, om du inte redan har gjort det, se till att installera Arduino -programvaran (nyare än 1.6.4). Du kan ladda ner den här.

När du har installerat Arduino-programvaran öppnar du den och navigerar till Arkiv-> Inställningar. Här bör du se (nära botten av fönstret) en textruta med etiketten: "Extra Boards Manager URLs". Kopiera och klistra in följande länk i den här textrutan:

arduino.esp8266.com/stable/package_esp8266com_index.json

Klicka på OK för att spara dina ändringar. Öppna nu Board Manager (Verktyg-> Board-> Board Manager) och sök efter ESP8266. Installera esp8266 by ESP8266 Community -paketet. Starta om Arduino -programvaran.

Nu, innan vi kan programmera tavlan, måste vi välja några olika alternativ. I menyalternativet Verktyg väljer du Adafruit HUZZAH ESP8266 för kort, 80 MHz för CPU -frekvensen (du kan använda 160 MHz om du vill överklocka det, men för närvarande ska jag använda 80 MHz), 4M (3M SPIFFS) för Flash -storlek och 115200 för uppladdningshastighet. Se också till att välja COM -porten du använder (detta beror på din inställning).

Innan du kan ladda upp någon kod måste du se till att HUZZAH är i bootloader -läge. För att aktivera detta, håll ned knappen på kortet som är markerat GPIO0, och medan den hålls inne, håll ner Reset -knappen också. Släpp sedan knappen Återställ och sedan GPIO0. Om du har gjort detta korrekt ska den röda lysdioden som tändes när du tryckte på GPIO0 nu vara svagt tänd.

För att ladda upp kod till mikrokontrollern, se först till att HUZZAH är i bootloader -läge, klicka sedan på uppladdningsknappen i Arduino IDE.

Om du har problem med att konfigurera HUZZAH kan du hitta mer information i Adafruits egen handledning.

Steg 5: Programmering av ESP8266

Nu börjar vi programmera ESP8266, men innan vi kan börja måste du installera följande bibliotek i Arduino Library manager (Sketch-> Include Libraries-> Manage Libraries)

• Bounce2
• PubSubClient

När du har installerat dessa bibliotek kommer du att kunna köra koden som jag har inkluderat i denna Instructable (MQTT_Publish.zip). Jag har sett till att kommentera det så att du kan förstå vad varje avsnitt gör, och detta borde förhoppningsvis göra det möjligt för dig att anpassa det till dina behov.

Kom ihåg att ändra konstanterna högst upp i koden så att din ESP8266 kan ansluta till ditt WiFi -nätverk och din MQTT -mäklare (Raspberry Pi).

Om du bestämde dig för att inte ange ett användarnamn och lösenord för MQTT -mäklaren, ladda ner filen MQTT_PublishNoPassword.zip istället.

Steg 6: Installera Python Client (paho-mqtt)

Tack och lov är detta steg väldigt enkelt! För att installera myggpython -klienten behöver du bara skriva följande på kommandoraden (Linux/Mac) eller till och med kommandotolken (Windows).

pip installera paho-mqtt

Obs: Windows -kommandotolken kan ha ett problem med pip -kommandot om du inte angav att du ville installera pip och att python skulle läggas till i din PATH -variabel när du installerade Python. Det finns ett antal sätt att fixa detta, men jag tror att det bara är det enklaste att installera om Python igen. Om du är osäker - ge det en google!

Steg 7: Python -klient - prenumerera

I det här steget kommer vi att konfigurera Python -skriptet (antingen på Raspberry Pi själv eller på en annan dator som är ansluten till nätverket) för att hantera alla meddelanden som skickas (publiceras) av ESP8266 till MQTT -ämnet.

Jag har inkluderat pythonkoden nedan (PythonMQTT_Subscribe.py), som har kommenterats för att hjälpa dig att förstå vad som händer, men jag kommer också att förklara några av huvudfunktionerna här.

Om du inte angav ett användarnamn och lösenord för MQTT -anslutningen tidigare, ladda ner filen PythonMQTT_SubscribeNoPassword.py istället.

Steg 8: Kommunicera mellan ESP8266 -enheter

Om du till exempel vill skapa ett IoT -nätverk kanske du vill kommunicera mellan ESP8266 -enheter. Tack och lov är detta inte mycket mer komplext än koden vi har skrivit tidigare, men det finns ett par anmärkningsvärda förändringar.

För att en ESP ska skicka data till en annan måste den första ESP publicera till ämnet och den andra ESP måste prenumerera på det ämnet. Denna inställning möjliggör en envägs konversation - ESP (1) till ESP (2). Om vi vill att ESP (2) ska tala tillbaka till ESP (1) kan vi skapa ett nytt ämne som ESP (2) kommer att publicera och ESP (1) kommer att prenumerera på. Tack och lov kan vi ha flera prenumeranter på samma ämne, så om du vill skicka data till ett antal system behöver du bara ett ämne (som alla prenumererar på, utom enheten som skickar data, eftersom det kommer att publicera).

Om du behöver hjälp med att ta reda på vad varje enhet behöver göra, tänk på systemet som ett rum för människor. Om ESP (1) publiceras kan du föreställa dig den här enheten som en "högtalare", och alla enheter som prenumererar på ämnet är "lyssnare" i detta exempel.

Jag har inkluderat några exempelkoder nedan, som visar hur en ESP8266 kan prenumerera på ett ämne och lyssna efter vissa meddelanden - 1 och 0. Om 1 tas emot, lyser den inbyggda lysdioden (för HUZZAH - GPIO 0). Om 0 tas emot stängs denna LED av.

Om du vill bearbeta mer komplexa data bör detta göras i funktionen ReceiveMessage (se kod).

För dina egna projekt, om du behöver både skicka och ta emot data, kan du införliva publiceringsfunktionen från föregående exempel i koden som ingår i detta steg. Detta bör hanteras i huvudfunktionen Arduino loop ().

Kom ihåg att ändra variablerna högst upp i koden så att de passar ditt nätverk!