Cloud IoT Core ESP32: envie dados para o Google Cloud Platform usando MQTT

Tempo de leitura: 6 minutes

Este tutorial aborda como integrar o Google Cloud IoT Core e o ESP32. Em mais detalhes, ele descreverá como enviar dados para o Google Cloud Platform IoT Core usando o ESP32 por meio do MQTT. Este tutorial do ESP32 abordará os seguintes tópicos:

  • Como configurar o Google Cloud Platform IoT Core no console
  • Enviando dados do ESP32 para o Google Cloud IoT usando o MQTT

Para entender melhor as etapas a seguir para integrar o ESP32 e o Google Cloud IoT, neste tutorial, enviaremos a temperatura e a umidade pelo MQTT. Portanto, conectaremos o ESP32 ao DHT11 para adquirir essas informações.

Configurando o núcleo da IoT do Google Cloud Platform

Em primeiro lugar, é necessário criar uma conta no Google Cloud Platform. Você pode criar esta conta gratuitamente e tem US$ 300 para gastar em seus testes. Em seguida, habilite a API IoT usando o console:

Esp32 Com Google

Criando Registro IoT Principal

Depois de ativar a API, a primeira coisa a fazer é criar um registro da IoT do Google Core. Assumimos que você já criou um projeto. Se não for esse o caso, você pode simplesmente criá-lo, dando um nome ao projeto. Antes de conectar o ESP32 ao Google Cloud Core IoT, é necessário criar e configurar o dispositivo usando o console ou a linha de comando.

Um registro de dispositivo representa um contêiner de um ou mais dispositivos. Usando um registro, podemos configurar algumas propriedades comuns. Então, adicione um novo registro:

Esp32 Com Google

Você precisa fornecer duas informações:

  • O registro ID (Registry ID) que usaremos posteriormente ao desenvolver o cliente ESP32 que se conecta ao Google Core IoT
  • E a região (region).

Além disso, você precisa criar um tópico. Este é o canal no qual publicaremos as leituras dos sensores provenientes do ESP32 e DHT11:

Esp32 Com Google

Neste exemplo, criamos um tópico chamado data-topic. Isso é tudo. Agora você pode salvar e criar seu registro.

Por padrão, os protocolos HTTP e MQTT estão ativados. Portanto, podemos usar os dois protocolos para conectar-se ao Google Cloud IoT. De qualquer forma, apenas o protocolo MQTT. Com essa intenção, o ESP32 se conectará ao IoT Core apenas usando o MQTT. Depois de salvar suas informações, a visão geral do registro será semelhante a:

Esp32 Com Google

Configurando o dispositivo Cloud IoT

Depois que o registro estiver configurado, podemos criar e configurar o dispositivo. O dispositivo representa nosso dispositivo físico e todas as informações que precisamos fornecer para conectar-se ao Google IoT. O Google Cloud IoT Core requer alguns certificados para que o ESP32 possa se conectar a ele. Portanto, vamos criar um novo certificado

Criando certificados

Nesta etapa, criaremos um par de chaves públicas e privadas do Certificado Elliptic:

openssl ecparam -genkey -name prime256v1 -noout -out esp32-device.pem
openssl ec -in esp32-device.pem -pubout -out esp32-device-public.pem

Agora, para obter a chave pública a ser usada na configuração do dispositivo, escreva este comando:

cat esp32-device-public.pem 

O código é a chave pública que você precisa copiar na definição do dispositivo.

Adicionando um novo dispositivo

Vamos adicionar um novo dispositivo:

Esp32 Com Google

Como você pode observar na imagem acima, é necessário fornecer:

>> ID do dispositivo que deve ser único

>> um certificado para autenticar o ESP32

Salve tudo.

No final, o dispositivo está pronto e as informações que você forneceu devem se parecer com a imagem abaixo:

Esp32 Com Google

Conectando o ESP32 ao Google Cloud Core IoT

Depois que concluímos toda a configuração, podemos concentrar nossa atenção em como conectar o ESP32 ao Cloud IoT Core. Mesmo que a conexão use o protocolo MQTT, não é tão fácil conectar diretamente o ESP32 ao Google Cloud IoT sem usar uma biblioteca. Mais detalhadamente, antes de conectar-se ao Core IoT, o ESP32 deve ser autenticado. Como mecanismo de autenticação, essa plataforma IoT usa o JWT assinado usando sua chave privada criada. Consequentemente, para conectar e enviar dados usando o MQTT, temos duas opções diferentes:

Neste tutorial do ESP32, usaremos a segunda opção, porque é mais fácil. Portanto, é necessário importar a biblioteca antes de continuar.

Clone o repositório ou copie de alguma forma esses arquivos no seu projeto ESP32:

  • esp32_mqtt.h
  • main.cpp
  • ciotc_config.h

Para personalizar a biblioteca de acordo com nossas necessidades, é necessário modificar o arquivo chamado ciotc_config.h:

const char *ssid = "your_ssid";
const char *password = "wifi_password";
 
