Erste Schritte mit AWS IoT mit drahtlosem Temperatursensor unter Verwendung von MQTT - Gunook

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

In früheren Instructables haben wir verschiedene Cloud-Plattformen wie Azure, Ubidots, ThingSpeak, Losant usw. durchlaufen. Wir haben das MQTT-Protokoll zum Senden der Sensordaten an die Cloud in fast allen Cloud-Plattformen verwendet. Weitere Informationen zu MQTT, seinen Vorteilen und Vorteilen gegenüber dem HTTP-Protokoll finden Sie in dieser Anleitung.

In diesem anweisbaren werden wir in eine weitere und bekannteste Cloud-Plattform Amazon Web Services hineinzoomen. Viele von Ihnen kennen vielleicht AWS, auch bekannt als Amazon Web Services, und die von AWS bereitgestellte Cloud-Funktionalität. Es ist seit vielen Jahren das Herzstück der Webentwicklung. Mit der zunehmenden Größe von IoT-Anwendungen hat AWS die Lösung von AWSIoT entwickelt. AWSIoT ist eine zuverlässige Lösung zum Hosten unserer IoT-Anwendungen.

Indem Sie diesem instructable folgen:

• Sie können ein AWS-Konto für Ihre IoT-Anwendung einrichten
• Sie können den ESP32 mit dem AWS IoT-Core verbinden
• Senden und empfangen Sie Nachrichten mit dem MQTT- und
• Visualisieren Sie die gesendeten Daten in AWS

Schritt 1: AWS-Konto einrichten

Das Einrichten eines AWS-Kontos ist ziemlich einfach. Sie müssen nur ein paar Zertifikate hochladen, Richtlinien anhängen, das Gerät registrieren und mit dem Empfang der Sensordatennachrichten in AWS beginnen.

Folgen Sie diesem Tutorial, um das AWS-Konto einzurichten.

Schritt 2: Hardware- und Softwarespezifikationen

Softwarespezifikation

Ein AWS-Konto

Hardware-Spezifikation

• ESP32
• Drahtloser Temperatur- und Vibrationssensor
• Zigmo Gateway-Empfänger

Schritt 3: Drahtlose Vibrations- und Temperatursensoren

Dies ist ein drahtloser IoT-Vibrations- und Temperatursensor mit langer Reichweite, der mit einer drahtlosen Mesh-Netzwerkarchitektur eine Reichweite von bis zu 2 Meilen bietet. Mit einem 16-Bit-Vibrations- und Temperatursensor überträgt dieser Sensor hochpräzise Vibrationsdaten in benutzerdefinierten Intervallen. Es hat die folgenden Funktionen:

• 3-Achsen-Vibrationssensor in Industriequalität mit einem Bereich von ±32 g
• Berechnet RMS, MAX und MIN g Vibration
• Rauschunterdrückung mit Tiefpassfilter
• Frequenzbereich (Bandbreite) bis zu 12.800 Hz
• Abtastrate bis zu 25, 600 Hz
• Verschlüsselte Kommunikation mit 2-Meilen-Wireless-Reichweite
• Betriebstemperaturbereich -40 bis +85 °C
• Wandmontiertes oder magnetmontiertes Gehäuse mit Schutzart IP65Beispielsoftware für Visual Studio und LabVIEW
• Vibrationssensor mit externer Sondenoption
• Bis zu 500.000 Übertragungen von 4 AA-BatterienViele Gateway- und Modemoptionen verfügbar

Schritt 4: ESP32 AWS-Firmware

Um eine Verbindung zu AWS herzustellen und mit dem Senden der Daten zu beginnen, führen Sie die folgenden Schritte durch

• Laden Sie die AWS-Bibliothek aus dem folgenden Github-Repository herunter
• Klonen Sie das Repository und legen Sie die AWS_IOT-Datei in den Bibliotheksordner des Arduino-Verzeichnisses

git-Klon

Gehen wir nun den Code durch:

• In dieser Anwendung haben wir ein Captive-Portal verwendet, 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 anweisbaren.

Schritt 5: Abrufen der Sensordaten vom drahtlosen Vibrations- und Temperatursensor

