Controle Automático de Umidificador usando ESP32/8266

Pessoal, hoje eu resolvi mostrar aqui para vocês um projeto que, na verdade, fiz pra usar na minha própria casa. Eu tenho um umidificador de ar e, ora ele deixa o ambiente seco demais, ora deixa até o piso molhado ao redor dele. Foi, então, que pensei: uso tanto o DHT em tudo, então, por que não fazer um controle automático de umidade? Foi o que fiz e vou te passar neste vídeo: como fazer um ESP32 ler a umidade e mostrá-la em um display Oled. Ainda, baseado na umidade, o ESP32 vai, através do protocolo ESP-NOW, enviar sinal para um ESP8266 ligar ou desligar o relé.

Uma dica é que, neste mesmo projeto, como já mostrei em outros vídeos, você também pode ler a temperatura do ambiente.

Loop

Neste fluxograma explicamos cada passo do projeto:

1º - ESP32 lê a umidade.

2º - Mostra umidade no display

3º - Verifica umidade:

- Abaixo do limite inferior: envia Sinal para o ESP8266 ligar o relé

- Acima do limite superior: envia Sinal para o ESP8266 desligar o relé

ESP32 Pinout

Montagem

Demonstração

Na demonstração que temos no vídeo, o Led está aceso porque a umidade está em 45%. Porém, quando eu sopro e a umidade vai a 93%, esse Led apaga. Isso é apenas para mostrar que, quando a umidade fica acima de 60%, o Led é apagado. Temos, então, o ESP8266 e o ESP32 montados sobre uma placa padrão. O ESP32 está conectado ao DHT e ao display Oled.

Biblioteca SimpleDHT

Na IDE do Arduino vá em Sketch->Incluir Biblioteca->Gerenciar Bibliotecas...

Instale SimpleDHT

Biblioteca U8g2

Na IDE do Arduino vá em Sketch->Incluir Biblioteca->Gerenciar Bibliotecas...

Instale U8g2

ESP32_EspNow_Master.ino

Sugiro que, antes de fazer este projeto, você assista este vídeo que eu já gravei de ESP-NOW: ESP32 COM PROTOCOLO ESP-NOW.

Para iniciar, aqui vamos incluir as bibliotecas e fazer a definição dos pinos. Instanciamos o objeto display, o objeto que realiza a leitura da umidade, apontamos o array que está aguardando o MacAdress, e criamos a variável que guarda o valor da umidade.

#include <esp_now.h>
#include <WiFi.h>
#include <SimpleDHT.h>
#include <U8x8lib.h>

#define DHTPIN 4
#define MAX_HUMIDITY 60
#define MIN_HUMIDITY 50
#define INTERVAL 10000
#define ESPNOW_CHANNEL 1

//SDA = 21 e SCL = 22
U8X8_SSD1306_128X64_NONAME_SW_I2C display(SCL, SDA, U8X8_PIN_NONE);

uint8_t slaveMacAddress[] = {0x1A,0xFE,0x34,0xA5,0x90,0x69};
esp_now_peer_info_t slave;

//Objeto que realiza a leitura da umidade
SimpleDHT22 dht;

//Variável para guardarmos o valor da umidade
float humidity = 0;

ESP32_EspNow_Master.ino – setup

No Setup, tenho um alerta: se você não der WiFi.disconnect o circuito fica instável, pois quando você faz isso, ele limpa qualquer informação anterior que tinha na memória.

void setup() {
  Serial.begin(115200);
  WiFi.disconnect();
  WiFi.mode(WIFI_STA);
  setupDisplay();
  setupESPNow();
  setupSlave();
}

ESP32_EspNow_Master.ino – loop

No Loop, fazemos a leitura do sensor e expomos os dados no display.

void loop() {
  readSensor();
  showOnDisplay();
  verifyHumidity();
  delay(INTERVAL);
}

ESP32_EspNow_Master.ino – setupDisplay

Aqui detalhamos as funções: inicializamos o display e configuramos alguns parâmetros. Iniciamos o modo powerSave e definimos a fonte a ser utilizada no display.

void setupDisplay(){
  //inicializa o display e configura alguns parâmetros
  display.begin();
  display.setPowerSave(0); //modo powerSave (0-Off ? 1-On)
  display.setFont(u8x8_font_torussansbold8_u); //fonte utilizada
}

ESP32_EspNow_Master.ino – setupESPNow

Determinamos aqui o que será impresso no display em caso de inicialização bem sucedida ou com algum tipo de erro. Neste último caso, após informar o seu estado, ele reinicia o ESP.

void setupESPNow() {
  //Se a inicialização foi bem sucedida
  if (esp_now_init() == ESP_OK) {
    Serial.println("ESPNow Init Success");
  }
  //Se houve erro na inicialização
  else {
    Serial.println("ESPNow Init Failed");
    ESP.restart();
  }
}

ESP32_EspNow_Master.ino – setupSlave

