Smart Humidity Controller

#include <Arduino.h>
// ============================================================
//  Orquidea IA v1.0
//  Humidificador Inteligente com Blynk 2.0 + Display OLED
//  ESP32 + DHT22 + Módulo de Névoa Ultrassónico (via relé)
//       + Sensor de Nível de Água + SSD1306 OLED 0.96"
// ============================================================
//
//  ANTES DE COMPILAR:
//    1. Cria uma conta gratuita em https://blynk.io
//    2. Cria um novo Template (Hardware: ESP32, Connection: WiFi)
//    3. Cria os seguintes Datastreams virtuais:
//         V0  – Temperature      (Double, -10 a 60 °C)   → Gauge
//         V1  – Humidity         (Double, 0 a 100 %)     → Gauge
//         V2  – Mist On/Off      (Integer, 0 / 1)        → Switch
//         V3  – Target Humidity  (Double, 30 a 95 %)     → Slider
//         V4  – Water Level %    (Double, 0 a 100 %)     → Gauge
//         V5  – Water Alert      (Integer, 0 / 1)        → LED / Notification
//         V6  – Hum Min          (Double, 30 a 95 %)     → Slider
//         V7  – Hum Max          (Double, 30 a 95 %)     → Slider
//         V8  – Temp Min         (Double, 0 a 50 °C)     → Slider
//         V9  – Temp Max         (Double, 0 a 50 °C)     → Slider
//    4. Substitui as credenciais abaixo com os teus dados.
//    5. Para notificações de temperatura: cria um Event no Blynk
//       com o nome "temp_alert" (Events → Create Event).
//       O firmware dispara-o automaticamente quando a temperatura
//       sair da faixa definida nos sliders V8 e V9.
//    6. Para notificações de água baixa: configura um Automation
//       no Blynk que dispara quando V5 == 1 e envia notificação push.
// ============================================================

#define BLYNK_TEMPLATE_ID   "TMPLxxxxxxxx"   // ← substitui
#define BLYNK_TEMPLATE_NAME "Humidificador"  // ← substitui
#define BLYNK_AUTH_TOKEN    "YourAuthToken"  // ← substitui

#include <WiFi.h>
#include <BlynkSimpleEsp32.h>
#include <DHT.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <time.h>

// ── Orquídea pixel art 32x32 (PROGMEM) ──────────────────────
// Flor estilizada de orquídea — 5 pétalas + centro
static const unsigned char PROGMEM orchid_bmp[] = {
  0x00,0x00,0x00,0x00,
  0x00,0x01,0x80,0x00,
  0x00,0x03,0xC0,0x00,
  0x00,0x07,0xE0,0x00,
  0x00,0x0F,0xF0,0x00,
  0x00,0x1C,0x38,0x00,
  0x00,0x38,0x1C,0x00,
  0x00,0x70,0x0E,0x00,
  0x03,0xE0,0x07,0xC0,
  0x07,0xC0,0x03,0xE0,
  0x0F,0x80,0x01,0xF0,
  0x1F,0x00,0x00,0xF8,
  0x1E,0x03,0xC0,0x78,
  0x3C,0x07,0xE0,0x3C,
  0x38,0x0F,0xF0,0x1C,
  0x30,0x1F,0xF8,0x0C,
  0x30,0x1F,0xF8,0x0C,
  0x38,0x0F,0xF0,0x1C,
  0x3C,0x07,0xE0,0x3C,
  0x1E,0x03,0xC0,0x78,
  0x1F,0x00,0x00,0xF8,
  0x0F,0x80,0x01,0xF0,
  0x07,0xC0,0x03,0xE0,
  0x03,0xE0,0x07,0xC0,
  0x00,0x70,0x0E,0x00,
  0x00,0x38,0x1C,0x00,
  0x00,0x1C,0x38,0x00,
  0x00,0x0F,0xF0,0x00,
  0x00,0x07,0xE0,0x00,
  0x00,0x03,0xC0,0x00,
  0x00,0x01,0x80,0x00,
  0x00,0x00,0x00,0x00
};

// ── Credenciais Wi-Fi ────────────────────────────────────────
char ssid[] = "O_Teu_WiFi";      // ← substitui
char pass[] = "A_Tua_Password";  // ← substitui

// ── Pinos ────────────────────────────────────────────────────
#define DHT_PIN        4
#define RELAY_PIN      26
#define WATER_SIG_PIN  32
#define WATER_PWR_PIN  27
#define OLED_SDA       21
#define OLED_SCL       22