Wir erhalten einen 54-Byte-Frame von den drahtlosen Temperatur- und Vibrationssensoren. Dieser Rahmen wird manipuliert, um die tatsächlichen Temperatur- und Vibrationsdaten zu erhalten.

ESP32 verfügt über drei UARTs für die serielle Verwendung

1. RX0 GPIO 3, TX0 GPIO 1
2. RX1 GPIO9, TX1 GPIO 10
3. RX2 GPIO 16, TX2 GPIO 17

und 3 serielle Hardware-Ports

• Seriennummer
• Seriell1
• Seriell2

Initialisieren Sie zunächst die Hardware Serial Header-Datei. Hier verwenden wir RX2 und TX2 aka. GPIO 16 und GPIO 17 Pins des ESP32 Boards zum Abrufen der seriellen Daten.

#enthalten

# RXD2 definieren 16 # TXD2 definieren 17

Serial2.begin(115200, SERIAL_8N1, RXD2, TXD2); // Pins 16 rx2, 17 tx2, 19200 bps, 8 Bit keine Parität 1 Stoppbit

Die folgenden Schritte führen Sie weiter, um die tatsächlichen Sensorwerte zu erhalten

• Erstellen Sie Variablen zum Speichern von Temperatur-, Feuchtigkeits-, Batterie- und anderen Sensorwerten
• Stellen Sie Rx, TX-Pin, Baudrate und Paritätsbits für die Hardware-Seriell ein
• Überprüfen Sie zuerst, ob etwas zu lesen ist, indem Sie Serial1.available () verwenden.
• Wir erhalten den Rahmen von 54 Bytes.
• Überprüfen Sie, ob 0x7E das Startbyte ist.
• Schwingungsdaten bestehen aus RMS-Werten für die 3 Achsen, Min-Werten für 3 Achsen, Max-Werten für 3 Achsen.
• Temperatur- und Batteriewerte enthalten 2 Byte Daten
• Holen Sie sich den Sensornamen, -typ, die Sensorversion enthält 1 Byte Daten und kann von der jeweiligen Adresse abgerufen werden