Definimos aqui o canal, copiamos o endereço do array para a estrutura do slave e adicionamos o slave.

void setupSlave(){
  slave.channel = ESPNOW_CHANNEL;
  //0 para não usar criptografia ou 1 para usar
  slave.encrypt = 0;
  //Copia o endereço do array para a estrutura do slave
  memcpy(slave.peer_addr, slaveMacAddress, 6);
  //Adiciona o slave
  esp_now_add_peer(&slave);
}

ESP32_EspNow_Master.ino – sendRelayStatus

Passo aqui um argumento que é o status do relé. Neste caso, especificamente, o meu era o Led. Ele exibe, então, se a ação foi bem sucedida ou deu erro.

void sendRelayStatus(int relayStatus){
  esp_err_t result = esp_now_send(slaveMacAddress, (uint8_t*)&relayStatus, 1);
  Serial.print("Send Status: ");

  if (result == ESP_OK) {
    Serial.println("Success");
  } 
  else {
    Serial.println("Error");
  }
}

ESP32_EspNow_Master.ino - verifyHumidity

Nesta fase é que verificamos se a umidade está fora dos limites e informamos ao ESP8266 se o relé deve ficar ligado ou desligado.

//Verifica se a umidade está fora dos limites e informa ao ESP8266 
//se o relê deve ficar ligado ou desligado
void verifyHumidity(){
  if(humidity > MAX_HUMIDITY)
  {
    Serial.println("Umidade máxima atingida, enviando sinal para desligar o relê");
    sendRelayStatus(LOW);
  }
  else if(humidity < MIN_HUMIDITY)
  {
    Serial.println("Umidade mínima atingida, enviando sinal para ligar o relê");
    sendRelayStatus(HIGH);
  }
}

ESP32_EspNow_Master.ino – readSensor

Função responsável por realizar a leitura da umidade.

//Função responsável por realizar a leitura 
//da umidade
void readSensor(){
  float h;
  int status = dht.read2(DHTPIN, NULL, &h, NULL);
 
  if (status == SimpleDHTErrSuccess) {
    humidity = h;
  }
}

ESP32_EspNow_Master.ino – showOnDisplay

Mostramos a umidade no display.

//Mostra a umidade no display
void showOnDisplay(){
  String strHumdity = "HUMIDITY: " + String(humidity);
  display.clearLine(0);
  display.drawString(0, 0, strHumdity.c_str());
}

ESP8266_EspNow_Slave.ino

No Setup do ESP8266 ESP-Now, temos uma nova biblioteca para incluir, as chamadas de funções, no entanto, são iguais. Também colocamos a ESP8266WiFI.h e definimos o 5 como pino de relé.

extern "C" {
  #include <espnow.h>
}

#include <ESP8266WiFi.h>
#define RELAY_PIN 5

ESP8266_EspNow_Slave.ino - setup

Colocamos o pino do relé como saída e com sinal baixo. Resetamos, então, as configurações de WiFi e colocamos em modo AP. Copiamos o endereço que aparece e colocamos no slaveMacAddress do Master.

void setup() {
  Serial.begin(115200);
  //Coloca o pino do relê como saída e coloca com sinal baixo
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW);

  //Reseta as configurações da WiFi
  WiFi.disconnect();
  //Coloca em modo AP
  WiFi.mode(WIFI_AP);

  setupESPNow();

  //Copiar o endereço que aparece aqui e colocar
  //no slaveMacAddress do Master
  Serial.print("AP MAC: "); 
  Serial.println(WiFi.softAPmacAddress());
}

ESP8266_EspNow_Slave.ino – setupESPNow

Inicializamos o ESP-Now e registramos a função que será executada quando novos dados chegarem.

void setupESPNow(){
  //Inicializa o ESPNOW
  if (esp_now_init()!=0) {
    Serial.println("EspNow init failed");
    ESP.restart();
  }

  //0=IDLE, 1=MASTER, 2=SLAVE and 3=MASTER+SLAVE
  esp_now_set_self_role(ESP_NOW_ROLE_SLAVE);
  //Registra a função que será executada quando novos
  //dados chegarem
  esp_now_register_recv_cb(receiveCallback);
}

 ESP8266_EspNow_Slave.ino – receiveCallback

Prosseguindo, na função Callback, definimos o relayStatus para receber o data[0].

//Função que será executada quando chegarem novos dados
void receiveCallback(uint8_t *mac, uint8_t *data, uint8_t len) {
  int relayStatus = data[0];
  digitalWrite(RELAY_PIN, relayStatus);
}

ESP8266_EspNow_Slave.ino - loop

Não temos nada para fazer no Loop já que as informações são recebidas pelo receiveCallback automaticamente quando novos dados chegam.

//Nada para fazer no loop já que as informações 
//são recebidas pelo receiveCallback
//automaticamente quando novos dados chegam
void loop() {
   
}

Faça o download dos arquivos:

PDF

INO