Armazenamento de dados na Nuvem com ESP32 e Node-RED

          Apenas componentes que possuam formas de estabelecer comunicação com a internet conseguirão ser inclusos, no caso desse projeto, apenas o ESP32. Através da IBM Watson será possível acessar algumas opções de  gráficos e funções capaz de analisar dados automaticamente, porém, iremos focar apenas em conectar o ESP32, deixando encargos de programação e análise para o editor Node-RED. A conexão de qualquer dispositivo nesta plataforma irá exigir a aplicação de um token de autenticação, que poderá ser encontrado em "Aplicativos" na opção "Gerar chave API".

          Para incluir o ESP32 ao servidor, acesse o menu "Dispositivos" e procure a opção "Incluir Dispisitivo". Esta opção irá construir um tipo de objeto virtual, e através de algumas configurações na própria programação, possibilita a coleta de informação diretamente no componente real, no caso desse projeto, irá coletar a transmissão de dados presente no ESP32.

          As chaves de API serão utilizadas tanto na sergurança do componente, quanto na conexão entre o ESP32 e o servidor. Na segunda etapa da iconfiguração do dispositivo, adicione o Token de autenticação corretamente, diferenciando letras minusculas de maiusculas.

Programação

          O status do dispositivo permanecerá o mesmo, até que a programação do ESP32 esteja ajustada com os seguintes parâmetros:

-------- Parâmetros de Conexão IBM - ESP32 -----------

Configure as informações na programação antes de transferi-la ao ESP32.

/* Projeto Curto Circuito – ESP32: Teste de conexão IBM WatsonF */
/*-------- Bibliotecas ----------- */
#include <WiFi.h>
#include <PubSubClient.h> /* https://github.com/knolleary/pubsubclient/releases/tag/v2.3 */
#include <ArduinoJson.h> /* https://github.com/bblanchon/ArduinoJson/releases/tag/v5.0.7 */
#include "Esp32MQTTClient.h"
/* -------- Configurações de Wi-fi ----------- */
const char* ssid = "REDE";           /* Nome */
const char* password = "SENHA";      /* Senha */
/* -------- Conexão IBM - ESP32 ----------- */
#define ORG "ORG" /* ID de organização */
#define DEVICE_TYPE "Componente" /* Insira o nome do componente */
#define DEVICE_ID "ID do componente" /* Insira o ID */
#define TOKEN "Token de autenticação"/* Insira o Token */
/*-------- Comunicação IOT – Não altere essa parte da programação -------- */
char server[] = ORG ".messaging.internetofthings.ibmcloud.com";
char authMethod[] = "use-token-auth";
char token[] = TOKEN;
char clientId[] = "d:" ORG ":" DEVICE_TYPE ":" DEVICE_ID;
const char eventTopic[] = "iot-2/evt/status/fmt/json";
const char cmdTopic[] = "iot-2/cmd/led/fmt/json";
/*-------- Variável Lógica -------- */
int cont = 0;                         /* Realiza uma contagem contínua */
WiFiClient wifiClient;

void callback(char* topic, byte* payload, unsigned int payloadLength)
{
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  if ((char)payload[0] == '0')
  { /* Caso receba o caractere 0 */
    digitalWrite(22, LOW);        /* Desliga o LED */
    Serial.println("LOW");
  }
  if ((char)payload[0] == '1')
  { /* Caso receba o caractere 1 */
    digitalWrite(22, HIGH);        /* Liga o LED */
    Serial.println("HIGH");
  }
}
PubSubClient client(server, 1883, callback, wifiClient);

