IoT DevKit - 14. Central de Monitoramento por MQTT

Introdução

Nos tutoriais anteriores aprendemos a enviar e receber dados pela conectividade Wi-Fi usando o protocolo MQTT, mas só aprendemos como fazer isso separadamente e não utilizamos ainda todas as funcionalidades do IoT DevKit.

Neste tutorial iremos criar uma central de monitoramento utilizando a conectividade Wi-Fi e o protocolo MQTT para enviar as leituras de todos os sensores da placa base, e ainda receber mensagens para acender um LED quando uma determinada mensagem for recebida.

Lista de Materiais

Lista completa de produtos

comprar

IoT DevKit - LoRaWAN

R$ 322,90 no PIX

Configurações da Plataforma

Neste tutorial iremos aproveitar muitas das configurações que já fizemos na plataforma para os tutoriais anteriores, porém ainda teremos que adicionar algumas variáveis e alguns "Widgets" ao painel para que possamos receber e exibir todas as informações de todos os sensores do kit.

Configuração das Variáveis

Além das variáveis que recebem os valores de temperatura e umidade do DHT11, também temos que criar as variáveis que receberão as leituras do LDR e do acelerômetro do IoT DevKit. Para isso, acesse a seção "Variáveis" do seu dispositivo e pressione o botão "+ Variável" para que a plataforma apresente a janela da imagem a seguir.

Com essa janela aberta, vamos primeiro configurar a variável para a leitura do LDR, então digite um nome para sua variável e digite no campo "Alias" o nome "Luminosidade" (este nome está pré configurado no código deste tutorial). Além disso, no campo "Unidade", digite "%" e garanta que o campo "Pontos Decimais" está com o valor "0" configurado. Deste modo, a sua variável ficará configurada como a da imagem abaixo.

variavel-luminosidade-configurada — Variável "Luminosidade" Configurada

Com a variável configurada, pressione o botão de confirmação verde e observe a sua adição à lista de variáveis do dispositivo. Feito isso, pressione o botão "+ Variável" novamente para que possamos adicionar a variável para o eixo "x" do acelerômetro. Com a nova janela aberta, digite um nome para a variável e digite no campo "Alias" o nome "Eixo_X" (nome pré configurado no código de exemplo deste tutorial). Em seguida, digite no campo "Unidade" a unidade "g", pois exibiremos na variável a força G no eixo do sensor. Por fim, altere o campo "Pontos Decimais" de "0" para "2". Assim, a sua variável ficará configurada como a da próxima imagem.

variavel-eixo-x-configurada — Variável "Eixo_X" Configurada

Repita esse processo mais duas vezes para adicionarmos as variáveis para os eixos "y" e "z" do acelerômetro. As configurações dessas variáveis são basicamente as mesmas da variável para o eixo "x", porém, nos campos "Alias", temos que digitar os nomes "Eixo_Y" e "Eixo_Z" para as respectivas variáveis, como nas imagens abaixo.

variavel-eixo-y-configurada — Variável "Eixo_Y" Configurada

variavel-eixo-z-configurada — Variável "Eixo_Z" Configurada

Feito isso, será possível observar todas as variáveis criadas na lista de variáveis do seu dispositivo.

Configuração do Painel

Agora que as variáveis estão configuradas e criadas, temos que ajustar o nosso painel do ESP32 para que as variáveis sejam exibidas. Para isso, acesse o painel que criamos e configuramos nos tutoriais anteriores e pressione o botão "+ Widget" para adicionarmos um "Widget" ao painel. Ao pressionar esse botão, será exibida uma lista de opções, mas primeiramente vamos configurar a exibição dos eixos do acelerômetro, então selecione a opção "Métrico", como na próxima imagem.

widget-metrico-selecionado — "Widget" "Métrico" Selecionado

Ao selecionar essa opção, será exibida uma janela de configuração do "Widget", como na imagem abaixo.