// ── OLED ─────────────────────────────────────────────────────
#define SCREEN_WIDTH  128
#define SCREEN_HEIGHT  64
#define OLED_RESET     -1
#define OLED_ADDRESS  0x3C

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// ── DHT22 ────────────────────────────────────────────────────
#define DHTTYPE DHT22
DHT dht(DHT_PIN, DHTTYPE);

// ── NTP / Data-Hora ──────────────────────────────────────────
// String POSIX oficial de Portugal — muda automaticamente em
// março (último domingo) e outubro (último domingo)
#define NTP_SERVER  "pool.ntp.org"
#define TZ_PORTUGAL "WET0WEST,M3.5.0/1,M10.5.0"
char timeStr[9]  = "--:--:--";
char dateStr[11] = "--/--/----";

// ── Estado ───────────────────────────────────────────────────
BlynkTimer timer;

float targetHumidity = 60.0;
float humMin         = 60.0;   // faixa mínima (Blynk V6)
float humMax         = 70.0;   // faixa máxima (Blynk V7)
float tempMin        = 20.0;   // faixa mínima temperatura (Blynk V8)
float tempMax        = 28.0;   // faixa máxima temperatura (Blynk V9)
bool  manualOverride = false;
bool  mistRunning    = false;

// Histerese ±2%
const float HYST = 2.0;

// Alertas de temperatura
bool  tempAlertLow  = false;   // abaixo de tempMin
bool  tempAlertHigh = false;   // acima de tempMax

// Nível de água
const int   RAW_EMPTY            = 0;
const int   RAW_FULL             = 3200;
const float WATER_LOW_THRESHOLD  = 20.0;
bool  waterAlertSent = false;

// Últimos valores lidos (para o display)
float lastTemp     = 0.0;
float lastHumidity = 0.0;
float lastWater    = 0.0;

// ── Forward declarations ──────────────────────────────────────
void mistOn();
void mistOff();
void updateDisplay();
void showBootScreen();
float readWaterLevel();
void readAndControl();
void updateTimeStrings();

// ── Relé: activo-LOW ─────────────────────────────────────────
void mistOn()  { digitalWrite(RELAY_PIN, LOW);  mistRunning = true;  }
void mistOff() { digitalWrite(RELAY_PIN, HIGH); mistRunning = false; }

// ── Hora NTP ─────────────────────────────────────────────────
void updateTimeStrings() {
  struct tm tinfo;
  if (!getLocalTime(&tinfo)) return;
  strftime(timeStr, sizeof(timeStr), "%H:%M:%S", &tinfo);
  strftime(dateStr, sizeof(dateStr), "%d/%m/%Y",  &tinfo);
}

// ── Ecrã de arranque ─────────────────────────────────────────
void showBootScreen() {
  display.clearDisplay();

  // Orquídea à esquerda (32x32)
  display.drawBitmap(2, 16, orchid_bmp, 32, 32, SSD1306_WHITE);

  // Título
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(40, 10);
  display.print(F("Orquidea IA"));

  // Versão
  display.setCursor(40, 22);
  display.print(F("v1.0"));

  // Linha separadora vertical
  display.drawLine(37, 8, 37, 50, SSD1306_WHITE);

  // Estado
  display.setCursor(40, 36);
  display.print(F("A ligar WiFi..."));

  display.display();
}

