Servizi AWS IoT core e MQTT: connettere i dispositivi esp32 – 4

Spread the love

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.

Amazon AWS IoT Core MQTT connect esp32 devices
Amazon AWS IoT Core MQTT connects esp32 devices.

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.

  1. 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)
  2. Quindi fai clic sul pulsante Crea in alto a destra, poi Crea singolo oggetto.
  3. 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 .
  4.  Scegli  Crea certificato.
  5. Scarica all’interno della cartella esp32_relay_iot_core/certificatesCertificato per questo Oggettochiave privata, quindi fai clic vicino a A CA root per AWS IoT sul link  Scarica, e seleziona Amazon Root CA 1.
  6. Scegli  Activate.
  7. Quindi fare clic su Collega una policy.
  8. 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.
IoT Core esp8266 esp32 MQTT Scarica certificati
IoT Core esp8266 esp32 MQTT Scarica certificati

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

  1. Per modificare la policy devi andare su AWS IoT Console;
  2. 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);
  3. Fai clic su esp8266_relay_policy;
  4. Clicca in alto a destra nel testo della policy Modifica documento policy;
  5. 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.

  1. 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 - Selectable - TTGO T-Display 1.14 ESP32 - NodeMCU V3 V2 ESP8266 Lolin32 - NodeMCU ESP-32S - WeMos Lolin32 CP2104 CH340 - 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 parti
    • THINGNAME è il nome della cosa esp32_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

  1. Servizi AWS IoT core e MQTT: introduzione e prerequisiti
  2. Servizi AWS IoT core e MQTT: creazione di oggetti AWS con certificato e policy
  3. Servizi AWS IoT core e MQTT: connettere i dispositivi esp8266
  4. Servizi AWS IoT core e MQTT: connettere i dispositivi esp32
  5. Servizi AWS IoT core e MQTT: connettere i dispositivi Arduino SAMD (WiFiNINA).
  6. Servizi AWS IoT core e MQTT: test da console e MQTT.fx

Spread the love

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *