_Negativo_pn.png)
Neste blog, vamos aplicar os conhecimentos e ferramentas discutidos em artigos anteriores, com o objetivo de demonstrar como ler dados de dois sensores (utilizando RS485) e enviá-los diretamente para uma planilha do Google.
Será apresentado como criar um sistema que fornece informações atualizadas sobre a temperatura de um líquido, bem como a temperatura e umidade do ambiente em tempo real. Além disso, esses dados serão enviados para uma planilha do Google, proporcionando uma maneira fácil e conveniente de armazenar, visualizar e analisar as informações coletadas ao longo do tempo. Esse tipo de ferramenta é extremamente útil em projetos da Indústria 4.0.
Se o seu desejo é fazer um projeto utilizando o Google Planilhas com ESP32 e sensores, este blog é a escolha ideal para você.
Sumário
1. Conhecendo a topologia do sistema
O projeto é composto por um tanque com água, sensores PT100 e XY-MD02, juntamente com uma CPB32h, um roteador e a integração com a planilha do Google. Na figura a seguir, podemos visualizar a topologia completa do sistema.
Com essa topologia a CPB32h pode medir a temperatura da água no tanque utilizando o PT100 e ao mesmo tempo a temperatura e umidade do ambiente utilizando o XY-MD02. Os dados são processados e em seguida enviados via Wi-Fi para a planilha do Google, garantindo uma comunicação eficiente e contínua entre os dispositivos.
Agora vamos examinar com mais detalhes cada componente do nosso sistema. Para medir a temperatura da água, estamos utilizando um PT100 juntamente com o módulo PTA8D08. Na figura a seguir podemos ver os dois componentes.
O PTA8D08 destaca-se como um módulo robusto, especialmente projetado para aplicações industriais, capacitando para leitura de até 8 sensores de temperatura PT100. Sua comunicação é estabelecida por meio de RS485, utilizando o protocolo MODBUS. Para ver mais informações sobre ele e um exemplo de aplicação recomendamos que veja este artigo do nosso blog.
Para medir a temperatura e umidade ambiente, utilizamos o sensor XY-MD02. Este sensor incorpora internamente o sensor de temperatura e umidade SHT20, reconhecido no setor de desenvolvimento pela sua qualidade e confiabilidade dos dados fornecidos durante a operação. Você pode visualizar o XY-MD02 na figura a seguir.
O sensor XY-MD02 utiliza comunicação através do protocolo RS485, seguindo as normas do padrão industrial Modbus. Para obter mais informações sobre ele e ver um exemplo de aplicação, recomendamos que acesse este artigo em nosso blog.
Como ambos os sensores utilizam RS485 e seguem as regras do protocolo Modbus, é possível conectá-los em paralelo no barramento da comunicação RS485. Diante disso, optou-se por utilizar a CPB32h, uma solução em hardware robusta e qualificada que permite a integração profissional do ESP32 em qualquer produto ou equipamento, independentemente da área de atuação. A CPB32h possui, por padrão, o hardware necessário para comunicação via RS232, mas podemos facilmente modificá-la para operar com RS485. Para fazer essa alteração de RS232 para RS485, consulte o item 4.5 do manual da CPB32h disponível neste link.
Neste projeto em particular, a CPB32h terá a responsabilidade de realizar a leitura do sensor, processar os valores obtidos, efetuar os cálculos necessários e enviar os dados para a planilha do Google. A figura a seguir ilustra a placa em questão.
Na figura a seguir podemos ver como foi feita a ligação dos sensores com a CPB32h.
A planilha do Google será utilizada para armazenar os dados coletados pelos sensores, juntamente com as respectivas datas e horários das leituras. No entanto, ela também pode ser utilizada para visualização e processamento desses valores. Na figura a seguir, é possível ver como os dados serão salvos na planilha.
Na coluna A da planilha, temos a data registrada; na coluna B, o horário; na coluna C, a temperatura ambiente; na coluna D, a umidade ambiente; e, por fim, na coluna E, a temperatura da água. Para ver como configurar a planilha, incluindo todos os mínimos detalhes de como enviar os dados para ela consulte este blog.
2. Entendendo o firmware
Primeiro, vamos compreender a comunicação dos sensores com o ESP32. Para isso, é necessário utilizar a biblioteca ModbusMaster, que contém todas as funções essenciais para implementar o protocolo MODBUS. A seguir, veja o código necessário para incluí-la no firmware:
#include <ModbusMaster.h>
Também é necessário informar o pino utilizado para definir a direção da comunicação RS485 e criar um objeto da classe ModbusMaster para cada dispositivo conectado à rede, conforme mostrado a seguir:
#define MAX485_dir 2
ModbusMaster xymd02;
ModbusMaster pta8d08;
O ESP32 irá comunicar-se com o MAX485 utilizando a Serial 2. Portanto, dentro da função setup, devemos inicializar esta porta usando o seguinte código:
Serial2.begin(9600);
Para utilizar o MAX485 junto com a biblioteca ModbusMaster, é necessário definir as funções que serão executadas antes e depois de uma transmissão. No caso, para estabelecer a direção da comunicação, criamos as seguintes funções:
void preTransmission() {
digitalWrite(MAX485_DIR, 1);
}
void postTransmission() {
digitalWrite(MAX485_DIR, 0);
}
Essas funções serão utilizadas na hora de inicializar cada um dos dispositivos da rede MODBUS. A seguir, podemos ver como é feita a inicialização de cada um dos dispositivos.
xymd02.begin(1, Serial2);
pta8d08.begin(0, Serial2);
xymd02.preTransmission(preTransmission);
xymd02.postTransmission(postTransmission);
pta8d08.preTransmission(preTransmission);
pta8d08.postTransmission(postTransmission);
Primeiramente, utilizamos a função "begin" para informar o endereço do dispositivo e a porta serial utilizada para comunicação. Em seguida, especificamos as funções que serão executadas antes e depois de uma transmissão.
Dentro da função "loop", realizamos a leitura de cada um dos sensores, armazenando os valores recebidos nas variáveis correspondentes a cada um deles. Após cada leitura, o programa envia o valor obtido para a planilha do Google. Para obter mais detalhes sobre como é feita a leitura de cada sensor, recomendamos que consulte os blogs específicos sobre o XY-MD02 e o PTA8D08.
Agora, vamos ver como enviar os dados para a planilha do Google. Primeiramente, devemos declarar as bibliotecas necessárias e realizar as configurações para o funcionamento da comunicação WiFi. As bibliotecas utilizadas são:
E as configurações são feitas da seguinte forma:
const char* ssid = "nome da rede";
const char* password = "senha";
char *server = "script.google.com";
char *GScriptId = "AKfycbz6OQACa2p6J0aio2t6s5hC_yjIPRhHi82jYm7JYkT24PIV3mfycbhsOUmgUm90YnJlHw";
const int httpsPort = 443;
WiFiClientSecure client;
Para conectar o ESP32 à rede, devemos chamar a função "connect_wifi" dentro da função "setup". Mais detalhes sobre a função "connect_wifi" podem ser vistos no código completo ao final dessa seção.
Agora, é necessário seguir as configurações e o exemplo base descritos no blog "Como publicar dados no Google Sheets usando ESP32". Neste projeto, fizemos uma simplificação no exemplo original para facilitar o entendimento. É importante ressaltar que, para realizar o envio dos dados, basta chamar a função "enviarMedicao()". Dentro dessa função, temos a seguinte linha de código:
String url = String("https://script.google.com") + "/macros/s/" + GScriptId + "/exec?" + "&value1=" + String(temp_ambiente) + "&value2=" + String(umidade) + "&value3=" + String(temp_pt100);Neste trecho do código, estamos montando a string para enviar as variáveis "temp_ambiente", "umidade" e "temp_pt100". Portanto, se você deseja alterar a variável que será enviada ou adicionar mais variáveis, é neste ponto da função que você deve fazer as alterações necessárias.
Além disso, é fundamental configurar corretamente a planilha que receberá os dados. Para obter as instruções de configuração, consulte o blog original, pois sem essa configuração adequada, o código exemplo fornecido neste blog não funcionará corretamente.
A seguir, apresento o código completo do projeto e, em seguida, os resultados obtidos:
#include <ModbusMaster.h>
#include <HTTPClient.h>
#include <WiFi.h>
#include "string.h"
#define MAX485_dir 2
ModbusMaster xymd02;
ModbusMaster pta8d08;
const char* ssid = "nome da rede";
const char* password = "senha";
char *server = "script.google.com";
char *GScriptId = "AKfycbz6OQACa2p6J0aio2t6s5hC_yjIPRhHi82jYm7JYkT24PIV3mfycbhsOUmgUm90YnJlHw"; //planilha teste
const int httpsPort = 443;
WiFiClientSecure client;
float temp_ambiente, umidade, temp_pt100;
void preTransmission() {
digitalWrite(MAX485_dir, 1);
}
void postTransmission() {
digitalWrite(MAX485_dir, 0);
}
void setup() {
// Initialize control pins
pinMode(MAX485_dir, OUTPUT);
digitalWrite(MAX485_dir, 0);
Serial.begin(115200);
connect_wifi();
Serial2.begin(9600);
xymd02.begin(1, Serial2);
pta8d08.begin(0, Serial2);
// Callbacks allow us to configure the RS485 transceiver correctly
xymd02.preTransmission(preTransmission);
xymd02.postTransmission(postTransmission);
// Callbacks allow us to configure the RS485 transceiver correctly
pta8d08.preTransmission(preTransmission);
pta8d08.postTransmission(postTransmission);
}
void loop() {
Serial.println("______________Data Requested______________");
Serial.println("");
uint8_t result1 = pta8d08.readHoldingRegisters(0x0000, 1);
if (result1 != pta8d08.ku8MBSuccess) {
Serial.println("Erro na leiura do PTA8D08");
}
if (result1 == pta8d08.ku8MBSuccess) {
// Get response data from sensor
Serial.print("Temperatura PTA8D08: ");
Serial.println(float(pta8d08.getResponseBuffer(0) / 10.00F));
temp_pt100 = float(pta8d08.getResponseBuffer(0) / 10.00F);
}
delay(1000);
uint8_t result2 = xymd02.readInputRegisters(0x0001, 2);
if (result2 != xymd02.ku8MBSuccess) {
Serial.print("Erro na leiura do XY-MD02 ");
Serial.println(result2);
}
if (result2 == xymd02.ku8MBSuccess) {
Serial.print("Temperatura XY-MD02: ");
Serial.print(float(xymd02.getResponseBuffer(0)));
temp_ambiente = float(xymd02.getResponseBuffer(0) );
Serial.print(" Umidade XY-MD02: ");
Serial.println(float(xymd02.getResponseBuffer(1) ));
umidade = float(xymd02.getResponseBuffer(1) );
}
Serial.println("");
enviarMedicao();
delay(10000);
}
void connect_wifi(void)
{
Serial.print("Connecting to wifi: ");
Serial.println(ssid);
Serial.flush();
WiFi.begin(ssid, password);
int cont_wifi = 0;
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
Serial.print(".");
cont_wifi++;
if (cont_wifi > 50) {
ESP.restart();
}
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
void enviarMedicao()
{
HTTPClient http;
String url = String("https://script.google.com") + "/macros/s/" + GScriptId + "/exec?" + "&value1=" + String(temp_ambiente) + "&value2=" + String(umidade) + "&value3=" + String(temp_pt100);
Serial.print("Making a request");
http.begin(url.c_str()); //Specify the URL and certificate
http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
int httpCode = http.GET();
String payload;
if (httpCode > 0) { //Check for the returning code
payload = http.getString();
Serial.println(httpCode);
Serial.println(payload);
// testdrawstyles(payload);
//if (httpCode == 200 or httpCode == 201) tempPing.Saida(0);
}
else {
Serial.println("Error on HTTP request");
}
http.end();
}3. Resultados
Na figura a seguir podemos ver uma foto da montagem feita para a realização deste projeto.
No monitor serial, é possível observar que o ESP32 consegue se conectar com sucesso à rede WiFi. Em seguida, os valores de temperatura e umidade obtidos dos sensores são apresentados. Por fim, é indicado que a escrita na planilha foi realizada corretamente.
No Google Planilhas, temos a capacidade de manipular esses dados de várias maneiras. Aqui, vamos apresentar um gráfico que ilustra temperatura e umidade ambiente, bem como a temperatura do líquido. Na figura a seguir, o eixo X representa o horário e o eixo Y representa os valores medidos.
No gráfico temos em laranja a umidade (em porcentagem), em azul a temperatura ambiente (em graus célsius) e em amarelo a temperatura da água (em graus célsius).
Após a introdução dos dados na planilha, adquirimos a habilidade de executar uma variedade de cálculos e criar diferentes relatórios. Podemos examinar a taxa de aumento da temperatura do líquido, avaliar a eficácia de materiais isolantes, acompanhar a temperatura em tempo real, fazer projeções de valores futuros com base em dados históricos, e explorar diversas outras aplicações.
Apesar de termos utilizado a leitura de sensores de temperatura, esse tipo de projeto pode ser implementado em várias áreas. O aspecto mais relevante é a economia de custos, visto que todo o armazenamento e processamento de dados são conduzidos gratuitamente pelo Google para os usuários.
Autor: Thales Ferreira