// ── Display principal ─────────────────────────────────────────
void updateDisplay() {
  updateTimeStrings();
  display.clearDisplay();

  // ══════════════════════════════════════════════════════════
  //  LINHA 1 — Título + versão
  // ══════════════════════════════════════════════════════════
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(2, 0);
  display.print(F("Orquidea IA"));
  display.setCursor(92, 0);
  display.print(F("v1.0"));
  display.drawLine(0, 9, 127, 9, SSD1306_WHITE);

  // ══════════════════════════════════════════════════════════
  //  LINHA 2 — Temperatura  |  gama 20C - 28C
  // ══════════════════════════════════════════════════════════
  display.setCursor(0, 12);
  display.print(F("Temp:"));
  display.setCursor(32, 12);
  display.print(lastTemp, 1);
  display.print(F(" C"));
  // divisor vertical
  display.drawLine(79, 10, 79, 22, SSD1306_WHITE);
  display.setCursor(82, 12);
  display.print((int)tempMin);
  display.print(F("C-"));
  display.print((int)tempMax);
  display.print(F("C"));

  // ══════════════════════════════════════════════════════════
  //  LINHA 3 — Humidade  |  gama 60% - 70%
  // ══════════════════════════════════════════════════════════
  display.setCursor(0, 23);
  display.print(F("Hum: "));
  display.setCursor(32, 23);
  display.print(lastHumidity, 1);
  display.print(F(" %"));
  display.drawLine(79, 22, 79, 34, SSD1306_WHITE);
  display.setCursor(82, 23);
  display.print((int)humMin);
  display.print(F("%"));
  display.print((int)humMax);
  display.print(F("%"));

  // Linha separadora
  display.drawLine(0, 33, 127, 33, SSD1306_WHITE);

  // ══════════════════════════════════════════════════════════
  //  LINHA 4 — Nebulizador  +  Nível de água
  // ══════════════════════════════════════════════════════════
  display.setCursor(0, 36);
  if (mistRunning) {
    display.print(F("NEBULIZ:ON "));
  } else {
    display.print(F("NEBULIZ:OFF"));
  }

  // Barra de água
  display.setCursor(68, 36);
  display.print(F("H2O:"));
  int barW   = 34;
  int filled = (int)((lastWater / 100.0f) * barW);
  filled = constrain(filled, 0, barW);
  display.drawRect(90, 36, barW + 2, 7, SSD1306_WHITE);
  display.fillRect(91, 37, filled, 5, SSD1306_WHITE);

  // Percentagem + alerta
  display.setCursor(68, 46);
  display.print(F("H2O:"));
  display.print((int)lastWater);
  display.print(F("%"));
  if (waterAlertSent) {
    display.setCursor(112, 46);
    display.print(F("!"));
  }

  // Linha separadora
  display.drawLine(0, 54, 127, 54, SSD1306_WHITE);

  // ══════════════════════════════════════════════════════════
  //  LINHA 5 — Data / Hora (NTP)
  // ══════════════════════════════════════════════════════════
  display.setCursor(0, 56);
  display.print(dateStr);
  display.setCursor(74, 56);
  display.print(timeStr);

  display.display();
}

// ── Blynk: interruptor manual (V2) ──────────────────────────
BLYNK_WRITE(V2) {
  int val = param.asInt();
  if (val == 1) {
    manualOverride = true;
    mistOn();
  } else {
    manualOverride = false;
  }
  updateDisplay();
}

// ── Blynk: humidade alvo pelo slider (V3) ───────────────────
BLYNK_WRITE(V3) {
  targetHumidity = param.asFloat();
  Serial.print(F("Nova humidade alvo: "));
  Serial.print(targetHumidity);
  Serial.println(F(" %"));
  updateDisplay();
}

// ── Blynk: faixa mínima de humidade (V6) ────────────────────
BLYNK_WRITE(V6) {
  humMin = param.asFloat();
  // Garante que min não ultrapassa max
  if (humMin > humMax) humMin = humMax - 1.0;
  // Atualiza alvo para centro da faixa
  targetHumidity = (humMin + humMax) / 2.0;
  Serial.print(F("Faixa hum: "));
  Serial.print(humMin); Serial.print(F("% - "));
  Serial.print(humMax); Serial.println(F("%"));
  updateDisplay();
}

// ── Blynk: faixa máxima de humidade (V7) ────────────────────
BLYNK_WRITE(V7) {
  humMax = param.asFloat();
  // Garante que max não é inferior a min
  if (humMax < humMin) humMax = humMin + 1.0;
  // Atualiza alvo para centro da faixa
  targetHumidity = (humMin + humMax) / 2.0;
  Serial.print(F("Faixa hum: "));
  Serial.print(humMin); Serial.print(F("% - "));
  Serial.print(humMax); Serial.println(F("%"));
  updateDisplay();
}

// ── Blynk: temperatura mínima (V8) ──────────────────────────
BLYNK_WRITE(V8) {
  tempMin = param.asFloat();
  if (tempMin > tempMax) tempMin = tempMax - 1.0;
  // Reset alertas para reavaliar com nova faixa
  tempAlertLow  = false;
  tempAlertHigh = false;
  Serial.print(F("Faixa temp: "));
  Serial.print(tempMin); Serial.print(F("C - "));
  Serial.print(tempMax); Serial.println(F("C"));
  updateDisplay();
}

// ── Blynk: temperatura máxima (V9) ──────────────────────────
BLYNK_WRITE(V9) {
  tempMax = param.asFloat();
  if (tempMax < tempMin) tempMax = tempMin + 1.0;
  // Reset alertas para reavaliar com nova faixa
  tempAlertLow  = false;
  tempAlertHigh = false;
  Serial.print(F("Faixa temp: "));
  Serial.print(tempMin); Serial.print(F("C - "));
  Serial.print(tempMax); Serial.println(F("C"));
  updateDisplay();
}

