ESP32 - AWS IoT
Ce tutoriel vous explique comment utiliser ESP32 avec AWS IoT Core. En détail, nous apprendrons :
- Comment connecter l'ESP32 à AWS IoT Core.
- Comment programmer l'ESP32 pour envoyer les données à AWS IoT Core.
- Comment programmer l'ESP32 pour recevoir les données de AWS IoT Core.
Préparation du matériel
| 1 | × | ESP-WROOM-32 Dev Module | |
| 1 | × | USB Cable Type-C | |
| 1 | × | Breadboard | |
| 1 | × | Jumper Wires | |
| 1 | × | (Recommended) ESP32 Screw Terminal Adapter |
Or you can buy the following sensor kits:
| 1 | × | DIYables Sensor Kit (30 sensors/displays) | |
| 1 | × | DIYables Sensor Kit (18 sensors/displays) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
À propos de ESP32 et AWS IoT
L'ESP32 se connecte à AWS IoT Core en utilisant le protocole MQTT. Bien que des bibliothèques soient disponibles pour faciliter cette connexion, ce n'est pas aussi simple que de se connecter à un courtier MQTT local comme Mosquitto sur votre PC. Cela est dû au fait que AWS IoT Core dispose de mesures de sécurité strictes, nécessitant des étapes de configuration pour obtenir les justificatifs d'authentification et l'autorisation avant de les intégrer dans le code ESP32. En résumé, le processus implique deux étapes principales :
- Étape 1 : Configuration de AWS IoT Core - Cela implique de configurer AWS IoT Core pour générer les informations d'authentification nécessaires, qui seront utilisées plus tard dans le code ESP32.
- Étape 2 : Écriture du code ESP32 - Une fois les informations d'authentification obtenues de AWS IoT Core, l'étape suivante consiste à écrire le code ESP32, en intégrant les protocoles d'authentification et de communication nécessaires.
Examinons de plus près chaque étape pour mieux la comprendre.
Configuration d'AWS IoT Core pour utilisation avec ESP32
Les objectifs de cette étape incluent :
- Création d'une représentation du dispositif ESP32 sur AWS IoT Core, appelée "Chose".
- Configuration des autorisations nécessaires pour permettre au dispositif ESP32 de se connecter, publier et s'abonner à/depuis AWS IoT Core, connue sous le nom de "Politique".
- Génération des identifiants AWS nécessaires pour l'authentification, appelés "Certificats". Ces identifiants seront téléchargés et intégrés dans le code Arduino ESP32.
Voici des instructions pour configurer AWS IoT Core pour une utilisation avec ESP32 via la console AWS IoT. Veuillez noter que, bien que l'interface utilisateur puisse changer avec le temps, le processus devrait rester similaire à celui décrit ci-dessous :
- Connectez-vous à AWS IoT Console
- Créez un objet en vous rendant à Gérer Tous les appareils Objets
- Cliquez sur le bouton Créer des choses.
- Sélectionnez Créer une chose simple et cliquez sur le bouton Suivant.
- Précisez le nom de l'objet, par exemple ESP32-thing et cliquez sur le bouton Suivant en bas de la page.
- Générez les identifiants en sélectionnant l'option Générer automatiquement un nouveau certificat et cliquez sur le bouton Suivant.
- Désormais, un Certificat est créé et lié à la Chose.
- Créez une politique en cliquant sur le bouton Créer une politique.
- Un nouvel onglet sera ouvert.
- Spécifiez le nom de la politique, par exemple, ESP32-policy et cliquez sur le bouton JSON.
- Copiez le contenu de la politique JSON ci-dessous et collez-le dans la zone Document de politique :
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "*",
"Resource": "*"
}
]
}
- Cliquez sur le bouton Créer en bas de la page pour créer la politique.
- À présent, une Politique est créée et attachée au Certificat. Fermez cette page et retournez à la page de l'Objet.
- Vérifiez la ESP32-policy et cliquez sur le bouton Créer un objet pour créer l'Objet.
- Une fenêtre popup apparaît et vous permet de télécharger les fichiers d'identification. Téléchargez tous les fichiers et stockez-les dans un emplacement sûr sur votre PC tout en les gardant confidentiels.
- Ensuite, cliquez sur le bouton Terminé.
Parmi les fichiers téléchargés, trois fichiers seront utilisés dans le code ESP32 lors des prochaines étapes :
- AmazonRootCA1.pem
- Xxxxxxxxxx-certificate.pem.crt
- Xxxxxxxxxx-private.pem.key
Ces fichiers peuvent être ouverts par n'importe quel éditeur de texte tel que Notepad ou Notepad++.
Écrire le code ESP32 pour se connecter à AWS IoT Core
/*
* Ce code ESP32 a été développé par newbiely.fr
* Ce code ESP32 est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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);
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"];
*/
}
Étapes rapides
- Si c'est la première fois que vous utilisez un ESP32, consultez comment configurer l'environnement pour ESP32 sur Arduino IDE.
- Ouvrez le gestionnaire de bibliothèques en cliquant sur l'icône Gestionnaire de bibliothèques dans la barre de navigation gauche de l'Arduino IDE.
- Tapez MQTT dans la boîte de recherche, puis recherchez la bibliothèque MQTT de Joel Gaehwiler.
- Cliquez sur le bouton Install pour installer la bibliothèque MQTT.
- - Tapez ArduinoJson dans la zone de recherche, puis recherchez la bibliothèque ArduinoJson de Benoit Blanchon.
- - Cliquez sur le bouton Install pour installer la bibliothèque ArduinoJson.
- Copiez le code ci-dessus et collez-le dans l'IDE Arduino.
- Créez le fichier secrets.h sur l'IDE Arduino en :
- Cliquant soit sur le bouton juste en dessous de l'icône du moniteur série et choisissez Nouvel Onglet, soit en utilisant les touches Ctrl+Shift+N.
- Donnez le nom du fichier secrets.h et cliquez sur le bouton OK
- Copiez le code ci-dessous et collez-le dans le fichier créé secrets.h.
- Mettez à jour les informations suivantes dans le secrets.h
- Le WIFI_SSID et WIFI_PASSWORD de votre réseau WiFi
- Les AWS_CERT_CA, AWS_CERT_CRT et AWS_CERT_PRIVATE. Ces informations se trouvent dans les fichiers que vous avez téléchargés à l'étape précédente.
- Le AWS_IOT_ENDPOINT. Cette information peut être trouvée sur la console IoT AWS en allant à Setting comme l'indique l'image ci-dessous :
- Compiler et téléverser le code sur la carte ESP32 en cliquant sur le bouton Upload de l'IDE Arduino.
#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";
Envoi de données de l'ESP32 vers AWS IoT
Le code ESP32 ci-dessus lit périodiquement les données d'une broche analogique et les envoie à AWS IoT toutes les 4 secondes. Si vous ouvrez le moniteur série sur Arduino IDE, vous verrez le journal comme ci-dessous :
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
Pour vérifier si les données sont reçues par AWS IoT ou non, suivez les étapes suivantes :
- Dans la console AWS IoT, accédez à Test Client de test MQTT
- Cliquez sur le bouton S'abonner à un sujet.
- Tapez esp32/esp32-to-aws dans le Filtre de sujet. Vous pouvez modifier le sujet, mais il DOIT correspondre au sujet dans le code ESP32.
- Cliquez sur le bouton S'abonner.
- Vous pourrez voir les données envoyées depuis l'ESP32 sur la console IoT AWS.
Envoyer des données d'AWS IoT à ESP32
Vous pouvez envoyer les données depuis la console IoT d'AWS vers l'ESP32 en suivant les étapes suivantes :
- Sur Arduino IDE, ouvrez le moniteur série
- Sur la console AWS IoT, naviguez jusqu'à Test Client de test MQTT
- Cliquez sur le bouton Publier dans un sujet.
- Tapez esp32/aws-to-esp32 dans le Nom du sujet. Vous pouvez changer le sujet mais il DOIT correspondre au sujet dans le code ESP32.
- Facultativement, vous pouvez changer le contenu du message, ou simplement le laisser par défaut.
- Cliquez sur le bouton Publier.
- Consultez le moniteur série dans l'IDE Arduino, vous verrez le message envoyé depuis la console IoT AWS.
COM6
received:
- topic: esp32/aws-to-esp32
- payload:
{
"message": "Hello from AWS IoT console"
}
Autoscroll
Clear output
9600 baud
Newline
Faites plus avec AWS
Vous pouvez désormais établir une communication bidirectionnelle entre l'ESP32 et AWS IoT Core. Cela signifie que vous pouvez envoyer des données de l'ESP32 vers AWS IoT Core et recevoir des données de AWS IoT Core sur l'ESP32. De plus, vous avez la capacité de configurer des IoTRules, permettant à l'ESP32 de se connecter de manière transparente avec d'autres services AWS tels que Lambda, DynamoDB, Amplify et RDS. Avec les IoTRules, vous pouvez automatiser des actions basées sur les données reçues de l'ESP32, permettant un large éventail d'applications et d'intégrations IoT.