Análise climática com ESP32 e Blynk

          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.

          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

          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 #define 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).

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

 

          As funções timer.run() e Blynk.run(), servirão para criar um bloqueio, impedindo que qualquer coisa aconteça fora das funções Blynk e Timer.  A timer.setInterval(1000L, sendSensor), faz parte da função Timer, e realiza a tarefa de direcionar a leitura para o void sendSensor(). Enquanto o Blynk.begin(auth, ssid, password), será responsável por manter a conexão entre o aplicativo e o circuito.

 

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

          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.