Veröffentlichen von drahtlosen Drucksensordaten mit MQTT - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:19

ESP32 und ESP 8266 sind im IoT-Bereich sehr bekannte SoCs. Diese sind eine Art Segen für die IoT-Projekte. ESP 32 ist ein Gerät mit integriertem WiFi und BLE. Geben Sie einfach Ihre SSID, Ihr Passwort und Ihre IP-Konfigurationen ein und integrieren Sie die Dinge in die Cloud. Hier in diesem anweisbaren werden wir über einige der grundlegenden Begriffe des IoT wie IoT-Plattform, MQTT, Captive Portale usw. nachdenken. Also lassen Sie uns es durchgehen

• Die IoT-Architektur besteht in sehr einfachen Worten aus einem eingebetteten Gerät und einer IoT-Plattform, um das Gerät in die Cloud zu stellen. Hier verwenden wir die UbiDots IoT-Plattform, um die Sensordaten zu visualisieren.
• Die Verwaltung der IP-Einstellungen und Benutzeranmeldeinformationen kann dem Benutzer Kopfschmerzen bereiten. Was ist, wenn der Benutzer die WLAN-Anmeldeinformationen ändern möchte? Was ist, wenn der Benutzer die DHCP/Statische IP-Einstellungen ändern möchte? Das Flashen des ESP32 jedes Mal ist nicht zuverlässig und nicht einmal die Lösung für diese Probleme. Wir werden also das Captive-Portal durchlaufen, um die WLAN-Anmeldeinformationen und andere Konfigurationen zu speichern.
• MQTT wird mittlerweile zu einem sehr gebräuchlichen Begriff in der IoT-Welt. Aufgrund der schnellen, robusten und schlanken Architektur hat es Request and Responses (HTTP) von Publish and Subscribe überholt.

Hier in diesem instructable werden wir demonstrieren.

• Geben Sie WiFi- und MQTT-Anmeldeinformationen über das Captive Portal an.
• Veröffentlichen und Abonnieren mehrerer Sensordaten auf UbiDots.
• Lesen der Sensordaten vom drahtlosen Druck- und Temperatursensor
• Hosten eines Webformulars vom ESP32.
• Lesen und Schreiben von SPIFFS ESP32.

Schritt 1: Hardware- und Softwarespezifikation

Hardware-Spezifikation

• ESP32 WLAN/BLE
• Kabelloser Druck- und Temperatursensor

Softwarespezifikation

• Arduino-IDE
• XCTU
• Labview-Dienstprogramm

Schritt 2: Drahtlose Druck- und Temperatursensoren

Merkmale

• Industrieller Sensor Kabelloser Drucktemperatursensor mit großer Reichweite
• Betriebsbereich 0 bis 14000 mbar -40° bis +85°C (-40° bis 185°F)
• Konfigurierbare interne Berechnung Druckauflösung 0,012 bis 0,065 mbar
• Konfigurierbare interne Berechnung Temperaturauflösung 0,002 bis 0,012 °C
• Genauigkeit ±2,5 mbar, ±2 °C
• Ausgänge Absolutdruck, Relativdruck und Relative Höhenänderung
• 2 Meilen Line-of-Sight-Reichweite mit integrierter Antenne
• Überlegene LOS-Reichweite von bis zu 28 Meilen mit High-Gain-Antennen
• Schnittstelle zu Raspberry Pi, Microsoft® Azure®, Arduino und mehr
• Drahtloses Mesh-Netzwerk mit DigiMesh®

Konfigurieren des drahtlosen Druck- und Temperatursensors mit Labview Utility und XCTU

Der Sensor läuft in zwei Modi

• Konfigurationsmodus: Konfigurieren Sie die Pan-ID, die Verzögerung, die Anzahl der Wiederholungen usw. Mehr dazu liegt außerhalb des Rahmens dieser Anleitung und wird in der nächsten Anleitung erläutert.
• Run-Modus: Wir führen das Gerät im Run-Modus aus. Und um diese Werte zu analysieren, verwenden wir das Labview Utility

Diese Labview-Benutzeroberfläche zeigt die Werte in schönen Diagrammen an. Es zeigt sowohl die aktuellen als auch die vergangenen Werte an. Sie können zu diesem Link gehen, um die Labview-Benutzeroberfläche herunterzuladen. Klicken Sie im Menü der Zielseite auf das Symbol Ausführen, um in den Ausführungsmodus zu wechseln.

