/********* Pleasedontcode.com **********

	Pleasedontcode thanks you for automatic code generation! Enjoy your code!

	- Terms and Conditions:
	You have a non-exclusive, revocable, worldwide, royalty-free license
	for personal and commercial use. Attribution is optional; modifications
	are allowed, but you're responsible for code maintenance. We're not
	liable for any loss or damage. For full terms,
	please visit pleasedontcode.com/termsandconditions.

	- Project: Smart Automation
	- Source Code NOT compiled for: ESP32 DevKit V1
	- Source Code created on: 2025-11-19 21:19:09

********* Pleasedontcode.com **********/

/****** SYSTEM REQUIREMENTS *****/
/****** SYSTEM REQUIREMENT 1 *****/
	/* relé umidificatore On se rh da dht11 <82 e off se */
	/* rh da dht11 >85. relé ventole (AC e DC) on 6 volte */
	/* in 24 ore per 74 secondi ogni volta. relé luci 12 */
	/* ore on e 12 ore off */
/****** END SYSTEM REQUIREMENTS *****/


/* START CODE */

/*******************************************************
 * ESP32 + Blynk IoT + DHT11 + Fototransistor + 4 Relè + Buzzer
 * - Umidificatore: isteresi RHmin/RHmax (editabili da app)
 * - Ventole: 6 cicli/24h, ON 74 s ciascuno (2 relè: DC e AC)
 * - Luci: 12 h ON / 12 h OFF (ciclo relativo all'avvio)
 * - Fototransistor: verifica accensione luci (soglia editabile)
 * - Allarmi (buzzer attivo):
 *    A) RH < RHmin per 30 min: 1 min beep 1 s ON / 1 s OFF
 *    B) Luci dovrebbero essere ON ma luce < soglia per 30 min:
 *       1 min beep 2 s ON / 2 s OFF
 *   Dopo 1 min l'allarme si ferma; la finestra 30 min riparte.
 *******************************************************/

#define BLYNK_TEMPLATE_ID "TMPL4X0xNGkPD"
#define BLYNK_TEMPLATE_NAME "Camera Fruttificazione"
#define BLYNK_AUTH_TOKEN "yu5gwTTfR31Gf1GBrGyEn8i2rxM7Ie9y"

#define BLYNK_PRINT Serial

#include <WiFi.h>
#include <BlynkSimpleEsp32.h>  // Blynk IoT per ESP32  (Virtual Pins, BlynkTimer)
#include <DHT.h>               // Adafruit DHT library

// ---- Credenziali Wi-Fi ----
char ssid[] = "WiFi";
char pass[] = "azz";
// ====== Pinout ======
#define PIN_DHT          4
#define PIN_PHOTO        34   // ADC1 (necessario con WiFi attivo)
#define PIN_RELAY_HUM    26
#define PIN_RELAY_FAN_DC 27
#define PIN_RELAY_FAN_AC 25
#define PIN_RELAY_LIGHT  33
#define PIN_BUZZER       32

// Moduli relè spesso "active LOW"
#define RELAY_ACTIVE_ON   LOW
#define RELAY_ACTIVE_OFF  HIGH

// ====== DHT ======
#define DHTTYPE DHT11
DHT dht(PIN_DHT, DHTTYPE);

// ====== Blynk ======
BlynkTimer timer;

// Virtual Pins
#define VP_HUM       V0
#define VP_TMP       V1
#define VP_HUM_RLY   V2
#define VP_FAN_DC    V3
#define VP_FAN_AC    V4
#define VP_LIGHT_RLY V5
#define VP_PHOTO     V6
#define VP_RH_MIN    V7
#define VP_RH_MAX    V8
#define VP_LUX_THR   V9
#define VP_EMERG     V10
#define VP_ALARM     V11

// ====== Parametri editabili da app (default) ======
volatile float rhMin = 82.0;   // % RH
volatile float rhMax = 85.0;   // % RH
volatile int   lightThreshold = 200; // ADC 0..4095

// ====== Stati ======
bool emergency = false;
bool humidifierOn = false;
bool fanDCOn = false;
bool fanACOn = false;
bool lightsOn = false;

// Scheduli
const unsigned long FAN_PERIOD     = 4UL * 60UL * 60UL * 1000UL; // ogni 4 h (6 volte/24h)
const unsigned long FAN_ON_TIME    = 74UL * 1000UL;              // 74 s
unsigned long nextFanMillis = 0;

const unsigned long LIGHT_HALF_DAY = 12UL * 60UL * 60UL * 1000UL; // 12 h
unsigned long nextLightToggle = 0;

// Allarmi (finestre 30 min)
const unsigned long WINDOW_30M = 30UL * 60UL * 1000UL;
unsigned long lowRHStart = 0;
unsigned long darkStart = 0;