// ── Leitura do nível de água ─────────────────────────────────
float readWaterLevel() {
  digitalWrite(WATER_PWR_PIN, HIGH);
  delay(10);
  int raw = analogRead(WATER_SIG_PIN);
  digitalWrite(WATER_PWR_PIN, LOW);
  float pct = ((float)(raw - RAW_EMPTY) / (float)(RAW_FULL - RAW_EMPTY)) * 100.0f;
  return constrain(pct, 0.0f, 100.0f);
}

// ── Leitura e controlo principal ─────────────────────────────
void readAndControl() {
  float humidity    = dht.readHumidity();
  float temperature = dht.readTemperature();

  if (isnan(humidity) || isnan(temperature)) {
    Serial.println(F("Erro: falha na leitura do DHT22!"));
    return;
  }

  float waterPct = readWaterLevel();

  // Guarda para o display
  lastTemp     = temperature;
  lastHumidity = humidity;
  lastWater    = waterPct;

  Serial.print(F("Temp: ")); Serial.print(temperature, 1);
  Serial.print(F(" C  |  Hum: ")); Serial.print(humidity, 1);
  Serial.print(F(" %  |  Alvo: ")); Serial.print(targetHumidity, 1);
  Serial.print(F(" %  |  Agua: ")); Serial.print(waterPct, 0);
  Serial.println(F(" %"));

  // Envia para Blynk
  Blynk.virtualWrite(V0, temperature);
  Blynk.virtualWrite(V1, humidity);
  Blynk.virtualWrite(V4, waterPct);

  // ── Alertas de temperatura ────────────────────────────────
  if (temperature < tempMin) {
    if (!tempAlertLow) {
      Blynk.logEvent("temp_alert",
        String("Temperatura baixa! ") + String(temperature, 1) + String(" C (min: ") + String(tempMin, 1) + String(" C)"));
      tempAlertLow  = true;
      tempAlertHigh = false;
      Serial.println(F("ALERTA: Temperatura abaixo do minimo!"));
    }
  } else if (temperature > tempMax) {
    if (!tempAlertHigh) {
      Blynk.logEvent("temp_alert",
        String("Temperatura alta! ") + String(temperature, 1) + String(" C (max: ") + String(tempMax, 1) + String(" C)"));
      tempAlertHigh = true;
      tempAlertLow  = false;
      Serial.println(F("ALERTA: Temperatura acima do maximo!"));
    }
  } else {
    // Temperatura voltou à faixa — reseta alertas
    tempAlertLow  = false;
    tempAlertHigh = false;
  }

  // ── Alerta nível baixo ─────────────────────────────────────
  if (waterPct < WATER_LOW_THRESHOLD) {
    if (!waterAlertSent) {
      Blynk.virtualWrite(V5, 1);
      waterAlertSent = true;
      Serial.println(F("ALERTA: Nivel de agua baixo!"));
    }
    // Abaixo de 10% desliga nebulizador para proteger disco
    if (waterPct < 10.0f && !manualOverride) {
      mistOff();
      Blynk.virtualWrite(V2, 0);
    }
  } else {
    if (waterAlertSent) {
      Blynk.virtualWrite(V5, 0);
      waterAlertSent = false;
    }
  }

  // ── Controlo automático ────────────────────────────────────
  if (!manualOverride) {
    // Controla com base na faixa definida (humMin / humMax)
    if (humidity < humMin) {
      mistOn();
      Blynk.virtualWrite(V2, 1);
    } else if (humidity > humMax) {
      mistOff();
      Blynk.virtualWrite(V2, 0);
    }
  }

  updateDisplay();
}

// ── Setup ─────────────────────────────────────────────────────
void setup() {
  Serial.begin(115200);

  pinMode(RELAY_PIN, OUTPUT);
  mistOff();

  pinMode(WATER_PWR_PIN, OUTPUT);
  digitalWrite(WATER_PWR_PIN, LOW);

  // Inicia I2C e OLED
  Wire.begin(OLED_SDA, OLED_SCL);
  if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDRESS)) {
    Serial.println(F("OLED nao encontrado!"));
  } else {
    showBootScreen();
  }

  dht.begin();

  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);

  // Sincroniza hora via NTP com fuso horário automático de Portugal
  // Muda sozinho para horário de verão/inverno (março e outubro)
  configTzTime(TZ_PORTUGAL, NTP_SERVER);
  delay(1500);

  // Timer de leitura e controlo (5s)
  timer.setInterval(5000L, readAndControl);
  // Timer de atualização do ecrã (1s) — mantém hora em tempo real
  timer.setInterval(1000L, updateDisplay);

  Serial.println(F("Orquidea IA v1.0 iniciada!"));
}

// ── Loop ──────────────────────────────────────────────────────
void loop() {
  Blynk.run();
  timer.run();
}