Schritt 3: Herstellen einer WLAN-Verbindung

Wir verwenden das Captive-Portal, um die WLAN-Anmeldeinformationen zu speichern und durch die IP-Einstellungen zu schweben. Für die detaillierte Einführung in das Captive-Portal können Sie die folgenden Anweisungen durchgehen.

Das Captive-Portal bietet uns die Möglichkeit, zwischen statischen und DHCP-Einstellungen zu wählen. Geben Sie einfach die Anmeldeinformationen wie Static IP, Subnet Mask, Gateway ein und das Wireless Sensor Gateway wird auf dieser IP konfiguriert.

Es wird eine Webseite gehostet, auf der eine Liste verfügbarer WiFi-Netzwerke und dort RSSI angezeigt wird. Wählen Sie das WLAN-Netzwerk und das Passwort aus und geben Sie Senden ein. Die Zugangsdaten werden im EEPROM gespeichert und die IP-Einstellung wird im SPIFFS gespeichert. Mehr dazu finden Sie in diesem instructable.

Schritt 4: UbiDots auf ESP32 einrichten

Hier verwenden wir drahtlose Druck- und Temperatursensoren mit dem ESP 32-Gerät, um die Temperatur- und Feuchtigkeitsdaten zu erhalten. Wir senden die Daten über das MQTT-Protokoll an UbiDots. MQTT folgt einem Publish-and-Subscribe-Mechanismus anstelle von Request und Response. Es ist schneller und zuverlässiger als HTTP. Dies funktioniert wie folgt.

• Wir verwenden den Taskplaner, um die Aufgabe wie das Abrufen von Daten von Sensoren, das Veröffentlichen der Sensormesswerte und das Abonnieren des MQTT-Themas zu planen.
• Fügen Sie zunächst die Header-Dateien des Taskplaners, seine Instanz und die Planung der Tasks hinzu.
• Wir haben zwei Aufgaben geplant, die sich auf zwei verschiedene Kontrollvorgänge beziehen.

#define _TASK_TIMEOUT#include Scheduler-ts; //---------Aufgaben------------// Aufgabe tSensor(4 * TASK_SECOND, TASK_FOREVER, &taskSensorCallback, &ts, false, NULL, &taskSensorDisable); Aufgabe tWiFi(10* TASK_SECOND, TASK_FOREVER, &taskWiFiCallback, &ts, false, NULL, &taskWiFiDisable);

• Task 1 dient zum Lesen des Sensorwertes dieser Task läuft 1 Sekunde lang, bis das Timeout von 10 Sekunden erreicht ist.
• Wenn Task1 sein Timeout erreicht, verbinden wir uns mit dem lokalen Wifi- und MQTT-Broker.
• Jetzt ist Aufgabe 2 aktiviert und wir deaktivieren Aufgabe 1
• Aufgabe 2 dient zum Veröffentlichen der Sensordaten an den UbiDots MQTT-Broker. Diese Aufgabe wird 20 Sekunden lang ausgeführt, bis das Timeout von 20 Sekunden erreicht ist
• Wenn Task2 sein Timeout erreicht, wird Task 1 wieder aktiviert und Task 2 wird deaktiviert. Auch hier erhalten wir den aktualisierten Wert und der Prozess geht weiter.

Auslesen der I2C-Sensordaten

Wir erhalten einen 29-Byte-Frame von den drahtlosen Temperatur- und Feuchtigkeitssensoren. Dieser Rahmen wird manipuliert, um die tatsächlichen Temperatur- und Feuchtigkeitsdaten zu erhalten

if (Seriell1.verfügbar())