// ====== Buzzer / allarme ======
enum AlarmType { ALARM_NONE, ALARM_HUM_LOW, ALARM_LIGHT_FAIL };
AlarmType currentAlarm = ALARM_NONE;

bool alarmActive = false;
bool buzzerState = false;         // stato ON/OFF corrente del buzzer
uint16_t buzzerPeriodMs = 1000;   // 1000 o 2000
int buzzerToggleTimerId = -1;
int alarmStopTimerId = -1;

// ====== Prototipi funzioni ======
void setRelay(int pin, bool on);
void publishStates();
void startBuzzer(AlarmType t, uint16_t periodMs, const char* logEventCode, const char* msg);

void readAndPublishSensors();
void controlHumidifier();
void fanScheduler();
void lightScheduler();
void checkAlarms();

// Callback timer (no lambda)
void buzzerToggleTask();
void alarmStopTask();
void fanOffTask();

// ====== Utility ======
void setRelay(int pin, bool on) {
  digitalWrite(pin, on ? RELAY_ACTIVE_ON : RELAY_ACTIVE_OFF);
}

void publishStates() {
  Blynk.virtualWrite(VP_HUM_RLY, humidifierOn);
  Blynk.virtualWrite(VP_FAN_DC,  fanDCOn);
  Blynk.virtualWrite(VP_FAN_AC,  fanACOn);
  Blynk.virtualWrite(VP_LIGHT_RLY, lightsOn);
}

// ====== Blynk ======
BLYNK_CONNECTED() {
  Blynk.syncVirtual(VP_RH_MIN, VP_RH_MAX, VP_LUX_THR, VP_EMERG);
}

BLYNK_WRITE(VP_RH_MIN) { rhMin = param.asFloat(); }
BLYNK_WRITE(VP_RH_MAX) { rhMax = param.asFloat(); }
BLYNK_WRITE(VP_LUX_THR){ lightThreshold = param.asInt(); }

BLYNK_WRITE(VP_EMERG)  {
  emergency = param.asInt();
  if (emergency) {
    // spegni tutto
    humidifierOn = fanDCOn = fanACOn = lightsOn = false;
    setRelay(PIN_RELAY_HUM,   false);
    setRelay(PIN_RELAY_FAN_DC,false);
    setRelay(PIN_RELAY_FAN_AC,false);
    setRelay(PIN_RELAY_LIGHT, false);
    publishStates();
  } else {
    // riavvia scheduler da ora
    nextFanMillis   = millis() + FAN_PERIOD;
    nextLightToggle = millis() + LIGHT_HALF_DAY;
  }
}

// ====== Sensori e logiche ======
void readAndPublishSensors() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  if (!isnan(h) && !isnan(t)) {
    Blynk.virtualWrite(VP_HUM, h);
    Blynk.virtualWrite(VP_TMP, t);
  }

  int raw = analogRead(PIN_PHOTO); // 0..4095
  Blynk.virtualWrite(VP_PHOTO, raw);

  // Gestione finestre 30 min
  unsigned long now = millis();

  if (!isnan(h)) {
    if (h < rhMin) {
      if (lowRHStart == 0) lowRHStart = now;
    } else {
      lowRHStart = 0;
    }
  }

  if (lightsOn) {
    if (raw < lightThreshold) {
      if (darkStart == 0) darkStart = now;
    } else {
      darkStart = 0;
    }
  } else {
    darkStart = 0;
  }
}

void controlHumidifier() {
  if (emergency || alarmActive) return;

  float h = dht.readHumidity();
  if (isnan(h)) return;

  if (!humidifierOn && h < rhMin) {
    humidifierOn = true;
  } else if (humidifierOn && h > rhMax) {
    humidifierOn = false;
  }
  setRelay(PIN_RELAY_HUM, humidifierOn);
  Blynk.virtualWrite(VP_HUM_RLY, humidifierOn);
}

void fanScheduler() {
  if (emergency || alarmActive) return;

  unsigned long now = millis();
  if (now >= nextFanMillis) {
    // Avvia ON di 74 s per entrambe le ventole
    fanDCOn = fanACOn = true;
    setRelay(PIN_RELAY_FAN_DC, true);
    setRelay(PIN_RELAY_FAN_AC, true);
    publishStates();

    // Spegni dopo 74 s (callback senza lambda)
    timer.setTimeout(FAN_ON_TIME, fanOffTask);

    nextFanMillis = now + FAN_PERIOD;
  }
}