void setup()
{
  Serial.begin(9600);                /* Taxa de transmissão 9600 ou 115200 dBs */
  pinMode(13, OUTPUT);              /* LED13 que será acionado pelo IBM */
  pinMode(2, OUTPUT);               /* LED2 indica falha na conexão com a internet */
  client.setCallback(callback);      /* Ajusta a função de retorno */
  wifiConnect();                     /* Cria o void wifiConnect */
  mqttConnect();                     /* Cria o void mqttConnect */
}
void wifiConnect()
{ /* Função void wifiConnect */
  Serial.print("Conectando a Rede ");
  Serial.print(ssid);                /* Indica a Rede que o ESP32 irá se conectar */
  WiFi.begin(ssid, password);        /* Conecta ao ssid e o password configurado */
  while (WiFi.status() != WL_CONNECTED)
  { /* Enquanto estiver desconectado */
    delay(500);                      /* Aguarda 500 milissegundos */
    Serial.print(".");
  }
  Serial.print("Wi-Fi conectado, Endereço de IP: ");
  Serial.println(WiFi.localIP());     /* Indica o endereço de IP */
}
void mqttConnect()
{ /* Função void mqttConnect */
  if (!!!client.connected())
  {
    Serial.print("Reconectando MQTT do cliente ");
    Serial.println(server);                       /* Indica o endereço do servidor */
    while (!!!client.connect(clientId, authMethod, token) )
    {
      Serial.print(".");
      delay(500);
    }
    if (client.subscribe(cmdTopic))
    {
      Serial.println("Resposta OK");              /* Se a resposta for OK */
      digitalWrite(2, LOW);                            /* LED 2 OFF */
    }
    else
    {
      Serial.println("Resposta FALHOU");   /* Se a resposta falhar */
      digitalWrite(2, HIGH);                          /* LED 2 ON */
    }
  }
}
void loop()
{
  if (!client.loop())
  {
    mqttConnect();
  }
  String payload = "{\"d\":{\"adc\":";      /* Inicia uma String associando ao endereço */
  payload += cont;                          /* Atribui o valor de leitura de cont a String */
  payload += "}}";                          /* Finaliza a String */
  Serial.print("Enviando payload: ");
  Serial.println(payload);                  /* Escreve a String no monitor Serial */
  client.publish(eventTopic, (char*) payload.c_str() );  /* Publica a String */
  cont ++;                                  /* Aumenta em 1 o valor de cont */
  delay(500);                               /* Aguarda 500 milissegundos */
}

          O plano de domínio Lite (Gratuito) engloba apenas duas opções de segurança, demonstradas na imagem a seguir, e, normalmente encontra-se configurada como Autenticação do Token, que limita o acesso às informações do componente de acordo com a chave de API inserida nele. Em fóruns da IBM Cloud, alguns desenvolvedores relataram que tal opção nem sempre funciona para planos gratuitos, portanto, procure selecionar o TLS opcional, que irá remover algumas opções segurança, tornando a comunicação mais simples.

          Após alterar o tipo de TSL, o componente adicionado deverá conectar-se ao servidor, indicando o horário de conexão em "Identidade", e exibir a contagem crescente do ESP32 ao clicar na opção Eventos Recentes. O status será considerado como "Inseguro", pois a categoria "Opcional" irá remover a proteção construida pela chave API.

          Acesse o painel de aplicativos em https://console.bluemix.net/dashboard/apps, na opção Aplicativos Cloud Foundry, clique no projeto em execução e visite a URL para iniciar a construção dos fluxos no Node-RED.

          O Link irá direciona-lo ao Node-RED, e, se este for o primeiro acesso a página, será possível criar um login de segurança com usuário e senha, limitando a edição dos fluxos a alguns usuários específicos. 

          Ao abrir o Node-RED, clique no botão  e selecione a opção Manage Palette, no menu Install escreva “dashboard”, e instale o conjunto node-red-dasboard. Este irá adicionar um novo grupo de nós programáveis a paleta de ferramentas, com a finalidade de personalizar a página de controle principal do navegador.

          A opção "Device Event" será utilizada no recebimento de mensagens (Payload) provenientes do ESP32, "Event" irá filtrar a leitura do nó, direcionando-a a algum um evento específico da programação, no caso desse exemplo, o sinal "+" será aplicado a coleta de quaisquer informações. As demais opções serão configuradas tal qual fôra apresentado nos parâmetros "Comunicação IOT ". Clique no botão Deploy para implantar a atualização da lógica, e selecione a opção Debug .

          Arraste um nó numerico (do conjunto dashboard), e construa o seguinte fluxo:

          A função "return", escrita no nó Function, irá resumir a leitura da mensagem direcionando-a ao final em adc "{\d:\adc\cont}}". O fluxo exibirá apenas uma contagem crescente de valores, que encontram-se em loop na variável "cont".

Acionamento de LEDs

          O próximo passo será o acionamento de algum componente, transmitindo comandos do servidor ao ESP32 através de qualquer aparelho conectado a internet. Para isso, contrua um circuito cimples com um LED, conectando o terminal positivo no pino D13 (GPIO13), um resistor de 1KΩ entre o terminal negativo e um dos pinos GND do ESP32.

          Configure a opção Topic de ambos os botões como “led”, e Payload com valores diferentes variando entre 1 e 0. De acordo com a programação aplicada ao ESP32, a função void callback interpretará tais informações, e irá atribui-las ao status do LED de acordo com o caractere recebido. 

          Adicione um nó IBM IoT Output e outro Debug, conectando ambos aos botões. Este fluxo, diferente do demonstrado anteriormente, será aplicado para enviar mensagens ao circuito, controlando funções de acordo com o valor configurado em Payload.

          A opção Type será alterada para Device Command, pois, como o próprio nome sugere, envia comandos ao ESP32. O Command Type estará ligado a função cmdTopic[] = "iot-2/cmd/led/fmt/json", escrita na programação, relacionando o comando a uma palavra chave, que no caso será led. Pressione Deploy, abra outra aba no navegador e reescreva o endereço /ui,  como mostra ao exemplo abaixo:

          A página apresentará uma aparência diferente do editor Node-RED, esta será a versão Dashboard do controle. Essa versão do navegador poderá ser acessada de qualquer aparelho com acesso a internet, portanto, procure testa-lo em outras plataformas, como smartphones, tablets, etc.

Considerações Finais

          O armazenamento de informações na nuvem apresenta inúmeras vantagens na construção de sistemas automatizados, além do investimento financeiro menor, demonstra ser mais flexível no compartilhamento de informações. Até mesmo no que se refere a segurança, como foi observado neste post, que mesmo em situações onde a proteção do sistema será considerada insegura, haverá outros meios para assegurar o projeto, mesmo que seja um simples controle de acesso para usuários. O sistema poderá ser operado em dispositivo e em qualquer local, desde que haja conexão com a internet.