- Vad är MQTT-protokoll?
- Hur fungerar MQTT?
- Eclipse Mosquitto-mäklaren
- Komponenter krävs
- Eclipse MQTT Test-Circuit - Schematisk
- Programmering ESP8266 för att skapa kommunikation med mäklare
- Testar MQTT med ESP8266 med Arduino
Under de senaste åren har IoT- enheter (Internet of Things) blivit en oskiljbar del av vårt dagliga liv. Från smarta hem, smarta glödlampor till smarta apparater; skapare och utvecklare använder den här tekniken för att skapa ett nätverk av anslutna enheter som gör vårt dagliga liv lite mer spännande. Allt detta har möjliggjorts på grund av den enkla kommunikationen. Det finns många möjliga sätt att kommunicera mellan enheter, men i kommersiella produkter och hobbyprodukter är ett enda protokoll som ofta används Message Queuing Telemetry Transport (MQTT). Vi byggde tidigare en röststyrd FM-radio med Arduino och Google Assistant som använder MQTT för att kommunicera med NodeMCU-kortet. Kolla in det om det låter intressant för dig.
I detta projekt kommer vi att använda en gratis och populär Eclipse MQTT-mäklare och lära oss hur man ansluter en IoT-enhet (i vårt fall är det en NodeMCU-modul) till en MQTT-mäklare och överför data mellan MQTT-mäklaren och NodeMCU.
Vad är MQTT-protokoll?
Innan vi går vidare, är det bättre att ha en klar uppfattning om MQTT (Message Queuing Telemetry Transport) protokoll. Det är ett lätta meddelandeprotokoll som använder publicerings- / prenumerationsmetoden och översätter meddelanden mellan flera enheter. Med hjälp av MQTT-protokollet kan vi också skicka / ta emot data och styra olika utdataenheter, som att läsa sensordata etc. Det är utvecklat ovanpå TCP, varför det är snabbare än liknande protokoll som HTTP. Bortsett från det har den många andra fördelar jämfört med andra protokoll som dess mycket lätta, så det förbrukar inte överflödigt minne, det kan fungera med mycket mindre nätverksbandbredd, dessutom har det ett robust inbyggt säkerhetsprotokoll. Dessa funktioner gör den lämplig för många applikationer.
Hur fungerar MQTT?
För att förstå hur MQTT-protokollet fungerar behöver vi bara förstå tre grundläggande saker; ovanstående diagram visar det. Vi har också förklarat det nedan i artikeln.
MQTT-klient:
En MQTT-klient är vilken enhet som helst (det kan vara en mikrokontroller eller en server) som kör MQTT-funktioner och kommunicerar med en central server, som kallas ” mäklaren ”. Mäklaren hanterar datakommunikationen mellan de anslutna klienterna.
MQTT-utgivare:
När en klient vill skicka någon information kallas klienten en ”Publisher”. Förläggaren kommer att publicera informationen om ett visst ämne. ” Ämne ” är en väg där vi kan publicera / prenumerera på meddelanden. Mäklaren skickar sedan informationen som publicerats av användaren till de klienter (även känd som prenumerant) som har prenumererat på det specifika ämnet.
MQTT-prenumerant:
Den MQTT Abonnenten prenumererar på ämnen i en MQTT mäklare att läsa meddelanden som skickas av mäklaren.
Eclipse Mosquitto-mäklaren
Eclipse Mosquitto är en MQTT-mäklare med öppen källkod, som är lätt och lämplig för användning på IoT-enheter för kommunikation. Den MQTT-protokollet tillhandahåller en lätt metod att överföra information med hjälp av en publicerings / prenumerationsmodell. Om du vill lära dig mer om ämnet kan du besöka den officiella myggwebbplatsen.
Ställa in mäklare för Eclipse Mosquitto:
För att upprätta kommunikation med mäklaren måste vi först ställa in den. I detta projekt används en Android-applikation för att publicera och prenumerera på informationen med mäklaren. Följande steg ger dig en bättre uppfattning om installationsprocessen.
Steg 1:
Ladda först ned alla MQTT-klientapplikationer som är tillgängliga i Google Play Store / App Store och installera det. I detta projekt används en applikation med namnet “MQTT-klient”, som ser ut som bilden som visas nedan.
Steg 2:
Klicka på “+” -tecknet för att lista de ytterligare alternativen i applikationen, där vi ska lägga till en ny mäklare. När du klickar på knappen visas en ny skärm som visas nedan.
Steg 3:
Därefter måste informationen om mäklaren fyllas i det obligatoriska fältet. Klicka först på alternativet "Enabled" som visas i applikationen. I detta projekt används Eclipse MQTT-mäklaren, detaljerna som ska fyllas ges nedan:
Smeknamn: Ge ett namn på dina preferenser
Värd: mqtt.eclipse.org
Hamn: 1883
Klient-ID: Ge ett ID om dina preferenser
Ovanstående detaljer måste fyllas i respektive fält. Alla andra fält är inte nödvändiga och kan lämnas tomma. När du är klar klickar du på spara-knappen för att spara information om mäklaren.
När det är gjort är installationsprocessen för Android-applikationen över och nu kan vi gå vidare till maskinvarusidan.
Komponenter krävs
En fullständig lista över nödvändiga delar beskrivs nedan. Eftersom denna krets är enkel kan du hitta alla nödvändiga delar i din lokala hobbybutik.
- NodeMCU
- LED
- Bakbord
- Anslutande ledningar
- Programmeringskabel
Eclipse MQTT Test-Circuit - Schematisk
Kretsschemat för Basic MQTT-projektet ges nedan:
Programmering ESP8266 för att skapa kommunikation med mäklare
En enkel Arduino-kod tar hand om all nödvändig kommunikation mellan MQTT-mäklaren och NodeMCU. I det här avsnittet lär vi oss hur denna funktionalitet fungerar i detalj.
Ställ in Arduino IDE och ladda upp koden:
Om du laddar upp koden till NodeMCU för första gången måste du ställa in Arduino IDE först. För att göra det, följ bara den enkla instruktionen nedan.
Öppna först Arduino IDE och gå sedan till Arkiv -> Inställningar -> Inställningar .
Därefter kopierar du webbadressen nedan och klistrar in den i fältet "Extra styrelsens webbadress " och klickar på "Ok". Du kan kontrollera bilden nedan för att veta hur vi har gjort det.
Länk:
Gå sedan till Verktyg> Board> Boards Manager . I styrelsens fönster skriver du ESP 8266 i sökrutan och trycker på enter. Välj sedan den senaste versionen i rullgardinsmenyn och klicka på installera. Bilden nedan ger dig en tydlig uppfattning.
Slutligen, när installationen är klar, gå till Verktyg -> Board -> och välj NodeMCU 1.0 (ESP-12E-modul). Nu kan du programmera NodeMCU med Arduino IDE. När vi är färdiga med att konfigurera Arduino IDE kan vi nu ladda upp hela koden. Men läs först den snabba förklaringen av hela koden.
För det första har vi inkluderat "ESP8266WiFi.h" för att använda ESP8266 och "PubSubClient.h" för MQTT.
Du hittar ESP8266-biblioteket förbyggt i Arduino-biblioteket, men du måste ladda ner PubSubClient-biblioteket från tillhörande GitHub-arkiv.
#omfatta
Definiera sedan nätverksuppgifterna som ditt Wi-Fi-användarnamn och lösenord. Byt ut dina referenser istället för “admin” respektive “12345678”.
const char * ssid = "admin"; const char * lösenord = "12345678";
Därefter måste vi konfigurera MQTT-servern. Vi har använt Eclipse MQTT-servern för detta projekt, varför serveradressen anges som “mqtt.eclipse.org”. Men om du planerar att använda någon annan server som Mosquitto, Adafruit, kan du ersätta den med din specifika serveradress och portnummer.
const char * mqtt_server = "mqtt.eclipse.org"; const int mqtt_port = 1883;
Därefter skapas instanserna för klass WiFiClient och PubSubClient , som kommer att användas i hela programmet.
WiFiClient espClient; PubSubClient-klient (espClient);
I avsnittet setup () ringer vi till WiFi.begin () först, om du ringer till den här metoden kommer ESP att anslutas till din föredragna HotSpot.
WiFi.begin (ssid, lösenord);
Därefter söker vi efter en lyckad nätverksanslutning med metoden WiFi.status () . Efter en lyckad anslutning skrivs ett meddelande ut på Serial Monitor med SSID för det anslutna nätverket.
medan (WiFi.status ()! = WL_CONNECTED) {fördröjning (500); Serial.println ("Ansluter till WiFi.."); } Serial.print ("Ansluten till WiFi:"); Serial.println (WiFi.SSID ());
Nu måste vi skapa en mäklare. För det har vi använt setServer- metoden; denna metod tar två argument som vi har fördefinierat tidigare. Om vi vill ta emot meddelanden från servern måste vi skapa en återuppringningsfunktion. För det använder vi metoden setCallback (callback) .
client.setServer (mqtt_server, mqtt_port); client.setCallback (MQTTcallback);
Nu har vi använt funktionen connect (clientID) för att ansluta till ESP8266-klienten. Här är clientID namnet på klienten och det måste vara unikt. Om den är ansluten kan ett framgångsmeddelande visas inuti den seriella bildskärmen.
if (client.connect ("ESP8266")) {Serial.println ("ansluten"); } annat {Serial.print ("misslyckades med tillstånd") Serial.println (client.state ()); fördröjning (2000); }
Därefter kallar vi client.subscribe () , en inbyggd MQTT-funktion, som används för att prenumerera på ett visst ämne. För detta projekt har vi använt " esp / test " som vårt abonnentnamn.
client.subscribe ("esp / test");
Nu kallas MQTTcallback- funktionen för att kontrollera om uppdaterad information är tillgänglig eller inte. Om nya data är tillgängliga hanterar den här funktionen de mottagna uppgifterna och skriver ut ett meddelande i den seriella monitorn med det ursprungliga meddelandet och ämnesnamnet där meddelandet tas emot.
Därefter konverterar vi meddelandena till en sträng så att de kan jämföras och kontrolleras för eventuella utlösande åtgärder. I detta projekt tänds / släcks en lysdiod med MQTT-kommandon, som visas i koden nedan.
för (int i = 0; i <längd; i ++) {meddelande = meddelande + (char) nyttolast; } Serial.print (meddelande); if (meddelande == "på") {digitalWrite (LED, HÖG); }
Slutligen, för att publicera informationen om ämnet. Den client.publish () funktionen används. I detta projekt kontrolleras en tryckknappsstatus, om knappen trycks in publiceras ett meddelande till ett ämne " esp / test1 " som visas nedan.
if (digitalRead (D1) == 0)) {client.publish ("esp / test1", "Hej från ESP8266"); } annat; client.loop ();
Testar MQTT med ESP8266 med Arduino
För vår slutliga testning kommer vi att använda Android-applikationen, som vi har ställt in tidigare.
Öppna MQTT-klientapplikationen och se till att din mobil har en aktiv internetanslutning. Hotspot som NodeMCU är ansluten till bör också ha en aktiv internetanslutning. När allt är anslutet till internet kommer vi att skicka en “Hello from ESP8266” -sträng från ESP-modulen, som kommer att återspeglas i Android-appen, och vi får ett meddelande. Därefter skickar vi en sträng från Android-appen, som tänder en lysdiod som är ansluten till ESP8266 Node MCU-kortet.
Steg 1: (Prenumerera på ämnet):
Klicka på alternativet Sparat MQTT i appen, som vi har konfigurerat tidigare. Det kommer att dyka upp på en skärm där den uppmanas att "Prenumerera på ett ämne". Vi har tidigare konfigurerat ämnet som “ esp / test1 ”. Så i Android-appen kommer vi att skriva " esp / test1 ". Klicka på Prenumerera så visas en skärm som nedan, där den kommer att skrivas som "Inget meddelande mottagen" från det aktuella ämnet.
Klicka nu på knappen 'Connected' som är ansluten till nodeMCU. Nu enligt vår kod kommer ett meddelande “ Hej från ESP8266 ” att publiceras till ämnet och det kommer att bli ett meddelande på skärmen med det mottagna meddelandet som visas nedan.
Steg 2: Publicera till ämnet:
Nu för att publicera i ämnet, klicka på UPP-PIL-knappen i applikationen och den öppnar en skärm som visas nedan.
Nu, i ämnesfältet, skriv " esp / test " och i meddelandefältet, skriv " på " eller " av " för att tända respektive stänga av lysdioden. Till exempel, om "på" publiceras i ämnet kommer lysdioden att slås på och om "av" publiceras i ämnet kommer lysdioden att stängas av.
Jag hoppas att du gillade artikeln och lärde dig något nytt. Om du har några frågor angående den här artikeln är du välkommen att kommentera nedan eller så kan du använda vårt forum istället.