ESP8266 - IoT AWS
Ce tutoriel vous explique comment utiliser l'ESP8266 avec AWS IoT Core. Plus précisément, nous couvrirons les sujets suivants en détail :
- Établir la connexion entre l'ESP8266 et AWS IoT Core.
- Programmer l'ESP8266 pour transmettre des données à AWS IoT Core.
- Programmer l'ESP8266 pour recevoir des données de AWS IoT Core.
En suivant ces étapes, vous acquerrez une compréhension complète de l'intégration de l'ESP8266 avec AWS IoT Core pour une communication sans faille.
Préparation du matériel
| 1 | × | ESP8266 NodeMCU | |
| 1 | × | Micro USB Cable | |
| 1 | × | Breadboard | |
| 1 | × | Jumper Wires | |
| 1 | × | (Optional) ESP8266 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 ESP8266 et AWS IoT
L'ESP8266 établit une connexion avec AWS IoT Core via le protocole MQTT. Bien que des bibliothèques soient disponibles pour simplifier cette connexion, elle est plus complexe que la connexion à un courtier MQTT local tel que Mosquitto sur votre PC. Cette complexité provient des mesures de sécurité strictes d'AWS IoT Core, nécessitant des étapes de configuration pour acquérir les justificatifs d'authentification et l'autorisation d'intégration dans le code ESP8266. En essence, le processus implique deux étapes principales :
- Configuration d'AWS IoT Core : Cette étape configure AWS IoT Core pour générer les justificatifs d'authentification nécessaires, qui seront par la suite intégrés dans le code ESP8266.
- Rédaction du code ESP8266 : Après avoir obtenu les justificatifs d'authentification d'AWS IoT Core, l'étape suivante consiste à rédiger le code ESP8266. Ce code intègre les protocoles d'authentification et de communication essentiels pour une interaction fluide avec AWS IoT Core.
Examinons de plus près chaque étape pour mieux la comprendre.
Configurer AWS IoT Core pour une utilisation avec ESP8266
Les objectifs de cette étape incluent :
- Création d'une représentation du dispositif ESP8266 sur AWS IoT Core, appelée "Thing."
- Configuration des autorisations nécessaires pour permettre au dispositif ESP8266 de se connecter, de publier et de s'abonner à partir de AWS IoT Core, appelée "Policy."
- Génération des identifiants AWS nécessaires pour l'authentification, appelés "Certificates." Ces identifiants seront téléchargés et intégrés dans le code Arduino ESP8266.
Voici les instructions pour configurer AWS IoT Core pour une utilisation avec l'ESP8266 via la console AWS IoT. Veuillez noter que, bien que l'interface utilisateur puisse changer avec le temps, le processus devrait rester similaire aux instructions fournies ci-dessous :
- Connectez-vous à la Console IoT AWS
- Créez un objet en allant dans Gérer Tous les appareils Objets
- Cliquez sur le bouton Créer des choses.
- Sélectionnez Créer une chose seule et cliquez sur le bouton Suivant.
- Précisez le nom de l'objet, par exemple, ESP8266-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.
- À présent, un Certificat est créé et associé à 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, ESP8266-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 des Choses.
- Vérifiez la ESP8266-policy et cliquez sur le bouton Créer une chose pour créer la Chose.
- Une fenêtre popup apparaît qui vous permet de télécharger les fichiers d'identification. Téléchargez tous les fichiers et stockez-les dans un endroit sûr sur votre PC et gardez-les de manière confidentielle.
- Ensuite, cliquez sur le bouton Terminé.
Parmi les fichiers téléchargés, trois fichiers seront utilisés dans le code ESP8266 lors des prochaines étapes :
- AmazonRootCA1.pem
- Xxxxxxxxxx-certificat.pem.crt
- Xxxxxxxxxx-prive.pem.key
Ces fichiers peuvent être ouverts par n'importe quel éditeur de texte tel que Notepad ou Notepad++.
Rédaction du code ESP8266 pour se connecter à AWS IoT Core
/*
* Ce code ESP8266 NodeMCU a été développé par newbiely.fr
* Ce code ESP8266 NodeMCU 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/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"];
*/
}
Étapes rapides
Pour commencer avec ESP8266 sur Arduino IDE, suivez ces étapes :
- Consultez le tutoriel comment configurer l'environnement pour ESP8266 sur Arduino IDE si c'est la première fois que vous utilisez ESP8266.
- Connectez la carte ESP8266 à votre ordinateur via un câble USB.
- Ouvrez Arduino IDE sur votre ordinateur.
- Choisissez la bonne carte ESP8266, telle que (par exemple NodeMCU 1.0 (Module ESP-12E)), et son port COM respectif.
- Ouvrez le Gestionnaire de bibliothèques en cliquant sur l'icône Gestionnaire de bibliothèques dans la barre de navigation gauche de Arduino IDE
- Tapez MQTT dans la boîte de recherche, puis recherchez la bibliothèque MQTT par Joel Gaehwiler.
- Cliquez sur le bouton Install pour installer la bibliothèque MQTT.
- Tapez ArduinoJson dans la zone de recherche, puis cherchez 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 dans 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 utilisez les touches Ctrl+Shift+N.
- Donnez au fichier le nom 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
- Le 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 dans Paramètre comme l'image ci-dessous :
- Compiler et télécharger le code sur la carte ESP8266 en cliquant sur le bouton Upload de l'IDE Arduino.
#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";
Envoyer des données de ESP8266 à AWS IoT
Le code ESP8266 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 l'IDE Arduino, vous verrez le journal comme ci-dessous :
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
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 esp8266/esp8266-to-aws dans le Filtre de sujet. Vous pouvez changer le sujet, mais cela DOIT correspondre au sujet du code ESP8266.
- Cliquez sur le bouton S'abonner.
- Vous pourrez voir les données envoyées depuis l'ESP8266 sur la console IoT AWS.
Envoyer des données d'AWS IoT à ESP8266
Vous pouvez envoyer les données de la console IoT AWS à l'ESP8266 en suivant les étapes suivantes :
- Sur l'IDE Arduino, ouvrez le moniteur série
- Sur la console AWS IoT, naviguez jusqu'à Test Client de test MQTT
- Cliquez sur le bouton Publier à un sujet.
- Tapez esp8266/aws-to-esp8266 dans le Nom du sujet. Vous pouvez changer le sujet mais il DOIT correspondre au sujet dans le code ESP8266.
- Facultativement, vous pouvez changer le payload du message, ou simplement le laisser par défaut.
- Cliquez sur le bouton Publier.
- Consultez le moniteur série sur Arduino IDE, vous verrez le message envoyé depuis la console AWS IoT.
COM6
received:
- topic: esp8266/aws-to-esp8266
- payload:
{
"message": "Hello from AWS IoT console"
}
Autoscroll
Clear output
9600 baud
Newline
Faites plus avec AWS
Désormais, vous pouvez établir une communication bidirectionnelle entre l'ESP8266 et AWS IoT Core. Cela signifie que vous pouvez envoyer des données de l'ESP8266 vers AWS IoT Core et recevoir des données depuis AWS IoT Core sur l'ESP8266. De plus, vous avez la capacité de configurer des IoTRules, permettant à l'ESP8266 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'ESP8266, permettant une large gamme d'applications et d'intégrations IoT.