É comum observar que algumas empresas, assim como alguns sistemas automatizados, reúnem informações e arquivos importantes em uma única rede de computadores locais. A aplicação desses recursos requer certo investimento, tanto no financeiro, quanto no tempo introduzindo medidas preventivas como HDs externos, Pendrives, ou cópias de segurança.  O armazenamento de dados na nuvem possibilita uma redução considerável em tais investimentos, afinal, tudo será alocado na internet, excluindo assim a necessidade de manter memórias e maquinários próprios para este tipo de tarefa. O Node-RED em parceria com a IBM Cloud, elaboraram uma plataforma de desenvolvimento voltada a construção de sistemas IoT, simplificando a comunicação do ESP32 com servidores web em host particular, elaborando um controle para a transmissão de informações na nuvem, e possibilitando até mesmo a aplicação de agentes inteligentes com habilidades cognitivas (Inteligências Artificiais).

          As funções e ferramentas da IBM Cloud serão utilizadas por esse post na construção de um host particular, limitando a edição do aplicativo a um único usuário, e, sendo capaz de visualizar a transmissão de dados de um ESP32 em qualquer aparelho com acesso a internet.

Componentes

          Para concluir as atividades desse post, tenha em mãos os seguintes componentes:

          Você pode compra-los clicando nos links acima ou visitando nosso site: www.curtocircuito.com.br.

IBM Cloud: Primeiros Passos

          O armazenamento de informações na nuvem requer uma comunicação entre o ESP32 e um servidor particular, no caso deste post,  o servidor será construido através da IBM Cloud, pois esta ferramenta possui um vinculo direto com o editor de fluxo Node-RED, apresentado anteriormente, além de deixar a disposição diversos recursos que facilitam o desenvolvimento de plataformas automatizadas. Para conectar o ESP32 ao IBM, crie um usuário no site bluemix.net, em seguida acesse o link Catálogo, e procure pela opção "Internet of Things Platform Starter".

O catálogo Bluemix dispõe de diversas funções para a construção de aplicativos.

 

          Nomeie o endereço de host e selecione o tipo de plano como Lite, caso queira trabalhar com o sistema de forma gratuita. Após criar o aplicativo, procure no menu lateral a opção Conexões, e clique em iniciar para acessar as ferramentas da IBM Watson, que servirá para incluir dispositivos eletrônicos, permitindo que a leitura e controle do componente sejam armazenadas nos servidores da IBM.

Acesse as conexão do IBM Cloud para iniciar o desenvolvimento no Watson Iot.


          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 cada dispositivo conectado ao Watson será necessário gerar uma chave de 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.

No menu Dispositivos, será possível incluir componentes virtuais, com a capacidade de coletar dados dos dispositivos reais,

          Nomeie o tipo e crie uma identificação (ID) exclusiva para este componente. Na imagem abaixo, por exemplo, declaramos o tipo como ESP32 e o ID do dispositivo test.

O tipo e ID do dispositivo serão utilizados para auxiliar na conexão do dispositivo.


          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.

Adicione o Token de autenticação para criar uma medida de segurança para o componente.

          Não há necessidade de configurar os metadados, apenas finalize as configurações do componente e siga para a lista de dispositivos, onde o status do componente deverá ser exibido, inicialmente, como "Desconectado".

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 -----------

DEVICE_TYPE: ESP32 (Tipo de componente declarado no IBM)
DEVICE_ID:       test      (ID do componente)
TOKEN:   xxxxxxxxxxxx (Chave API )
ORG:                 ctu10j   (será os seis primeiros dígitos do link internetofthings). 

ORG de Conexão do Dispositivo

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

// Projeto Curto Circuito – ESP32: Teste de conexão IBM Watson
//-------- 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
}
          Todas as opções presente na programação poderão ser ajustadas como bem entender, porém, recomendamos que a opção "Comunicação IOT "seja mantida intacta, pois as variável terão a serventia exclusiva de conectar-se com a IBM.A troca de mensagens entre o servidor e o ESP32 irá exigir uma aplicação mínima de linguagem JSON, por exemplo, na função void loop, as mensagens enviadas ao servidor deverão ser compostas por:

String payload = "{\"d\":{\"adc\":"; // Inicia uma variável do tipo String  que irá armazenar um determinado endereço
payload += cont;                          // Atribui o valor de leitura de cont a String
payload += "}}";                            // Finaliza a variável
client.publish(eventTopic, (char*) payload.c_str() ); // Publica a String

          A função client.publish será responsável por transmitir as informações coletadas ao servidor, no caso acima, será enviada uma contagem crescente. A mensagem será composta por duas variáveis, o eventTopic[], que foi declarado no inicio da programação com o cógido "iot-2/evt/status/fmt/json", e o payload, que irá exibir a mensagem "{\d:\adc\cont}}". A junção das variáveis irá construir um evento, capaz de transmitir os valore de contagem  do ESP32 em formato JSON.  O void callback recebe e interpreta as mensagens (Payload) enviadas pelo servidor, na configuração da função foram especificados apenas dois tipos de comandos binários, "0" (if(char)payload[0] == '0'), ou "1" (if(char)payload[0] == '1'), e ambos serão utilizados no acionamento de um LED ligando em 1 (HIGH) e desligando em 0 (LOW).

Conectando ao Node-RED

          Após transferir a programação, retorne aos Dispositivos do IBM Watson e verifique se o status do componente encontra-se como "Conectado", caso contrário, será preciso alterar o nível de segurança do projeto, em "Configurações" no menu lateral e procure a opção "Segurança da Conexão".

Ajuste as opções de segurança para facilitar a conexão.


          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.

TLS opcional diminui a segurança do projeto, porém, facilita a conexão.


          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.

No instante em que a conexão for estabelecida, as informações serão ajustadas para o último status de conexão.


          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.

A URL  estará localizado ao lado do status do aplicativo.


          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. 

          O layout do Node-RED será dividido entre Paleta, com opções de nós (blocos), Área de Trabalho, utilizada na construção dos fluxos, e Configurações, ajustes e monitoramento.

O Node-RED será exibido em um navegador on-line de edição.


          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.

Conjunto de blocos para o desenvolvimento de ferramentas de controle on-line.

          Primeiramente, iremos testar a comunicação entre o servidor IBM Cloud e o ESP32, construindo um fluxo na área de trabalho, através dos nós IBM IoT Input e um Debug.

Bloco de comunicação entre o componente e a IBM

          As opções de configuração do nó IBM IoT deverão ser ajustadas da seguinte forma:


Configure o nó de acordo com o exemplo demonstrado na imagem.


          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 .

As mensagens recebidas serão exibidas por meio da opção Debug

          A visualização inicial das mensagens será apresentada de forma pouco prática,  dividindo o objeto em subtópicos. A solução deste problema estará em um nó Function, que será utilizado para construir uma função em JSON, simplificando a leitura em uma única variável. Clique duas vezes no nó e escreva: return {payload:msg.payload.d.adc}.

O nó função servirá para construir ajustes e programações em linguagem JSON.


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


O fluxo irá exibir uma versão reduzida da mensagem exibida anteriormente


          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".


A mensagem irá se ajustar, exibindo apenas a numeração enviada.



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.

A análise de hall será realizada por meio do chip do módulo WI-FI.


          O controle do LED será composto por dois nós Button do conjunto Dashboard.

As ferramentas presente em Dashboard serão exibidas no layout do aplicativo,


          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. 


O Payload de cada botão deverá ser configurado de acordo com o comando que deseja transmitir, se for 1 o LED liga, e 0 desliga.


          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.

O fluxo de comunicação entre os botões dashboard e o ESP32 será estabelecido de acordo com as configurações presente no nó IBM.


          A Configuração do nó IBM deverá seguir o seguinte padrão: 

Defina o command Type como LED, para direcionar o controle do nó para uma determinada função.


          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:


https://IOTESP32.mybluemix.net/ui

Ao acessar o endereço do aplicativo "/ui", será possível visualizar o layout real do navegador de controle do sistema.


          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.