A análise de condições climáticas atua em benefício da qualidade de vida, auxiliando em plantações, sistemas hídricos, e até mesmo na prevenção de doenças humanas. Anteriormente, desenvolvemos uma ferramenta de estudo meteorológico através do IBM Cloud e Node-RED, armazenando as informações coletadas em um navegador web com host particular. Nesse post iremos explorar a construção de tal projeto através das ferramentas disponíveis pelo Blynk, transmitindo o controle e monitoramento sem fio de um ESP32 a uma plataforma mobile.
Circuito Elétrico
Para concluir as atividades desse post, tenha em mãos os seguintes componentes:
- Placa DOIT ESP32 - ESP-WROOM-32 - WiFi / Bluetooth;
- Resistor 330R 1/4W - 5%;
- Led Alto Brilho RGB - 5mm;
- Kit Jumper Macho Macho;
- Protoboard 400 Pontos;
- Sensor de Pressão BMP 280;
- Módulo DHT- Sensor de Temperatura;
- Sensor de Chuva;
- Conversor AC/DC 90~240 VAC - 5VDC/1A - JP4;
- Fonte 12V - 5V/3,3V p/ Protoboard.
Você pode compra-los clicando nos links acima ou visitando nosso site: www.curtocircuito.com.br.
A construção do circuito elétrico irá exigir um valor de correte elétrica maior do que o fornecido internamente em placas DOIT ESP32, portanto, iremos utilizar uma fonte de Protoboard como meio de fornecer uma alimentação externa para o projeto. A tensão de saída da fonte poderá ser ajustada entre 5V e 3,3V de acordo com a posição dos plugs amarelos, destacados na imagem abaixo, e no caso desse projeto, iremos ajusta-la em 5V. A fonte de Protoboard possui polaridade, portanto verifique os polos atentamente antes de conectá-los ao Protoboard.
LEDs RGB possuem quatro terminais, sendo três responsáveis por emitir as cores e um (o maior entre eles) a polaridade. A alimentação do LED será dividida entre Ánodo ou Catodo comu, se for anodo conecte a fileira positiva, se for catodo na fileira negativa.
Encaixe o LED no Protoboard, conectando os resistores de 330 Ω entre os pinos do LED e as portas digitais D02, D04 e D23 do ESP32, e alimente o pino maior de acordo com o tipo de LED.
Sensor de Chuva
Este componente emite leituras analógicas e digitais, ao entrar em contato com água, possibilitando diferenciar um chuvisco de uma tempestade. A leitura digital irá identificar a presença de água sob as hastes metálicas do sensor, alternando entre 0 e 1, enquanto o valor analógico permite analisar a intensidade, variando de 0 á 4095. A pinagem do componente será divida da seguinte maneira:
A leitura analógica será limitada a alguns terminais ao acionar o módulo Wi-Fi, sendo essas as portas ADC1 32, 33, 34, 35, 36 e 39. Encaixe os pinos GND e VCC nas fileiras de alimentação do Protoboard, o terminal D0 do sensor na porta digital D12 e o A0 na porta VP.Como a largura de um único protoboard mostra-se insuficiente para acoplar um ESP32, recomendamos a junção de duas placas.
Os valores do sensor serão interpretados de forma decrescente, ou seja, quanto menor for a leitura analógica, maior será o volume da chuva. Para testar o funcionamento do sensor utilize o seguinte exemplo:
/* Projeto Curto Circuito - ESP32: Sensor de Chuva */
/* Sensor de Chuva - Pinagem e variáveis */
int pino_d = 12; /* Pino ligado ao D0 do sensor */
int pino_a = 36; /* Pino ligado ao A0 do sensor */
int val_d = 0; /* Armazena o valor lido do pino digital */
int val_a = 0; /* Armazena o valor lido do pino analógico */
/* LED */
int pin = 2; /* Vermelho Pino D2 do ESP32 */
int pin2 = 4; /* Azul Pino D4 do ESP32 */
void setup()
{
Serial.begin(9600);
/* Sensores INPUT */
pinMode(pino_d, INPUT);
pinMode(pino_a, INPUT);
/* LEDs OUTPUT */
pinMode(pin, OUTPUT);
pinMode(pin2, OUTPUT);
}
void loop()
{
/* Armazena os valores de leitura */
val_a = analogRead(pino_a);
/* Se a leitura analógica for menor que 300 */
if ( val_a < 1000)
{ /* Chuva intensa */
digitalWrite(pin, 0); /* Desliga */
digitalWrite(pin2, 1); /* Liga */
Serial.println("Chuva Intensa");
Serial.println(val_a );
}
/* Se a leitura analógica for menor que 500 e maior que 300 */
if (val_a <= 3000 && val_a >= 1000)
{ /* Chuva moderada */
digitalWrite(pin, 1); /* Liga */
digitalWrite(pin2, 1); /* Liga */
Serial.println("Chuva Moderada ou Chuvisco");
Serial.println(val_a );
}
/* Se a leitura analógica for maior que 500 */
if ( val_a > 4000)
{ /* Sem previsão de Chuva */
digitalWrite(pin, 1); /* Liga */
digitalWrite(pin2, 0); /* Desliga */
Serial.println("Sem previsão de chuva");
Serial.println(val_a );
}
}
Módulo DHT22
A pinagem do sensor será distribuída de acordo com a imagem seguir, sendo a alimentação lógica entre 3,3 á 5 V, o ENB deverá ser isolado, ou seja, não será conectado a nenhum terminal, e o píno OUT será o sinal de leitura, que no caso do sensor comum de quatro terminais deverá ser acompanhado por um resistor de aproximadamente 10KΩ.
Caso tenha optado por utilizar o módulo conecte os pinos de alimentação no Protoboard, e o pino OUT na porta D14.
Se optou pelo modelo comum de quatro terminais, conecte os pinos de alimentação nas fileiras do protoboard, um resistor de 10KΩ entre a porta digital D3 e o pino 2 do sensor, um jumper entre o resistor e polo positivo do Protoboard, e pino ENB deverá ser isolado.
Recomendamos instalar a biblioteca “DHT sensor library”, como meio de auxilio no desenvolvimento de futuros projetos referente a este componente, que pode ser facilmente instalada através do Gerenciador de Bibliotecas da IDE do software Arduino;
Utilize o exemplo apresentado abaixo como meio de testar o funcionamento do módulo:
/* Projeto Curto Circuito – ESP32: DHT22 Teste */
#include "DHT.h" /* Inclui a biblioteca DHT */
#define DHTPIN 13 /* Define que OUT será conectado em D13 */
#define DHTTYPE DHT22 /* Define o modelo de sensor como DHT 22 */
/* DHT irá interpretar os valores de leitura do pino de acordo com o tipo de sensor */
DHT dht(DHTPIN, DHTTYPE);
void setup()
{
Serial.begin(9600); /* Taxa de transmissão 9600 dBs */
dht.begin(); /* Taxa de transmissão do sensor */
}
void loop()
{
delay(2000); /* Intervalo de 2 segundos entre as leituras */
/* Indica a Umidade (%) */
float h = dht.readHumidity();
/* Indica a temperatura em Celsius (°C) */
float t = dht.readTemperature();
/* Escreve os valores de leitura no monitor serial */
Serial.print("Umidade: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperatura: ");
Serial.print(t);
Serial.print(" *C ");
}
A biblioteca DHT trará consigo algumas funções próprias que irão simplificar a coleta de leituras climáticas, em dht.readHumidity() iremos obter os valores referentes a umidade, enquanto o dht.readTemperature() nos fornecerá a temperatura ambiente. Em # DHTTYPE, definimos o tipo de sensor DHT que será atribuído a programação, sendo eles divididos entre: DHT11, DHT21, DHT22.
BMP280
O módulo BMP 280 será utilizado para obter leituras referentes à Altitude, Pressão e Temperatura, com precisão de 1% e tempo de resposta em aproximadamente dois segundos. A faixa de leitura da temperatura será similar ao apresento pelo módulo DHT22, a pressão será de 30000 á 110000 Pa (Pascal), e a altitude de 100000 á 100 m (metros).
Para adiciona-lo ao circuito, conecte os pinos de alimentação no Protoboard, SCK na porta D4, SDA porta D5, CS porta D18, e SDO porta D19.
Adicione a biblioteca “Adafruit BMP280 Library”, que poderá ser facilmente instalada através do Gerenciador de Bibliotecas da IDE do software Arduino.
As leituras de pressão variam de acordo com a altitude e as condições de temperatura no ar, quanto maior for a altitude em relação ao mar, menor será a pressão. A proporção de comparação do nível do mar poderá ser dada pelos seguintes valores:
/* Projeto Curto Circuito – ESP32: BMP280 teste */
/*---Bibliotecas--- */
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BMP280.h>
/*---BMP Pinagem--- */
#define BMP_SCK 4
#define BMP_SDI 5
#define BMP_CS 18
#define BMP_SDO 19
Adafruit_BMP280 bmp280(BMP_CS, BMP_SDI, BMP_SDO, BMP_SCK);
void setup()
{
Serial.begin(9600);
bmp280.begin();
}
void loop()
{
/* Temperatura em Celsius */
Serial.print("Temperature = ");
Serial.print(bmp280.readTemperature());
Serial.println(" *C");
/* Pressão em Pascal */
Serial.print("Pressure = ");
Serial.print(bmp280.readPressure());
Serial.println(" Pa");
/* Altitude em Metros */
Serial.print("Approx altitude = ");
Serial.print(bmp280.readAltitude(1013.25));
Serial.println(" m");
Serial.println();
delay(2000);
}
/*---BMP Pinagem---*/
#define BMP_SCK 4
#define BMP_SDI 5
#define BMP_CS 18
#define BMP_SDO 19
A função Adafruit_BMP280 bmp280, cria uma variável responsável por interpretar a leitura nos pinos de comunicação, para realizar a leitura das condições climáticas, basta aplicar as funções readTemperature, readPressure, que funcionarão de forma similar a ferramentas como digitalWrite ou analogWrite, ou readAltitude(1013.25), que irá utilizar um cálculo simples de conversão dos valores em metros.
Programação
/* Projeto Curto Circuito – ESP32 & Blynk: Análise Meteorológica */
/*-------- Bibliotecas ----------- */
#define BLYNK_PRINT Serial
#include "DHT.h" /* DHT */
#include <BlynkSimpleEsp32.h> /* Blynk-ESP32 */
#include <Adafruit_BMP280.h>
#include <SPI.h>
#include <WiFi.h> /* Wi-Fi */
#include <WiFiClient.h> /* Wi-Fi client */
/* -------- DHT 22 ----------- */
#define DHTTYPE DHT22 /* Tipo DHT 22, AM2302, AM2321 */
#define DHTPIN 12 /* Pino 12 (GP12) */
DHT dht(DHTPIN, DHTTYPE);
/*-------- Token de Autenticação ----------- */
char auth[] = " TOKEN_DE_AUTENTICAÇÃO"; /* Coloque aqui o código de Token */
/*-------- Configurações de Wi-fi ----------- */
const char* ssid = "NOME_DA_REDE"; /* Nome da rede Wi-Fi */
const char* password = "SENHA"; /* Senha da rede */
/*-------- Sensor bmp280 -------- */
#define BMP_SCK 4
#define BMP_SDI 5
#define BMP_CS 18
#define BMP_SDO 19
Adafruit_BMP280 bmp280(BMP_CS, BMP_SDI, BMP_SDO, BMP_SCK);
/*-------- Sensor de Chuva-------- */
#define pino_d 2
#define pino_a 36
int val_a = 0;
int val_d = 0;
BlynkTimer timer;
void sendSensor()
{
float h = dht.readHumidity(); /* Armazena a leitura da umidade em “h” */
float t = dht.readTemperature();/* Armazena a leitura da umidade em “t” */
float p = bmp280.readPressure();
float a = bmp280.readAltitude(1013.25);
val_a = analogRead(pino_a); /* Armazena os valores de leitura do sensor de Chuva */
Blynk.virtualWrite(V5, h); /* Umidade porta virtual V5 */
Blynk.virtualWrite(V2, t); /* Temperatura porta virtual V2 */
Blynk.virtualWrite(V3, p); /* Pressão porta virtual V3 */
Blynk.virtualWrite(V9, a); /* Altitude porta virtual V9 */
Blynk.virtualWrite(V10, val_a); /* Chuva porta virtual V10 */
}
void setup()
{
Serial.begin(115200);
bmp280.begin(); /* bmp280 */
dht.begin(); /* DHT */
Blynk.begin(auth, ssid, password); /* TOKEN+REDE+SENHA */
timer.setInterval(1000L, sendSensor);
}
void loop()
{
timer.run();
Blynk.run();
}
Os sensores serão declarados da mesma forma que foram apresentado nos exemplo anteriores, o único diferencial será para enviar as informações de leitura, que deverão ser armazenadas em portas virtuais do aplicativo, através da função Blynk.virtualWrite. Na programação utilizamos os seguintes pinos virtuais:
Blynk.virtualWrite(V3, p);
Blynk.virtualWrite(V9, a);
Blynk.virtualWrite(V10, val_a);
Blynk
Instale em algum dispositivo mobile o aplicativo Blynk (disponível gratuitamente para plataformas IOS e Android), clique em NEW Project e selecione o tipo de sistema/placa que estará utilizando, no caso desse projeto "ESP32 Dev Board".
Na tela inicial do aplicativo, clique em , procure pela ferramenta Gauge e adicione uma unidade, que será aplicado a leitura da umidade.
Nas configurações de cada Gauge ajuste os seguintes parâmetros:
Retorne ao menu de ferramentas e adicione um objeto SuperChart, este será utilizado na exibição das informações em gráficos.
Nas opções de configuração construa um tópico para cada informação que deseja inserir no gráfico (Temperatura, Umidade e Pressão). Procure colocar cores diferentes em cada tópico.
Clique no botão e acesse as opções de formatação do gráfico. Configure os parâmetros de cada tópico como mostra o exemplo da imagem a seguir:
Em modo AUTO os valores serão ajustados automaticamente em tempo real, porém, em alguns casos, como a temperatura e a umidade, será melhor definir um ponto mínimo/máximo de leitura.
Adicione uma barra de progresso Level H, e configure-o com a finalidade de exibir a leitura do sensor de chuva. O senso interpreta valores abaixo de 2000 como chuva, portanto, a melhor forma de visualizar essa barra será colocar a ordem de leitura de forma decrescente de 4000 á 0.
Adicione duas ferramentas button para controlar as cores do LED RGB, infelizmente não será possível controlar as três cores nesse caso, pois o valor de 2000 energias será insuficiente.
Pressione o botão , iniciando o funconamento do aplicativo. Em poucos instantes as ferramentas irão exibir as informações coletadas nos respectivos sensores. A conexão entre o Blynk e p ESP32 costuma ser imediata, caso haja algum problema, verifique se as informações de Wi-Fi e Token foram adicionadas corretamente na programação.
Considerações Finais
O gráfico SuperChart permitirá a visualização dos dados coletados, tanto em tempo real, quanto a horas e dias atrás, demonstrando assim que a plataforma possui um armazenamento de informações na nuvem. E mesmo com um valor limite para a construção de aplicativos gratuitos, foi possível transmitir a leitura de todos os sensores de forma clara e objetiva, gerando assim uma estação meteorológica mobile completa. O Blynk também permite a reciclagem de ferramentas, por exemplo, se quiser trocar o layout desse projeto, substituir ou adicionar funções, basta clicar no objeto e arrasta-lo ao canto superior da tela, o item será deletado, e o saldo referente ao mesmo será retornado, possibilitando que o usuário explore outras opções como Bluetooth, MQTT, envio de notificações por e-mail, redes sociais, etc. O compartilhamento e publicação dos aplicativos particulares também irá consumir parte do dinheiro virtual, sendo praticamente preciso adquirir um pequeno saldo, porém, não há necessidade caso queira manter apenas em um único celular.