{ data[0] = Serial1.read (); Verzögerung(k); if(data[0]==0x7E) { while (!Serial1.available()); für (i = 1; i<36; i++) {Daten = Serial1.read(); Verzögerung(1); } if(data[15]==0x7F) /////// um zu überprüfen, ob die empfangenen Daten korrekt sind { if(data[22]==0x06) //////// Stellen Sie sicher, dass der Sensortyp ist ist richtig { int cTemp = ((((Daten[24]) * 256) + Daten[25])); int16_t abs_pressure = ((((uint16_t)(data[26])<<8)| data[27])*0,001); int rlt_pressure = ((((Daten[28]) * 256) + Daten[29])*0,001); int16_t delta_alt = ((((uint16_t)(Daten[30])<<8)|Daten[31])*0,01); Schwimmerbatterie = ((Daten [18] * 256) + Daten [19]); Erhaltungsspannung = 0,00322 * Batterie; Serial.print ("Sensornummer"); Serial.println (Daten [16]); Serial.print ("Sensortyp"); Serial.println (Daten[22]); Serial.print ("Firmware-Version"); Serial.println (Daten [17]); Serial.print ("Temperatur in Celsius:"); Serial.print (cTemp); Serial.println("C"); Serial.print ("Absoluter Druck:"); Serial.println (abs_pressure); Serial.print("mbar"); Serial.print ("Relativer Druck:"); Serial.println (rlt_pressure); Serial.print("mbar"); Serial.print ("Deltahöhe:"); Serial.println (delta_alt); Serial.print ("Meter"); Serial.print ("ADC-Wert:"); Serial.println (Batterie); Serial.print ("Batteriespannung:"); Serial.print (Spannung); Serial.println("\n"); if (Spannung < 1) {Serial.println ("Zeit zum Ersetzen der Batterie"); aufrechtzuerhalten.}}} sonst { für (i = 0; i<36; i++) {Serial.print (data); Serial.print (", "); Verzögerung(1); }} } }

Verbindung zur UbiDots MQTT-API herstellen

Fügen Sie die Header-Datei für den MQTT-Prozess ein

#enthalten

Definieren Sie andere Variablen für MQTT wie Clientname, Brokeradresse, die Token-ID

#define TOKEN "BBFF-************************************" // Dein Ubidot-TOKEN#define MQTT_CLIENT_NAME "****************************"

char mqttBroker = "things.ubidots.com";

char-Nutzlast[100]; Zeichenthema[150]; // Variable zum Speichern des Token-ID-Tokes erstellen

Schritt 5: Veröffentlichen von Sensormesswerten in UbiDots

Erstellen Sie Variablen zum Speichern verschiedener Sensordaten und erstellen Sie eine char-Variable zum Speichern des Themas

#define VARIABLE_LABEL_TEMPF "tempF" // Bewertung des Variablenlabels#define VARIABLE_LABEL_TEMPC "tempC" // Bewertung des Variablenlabels #define VARIABLE_LABEL_BAT "bat" #define VARIABLE_LABEL_HUMID "humid" // Bewertung des Variablenlabels

char Thema1[100];

char Thema2[100]; char Thema3[100];

Veröffentlichen Sie die Daten im erwähnten MQTT-Thema, die Nutzlast sieht wie folgt aus: { "tempc": {value: "tempData"}}

sprintf(topic1, "%s", ""); sprintf(topic1, "%s%s", "/v1.6/devices/", DEVICE_LABEL); sprintf(Nutzlast, "%s", ""); // Bereinigung der Nutzdaten sprintf(payload, "{"%s\":", VARIABLE_LABEL_TEMPC); // Fügt den Wert hinzu sprintf(payload, "%s{"value\":%s}", payload, str_cTemp); // Fügt den Wert hinzu sprintf(payload, "%s}", payload); // Schließt die Wörterbuchklammern Serial.println(payload); Serial.println (client.publish (topic1, payload)? "veröffentlicht": "nicht veröffentlicht"); // Machen Sie dasselbe auch für andere Themen

client.publish() veröffentlicht die Daten an UbiDots

Schritt 6: Visualisierung der Daten

• Gehen Sie zu Ubidots und melden Sie sich bei Ihrem Konto an.
• Navigieren Sie über die oben aufgeführte Registerkarte Daten zum Dashboard.
• Klicken Sie nun auf das Symbol "+", um die neuen Widgets hinzuzufügen.
• Wählen Sie ein Widget aus der Liste aus und fügen Sie eine Variable und Geräte hinzu.
• Die Sensordaten können über verschiedene Widgets auf dem Dashboard visualisiert werden.

Schritt 7: Gesamtcode

Den Over-Code für HTML und ESP32 finden Sie in diesem GitHub-Repository.

Credits

• ncd ESP32 Breakout-Board.
• ncd Kabellose Druck- und Temperatursensoren
• pubsubclient
• UbiDots
• Aufgabenplaner