Com esta janela aberta, selecione a sua "Organização", sua "Aplicação", o dispositivo criado e primeiramente a variável "Eixo_X". Então dê um nome para o "Widget", altere o campo "Pontos Decimais" de "0" para "2", e altere a cor de exibição, se desejar. Quando o "Widget" estiver configurado corretamente, pressione o botão de confirmação verde para que ele seja adicionado ao painel. Feito isso, repita esse processo para as duas outras variáveis do acelerômetro, como nas imagens abaixo.

widget-eixo-x-configurado — "Widget" "Eixo_X" Configurado

widget-eixo-y-configurado — "Widget" "Eixo_X" Configurado

Com os três "Widgets" adicionados ao painel, pressione novamente o botão "+ Widget" para adicionarmos o "Widget" para a variável "Luminosidade". Quando a lista de "Widgets" for aberta, selecione a opção "Tanque", como na imagem a seguir.

widget-tanque-selecionado — "Widget" "Tanque" Selecionado

Ao selecionar essa opção, será aberta a janela de configuração do "Widget", como na próxima imagem.

Neste momento, selecione sua "Organização", sua "Aplicação", o seu dispositivo e a variável "Luminosidade". Feito isso, dê um nome para o "Widget" e selecione a opção "Mostrar valor como porcentagem", para que ele fique configurado como o da próxima imagem.

widget-luminosidade-configurado — "Widget" "Luminosidade" Configurado

Por fim, pressione o botão de confirmação verde, assim ele também será adicionado ao painel. Entretanto, o seu painel deve estar um pouco desorganizado, portanto tome um tempo para alterar os tamanhos e as posições dos "Widgets" da maneira que desejar, assim eles podem ficar dispostos como na imagem a seguir.

Código

Com a plataforma devidamente configurada, carregue o código a seguir para a sua placa. Lembre de alterar as variáveis que armazenam o nome e a senha da sua rede Wi-Fi (REDE e SENHA), juntamente com as variáveis para o ID único do dispositivo (ID_DISPOSITIVO) e para a Token API (TOKEN_API), com os valores que foram gerados pela plataforma anteriormente.