if (Serial2.available ()) {Serial.println ("Seriell lesen"); data[0] = Serial2.read(); Verzögerung(k); if (data [0] = = 0x7E) {Serial.println ("Paket erhalten"); while (!Seriell2.verfügbar()); für (i = 1; i<55; i++) {Daten = Serial2.read(); Verzögerung(1); } if(data[15]==0x7F) /////// um zu überprüfen, ob die empfangenen Daten korrekt sind { if(data[22]==0x08) //////// Stellen Sie sicher, dass der Sensortyp ist ist richtig { rms_x = ((uint16_t)(((data[24])<<16) + ((data[25])<<8) + (data[26]))/100); rms_y = ((uint16_t)(((Daten[27])<<16) + ((Daten[28])<<8) + (Daten[29]))/100); rms_z = ((uint16_t)(((Daten[30])<<16) + ((Daten[31])<<8) + (Daten[32]))/100); int16_t max_x = ((uint16_t)(((Daten[33])<<16) + ((Daten[34])<<8) + (Daten[35]))/100); int16_t max_y = ((uint16_t)(((Daten[36])<<16) + ((Daten[37])<<8) + (Daten[38]))/100); int16_t max_z = ((uint16_t)(((Daten[39])<<16) + ((Daten[40])<<8) + (Daten[41]))/100);

int16_t min_x = ((uint16_t)(((Daten[42])<<16) + ((Daten[43])<<8) + (Daten[44]))/100); int16_t min_y = ((uint16_t)(((Daten[45])<<16) + ((Daten[46])<<8) + (Daten[47]))/100); int16_t min_z = ((uint16_t)(((Daten[48])<<16) + ((Daten[49])<<8) + (Daten[50]))/100);

cTemp = ((((Daten[51]) * 256) + Daten[52])); Schwimmerbatterie = ((Daten [18] * 256) + Daten [19]); Spannung = 0,00322 * Batterie; Serial.print ("Sensornummer"); Serial.println (Daten [16]); senseNumber = 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 ("RMS-Vibration in der X-Achse:"); Serial.print (rms_x); Serial.println ("mg"); Serial.print ("RMS-Vibration in der Y-Achse:"); Serial.print (rms_y); Serial.println ("mg"); Serial.print ("RMS-Vibration in der Z-Achse:"); Serial.print (rms_z); Serial.println ("mg");

Serial.print ("Min. Vibration in der X-Achse:");

Serial.print (min_x); Serial.println ("mg"); Serial.print ("Min. Vibration in der Y-Achse:"); Serial.print (min_y); Serial.println ("mg"); Serial.print ("Min. Vibration in der Z-Achse:"); Serial.print (min_z); Serial.println ("mg");

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"); } } } Else { for (i = 0; i<54; i++) {Serial.print (data); Serial.print (", "); Verzögerung(1); } } } }

Schritt 6: Herstellen einer Verbindung mit AWS

• Fügen Sie AWS_IOT.h, WiFi.h-Header-Dateien hinzu, um eine Verbindung mit AWSIoT Hub einzurichten
• Geben Sie Ihre Host-Adresse, die Client-ID als Richtlinienname und den Themennamen als Ding-Namen ein

//*********AWS-Anmeldeinformationen*************//char HOST_ADDRESS="a2smbp7clzm5uw-ats.iot.us-east-1.amazonaws.com"; char CLIENT_ID= "ncdGatewayPolicy"; char TOPIC_NAME= "ncdGatewayThing";

Erstellen Sie eine char-Variable zum Speichern Ihres JSON. In diesem Fall haben wir ein Format zum Speichern von JSON erstellt

const char *format = "{"SensorId\":\"%d\", \"messageId\":%d, \"rmsX\":%d, \"rmsY\":%d, \"rmsZ \":%d, \"cTemp\":%d, \"Spannung\":%.2f}";

Erstellen Sie eine Instanz der AWS_IOT-Klasse

AWS_IOT esp; //Instanz der AWS_IOT-Klasse

Stellen Sie nun mithilfe der folgenden Methode eine Verbindung zum AWSIoT-Hub her

Void reconnectMQTT () { if (hornbill.connect (HOST_ADDRESS, CLIENT_ID) == 0) { Serial.println ("Mit AWS verbunden"); Verzögerung (1000);

if(0==hornbill.subscribe(TOPIC_NAME, mySubCallBackHandler))

{Serial.println ("Erfolgreich abonnieren"); } else {Serial.println ("Abonnieren fehlgeschlagen, überprüfen Sie den Namen und die Zertifikate des Dings"); während(1); } } else { Serial.println ("AWS-Verbindung fehlgeschlagen, HOST-Adresse überprüfen"); während(1); }

Verzögerung (2000);

}

Veröffentlichen Sie die Sensordaten alle 1 Minute

if(tick >= 60) // Alle 5 Sekunden zum Thema veröffentlichen { tick=0; char-Nutzlast[PAYLOAD_MAX_LEN]; snprintf(Nutzlast, PAYLOAD_MAX_LEN, Format, senseNumber, msgCount++, rms_x, rms_y, rms_z, cTemp, Spannung); Serial.println (Nutzlast); if (hornbill.publish (TOPIC_NAME, payload) == 0) { Serial.print ("Nachricht veröffentlichen:"); Serial.println (Nutzlast); aufrechtzuerhalten. Else { Serial.println ("Veröffentlichen fehlgeschlagen"); } } vTaskDelay(1000 / portTICK_RATE_MS); Häkchen++;

Schritt 7: Daten in AWS visualisieren

• Melden Sie sich bei Ihrem AWS-Konto an.
• In der linken Ecke der Symbolleiste finden Sie die Registerkarte Dienste
• Klicken Sie auf diese Registerkarte und wählen Sie unter der Überschrift Internet der Dinge die Option IoT Core aus.
• Wählen Sie QoS und Nr. von Nachrichten an Abonnenten. Geben Sie den Themennamen ein.

Schritt 8: Gesamtcode

Den Gesamtcode finden Sie in diesem Github-Repository.

Credits

• Arduino Json
• Drahtlose Temperatur- und Feuchtigkeitssensoren
• ESP32
• PubSubClient