Arduino Nano ESP32 – AWS IoT
Dieses Tutorial zeigt Ihnen, wie Sie den Arduino Nano ESP32 mit AWS IoT Core verbinden. Im Detail werden wir lernen:
- Wie man den Arduino Nano ESP32 mit AWS IoT Core verbindet.
- Wie man den Arduino Nano ESP32 programmiert, um Nachrichten an AWS IoT Core zu senden.
- Wie man den Arduino Nano ESP32 programmiert, um Nachrichten von AWS IoT Core zu empfangen.
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 Arduino Nano ESP32 und AWS IoT
Arduino Nano ESP32 verbindet sich mit AWS IoT Core über das MQTT-Protokoll. Das ist kein großes Problem, da die Bibliotheken verfügbar sind, was die Nutzung erleichtert.
Allerdings ist es nicht so einfach, den Arduino Nano ESP32 mit einem MQTT-Broker wie Mosquitto zu verbinden, der auf deinem PC installiert ist. Dies liegt daran, dass der AWS IoT Core strenge Sicherheitsmaßnahmen durchsetzt. Auf AWS IoT Core ist eine Konfiguration erforderlich, um Authentifizierungsnachweise und Autorisierung zu erhalten, bevor du den Arduino Nano ESP32-Code schreibst. Zusammengefasst müssen wir zwei große Schritte durchführen:
- Schritt 1: AWS IoT Core konfigurieren. Nach diesem Schritt erhalten wir die Authentifizierungsdaten, die im Arduino Nano ESP32-Code verwendet werden.
- Schritt 2: Den Arduino Nano ESP32-Code schreiben.
Lassen Sie uns ins Detail gehen.
Konfiguration von AWS IoT Core zur Verwendung mit dem Arduino Nano ESP32
Die Zwecke dieses Schrittes sind:
- Erstellung einer Repräsentation des Arduino Nano ESP32 in AWS IoT Core (als "Thing" bezeichnet).
- Konfiguration der Berechtigungen, die dem Arduino Nano ESP32 das Verbinden, Veröffentlichen und Abonnieren mit AWS IoT Core ermöglichen (als "Policy" bezeichnet).
- Generierung der AWS-Zugangsdaten, die für die Authentifizierung verwendet werden (als Zertifikate bezeichnet). Sobald sie erstellt wurden, laden wir die Anmeldeinformationen herunter und fügen sie in den Arduino ESP32-Code ein.
Das Folgende zeigt, wie Sie den AWS IoT Core für die Verwendung mit dem Arduino Nano ESP32 über die AWS IoT-Konsole konfigurieren. Bitte beachten Sie, dass die Benutzeroberfläche von AWS im Laufe der Zeit geändert werden kann, aber sie wird dem unten Gezeigten ähnlich sein:
- Melde dich bei der AWS IoT-Konsole an
- Erstelle ein Thing, indem du zu Verwalten Alle Geräte Things navigierst
- 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 ein, zum Beispiel ESP32-thing, und klicken Sie auf die Weiter-Schaltfläche am unteren Rand der Seite.
- Generieren Sie die Anmeldedaten, 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 ein, 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 Richtliniendokument-Bereich 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 Thing-Seite zurück.
- Überprüfen Sie die ESP32-Richtlinie und klicken Sie auf die Gerät erstellen-Schaltfläche, um das Thing zu erstellen.
- Ein Pop-up-Fenster erscheint, über das Sie die Zugangsdaten-Dateien herunterladen können. 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 Fertig-Schaltfläche.
Unter den heruntergeladenen Dateien befinden sich drei Dateien, die im nächsten Schritt im Arduino Nano ESP32-Code verwendet werden:
- xxxxxxxxxx-certificate.pem.crt
- xxxxxxxxxx-private.pem.key
- AmazonRootCA1.pem
Diese Dateien können mit jedem Texteditor geöffnet werden, z. B. Notepad oder Notepad++.
Schreiben des Arduino Nano ESP32-Codes, um eine Verbindung zu AWS IoT Core herzustellen
/*
* Dieser Arduino Nano ESP32 Code wurde von newbiely.de entwickelt
* Dieser Arduino Nano 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/arduino-nano-esp32/arduino-nano-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("Arduino Nano 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("Arduino Nano ESP32 connecting to AWS IOT");
while (!client.connect(THINGNAME)) {
Serial.print(".");
delay(100);
}
Serial.println();
if (!client.connected()) {
Serial.println("Arduino Nano 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("Arduino Nano 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
- Wenn dies das erste Mal ist, dass Sie Arduino Nano ESP32 verwenden, sehen Sie sich wie man die Umgebung für Arduino Nano ESP32 in der Arduino IDE einrichtet.
- Ö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 Install-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 Schaltfläche Install, 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 durch:
- Entweder klicken Sie auf die Schaltfläche direkt unter dem Symbol des seriellen Monitors und wählen Sie New Tab, 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.
- Die AWS_IOT_ENDPOINT. Diese Information finden Sie in der AWS IoT-Konsole, indem Sie zu Einstellungen navigieren, wie im folgenden Bild dargestellt:
- Kompiliere und lade den Code auf das Arduino Nano 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übertragung vom Arduino Nano ESP32 zu AWS IoT
Der oben gezeigte Arduino Nano ESP32-Code liest regelmäßig 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 Protokoll wie unten:
COM6
Arduino Nano ESP32 connecting to AWS IOT.
Arduino Nano 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 Schaltfläche Thema abonnieren.
- Geben Sie esp32/esp32-to-aws in das Themenfilter ein. Sie können das Thema ändern, aber es muss mit dem Thema im Arduino Nano ESP32-Code übereinstimmen.
- Klicken Sie auf die Schaltfläche Abonnieren.
- Sie können die vom Arduino Nano ESP32 gesendeten Daten in der AWS IoT-Konsole sehen.
Daten von AWS IoT an Arduino Nano ESP32 senden
Sie können die Daten von der AWS IoT-Konsole an den Arduino Nano ESP32 senden, indem Sie die folgenden Schritte ausführen:
- In der Arduino-IDE öffnen Sie den seriellen Monitor
- In der AWS IoT-Konsole navigieren Sie zum Test MQTT Test Client
- Klicken Sie auf die Schaltfläche Zu einem Topic veröffentlichen.
- Geben Sie esp32/aws-to-esp32 in den Topic-Name ein. Sie können den Topic ändern, aber MUSS mit dem Topic im Arduino Nano ESP32-Code übereinstimmen.
- Optional können Sie die Payload der Nachricht ändern oder sie einfach unverändert belassen.
- Klicken Sie auf die Schaltfläche Veröffentlichen.
- Öffnen Sie den Serial Monitor in der Arduino IDE; Sie sehen die von der AWS IoT Console gesendete Nachricht.
COM6
received:
- topic: esp32/aws-to-esp32
- payload:
{
"message": "Hello from AWS IoT console"
}
Autoscroll
Clear output
9600 baud
Newline
Mehr mit AWS erreichen
Nun können Sie Daten vom Arduino Nano ESP32 an AWS IoT Core senden und umgekehrt. Anschließend können Sie IoTRule einrichten, um den Arduino Nano ESP32 mit anderen AWS-Diensten wie Lambda, DynamoDB, Amplify, RDS ... zu verbinden.