/*******************************************************************************
* IoT DevKit - Central de Monitoramento Wi-Fi via MQTT (v1.0)
* 
* Codigo utilizado para realizar a leitura de todos os sensores do IoT DevKit, 
* e entao enviar essas leituras para a plataforma PROIoT utilizando a 
* conectividade Wi-Fi e o protocolo MQTT.
* 
* Copyright 2020 RoboCore.
* Escrito por Giovanni de Castro (15/09/2020).
* Creditos - @francois - RoboCore
*          - @bijilbaji - Solucao proposta no topico #102 do GitHub
*            - (https://github.com/espressif/arduino-esp32/issues/102#issuecomment-611307887)
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

//Verifica se o modelo de placa selecionado esta correto
#if !defined(ARDUINO_ESP32_DEV) // ESP32
#error Use this example with the ESP32
#endif

//Inclusao das Bibliotecas
#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>
#include <ArduinoJson.h>
#include "RoboCore_MMA8452Q.h"
#include <soc/sens_reg.h> //Biblioteca para leitura dos registradores

//Declaracao das variaveis da rede Wi-Fi
const char* REDE = "SUA-REDE-WIFI-AQUI";
const char* SENHA = "SENHA-REDE-WIFI-AQUI";

//Criacao dos objetos que serao resposaveis pela conexao ao servidor
WiFiClient cliente; //Objeto "cliente" para a biblioteca WiFi
PubSubClient MQTT(cliente); //Objeto "MQTT" pela biblioteca "PubSubClient" através do objeto "cliente"

//Criacao do objeto "acelerometro" pela biblioteca "MMA8452Q"
MMA8452Q acelerometro;

//Declaracao do servidor e da sua porta
const char* SERVIDOR = "mqtt.proiot.network";
const uint16_t PORTA = 1883;

//Declaracao das variaveis geradas na plataforma
const char* ID_DISPOSITIVO = "ID-DISPOSITIVO-AQUI"; //ID Unico do Dispositivo
const char* TOKEN_API = "SEU-TOKEN-API-AQUI"; //Token da Organizacao
//Altere as variaveis acima de acordo com os valores gerados na plataforma

//Declaracao da variavel que armazena a senha de conexao ao servidor
const char* SENHA_ID = ""; //Nao e necessario altera-la

//Declaracao das variaveis que armazenam os Alias das variaveis da plataforma
const char ALIAS1[] = "Temperatura";
const char ALIAS2[] = "Umidade";
const char ALIAS3[] = "Luminosidade";
const char ALIAS4[] = "Eixo_X";
const char ALIAS5[] = "Eixo_Y";
const char ALIAS6[] = "Eixo_Z";
//Altere as variaveis acima de acordo com o que foi configurado na plataforma

//Declaracao da variavel auxiliar para a criacao do topico para publish
char TOPICO[50] = "device/";

//Declaracao do pino conectado ao sensor DHT no DevKit
const int PINO_DHT = 12;

//Criacao do objeto DHT de acordo com o pino que ele esta conectado, e o seu modelo
DHT dht(PINO_DHT, DHT11); //Modelo de fabrica do DevKit - DHT11

//Declaracao das variaveis que armazenam as leituras do sensor
float temperatura;
float umidade;

//Declaracao da variavel que armazena o intervalo de tempo entre mensagens
unsigned long espera; //Variavel para o envio de mensagens
unsigned long reconecta; //Variavel para a conexao com o servidor
const long INTERVALO = 1200000; //20 minutos

//Declaracao das variaveis para o LED
const int PINO_LED = 13;
int estado = LOW;

//Declaracao das variaveis para o LDR
const int PINO_LDR = 15;
int leitura_LDR = 0;

//Declaracao da variavel auxiliar "mensagem_enviada" para verificacao de mensagem recebida
String mensagem_enviada;

//Declaracao da variavel e da funcao para leitura do LDR
uint32_t adc_register; //Variavel para o resgitrador
int customARead(int); //Funcao para a leitura do sensor

//---------------------------------------------------------------------------------------
void setup () {

  //Inicializacao do monitor serial
  Serial.begin(115200);
  Serial.println("--- Central de Monitoramento WiFi ---");

  //Inicializacao do sensor DHT
  dht.begin();

  //Inicializacao do acelerometro
  acelerometro.init();

  //Define o "PINO_LED" como uma saida
  pinMode(PINO_LED, OUTPUT);

  //Define o "PINO_LDR" como uma entrada
  pinMode(PINO_LDR, INPUT);
  adc_register = READ_PERI_REG(SENS_SAR_READ_CTRL2_REG); //Estado atual do registrador

  //Requisita a conexao do dispositivo a rede
  Serial.print("Conectando a rede: ");
  Serial.println(REDE);
  WiFi.mode(WIFI_STA);
  WiFi.begin(REDE, SENHA);

  //Aguarda ate que o dispositivo se conecte a rede
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
    Serial.print(".");
  }

  //Quando conectado, exibe o endereco IP
  Serial.println("Conectado!");
  Serial.print("Endereco IP: ");
  Serial.println(WiFi.localIP());

  //Indica para o objeto "MQTT" em que servidor e em que porta iremos nos conectar
  Serial.print("Servidor configurado: ");
  Serial.print(SERVIDOR);
  Serial.print(" : ");
  Serial.println(PORTA);
  MQTT.setServer(SERVIDOR, PORTA);

  //Atribui a funcao "mqtt_callback" (do final do codigo) ao objeto "MQTT"
  MQTT.setCallback(mqtt_callback);

  //Concatena a variavel "TOPICO" com a variavel "ID_DISPOSITIVO"
  strcat(TOPICO, ID_DISPOSITIVO);

}

//---------------------------------------------------------------------------------------
void loop () {

  //Mantem a conexao ativa com o servidor
  MQTT.loop();

  //Verifica a conexao com o servidor
  if (!MQTT.connected()) { //Se nao estiver conectado
    if (reconecta < millis()) { //Executa a solicitacao de conexao a cada 5 segundos
      Serial.println("");
      Serial.println("Conectando ao servidor...");
      //Solicita a conexao com o servidor utilizando os parametros "ID_DISPOSITIVO", "TOKEN_API" e "SENHA_ID"
      if (!MQTT.connect(ID_DISPOSITIVO, TOKEN_API, SENHA_ID)) {
        Serial.println("Falha na conexao com o servidor.");
      } else {
        Serial.println("Conectado!");
        Serial.print("Enviando publicacoes para ");
        Serial.println(TOPICO);
        Serial.print("Estabelecendo inscricao com ");
        Serial.println(TOPICO);
        //Solicita a inscricao no "TOPICO"
        if (!MQTT.subscribe(TOPICO)) {
          Serial.println("Erro ao se inscrever no topico");
          Serial.println("Desconectando do servidor...");
          MQTT.disconnect(); //Desconecta a placa do servidor
          Serial.println("Desconectado.");
        } else {
          Serial.println("Inscricao concluida!");
        }
      }
      reconecta = millis() + 5000; //Atualiza a contagem de tempo
    }
  } else { //Se estiver conectado
    //Executa o envio de mensagens de acordo com a variavel "intervalo"
    if (espera < millis()) { //Padrao 20 minutos

      //Realiza a leitura do LDR e mapeia a leitura entre 0 e 100
      leitura_LDR = customARead(PINO_LDR);
      leitura_LDR = map(leitura_LDR, 0, 4095, 100, 0);

      //Realiza a leitura do acelerometro
      acelerometro.read();

      //Realiza a leitura de temperatura e umidade do sensor
      temperatura = dht.readTemperature();
      umidade = dht.readHumidity();

      //Verifica se a leitura foi feita corretamente
      if (isnan(umidade) || isnan(temperatura)) {
        Serial.println("Falha na leitura do Sensor DHT!");
      } else {

        //Cria o objeto dinamico "json" com tamanho "2" para a biblioteca
        DynamicJsonDocument json(JSON_OBJECT_SIZE(6));

        //Atrela ao objeto "json" as leitura do sensor com os Alias definidos
        json[ALIAS1] = temperatura;
        json[ALIAS2] = umidade;
        json[ALIAS3] = leitura_LDR;
        json[ALIAS4] = acelerometro.x;
        json[ALIAS5] = acelerometro.y;
        json[ALIAS6] = acelerometro.z;

        //Mede o tamanho da mensagem "json" e atrela o valor somado em uma unidade ao objeto "tamanho_mensagem"
        size_t tamanho_mensagem = measureJson(json) + 1;

        //Cria a string "mensagem" de acordo com o tamanho do objeto "tamanho_mensagem"
        char mensagem[tamanho_mensagem];

        //Copia o objeto "json" para a variavel "mensagem" e com o "tamanho_mensagem"
        serializeJson(json, mensagem, tamanho_mensagem);

        //Atribuida a variavel "mensagem_enviada" a mensagem JSON que sera enviada
        mensagem_enviada = mensagem;

        //Publica a variavel "mensagem" no servidor utilizando a variavel "TOPICO"
        Serial.println("");
        Serial.print("Mensagem enviada: ");
        Serial.println(mensagem);
        MQTT.publish(TOPICO, mensagem);

      }
      espera = millis() + INTERVALO; //Atualiza a contagem de tempo pela variavel "intervalo"
    }
  }
  
}

//---------------------------------------------------------------------------------------
void mqtt_callback (char* topico, byte* payload, unsigned int comprimento) {

  //Declaracao da variavel que armazena a mensagem recebida
  String mensagem_recebida;

  //Salva os caracteres da mensagem a variavel "mensagem"
  for (int i = 0; i < comprimento; i++) {
    char c = (char)payload[i];
    mensagem_recebida += c;
  }

  //Verifica a mensagem recebida
  if (mensagem_recebida != mensagem_enviada) {
    if (mensagem_recebida == "L") {
      estado = ! estado; //Inverte a variavel "estado"
      digitalWrite(PINO_LED, estado); //Aciona o "PINO_LED" de acordo com o "estado"
    }
    Serial.println("");
    Serial.print("Mensagem recebida: ");
    Serial.println(mensagem_recebida);
  }
  
}

//---------------------------------------------------------------------------------------
//Funcao responsavel por ler o ADC conectado ao LDR
int customARead(int pin){
  uint32_t wifi_register = READ_PERI_REG(SENS_SAR_READ_CTRL2_REG);
  WRITE_PERI_REG(SENS_SAR_READ_CTRL2_REG, adc_register);
  SET_PERI_REG_MASK(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_DATA_INV);
  int value = analogRead(pin); //Realiza a leitura
  WRITE_PERI_REG(SENS_SAR_READ_CTRL2_REG, wifi_register);
  return value; //Retorna o valor lido
}

Entendendo o Código

O código deste projeto é basicamente uma mescla dos códigos para os projetos anteriores de envio e recebimento de dados por MQTT, porém com algumas funções a mais. Nas declarações globais do código, além das bibliotecas que já estávamos utilizando anteriormente, nós também incluímos as bibliotecas que nos ajudarão a ler o acelerômetro do IoT DevKit e a acessar os registradores do ADC do ESP32.

#include "RoboCore_MMA8452Q.h"
#include <soc/sens_reg.h> //Biblioteca para leitura dos registradores

O que é um ADC? ADC é uma sigla para "Analog-Digital Converter" (Conversor Analógico-Digital) e ele nos permite realizar leituras analógicas em uma porta do microcontrolador, como o pino 15 do ESP32, onde o LDR do IoT DevKit está conectado. Mas por que precisamos acessar os registradores do ADC da placa? O ESP32, quando utiliza a conectividade Wi-Fi, desabilita a leitura direta do seu ADC2, o que impede que realizemos leituras analógicas através de um comando analogRead(). Portanto acessamos os registradores deste ADC para realizar as leituras do LDR.

Em seguida criamos o objeto acelerometro, a partir da biblioteca "RoboCore_MMA8452Q", e declaramos mais 4 variáveis para armazenar os "Aliases" configurados anteriormente ("Luminosidade", "Eixo_X", "Eixo_Y" e "Eixo_Z"). Feito isso, criamos as variáveis PINO_LDR, que armazena o pino do ESP32 que está conectado ao LDR; leitura_LDR, que armazenará as leituras mapeadas do sensor; e mensagem_enviada, que armazenará as mensagens JSON enviadas, para compararmos se a recebemos de volta. Isso é necessário, pois a PROIoT cria um único tópico para o nosso dispositivo, assim todas as mensagens que enviamos pelo ESP32 também são retornadas para a placa. Por fim, declaramos a variável e a função que nos ajudarão a realizar a leitura do ADC da placa.

//Criacao do objeto "acelerometro" para a biblioteca "MMA8452Q"
MMA8452Q acelerometro;
      
//Declaracao das variaveis que armazenam os Alias das variaveis da plataforma
const char ALIAS1[] = "Temperatura";
const char ALIAS2[] = "Umidade";
const char ALIAS3[] = "Luminosidade";
const char ALIAS4[] = "Eixo_X";
const char ALIAS5[] = "Eixo_Y";
const char ALIAS6[] = "Eixo_Z";
//Altere as variaveis acima de acordo com o que foi configurado na plataforma
      
//Declaracao das variaveis para o LDR
const int PINO_LDR = 15;
int leitura_LDR = 0;

//Declaracao da variavel auxiliar "mensagem_enviada" para verificacao de mensagem recebida
String mensagem_enviada;

//Declaracao da variavel e da funcao para leitura do LDR
uint32_t adc_register; //Variavel para o resgitrador
int customARead(int); //Funcao para a leitura do sensor

A configuração do código é praticamente idêntica à dos dois tutoriais anteriores juntos, mas nela também inicializamos o acelerômetro do kit através do comando acelerometro.init(). Além disso, configuramos o pino conectado ao LDR como entrada, e armazenamos na variável adc_register as configurações iniciais do ADC.

//Inicializacao do acelerometro
acelerometro.init();
      
//Define o "PINO_LDR" como uma entrada
pinMode(PINO_LDR, INPUT);
adc_register = READ_PERI_REG(SENS_SAR_READ_CTRL2_REG); //Estado atual do registrador

Já na repetição do código, ela também é basicamente a junção das repetições dos códigos dos projetos anteriores. Mas, na lógica de envio de mensagens, atribuímos a leitura do LDR do DevKit à variável leitura_LDR, através do comando leitura_LDR = customARead(PINO_LDR), e em seguida mapeamos essa leitura utilizando o comando leitura_LDR = map(leitura_LDR, 0, 4095, 100, 0). Além disso, lemos os três eixos do acelerômetro graças ao comando acelerometro.read().

Para a conversão das leituras em mensagens JSON, criamos o objeto json com tamanho "6" desta vez (JSON_OBJECT_SIZE(6)), já que iremos enviar 6 informações distintas para a plataforma. Com isso, criamos 6 elementos, cada um com o nome de um Alias (ALIAS1, ALIAS2, ALIAS3, ALIAS4, ALIAS5 e ALIAS6), que recebem, respectivamente, os valores das leituras dos sensores através das variáveis temperatura, umidade, leitura_LDR, e através dos membros acelerometro.x, acelerometro.y e acelerometro.z. Por fim, antes de publicarmos a mensagem no tópico da plataforma, nós atribuímos à variável mensagem_enviada a mensagem JSON contida na variável mensagem, para que possamos compará-la com a mensagem recebida na função de recebimento do código.

//Realiza a leitura do LDR e mapeia a leitura entre 0 e 100
leitura_LDR = customARead(PINO_LDR);
leitura_LDR = map(leitura_LDR, 0, 4095, 100, 0);

//Realiza a leitura do acelerometro
acelerometro.read();
      
//Cria o objeto dinamico "json" com tamanho "2" para a biblioteca
DynamicJsonDocument json(JSON_OBJECT_SIZE(6));

//Atrela ao objeto "json" as leitura do sensor com os Alias definidos
json[ALIAS1] = temperatura;
json[ALIAS2] = umidade;
json[ALIAS3] = leitura_LDR;
json[ALIAS4] = acelerometro.x;
json[ALIAS5] = acelerometro.y;
json[ALIAS6] = acelerometro.z;
      
//Atribuida a variavel "mensagem_enviada" a mensagem JSON que sera enviada
mensagem_enviada = mensagem;

A função mqtt_callback deste código também é bastante similar à do código do tutorial de recebimento de dados, mas dessa vez declaramos a variável mensagem_recebida para armazenar a mensagem que foi recebida da plataforma. Com isso, realizamos a comparação entre a mensagem enviada pelo ESP32 com a mensagem recebida da plataforma através da condição if (mensagem_recebida != mensagem_enviada). Deste modo, a mensagem só será impressa no monitor serial, e verificada para acionamento do LED, se a mensagem recebida for diferente da mensagem enviada.

//Verifica a mensagem recebida
if (mensagem_recebida != mensagem_enviada) {
  if (mensagem_recebida == "L") {
    estado = ! estado; //Inverte a variavel "estado"
    digitalWrite(PINO_LED, estado); //Aciona o "PINO_LED" de acordo com o "estado"
  }
  Serial.println("");
  Serial.print("Mensagem recebida: ");
  Serial.println(mensagem_recebida);
}

Ao final do código temos a função customARead() que, como você deve ter notado ao decorrer do código, é a função responsável por realizar a leitura do pino 15 do ESP32, onde o LDR do IoT DevKit está conectado. Nela operamos um registrador do ADC do ESP32 para realizar a leitura do sensor e retornamos essa informação para o trecho que a chamou.

O Que Deve Acontecer

Após carregar o código para a placa, abra o monitor serial, assim você verá uma resposta como a da imagem a seguir.

resultado-monitor-serial — Resultado no Monitor Serial

A mensagem JSON que enviamos para a plataforma é bem extensa, por conta da quantidade de variáveis que atualizamos. Porém, se você rolar a janela do monitor serial um pouco para o lado, será possível observar a mensagem completa, como a mensagem a seguir, por exemplo.

Além disso, caso queira enviar uma mensagem pela plataforma, ainda é possível e a mensagem será exibida no monitor serial, como na imagem a seguir.

resposta-recebimento-monitor-serial — Resposta de Recebimento no Monitor Serial

Caso a mensagem enviada pela plataforma seja igual à que configuramos no código, além da mensagem ser exibida no monitor serial, será possível observar a mudança de estado do LED do DevKit. Como ele iniciou apagado, será possível vê-lo aceso, como na imagem a seguir.

Juntamente com o envio e recebimento da mensagem no monitor serial, será possível observar a atualização do painel da plataforma e, após algum tempo de funcionamento do projeto, será possível ter um painel semelhante ao da imagem a seguir.

Conclusão

Neste tutorial utilizamos a conectividade Wi-Fi do IoT DevKit para explorar todas as funcionalidades da placa base através do protocolo MQTT, que nos permitiu enviar as leituras de todos os sensores e ainda receber mensagens da plataforma para acionarmos uma carga.

Solução de Problemas

Se mesmo seguindo as soluções propostas abaixo você não conseguir solucionar o seu problema, encaminhe um e-mail para suporte@robocore.net para que possamos te ajudar da melhor maneira possível.

Arduino IDE Retornou a Mensagem "#error Use this example with the ESP32"

Como vimos anteriormente, esta é uma mensagem personalizada que criamos no início do código para quando o modelo de placa selecionado não está corretamente selecionado, portanto certifique-se que o modelo da placa nas "Ferramentas" da IDE está como "ESP32 Dev Module".

Monitor Serial Apresenta Pontos Infinitamente e Não se Conecta

Se isso acontecer, verifique as variáveis REDE e SENHA do código carregado, pois é possível que elas não estejam exatamente iguais aos parâmetros configurados no roteador. Além disso, certifique-se que tanto a rede quanto a senha não possuem caracteres especiais, como acentos, pois o ESP32 não deve estar os interpretando corretamente.

Monitor Serial Apresentou a Mensagem "Falha na conexao com o servidor."

Se esta mensagem for exibida no monitor serial, verifique as variáveis ID_DISPOSITIVO e TOKEN_API, pois é possível que elas não sejam exatamente iguais aos parâmetros gerados na plataforma. Além disso, verifique se o seu dispositivo está com a opção "Conectado" selecionada na plataforma, como na imagem abaixo. Se não estiver selecionado, selecione esta opção e observe o resultado ao tentar novamente.

dispositivo-conectado — Dispositivo Conectado

Valor Atualizado na Plataforma Não é Igual ao Enviado pelo ESP32

Caso a mensagem exibida pelo monitor serial seja diferente dos valores que foram atualizados na plataforma, verifique se o campo "Formato de payload", na seção "Opções de payload" do dispositivo, está corretamente selecionado para "JSON" como na imagem a seguir.

payload-configurado-json — "Payload" Configurado como "JSON"