ESP32 - AWS IoT
Dieses Tutorial zeigt Ihnen, wie Sie den ESP32 mit AWS IoT Core verwenden. Im Detail werden wir Folgendes lernen:
- Wie man den ESP32 mit AWS IoT Core verbindet.
- Wie man den ESP32 programmiert, um die Daten an AWS IoT Core zu senden.
- Wie man den ESP32 programmiert, um die Daten von AWS IoT Core zu empfangen.
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables ESP32 Starter-Kit (ESP32 enthalten) | |
| 1 | × | DIYables Sensor-Kit (30 Sensoren/Displays) | |
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Über ESP32 und AWS IoT
Der ESP32 verbindet sich über das MQTT-Protokoll mit AWS IoT Core. Während Bibliotheken vorhanden sind, die diese Verbindung erleichtern, ist es nicht so einfach wie die Verbindung zu einem lokalen MQTT-Broker wie Mosquitto auf Ihrem PC. Dies liegt daran, dass AWS IoT Core strenge Sicherheitsmaßnahmen implementiert hat, die Konfigurationsschritte zur Beschaffung von Authentifizierungsnachweisen und Berechtigungen erfordern, bevor sie in den ESP32-Code integriert werden. Zusammengefasst umfasst der Prozess zwei Hauptschritte:
- Schritt 1: AWS IoT Core konfigurieren - Dabei wird AWS IoT Core so eingerichtet, dass die notwendigen Authentifizierungsdaten erzeugt werden, die später im ESP32-Code verwendet werden.
- Schritt 2: ESP32-Code schreiben - Sobald die Authentifizierungsdaten von AWS IoT Core erhalten wurden, besteht der nächste Schritt darin, den ESP32-Code zu schreiben und die erforderlichen Authentifizierungs- und Kommunikationsprotokolle zu integrieren.
Schauen wir uns jeden Schritt genauer an, um ihn besser zu verstehen.
Konfiguration von AWS IoT Core für die Verwendung mit ESP32
Die Ziele dieses Schritts umfassen:
- Erstellung einer Repräsentation des ESP32-Geräts in AWS IoT Core, bezeichnet als 'Thing'.
- Konfigurieren der notwendigen Berechtigungen, damit das ESP32-Gerät sich mit AWS IoT Core verbinden, Daten veröffentlichen und abonnieren kann, bekannt als 'Policy'.
- Generieren der für die Authentifizierung erforderlichen AWS-Zertifikate, bekannt als 'Certificates'. Diese Zertifikate werden heruntergeladen und in den Arduino ESP32-Code integriert.
Nachfolgend finden Sie Anweisungen zur Konfiguration von AWS IoT Core für die Verwendung mit dem ESP32 über die AWS IoT-Konsole. Bitte beachten Sie, dass sich die Benutzeroberfläche im Laufe der Zeit ändern kann; der Prozess sollte jedoch den unten stehenden Anweisungen ähneln:
- Melden Sie sich bei der AWS IoT-Konsole an
- Erstellen Sie ein Thing indem Sie zu Verwalten Alle Geräte Dinge
- Klicken Sie auf die Dinge erstellen-Schaltfläche.
- Wählen Sie Einzelne Dinge erstellen aus und klicken Sie auf die Weiter-Schaltfläche.
- Geben Sie den Gerätenamen an, zum Beispiel ESP32-thing, und klicken Sie auf die Weiter-Schaltfläche am unteren Rand der Seite.
- Generieren Sie die Anmeldeinformationen, indem Sie die Option Automatisch ein neues Zertifikat erzeugen auswählen und auf die Schaltfläche Weiter klicken.
- Jetzt wird ein Zertifikat erstellt und mit dem Objekt verknüpft.
- Richtlinie erstellen, indem Sie auf die Schaltfläche Richtlinie erstellen klicken.
- Ein neuer Tab wird geöffnet
- Geben Sie den Richtlinienname an, zum Beispiel ESP32-policy und klicken Sie auf die JSON-Schaltfläche.
- Kopieren Sie den untenstehenden JSON-Richtlinieninhalt und fügen Sie ihn in den Bereich Richtliniendokument ein:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "*",
"Resource": "*"
}
]
}
- Klicken Sie auf die Erstellen-Schaltfläche am unteren Rand der Seite, um die Richtlinie zu erstellen.
- Nun ist eine Richtlinie erstellt und an das Zertifikat angehängt. Schließen Sie diese Seite und kehren Sie zur Geräte-Seite zurück.
- Prüfen Sie die ESP32-Richtlinie und klicken Sie auf die Gerät erstellen-Schaltfläche, um das Gerät zu erstellen.
- Ein Pop-up-Fenster erscheint, über das Sie die Dateien mit Zugangsdaten herunterladen können. Laden Sie alle Dateien herunter und bewahren Sie sie an einem sicheren Ort auf Ihrem PC auf und halten Sie sie vertraulich.
- Dann klicken Sie auf die Fertig Schaltfläche.
Unter den heruntergeladenen Dateien befinden sich drei Dateien, die im ESP32-Code in den nächsten Schritten verwendet werden:
- AmazonRootCA1.pem
- xxxxxxxxxx-zertifikat.pem.crt
- xxxxxxxxxx-privat.pem.key
Diese Dateien können mit jedem Texteditor geöffnet werden, z. B. Notepad oder Notepad++.
Schreiben des ESP32-Codes, um eine Verbindung zu AWS IoT Core herzustellen
/*
* Dieser ESP32 Code wurde von newbiely.de entwickelt
* Dieser ESP32 Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/esp32/esp32-aws-iot
*/
#include "secrets.h"
#include <WiFiClientSecure.h>
#include <MQTTClient.h>
#include <ArduinoJson.h>
#include "WiFi.h"
// The MQTT topics that this device should publish/subscribe
#define AWS_IOT_PUBLISH_TOPIC "esp32/esp32-to-aws"
#define AWS_IOT_SUBSCRIBE_TOPIC "esp32/aws-to-esp32"
#define PUBLISH_INTERVAL 4000 // 4 seconds
WiFiClientSecure net = WiFiClientSecure();
MQTTClient client = MQTTClient(256);
unsigned long lastPublishTime = 0;
void setup() {
Serial.begin(9600);
// set the ADC attenuation to 11 dB (up to ~3.3V input)
analogSetAttenuation(ADC_11db);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
Serial.println("ESP32 connecting to Wi-Fi");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
connectToAWS();
}
void loop() {
client.loop();
if (millis() - lastPublishTime > PUBLISH_INTERVAL) {
sendToAWS();
lastPublishTime = millis();
}
}
void connectToAWS() {
// Configure WiFiClientSecure to use the AWS IoT device credentials
net.setCACert(AWS_CERT_CA);
net.setCertificate(AWS_CERT_CRT);
net.setPrivateKey(AWS_CERT_PRIVATE);
// Connect to the MQTT broker on the AWS endpoint we defined earlier
client.begin(AWS_IOT_ENDPOINT, 8883, net);
// Create a handler for incoming messages
client.onMessage(messageHandler);
Serial.print("ESP32 connecting to AWS IOT");
while (!client.connect(THINGNAME)) {
Serial.print(".");
delay(100);
}
Serial.println();
if (!client.connected()) {
Serial.println("ESP32 - AWS IoT Timeout!");
return;
}
// Subscribe to a topic, the incoming messages are processed by messageHandler() function
client.subscribe(AWS_IOT_SUBSCRIBE_TOPIC);
Serial.println("ESP32 - AWS IoT Connected!");
}
void sendToAWS() {
StaticJsonDocument<200> message;
message["timestamp"] = millis();
message["data"] = analogRead(0); // Or you can read data from other sensors
char messageBuffer[512];
serializeJson(message, messageBuffer); // print to client
client.publish(AWS_IOT_PUBLISH_TOPIC, messageBuffer);
Serial.println("sent:");
Serial.print("- topic: ");
Serial.println(AWS_IOT_PUBLISH_TOPIC);
Serial.print("- payload:");
Serial.println(messageBuffer);
}
void messageHandler(String &topic, String &payload) {
Serial.println("received:");
Serial.println("- topic: " + topic);
Serial.println("- payload:");
Serial.println(payload);
// You can process the incoming data as json object, then control something
/*
StaticJsonDocument<200> doc;
deserializeJson(doc, payload);
const char* message = doc["message"];
*/
}
Schnelle Schritte
- Falls Sie ESP32 zum ersten Mal verwenden, sehen Sie sich wie man die Umgebung für ESP32 in der Arduino IDE einrichtet an.
- Öffnen Sie den Bibliotheks-Manager, indem Sie auf das Bibliotheks-Manager-Symbol in der linken Navigationsleiste der Arduino IDE klicken.
- Geben Sie MQTT in das Suchfeld ein, suchen Sie dann nach der MQTT-Bibliothek von Joel Gaehwiler.
- Klicken Sie auf die Installieren-Schaltfläche, um die MQTT-Bibliothek zu installieren.
- Geben Sie ArduinoJson in das Suchfeld ein, und suchen Sie anschließend nach der ArduinoJson-Bibliothek von Benoit Blanchon.
- Klicken Sie auf die Installieren-Schaltfläche, um die ArduinoJson-Bibliothek zu installieren.
- Kopieren Sie den obigen Code und fügen Sie ihn in die Arduino-IDE ein.
- Erstellen Sie die secrets.h-Datei im Arduino-IDE durch:
- Entweder klicken Sie auf die Schaltfläche direkt unter dem Symbol des seriellen Monitors und wählen Sie Neuer Tab, oder verwenden Sie die Tastenkombination Strg+Umschalt+N.
- Geben Sie den Dateinamen secrets.h ein und klicken Sie auf die OK-Schaltfläche
- Kopieren Sie den untenstehenden Code und fügen Sie ihn in die erstellte secrets.h Datei ein.
- Aktualisieren Sie die folgenden Informationen in der secrets.h
- Die WIFI_SSID- und WIFI_PASSWORD-Angaben Ihres WLAN-Netzes
- Die AWS_CERT_CA, AWS_CERT_CRT und AWS_CERT_PRIVATE. Diese Informationen befinden sich in den Dateien, die Sie im vorherigen Schritt heruntergeladen haben.
- Die AWS_IOT_ENDPOINT. Diese Information finden Sie in der AWS IoT-Konsole, indem Sie zu Einstellungen gehen, wie im unten gezeigten Bild:
- Kompiliere und lade den Code auf das ESP32-Board hoch, indem du in der Arduino-IDE auf die Hochladen-Schaltfläche klickst.
#include <pgmspace.h>
#define SECRET
#define THINGNAME "ESP32-thing"
const char WIFI_SSID[] = "";
const char WIFI_PASSWORD[] = "";
const char AWS_IOT_ENDPOINT[] = "xxxxx.amazonaws.com";
// Amazon Root CA 1
static const char AWS_CERT_CA[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
-----END CERTIFICATE-----
)EOF";
// Device Certificate
static const char AWS_CERT_CRT[] PROGMEM = R"KEY(
-----BEGIN CERTIFICATE-----
-----END CERTIFICATE-----
)KEY";
// Device Private Key
static const char AWS_CERT_PRIVATE[] PROGMEM = R"KEY(
-----BEGIN RSA PRIVATE KEY-----
-----END RSA PRIVATE KEY-----
)KEY";
Daten vom ESP32 an AWS IoT senden
Der obige ESP32-Code liest periodisch Daten von einem analogen Pin und sendet sie alle 4 Sekunden an AWS IoT. Wenn Sie den Serial Monitor in der Arduino-IDE öffnen, sehen Sie das Log unten wie folgt:
COM6
ESP32 connecting to AWS IOT.
ESP32 - AWS IoT Connected!
sent:
- topic: esp32/esp32-to-aws
- payload:{"timestamp":12743,"data":0}
sent:
- topic: esp32/esp32-to-aws
- payload:{"timestamp":16745,"data":130}
Autoscroll
Clear output
9600 baud
Newline
Um zu überprüfen, ob die Daten von AWS IoT empfangen werden oder nicht, führen Sie die folgenden Schritte aus:
- In der AWS IoT-Konsole navigieren Sie zu Test MQTT Test Client
- Klicken Sie auf die Thema abonnieren-Schaltfläche.
- Geben Sie esp32/esp32-to-aws in das Themenfilter ein. Sie können das Thema ändern, es muss jedoch mit dem im ESP32-Code verwendeten Thema übereinstimmen.
- Klicken Sie auf die Abonnieren-Schaltfläche.
- Sie können die vom ESP32 gesendeten Daten in der AWS IoT-Konsole sehen.
Daten von AWS IoT an ESP32 senden
Sie können die Daten von der AWS IoT-Konsole an den ESP32 senden, indem Sie die folgenden Schritte ausführen:
- In der Arduino-IDE den seriellen Monitor öffnen
- In der AWS IoT-Konsole zu Test MQTT Test Client navigieren
- Klicken Sie auf die Schaltfläche Auf ein Thema veröffentlichen.
- Geben Sie esp32/aws-to-esp32 in das Themenname ein. Sie können das Thema ändern, es muss jedoch dem Thema im ESP32-Code entsprechen.
- Optional können Sie die Payload der Nachricht ändern oder sie einfach auf den Standardwert belassen.
- Klicken Sie auf die Schaltfläche Veröffentlichen.
- Öffnen Sie den seriellen Monitor in der Arduino-IDE; Sie sehen die von der AWS IoT-Konsole gesendete Nachricht.
COM6
received:
- topic: esp32/aws-to-esp32
- payload:
{
"message": "Hello from AWS IoT console"
}
Autoscroll
Clear output
9600 baud
Newline
Mach mehr mit AWS
Jetzt können Sie eine bidirektionale Kommunikation zwischen dem ESP32 und AWS IoT Core herstellen. Das bedeutet, dass Sie Daten vom ESP32 zu AWS IoT Core senden und Daten von AWS IoT Core auf dem ESP32 empfangen können. Zusätzlich haben Sie die Möglichkeit, IoTRules zu konfigurieren, wodurch der ESP32 sich nahtlos mit anderen AWS-Diensten wie Lambda, DynamoDB, Amplify und RDS verbinden kann. Mit IoTRules können Sie Aktionen basierend auf Daten automatisieren, die vom ESP32 empfangen werden, was eine breite Palette von IoT-Anwendungen und Integrationen ermöglicht.