// Detalhes da nuvem IOT.
const char *project_id = "esp32-project-266916";
const char *location = "europe-west1";
const char *registry_id = "esp32-swa-registry";
const char *device_id = "esp32-device";
 
// Configuração para NTP
const char* ntp_primary = "pool.ntp.org";
const char* ntp_secondary = "time.nist.gov";
 
#ifndef LED_BUILTIN
#define LED_BUILTIN 13
#endif
 
const char *private_key_str =
    "xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:"
    "de:17:9c:8f:fe:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:"
    "e8:fa";
 
// Tempo (segundos) para expirar o token + = 20 minutos para desvio
const int jwt_exp_secs = 3600; //Máximo de 24 horas (3600 * 24)
 
const char *root_cert =
    "-----BEGIN CERTIFICATE-----\n"
   "MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb\n"
"MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow\n"
"GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj\n"
"YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL\n"
"MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE\n"
"BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM\n"
"GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP\n"
"ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua\n"
"BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe\n"
"3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4\n"
"YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR\n"
"rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm\n"
"ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU\n"
"oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF\n"
"MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v\n"
"QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t\n"
"b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF\n"
"AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q\n"
"GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz\n"
"Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2\n"
"G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi\n"
"l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3\n"
"smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg==\n"
    "-----END CERTIFICATE-----\n";

Neste arquivo, você deve substituir as seguintes informações:

  • Wifi ssid
  • Wifi password
  • project_id
  • registry_id
  • location
  • device_id

Você pode obter essas informações nas etapas de configuração mostradas nos parágrafos anteriores. Além disso, você precisa da chave privada. Você pode obtê-lo usando este comando:

openssl ec -in esp32-device.pem -noout -text

Copie o resultado para private_key_str. Para obter o certificado raiz em root_cert, abra seu navegador e digite:

https://pki.goog/roots.pem

Salve o arquivo e copie o conteúdo no root_cert.

Antes de continuar, é necessário importar a biblioteca MQTT (usando este repositório) para que o projeto seja compilado.

Enviando dados para o Google Cloud Core IoT do ESP32 usando o MQTT

Finalmente, é hora de enviar dados do ESP32 para o IoT Core usando o MQTT. Como dito anteriormente, para explicar como fazê-lo, adquiriremos temperatura e umidade usando o DHT11. Portanto, modificaremos o arquivo main.cpp desta maneira:

#include <Arduino.h>
#include <WiFiClientSecure.h>
#include "esp32-mqtt.h"
#include <Adafruit_Sensor.h>
#include "DHT.h"
#include <ArduinoJson.h>
 
#define DHTTYPE DHT11
#define DHT_PIN 27
 
DHT dht(DHT_PIN,DHTTYPE);
 
char buffer[100];
 
void setup() {
  Serial.begin(9600);
  Serial.println("Setup.....");
  dht.begin();
  pinMode(LED_BUILTIN, OUTPUT);
 
  setupCloudIoT();
}
 
unsigned long lastMillis = 0;
 
void loop() {
  mqtt->loop();
  delay(10);  // <- corrige alguns problemas com a estabilidade do WiFi
 
  if (!mqttClient->connected()) {
    connect();
  }
 
  if (millis() - lastMillis > 60000) {
    Serial.println("Valor de publicação");
    lastMillis = millis();
    float temp = dht.readTemperature();
    float hum = dht.readHumidity();
    StaticJsonDocument<100> doc;
    doc["temp"] = temp;
    doc["humidity"] = hum;
    serializeJson(doc, buffer);
    //publishTelemetry(mqttClient, "/sensors", getDefaultSensor());
    publishTelemetry( buffer);
  }
}

O código é muito simples. O DHT11 conectado ao ESP32 usando o PIN 27 lê a temperatura e a umidade. O código gera uma carga útil JSON e a envia para o Cloud Core IoT usando MQTT.

Testando os resultados

Para visualizar os dados enviados através do protocolo MQTT, podemos criar um assinante que lê dados no canal de tópico de dados. Vamos criar um assinante, como mostra a figura abaixo:

Esp32 Com Google

Executa o código acima e verifique o painel no Cloud Core IoT:

Esp32 Com Google

Em seguida, você pode visualizar as mensagens MQTT enviadas pelo ESP32:

Esp32 Com Google

Isso é tudo!!!

Empacotando

Para resumir, neste tutorial do ESP32, abordamos como conectar o ESP32 ao Google Cloud Platform IoT Core. Aprendemos como configurar o Google Cloud IoT para aceitar dados por meio do protocolo MQTT.

No final deste artigo, você aprendeu como começar com o Google Cloud Plataform IOT construindo uma estação meteorológica simples. Este tutorial descobriu como conectar o ESP32 ao MQTT0 e como mostrar as leituras do sensor no Grafico do Cloud. Você pode melhorar ainda mais esse projeto do ESP32, adicionando novos sensores ou novos recursos.

TAGS : GCP, Google Cloud Platform, MQTT

Visits: 3 Visits: 1191795