_Negativo_pn.png)
Neste blog, vamos aplicar conhecimentos e ferramentas discutidas em outros artigos já publicados, com o objetivo de demonstrar como monitorar o nível de água e enviar os dados diretamente para uma planilha do Google.
Mostraremos como criar um sistema inteligente e eficiente que fornece informações atualizadas sobre o volume de água em tempo real. Além disso, ao enviar esses dados para uma planilha do Google, teremos uma maneira fácil e conveniente de armazenar, visualizar e analisar as informações coletadas ao longo do tempo. Esse tipo de projeto é extremamente útil em aplicações da indústria 4.0.
Se você deseja explorar uma aplicação excepcional do Google Planilhas com ESP32 e sensores, este blog é a escolha ideal para aprofundar seus conhecimentos.
Sumário
1. Conhecendo a topologia do sistema
O sistema completo é composto por um tanque equipado com um sensor, uma placa CPB32, um roteador e a integração com o Google Planilhas. Na figura a seguir, é apresentada a topologia do sistema.
Dessa forma, o sensor no tanque coleta as informações necessárias, a CPB32 realiza o processamento dos dados e, em seguida, os envia 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 os principais componentes desse sistema, começando pelo tanque. Para a construção do tanque, utilizamos um recipiente cilíndrico com um diâmetro de 14 cm e uma altura de 15 cm. Para calcular o volume de líquido no tanque, empregamos a fórmula do volume de um cilindro, que é πr²h, em que "r" representa o raio do recipiente e "h" a altura do líquido. Utilizando essa fórmula, obtemos o volume do líquido em metros cúbicos. Para convertê-lo para litros, basta multiplicar o valor por 1000, pois 1 m³ equivale a 1000 litros.
Para medir a altura do líquido no recipiente, utilizamos um sensor HC-SR04, um sensor ultrassônico capaz de medir a distância entre ele e a superfície do líquido. Na figura a seguir, é apresentado o sensor utilizado:
O sensor HC-SR04 desempenha um papel fundamental no sistema, permitindo obter leituras confiáveis e em tempo real da altura do líquido. Essas informações são cruciais para o cálculo do volume e para o monitoramento do nível de água no tanque.
O sensor foi posicionado de acordo com a figura apresentada. Para determinar a altura do líquido, é necessário conhecer a posição em que o sensor foi instalado. Com essa informação, podemos calcular a altura do líquido com base na distância entre o sensor e a superfície do líquido. Portanto, a altura do líquido é igual à altura do sensor menos a medição realizada por ele.
A CPB32 é uma placa que desenvolvemos e comercializamos. Ela é uma solução de hardware robusta que possibilita a utilização profissional do ESP32 em qualquer aplicação ou dispositivo, independentemente da área de atuação.
Neste projeto em particular, a CPB32 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.
O sensor HC-SR04 requer alimentação de 5V, enquanto o ESP32 trabalha com 3,3V. Como a CPB32 não possui uma saída de alimentação de 5V, existem duas opções para resolver essa questão.
A primeira opção é adicionar um regulador chaveado de tensão na CPB32. Esse procedimento pode ser encontrado em detalhes nesse blog.
A segunda opção é utilizar um módulo step-down externo à CPB32. Isso pode ser visualizado na figura a seguir.
Nessa configuração, o módulo step-down é alimentado pela saída de 12V da CPB32 e ajustado para fornecer 5V ao sensor. Na figura, também é possível observar quais pinos do ESP32 estão conectados aos pinos de comunicação do sensor.
A planilha do Google será principalmente utilizada para armazenar os dados coletados pelo sensor, 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 e na coluna C o volume de líquido em mililitros. Para ver todos os detalhes desse processo, incluindo todos os seus mínimos detalhes consulte esse blog. Lá você encontrará informações abrangentes sobre o processo, explicando todos os passos de forma detalhada.
2. Entendendo o firmware
Para utilizar o sensor ultrassônico HC-SR04 para medir o volume de líquido no tanque, é necessário incluir a biblioteca "afstandssensor" no código. Veja o exemplo abaixo:
#include <afstandssensor.h>Certifique-se de que a biblioteca "afstandssensor" esteja corretamente instalada em seu ambiente de desenvolvimento antes de usar. Em seguida, é necessário definir os pinos do ESP32 aos quais os pinos echo e trig do sensor estão conectados.
Agora vamos criar o objeto ultrassônico, que será utilizado para ler os dados obtidos pelo sensor.
AfstandsSensor ultrasonic(TRIGGER_PIN, ECHO_PIN);A fim de facilitar possíveis alterações futuras no código, utilizamos essas definições do tanque. Dessa forma, se for necessário alterar o recipiente, podemos facilmente adaptar o código modificando esses parâmetros. O parâmetro "altura_tanque_cm" representa o valor medido pelo sensor quando o tanque está vazio.
Por fim, declaramos a variável global "volume" em mililitros (ml), que será utilizada na hora de enviar os valores para a planilha.
int volume_ml;Dentro da função loop, realizaremos a medição e exibiremos o valor obtido no monitor serial. Para reduzir oscilações causadas pelo movimento do líquido e por ruídos, faremos 50 leituras do sensor utilizando a função "ultrasonic.afstandCM()" e calcularemos a média dessas leituras. Utilizando o código a seguir.
float altura_somatorio = 0;
float altura_cm;
float volume_l;
for (int i = 0; i < 50; i++) {
altura_somatorio = altura_somatorio + (altura_tanque_cm - ultrasonic.afstandCM());
delay(50);
}
altura_cm = altura_somatorio / 50;Como visto anteriormente, para calcular a altura do líquido precisamos realizar o seguinte cálculo:
Para realizar esse cálculo no código, utilizamos a seguinte fórmula: altura_tanque_cm - ultrasonic.afstandCM(). O valor obtido para a altura do líquido está em centímetros e é armazenado na variável "altura_cm". Para converter esse valor para metros, basta dividir por 100. Em seguida, utilizando a equação a seguir, calculamos o volume do líquido em metros cúbicos.
Para converter o volume de metros cúbicos para litros, devemos multiplicá-lo por 1000. Juntando todas essas conversões de unidades, obtemos a seguinte fórmula que foi utilizada no código.
volume_l = (3.14 * (raio_cm / 100.0) * (raio_cm / 100.0) * altura_cm) * 10.0;Após obtermos o volume em litros, podemos convertê-lo para mililitros. Essa conversão é útil para facilitar a transmissão dos dados para a planilha e evitar algumas conversões adicionais.
volume_ml = volume_l * 1000.0;
Serial.println("");
Serial.print(altura_cm);
Serial.print(" ");
Serial.println(volume_ml);
Serial.println("");Com esse código, agora é possível realizar a leitura do volume e exibi-lo no monitor serial. Para enviar os dados para a planilha, é necessário seguir as configurações e o exemplo base descritos no blog "Como publicar dados no Google Sheets usando ESP32".
Neste projeto, foi feita uma simplificação no exemplo original, uma vez que o uso das funções de multitarefa do ESP32 estava causando conflito com as leituras do sensor. Portanto, esse ponto do código foi simplificado.
É importante ressaltar um ponto específico: 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(volume_ml);Neste trecho do código, estamos montando a string para enviar a variável "volume_ml". Portanto, se você deseja alterar a variável que será enviada ou adicionar mais variáveis, é nesta 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 <HTTPClient.h>
#include <WiFi.h>
#include "string.h"
#include <afstandssensor.h>
//Define as dimenções do tanque
#define altura_tanque_cm 11.8
#define raio_cm 7
// Define os pinos do sensor HCSR04
#define TRIGGER_PIN 13
#define ECHO_PIN 15
// AfstandsSensor(triggerPin, echoPin);
AfstandsSensor ultrasonic(TRIGGER_PIN, ECHO_PIN); // Starter afstandssensoren på ben 13 og 12.
const char* ssid = " nome da rede"; // your network SSID (name of wifi network)
const char* password = "senha"; // your network password
char *server = "script.google.com"; // Server URL
char *GScriptId = "AKfycbwfgfHDJ7byKCjbxU53VmqmV6IAX2x19s7owg5lWBcWMasAY8U3Dxm1CeJCOz1WAQw";
const int httpsPort = 443;
WiFiClientSecure client;
int volume_ml;
void setup() {
Serial.begin(115200);
connect_wifi();
}
void loop() {
float altura_somatorio = 0;
float altura_cm;
float volume_l;
for (int i = 0; i < 50; i++) {
altura_somatorio = altura_somatorio + (altura_tanque_cm - ultrasonic.afstandCM());
delay(50);
}
altura_cm = altura_somatorio / 50;
volume_l = (3.14 * (raio_cm / 100.0) * (raio_cm / 100.0) * altura_cm) * 10.0;
volume_ml = volume_l * 1000.0;
Serial.println("");
Serial.print(altura_cm);
Serial.print(" ");
Serial.println(volume_ml);
Serial.println("");
enviarMedicao();
}
void connect_wifi(void)
{
Serial.print("Connecting to wifi: ");
Serial.println(ssid);
Serial.flush();
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
Serial.print(WiFi.status());
Serial.print(".");
}
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(volume_ml);
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 temos o protótipo que foi montado para a realização desse tutorial.
Vamos analisar os resultados exibidos no monitor serial. Na figura a seguir, é possível observar que o ESP32 estabelece com sucesso a conexão com a rede WiFi e exibe o endereço IP correspondente. Em seguida, são apresentados o valor da altura do líquido, em centímetros, e o volume, em mililitros. Por fim, é indicado que a escrita na planilha foi realizada com êxito.
No Google Planilhas, temos a capacidade de manipular esses dados de várias maneiras. Aqui, vamos apresentar um gráfico que ilustra o nível de água no tanque. Na figura a seguir, o eixo X representa o horário e o eixo Y representa o volume de água em mililitros.
Uma vez que os dados são inseridos na planilha, temos a capacidade de realizar uma variedade de cálculos e gerar diversos relatórios. Podemos analisar o consumo de água diário, mensal ou anual, calcular os gastos associados, estimar os consumos futuros com base nos dados históricos e explorar muitas outras aplicações.
Embora tenhamos utilizado o exemplo do nível de água, esse tipo de projeto pode ser aplicado em diversas áreas. E o mais importante é o baixo custo envolvido, uma vez que todo o armazenamento e processamento dos dados são realizados pelo Google gratuitamente para os usuários.
Autor: Thales Ferreira