ESP8266 - AWS IoT
Dieses Tutorial zeigt dir, wie du den ESP8266 mit AWS IoT Core verwendest. Konkret werden wir die folgenden Themen im Detail behandeln:
- Herstellung der Verbindung zwischen dem ESP8266 und AWS IoT Core.
- Programmierung des ESP8266, um Daten an AWS IoT Core zu übertragen.
- Programmierung des ESP8266, um Daten von AWS IoT Core zu empfangen.
Indem Sie diese Schritte befolgen, erhalten Sie ein umfassendes Verständnis der Integration des ESP8266 mit AWS IoT Core für eine nahtlose Kommunikation.
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 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 ESP8266 und AWS IoT
Der ESP8266 stellt eine Verbindung zu AWS IoT Core über das MQTT-Protokoll her. Obwohl Bibliotheken verfügbar sind, um diese Verbindung zu vereinfachen, ist sie komplexer als die Verbindung zu einem lokalen MQTT-Broker wie Mosquitto auf Ihrem PC. Diese Komplexität ergibt sich aus den strengen Sicherheitsmaßnahmen von AWS IoT Core, die Konfigurationsschritte erfordern, um Authentifizierungsnachweise und Autorisierung für die Integration in den ESP8266-Code zu erhalten. Im Wesentlichen umfasst der Prozess zwei Hauptschritte:
- AWS IoT Core konfigurieren: Dieser Schritt konfiguriert AWS IoT Core so, dass die erforderlichen Authentifizierungsdaten erzeugt werden, die anschließend in den ESP8266-Code integriert werden.
- ESP8266-Code schreiben: Nachdem die Authentifizierungsdaten von AWS IoT Core erhalten wurden, besteht der nächste Schritt darin, den ESP8266-Code zu schreiben. Dieser Code integriert die notwendigen Authentifizierungs- und Kommunikationsprotokolle, die für eine nahtlose Interaktion mit AWS IoT Core erforderlich sind.
Lass uns jeden Schritt genauer betrachten, um ihn besser zu verstehen.
AWS IoT Core für die Verwendung mit dem ESP8266 konfigurieren
Die Ziele dieses Schrittes umfassen:
- Eine Darstellung des ESP8266-Geräts in AWS IoT Core erstellen, als "Thing" bezeichnet.
- Die notwendige Autorisierung konfigurieren, damit das ESP8266-Gerät sich mit AWS IoT Core verbinden, veröffentlichen und abonnieren kann, bekannt als "Policy".
- Die für die Authentifizierung benötigten AWS-Zertifikate erstellen. Diese Zertifikate werden heruntergeladen und in den Arduino ESP8266-Code integriert.
Nachfolgend finden Sie Anweisungen zur Konfiguration von AWS IoT Core für die Verwendung mit dem ESP8266 über die AWS IoT-Konsole. Bitte beachten Sie, dass sich die Benutzeroberfläche im Laufe der Zeit ändern kann; der Ablauf sollte den untenstehenden Anweisungen ähnlich sein:
- Melden Sie sich beim AWS IoT Console an
- Erstellen Sie ein Thing, indem Sie zu Verwalten Alle Geräte Things gehen
- Klicken Sie auf die Schaltfläche Dinge erstellen.
- Wählen Sie einzelne Dinge erstellen und klicken Sie auf die Schaltfläche Weiter.
- Geben Sie den Gerätenamen an, zum Beispiel ESP8266-thing, und klicken Sie auf die Schaltfläche Weiter am unteren Rand der Seite.
- Generieren Sie die Anmeldeinformationen, indem Sie die Option Automatisch ein neues Zertifikat generieren auswählen, und klicken Sie auf die Weiter Schaltfläche.
- Jetzt wird ein Zertifikat erstellt und mit dem Objekt verknüpft.
- Eine Richtlinie erstellen, indem Sie auf die Richtlinie erstellen-Schaltfläche klicken.
- Eine neue Registerkarte wird geöffnet.
- Geben Sie den Richtlinienname an, zum Beispiel ESP8266-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.
- Jetzt wird eine Richtlinie erstellt und an das Zertifikat angehängt. Schließen Sie diese Seite und kehren Sie zur Geräteseite zurück.
- Überprüfen Sie die ESP8266-Richtlinie und klicken Sie auf die Gerät erstellen-Schaltfläche, um das Gerät zu erstellen.
- Ein Popup-Fenster erscheint, das Ihnen das Herunterladen der Zugangsdaten-Dateien ermöglicht. Laden Sie alle Dateien herunter und speichern Sie sie an einem sicheren Ort auf Ihrem PC und bewahren Sie sie vertraulich auf.
- Dann klicken Sie auf die Schaltfläche Fertig.
Unter den heruntergeladenen Dateien befinden sich drei Dateien, die im ESP8266-Code in den nächsten Schritten verwendet werden:
- AmazonRootCA1.pem
- xxxxxxxxxx-certificate.pem.crt
- xxxxxxxxxx-private.pem.key
Diese Dateien können mit jedem Texteditor geöffnet werden, z. B. Notepad oder Notepad++.
Schreiben des ESP8266-Codes, um sich mit AWS IoT Core zu verbinden
/*
* Dieser ESP8266 NodeMCU Code wurde von newbiely.de entwickelt
* Dieser ESP8266 NodeMCU 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/esp8266/esp8266-aws-iot
*/
#include "secrets.h"
#include <ESP8266WiFi.h>
#include <MQTTClient.h>
#include <ArduinoJson.h>
// The MQTT topics that this device should publish/subscribe
#define AWS_IOT_PUBLISH_TOPIC "esp8266/esp8266-to-aws"
#define AWS_IOT_SUBSCRIBE_TOPIC "esp8266/aws-to-esp8266"
#define PUBLISH_INTERVAL 5000 // 5 seconds
BearSSL::WiFiClientSecure network;
MQTTClient client = MQTTClient(256);
unsigned long lastPublishTime = 0;
void setup() {
Serial.begin(9600);
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
Serial.println("Connecting");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Connected to WiFi network with IP Address: ");
Serial.println(WiFi.localIP());
setClock();
connectToAWS();
}
void loop() {
client.loop();
if (millis() - lastPublishTime > PUBLISH_INTERVAL) {
sendToAWS();
lastPublishTime = millis();
}
}
// Set time via NTP, as required for x.509 validation
void setClock() {
configTime(3 * 3600, 0, "pool.ntp.org", "time.nist.gov");
Serial.print("Waiting for NTP time sync: ");
time_t now = time(nullptr);
while (now < 8 * 3600 * 2) {
delay(500);
Serial.print(".");
now = time(nullptr);
}
Serial.println("");
struct tm timeinfo;
gmtime_r(&now, &timeinfo);
Serial.print("Current time: ");
Serial.print(asctime(&timeinfo));
}
void connectToAWS() {
// Configure the AWS IoT device credentials
network.setTrustAnchors(new BearSSL::X509List(AWS_CERT_CA));
network.setClientRSACert(new BearSSL::X509List(AWS_CERT_CRT), new BearSSL::PrivateKey(AWS_CERT_PRIVATE));
// Connect to the MQTT broker on the AWS endpoint we defined earlier
client.begin(AWS_IOT_ENDPOINT, 8883, network);
// Create a handler for incoming messages
client.onMessage(messageHandler);
Serial.print("ESP8266 connecting to AWS IOT");
while (!client.connect(THINGNAME)) {
Serial.print(".");
delay(100);
}
Serial.println();
if (!client.connected()) {
Serial.println("ESP8266 - AWS IoT Timeout!");
return;
}
// Subscribe to a topic, the incoming messages are processed by messageHandler() function
client.subscribe(AWS_IOT_SUBSCRIBE_TOPIC);
Serial.println("ESP8266 - 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
Um mit ESP8266 in der Arduino-IDE zu starten, befolgen Sie diese Schritte:
- Schauen Sie sich das Tutorial zur Einrichtung der Umgebung für ESP8266 in der Arduino IDE an, wenn Sie ESP8266 zum ersten Mal verwenden.
- Schließen Sie das ESP8266-Board über ein USB-Kabel an Ihren Computer an.
- Öffnen Sie die Arduino-IDE auf Ihrem Computer.
- Wählen Sie das passende ESP8266-Board aus, z. B. NodeMCU 1.0 (ESP-12E-Modul), und den entsprechenden COM-Port.
- Ö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, und suchen Sie dann nach der MQTT-Bibliothek von Joel Gaehwiler.
- Klicken Sie auf die Schaltfläche Install, um die MQTT-Bibliothek zu installieren.
- Geben Sie ArduinoJson in das Suchfeld ein, suchen Sie dann nach der ArduinoJson-Bibliothek von Benoit Blanchon.
- Klicken Sie auf die Schaltfläche Installieren, 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 in der Arduino-IDE, indem Sie:
- Entweder klicken Sie auf die Schaltfläche direkt unter dem Symbol des seriellen Monitors und wählen Sie Neue Registerkarte, oder verwenden Sie die Tasten Ctrl+Shift+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 Ihres WLAN-Netzwerks
- 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.
- Der Endpunkt AWS_IOT_ENDPOINT. Diese Informationen finden Sie in der AWS IoT-Konsole, indem Sie zu Einstellungen gehen, wie im untenstehenden Bild gezeigt:
- Kompilieren und Code auf das ESP8266-Board hochladen, indem Sie in der Arduino IDE auf den Hochladen-Button klicken.
#include <pgmspace.h>
#define SECRET
#define THINGNAME "ESP8266-thing"
const char WIFI_SSID[] = ""; // CHANGE IT TO MATCH YOUR OWN NETWORK CREDENTIALS
const char WIFI_PASSWORD[] = ""; // CHANGE IT TO MATCH YOUR OWN NETWORK CREDENTIALS
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 ESP8266 an AWS IoT senden
Der obige ESP8266-Code liest regelmäßig Daten von einem analogen Pin aus und sendet sie alle 4 Sekunden an AWS IoT. Wenn Sie den Serial Monitor in der Arduino-IDE öffnen, sehen Sie das Protokoll wie unten:
COM6
ESP8266 connecting to AWS IOT.
ESP8266 - AWS IoT Connected!
sent:
- topic: esp8266/esp8266-to-aws
- payload:{"timestamp":12743,"data":0}
sent:
- topic: esp8266/esp8266-to-aws
- payload:{"timestamp":16745,"data":130}
Autoscroll
Clear output
9600 baud
Newline
Um zu prüfen, ob die Daten von AWS IoT empfangen werden, führen Sie die folgenden Schritte aus:
- Gehen Sie in der AWS IoT-Konsole zu Test MQTT Test Client
- Klicken Sie auf die Thema abonnieren-Schaltfläche.
- Geben Sie esp8266/esp8266-to-aws in das Themenfilter ein. Sie können das Thema ändern, aber ES MUSS dem im ESP8266-Code verwendeten Thema entsprechen.
- Klicken Sie auf die Abonnieren-Schaltfläche.
- Sie können die vom ESP8266 gesendeten Daten in der AWS IoT-Konsole sehen.
Daten von AWS IoT an ESP8266 senden
Sie können die Daten von der AWS IoT Console an den ESP8266 senden, indem Sie die folgenden Schritte ausführen:
- Im Arduino-IDE den seriellen Monitor öffnen
- In der AWS IoT-Konsole navigieren Sie zu Test MQTT Test Client
- Klicken Sie auf die In ein Thema veröffentlichen-Schaltfläche.
- Geben Sie esp8266/aws-to-esp8266 in den Themenname ein. Sie können das Thema ändern, aber es MUSS mit dem im ESP8266-Code verwendeten Thema übereinstimmen.
- Optional können Sie die Nutzlast der Nachricht ändern oder sie einfach als Standard belassen.
- Klicken Sie auf die Veröffentlichen-Schaltfläche.
- Überprüfen Sie den seriellen Monitor in der Arduino-IDE; Sie werden die von der AWS IoT-Konsole gesendete Nachricht sehen.
COM6
received:
- topic: esp8266/aws-to-esp8266
- payload:
{
"message": "Hello from AWS IoT console"
}
Autoscroll
Clear output
9600 baud
Newline
Mach mehr mit AWS
Nun können Sie eine bidirektionale Kommunikation zwischen dem ESP8266 und AWS IoT Core herstellen. Das bedeutet, Sie können Daten vom ESP8266 zu AWS IoT Core senden und Daten von AWS IoT Core auf dem ESP8266 empfangen. Zusätzlich haben Sie die Möglichkeit, IoTRules zu konfigurieren, wodurch der ESP8266 nahtlos mit anderen AWS-Diensten wie Lambda, DynamoDB, Amplify und RDS verbunden werden kann. Mit IoTRules können Sie basierend auf den vom ESP8266 empfangenen Daten automatisierte Aktionen durchführen, was eine breite Palette von IoT-Anwendungen und Integrationen ermöglicht.