Servizi AWS IoT core e MQTT: connettere i dispositivi esp32 – 4
Su questo articolo continuiamo la parte di articoli relativi all’integrazione con un altro tipo di dispositivo appartenente alla famiglia degli esp32, che è molto potente e versatile.
Come per gli esp8266, bisogna creare un oggetto nuovo con il relativo certificato (oppure riutilizzare l’oggetto esp8266 ma interrompere l’utilizzo dell’altro dispositivo).
Creare un nuovo oggetto
Nel progetto che avevi già scaricato, verifica la presenza della cartella esp32_relay_iot_core/certificates, in caso contrario, creala.
- Nella console AWS IoT (IoT Core), scegli dal menù di sinistra Gestione e Oggetti .
Oppure direttamente:
https://us-east-1.console.aws.amazon.com/iot/home?region=us-east-1#/thinghub (Nord America)
https://eu-west-1.console .aws.amazon.com/iot/home?region=eu-west-1#/thinghub (Europa) - Quindi fai clic sul pulsante Crea in alto a destra, poi Crea singolo oggetto.
- Assegna un nome al nuovo oggetto esp32_relay e copialo anche nel file
setup.txt
nella sezione[Device name]
. Lascia i campi rimanenti impostati sui valori predefiniti. Scegli Next . - Scegli Crea certificato.
- Scarica all’interno della cartella
esp32_relay_iot_core/certificates
: Certificato per questo Oggetto, chiave privata, quindi fai clic vicino a A CA root per AWS IoT sul link Scarica, e seleziona Amazon Root CA 1. - Scegli Activate.
- Quindi fare clic su Collega una policy.
- Seleziona la policy già creata, se non la crei clicca per ora su Fatto e controlla l’articolo 2 “Servizi AWS IoT core e MQTT: creazione di cosa AWS con certificato e policy” dove spiego che creazione della policy.
Ma fai attenzione; non puoi connettere esp32 e esp8266 contemporaneamente con lo stesso certificato .
Quindi, se desideri connettere questi due dispositivi contemporaneamente, devi creare un nuovo oggetto AWS con un certificato e una policy. Quindi esegui tutti i passaggi relativi e cambia esp8266 in esp32.
Puoi utilizzare la stessa politica esp8266_relay_policy che abbiamo creato nell’ultimo articolo, ma devi apportare una modifica.
Modifica la policy per aggiungere un nuovo dispositivo
- Per modificare la policy devi andare su AWS IoT Console;
- Nel menu a sinistra devi fare clic su Sicurezza e nel sottomenu selezionare Policy
https://eu-west-1.console.aws.amazon.com/iot/home?region=eu-west-1#/policy/esp8266_relay_policy (Europa)
https://us-east-1.console.aws.amazon.com/iot/home?region=us-east-1#/policy/esp8266_relay_policy (Nord America); - Fai clic su
esp8266_relay_policy
; - Clicca in alto a destra nel testo della policy Modifica documento policy;
- Tutti i permessi di iscrizione al topic sono pronti, devi solo aggiungere queste righe
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:[Region]:[Account ID]:client/esp32_relay"
},
esp32_relay
è il nome dell’oggetto creato ora.
- E ora fai clic su Salva come nuova versione.
Configurare l’IDE
Come per leesp8266, naturalmente è necessario prima il dispositivo, poi configurare il dispositivo per poter creare e caricare il codice. Per fare ciò, puoi fare riferimento a questo articolo “Esp32: piedinatura, specifiche e configurazione dell’Arduino IDE”.
You can find esp32 here ESP32 Dev Kit v1 - TTGO T-Display 1.14 ESP32 - NodeMCU V3 V2 ESP8266 Lolin32 - NodeMCU ESP-32S - WeMos Lolin32 - WeMos Lolin32 mini - ESP32-CAM programmer - ESP32-CAM bundle - ESP32-WROOM-32 - ESP32-S
Codice di esempio
Puoi trovare il codice sorgente nella cartella
alexa-skill-manage-relay/esp32_relay_iot_core/sketch/aws_iot_core_esp32
all’interno trovi quattro file
aws_certificate.h
aws_parameter.h
wifi_credential.h
aws_iot_core_esp32.ino
Configurazione
E devi riempire con queste informazioni
wifi_credential.h
: inserisci il tuo SSID WiFi e password.
char WIFI_SSID[] = "<YOUR-SSID>";
char WIFI_PASSWORD[] = "<YOUR-PASSWD>";
aws_parameter.h
: hai questo file precompilato in alcune partiTHINGNAME
è il nome della cosaesp32_relay
;- AWS_IOT_ENDPOINT: è il valore che avevi messo su [IoT MQTT EndPoint], lo trovi nella sezione Impostazioni della Console AWS IoT ;
- AWS_IOT_PUBLISH_TOPIC: è l’argomento di pubblicazione [IoT MQTT publish topic], per la nostra policy è
relay/pub
; - AWS_IOT_SUBSCRIBE_TOPIC: è l’argomento di pubblicazione [IoT MQTT subscribe topicper la nostra policy è
relay/sub
;
#define THINGNAME "esp32_relay"
char AWS_IOT_ENDPOINT[] = "XXXXXXXXXXXXXX-ats.iot.eu-west-1.amazonaws.com";
#define AWS_IOT_PUBLISH_TOPIC "relay/pub"
#define AWS_IOT_SUBSCRIBE_TOPIC "relay/sub"
aws_certificate.h
:
questo file ha 3 sezioni una per ogni certificato e chiave che abbiamo scaricato, l’unica modifica dalla versione esp8266 è che usa char al posto uint8_t
#include <pgmspace.h>
// Amazon Root CA 1 (AmazonRootCA1.pem)
static const char AWS_CERT_CA[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
[...]
-----END CERTIFICATE-----
)EOF";
// Device Certificate (XXXXXXXXXX-certificate.pem.crt)
static const char AWS_CERT_CRT[] PROGMEM = R"KEY(
-----BEGIN CERTIFICATE-----
[...]
-----END CERTIFICATE-----
)KEY";
// Device Private Key (XXXXXXXXXX-private.pem.key)
static const char AWS_CERT_PRIVATE[] PROGMEM = R"KEY(
-----BEGIN RSA PRIVATE KEY-----
[...]
-----END RSA PRIVATE KEY-----
)KEY";
Sketch
Ricordati di scaricare la libreria ArduinoJSON e MQTT
Ecco lo sketch completo; come puoi vedere, è abbastanza simile a quello dell’esp8266; l’unica differenza è come viene impostata la CA al WiFiClientSecure.
/*
* Amazon AWS IoT core connection from esp8266 boards
*
* This sketch securely connects to an AWS IoT using MQTT over WiFi.
* With MQTT library.
*
* It publishes a message every 5 seconds to arduino/pub
* topic and subscribes to messages on the arduino/sub
* topic.
*
* by Mischianti Renzo <https://mischianti.org>
*
* https://mischianti.org
*
*/
#include "Arduino.h"
#include "aws_certificate.h"
#include "aws_parameter.h"
#include "wifi_credential.h"
#include "WiFi.h"
#include "WiFiClientSecure.h"
#include <MQTTClient.h>
#include <ArduinoJson.h>
// Secure connection
WiFiClientSecure client = WiFiClientSecure();
// Client MQTT
MQTTClient clientMQTT = MQTTClient(256);
// Callback for every message on the topic subscribed
void messageCallback(String &topic, String &payload);
// Establish connection to MQTT
bool manageAWSConnection();
// Subscribe topic
bool manageAWSSubscription();
// Publish message to topic
bool publishMessage();
void setup()
{
Serial.begin(115200);
while(!Serial){}
Serial.flush();
Serial.println();
// WIFI_SSID, WIFI_PASSWORD Stored on wifi_credential.h file
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
Serial.print("Connecting to ");
Serial.print(WIFI_SSID); Serial.println("");
int i = 0;
while (WiFi.status() != WL_CONNECTED) { // Wait for the Wi-Fi to connect
delay(1000);
Serial.print(++i); Serial.print('.');
}
Serial.println('\n');
Serial.println("Connection established!");
Serial.print("IP address:\t");
Serial.println(WiFi.localIP()); // Send the IP address of the ESP8266 to the computer
if (manageAWSConnection()){
manageAWSSubscription();
}
}
unsigned long lastSendingTime = millis();
unsigned long sendMessageEveryMillis = 5000;
void loop()
{
clientMQTT.loop();
if (lastSendingTime+sendMessageEveryMillis<millis()){
publishMessage();
lastSendingTime = millis();
}
}
bool manageAWSConnection(){
// Configure WiFiClientSecure for the AWS IoT device certificate
client.setCACert(AWS_CERT_CA);
client.setCertificate(AWS_CERT_CRT);
client.setPrivateKey(AWS_CERT_PRIVATE);
// Connect to the MQTT broker on the AWS endpoint
clientMQTT.begin(AWS_IOT_ENDPOINT, 8883, client);
// Create a message handler
clientMQTT.onMessage(messageCallback);
Serial.print("Connecting to AWS IOT");
while (!clientMQTT.connect(THINGNAME)) {
Serial.print(".");
delay(100);
}
if(!clientMQTT.connected()){
Serial.println("AWS IoT Timeout!");
return false;
}
return true;
}
bool manageAWSSubscription(){
// Subscribe to a topic
if (clientMQTT.subscribe(AWS_IOT_SUBSCRIBE_TOPIC)){
Serial.println("AWS IoT Connected!");
return true;
}else{
Serial.print("AWS IoT ERROR: ");
Serial.println(clientMQTT.lastError());
return false;
}
}
void messageCallback(String &topic, String &payload) {
Serial.println("incoming: [" + topic + "]" );
Serial.println("---------------------------" );
StaticJsonDocument<200> doc;
deserializeJson(doc, payload);
serializeJsonPretty(doc, Serial);
Serial.println();
Serial.println("---------------------------" );
}
bool publishMessage()
{
// Create simple message
DynamicJsonDocument doc(512);
doc["time"] = millis();
doc["deviceName"] = "esp32";
doc["status"] = "OK";
char jsonBuffer[512];
serializeJson(doc, jsonBuffer); // print to client
Serial.print("Message on ");
Serial.print(AWS_IOT_PUBLISH_TOPIC);
Serial.print(" topic... ");
// Publish message to AWS_IOT_PUBLISH_TOPIC
if (clientMQTT.publish(AWS_IOT_PUBLISH_TOPIC, jsonBuffer)){
Serial.println("Published!");
return true;
}else{
Serial.println("Error!");
return false;
}
}
Grazie
- Servizi AWS IoT core e MQTT: introduzione e prerequisiti
- Servizi AWS IoT core e MQTT: creazione di oggetti AWS con certificato e policy
- Servizi AWS IoT core e MQTT: connettere i dispositivi esp8266
- Servizi AWS IoT core e MQTT: connettere i dispositivi esp32
- Servizi AWS IoT core e MQTT: connettere i dispositivi Arduino SAMD (WiFiNINA).
- Servizi AWS IoT core e MQTT: test da console e MQTT.fx