void lightScheduler() {
  if (emergency || alarmActive) return;

  unsigned long now = millis();
  if (now >= nextLightToggle) {
    lightsOn = !lightsOn; // 12 h ON / 12 h OFF
    setRelay(PIN_RELAY_LIGHT, lightsOn);
    Blynk.virtualWrite(VP_LIGHT_RLY, lightsOn);
    nextLightToggle = now + LIGHT_HALF_DAY;
  }
}

void checkAlarms() {
  if (alarmActive || emergency) return;

  unsigned long now = millis();

  // A) Umidità bassa persistente 30 min
  if (lowRHStart != 0 && (now - lowRHStart >= WINDOW_30M)) {
    lowRHStart = 0;
    startBuzzer(ALARM_HUM_LOW, 1000, "humidity_low_30m", "Umidità sotto soglia per 30 minuti");
    return;
  }

  // B) Luci ON attese ma non rilevate per 30 min
  if (darkStart != 0 && (now - darkStart >= WINDOW_30M)) {
    darkStart = 0;
    startBuzzer(ALARM_LIGHT_FAIL, 2000, "light_fail_30m", "Luci attese ON ma non rilevate per 30 minuti");
    return;
  }
}

// ====== Buzzer ======
void startBuzzer(AlarmType t, uint16_t periodMs, const char* logEventCode, const char* msg) {
  if (alarmActive) return;

  alarmActive = true;
  currentAlarm = t;
  buzzerPeriodMs = periodMs;

  if (logEventCode) {
    Blynk.logEvent(logEventCode, msg); // Richiede eventi creati nel Template
  }

  Blynk.virtualWrite(
    VP_ALARM,
    (t == ALARM_HUM_LOW)    ? "ALLARME: Umidità bassa" :
    (t == ALARM_LIGHT_FAIL) ? "ALLARME: Luci non rilevate" : ""
  );

  pinMode(PIN_BUZZER, OUTPUT);
  buzzerState = true;
  digitalWrite(PIN_BUZZER, HIGH);

  // Toggle periodico (1 s o 2 s)
  buzzerToggleTimerId = timer.setInterval(buzzerPeriodMs, buzzerToggleTask);

  // Stop dopo 60 s
  alarmStopTimerId = timer.setTimeout(60UL * 1000UL, alarmStopTask);
}

void buzzerToggleTask() {
  buzzerState = !buzzerState;
  digitalWrite(PIN_BUZZER, buzzerState ? HIGH : LOW);
}

void alarmStopTask() {
  if (buzzerToggleTimerId != -1) {
    timer.disable(buzzerToggleTimerId);
    timer.deleteTimer(buzzerToggleTimerId);
    buzzerToggleTimerId = -1;
  }
  digitalWrite(PIN_BUZZER, LOW);
  alarmActive = false;
  currentAlarm = ALARM_NONE;
  Blynk.virtualWrite(VP_ALARM, "");
}

void fanOffTask() {
  fanDCOn = fanACOn = false;
  setRelay(PIN_RELAY_FAN_DC, false);
  setRelay(PIN_RELAY_FAN_AC, false);
  publishStates();
}

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

  // Relè
  pinMode(PIN_RELAY_HUM,    OUTPUT);
  pinMode(PIN_RELAY_FAN_DC, OUTPUT);
  pinMode(PIN_RELAY_FAN_AC, OUTPUT);
  pinMode(PIN_RELAY_LIGHT,  OUTPUT);
  // Tutto OFF
  setRelay(PIN_RELAY_HUM,   false);
  setRelay(PIN_RELAY_FAN_DC,false);
  setRelay(PIN_RELAY_FAN_AC,false);
  setRelay(PIN_RELAY_LIGHT, false);
  publishStates();

  // ADC: 12 bit e attenuazione 11 dB (~0..3.1 V)
  analogReadResolution(12);
  analogSetPinAttenuation(PIN_PHOTO, ADC_11db);

  dht.begin();

  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);

  // Timers (funzioni senza lambda)
  timer.setInterval(2000, readAndPublishSensors); // ogni 2 s
  timer.setInterval(1000, controlHumidifier);     // ogni 1 s
  timer.setInterval(1000, fanScheduler);          // ogni 1 s
  timer.setInterval(1000, lightScheduler);        // ogni 1 s
  timer.setInterval(5000, publishStates);         // ogni 5 s
  timer.setInterval(10000, checkAlarms);          // ogni 10 s

  // Inizializza scheduler da "adesso"
  unsigned long now = millis();
  nextFanMillis   = now;                  // prima accensione ventole subito
  lightsOn        = true;                 // avvia con 12 h ON
  setRelay(PIN_RELAY_LIGHT, lightsOn);
  Blynk.virtualWrite(VP_LIGHT_RLY, lightsOn);
  nextLightToggle = now + LIGHT_HALF_DAY;
}

void loop() {
  Blynk.run();
  timer.run();
}

/* END CODE */