esp32_24h_timer_ontime_eeprom_gpioreset_universaltelegram

/*
  ESP32 Motor Timer with Web Setup, EEPROM Backup, GPIO Reset, and Telegram Notification

  DESCRIPTION:
  -------------
  This sketch controls a motor (or relay) connected to an ESP32, allowing you to schedule its operation for specific hours each day.
  - Configuration is done via a WiFi Access Point and web interface hosted by the ESP32.
  - All settings (schedule, run time, time) are saved to EEPROM for power-loss recovery.
  - A special reset mode (by connecting GPIO14 to 3.3V and resetting) clears all settings.
  - After each scheduled motor run, a notification is sent to your Telegram account.

  FEATURES:
  ---------
  - Web-based setup: Set current time, motor run time (5–300s), and select operation hours (per hour, 24h grid).
  - Settings backup: All settings are stored in EEPROM and restored after power loss.
  - Reset mode: Connect GPIO14 to 3.3V and reset to clear all settings and re-enter setup.
  - Telegram notification: After each motor run, a message is sent to your Telegram bot.

  WIRING:
  -------
  - MOTOR_PIN: GPIO33 (connect to relay or motor driver)
  - LED_PIN:   GPIO32 (status LED)
  - RESET_PIN: GPIO14 (connect to 3.3V and reset to clear settings)
  - Ensure your relay/motor driver is compatible with 3.3V logic.

  USAGE INSTRUCTIONS:
  -------------------
  1. Power on the ESP32. It will start as a WiFi Access Point (SSID: ESP32-Motor-Timer, Password: 12345678).
  2. Connect to this WiFi network with your phone or computer.
  3. Open a browser and go to the address shown in the Serial Monitor (usually http://192.168.4.1).
  4. Follow the web interface steps:
     - Set the current time (syncs with your device).
     - Set the motor run time (slider, 5–300 seconds).
     - Select the hours you want the motor to run (checkbox grid).
     - When all steps are complete, click "Start Operation".
  5. The ESP32 will enter deep sleep and wake up at the scheduled hours to run the motor.
  6. After each run, a Telegram message will be sent (see below for setup).
  7. To reset all settings, connect GPIO14 to 3.3V and reset the ESP32.

  TELEGRAM NOTIFICATION SETUP:
  ----------------------------
  1. Create a Telegram bot using BotFather and get your bot token.
  2. Start a chat with your bot and get your chat ID (see UniversalTelegramBot library examples).
  3. Enter your WiFi credentials, bot token, and chat ID in the placeholders at the top of this sketch.
  4. Install the UniversalTelegramBot and WiFiClientSecure libraries via the Arduino Library Manager.
  5. Ensure your ESP32 can connect to your WiFi for Telegram notifications.

  DEPENDENCIES:
  -------------
  - ESP32 board support (install via Arduino Board Manager)
  - UniversalTelegramBot library
  - WiFiClientSecure library
  - ESP32Time, WiFi, EEPROM libraries (included with ESP32 core)

*/

#include "soc/soc.h"           // Brownout error fix
#include "soc/rtc_cntl_reg.h"  // Brownout error fix

#include "driver/rtc_io.h" // https://github.com/pycom/esp-idf-2.0/blob/master/components/driver/include/driver/rtc_io.h

#include <ESP32Time.h>
#include <WiFi.h>
#include <EEPROM.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>

#define uS_TO_S_FACTOR 1000000ULL
#define DEFAULT_MOTOR_ON_TIME 5
#define MIN_MOTOR_ON_TIME 5
#define MAX_MOTOR_ON_TIME 300
#define MOTOR_PIN 33
#define LED_PIN 32
#define WAKEUP_GPIO GPIO_NUM_14 // Only RTC IO are allowed
#define EEPROM_SIZE 512

// EEPROM Memory Map
#define EEPROM_MAGIC_ADDR 0
#define EEPROM_SCHEDULE_ADDR 4
#define EEPROM_RUNTIME_ADDR 28
#define EEPROM_LAST_SYNC_ADDR 32
#define EEPROM_MAGIC_NUMBER 0xDEADBEEF
#define MAX_TIME_STALENESS 7 * 24 * 3600

const char *ssid = "ESP32-Motor-Timer";
const char *password = "12345678";

ESP32Time rtc(3600);
WiFiServer server(80);

// RTC memory variables
RTC_DATA_ATTR bool timeWasSet = false;
RTC_DATA_ATTR bool scheduleWasSet = false;
RTC_DATA_ATTR bool runTimeWasSet = false;
RTC_DATA_ATTR int bootCount = 0;
RTC_DATA_ATTR unsigned long webServerStartTime = 0;
RTC_DATA_ATTR bool usingBackupSettings = false;
RTC_DATA_ATTR bool hourlySchedule[24] = {0};
RTC_DATA_ATTR int motorRunTime = DEFAULT_MOTOR_ON_TIME;

// --- Telegram Bot Placeholders ---
const char* TELEGRAM_WIFI_SSID = "YOUR_WIFI_SSID";
const char* TELEGRAM_WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";
const char* BOT_TOKEN = "YOUR_BOT_TOKEN";
const char* CHAT_ID = "YOUR_CHAT_ID";

WiFiClientSecure secured_client;
UniversalTelegramBot bot(BOT_TOKEN, secured_client);

struct EEPROMSettings {
  uint32_t magic;
  bool schedule[24];
  int runTime;
  uint32_t lastSyncTime;
};

void setup() {
  Serial.begin(115200);
  delay(1000);
  EEPROM.begin(EEPROM_SIZE);

  bootCount++;
  Serial.println("Boot count: " + String(bootCount));

  pinMode(MOTOR_PIN, OUTPUT);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(MOTOR_PIN, LOW);

  printWakeupReason();

  // Check if woken up by GPIO14 - clear EEPROM and reset
  if (esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_EXT0) {
    Serial.println("=== GPIO RESET TRIGGERED ===");
    Serial.println("Clearing EEPROM settings...");
    clearEEPROMSettings();

    // Reset RTC memory flags
    timeWasSet = false;
    scheduleWasSet = false;
    runTimeWasSet = false;
    usingBackupSettings = false;

    Serial.println("EEPROM cleared - entering setup mode");
    webServerStartTime = millis();
    setupWebServer();
    return;
  }

  // Normal wakeup logic
  if (timeWasSet && scheduleWasSet && runTimeWasSet && esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_TIMER) {
    handleScheduledWakeup();
  } else {
    if (tryLoadBackupSettings()) {
      Serial.println("=== POWER FAILURE RECOVERY ===");
      Serial.println("Loaded backup settings from EEPROM");
      printCurrentSettings();

      timeWasSet = false;
      usingBackupSettings = true;

      EEPROMSettings settings;
      loadSettingsFromEEPROM(settings);
      uint32_t currentEpoch = settings.lastSyncTime + (millis() / 1000);
      rtc.setTime(currentEpoch);
      timeWasSet = true;

      Serial.println("Estimated time: " + rtc.getTime("%A, %B %d %Y %H:%M:%S"));
      scheduleNextWakeup();
    } else {
      Serial.println("No backup settings found - entering setup mode");
      webServerStartTime = millis();
      setupWebServer();
    }
  }
}

void loop() {
  if (!timeWasSet || !scheduleWasSet || !runTimeWasSet) {
    if (millis() - webServerStartTime > 240000) {
      if (tryLoadBackupSettings()) {
        Serial.println("Timeout reached - falling back to EEPROM settings");
        usingBackupSettings = true;

        EEPROMSettings settings;
        loadSettingsFromEEPROM(settings);
        uint32_t estimatedTime = settings.lastSyncTime + (millis() / 1000);
        rtc.setTime(estimatedTime);
        timeWasSet = true;

        scheduleNextWakeup();
      } else {
        Serial.println("No backup settings - entering 3-hour sleep");
        setupSleepWakeup();
        esp_deep_sleep_start();
      }
    }
    handleWebClient();
  }
}

void clearEEPROMSettings() {
  // Clear magic number to invalidate settings
  uint32_t clearMagic = 0x00000000;
  EEPROM.put(EEPROM_MAGIC_ADDR, clearMagic);
  EEPROM.commit();
  Serial.println("EEPROM settings cleared");
}

bool tryLoadBackupSettings() {
  EEPROMSettings settings;
  if (loadSettingsFromEEPROM(settings)) {
    for (int i = 0; i < 24; i++) {
      hourlySchedule[i] = settings.schedule[i];
    }
    motorRunTime = settings.runTime;
    scheduleWasSet = true;
    runTimeWasSet = true;
    return true;
  }
  return false;
}

bool loadSettingsFromEEPROM(EEPROMSettings &settings) {
  uint32_t magic;
  EEPROM.get(EEPROM_MAGIC_ADDR, magic);

  if (magic != EEPROM_MAGIC_NUMBER) {
    Serial.println("No valid EEPROM settings found");
    return false;
  }

  EEPROM.get(EEPROM_MAGIC_ADDR, settings.magic);
  for (int i = 0; i < 24; i++) {
    settings.schedule[i] = EEPROM.read(EEPROM_SCHEDULE_ADDR + i);
  }
  EEPROM.get(EEPROM_RUNTIME_ADDR, settings.runTime);
  EEPROM.get(EEPROM_LAST_SYNC_ADDR, settings.lastSyncTime);

  if (settings.runTime < MIN_MOTOR_ON_TIME || settings.runTime > MAX_MOTOR_ON_TIME) {
    Serial.println("Invalid run time in EEPROM: " + String(settings.runTime));
    return false;
  }

  Serial.println("Valid EEPROM settings loaded");
  return true;
}

void saveSettingsToEEPROM() {
  Serial.println("Saving settings to EEPROM...");

  EEPROMSettings settings;
  settings.magic = EEPROM_MAGIC_NUMBER;

  for (int i = 0; i < 24; i++) {
    settings.schedule[i] = hourlySchedule[i];
  }
  settings.runTime = motorRunTime;
  settings.lastSyncTime = rtc.getEpoch();

  EEPROM.put(EEPROM_MAGIC_ADDR, settings.magic);
  for (int i = 0; i < 24; i++) {
    EEPROM.write(EEPROM_SCHEDULE_ADDR + i, settings.schedule[i]);
  }
  EEPROM.put(EEPROM_RUNTIME_ADDR, settings.runTime);
  EEPROM.put(EEPROM_LAST_SYNC_ADDR, settings.lastSyncTime);
  EEPROM.commit();

  Serial.println("Settings saved to EEPROM successfully");
  printCurrentSettings();
}

void printCurrentSettings() {
  Serial.println("Current Settings:");
  Serial.println("- Motor run time: " + String(motorRunTime) + " seconds");
  Serial.print("- Schedule: ");

  int count = 0;
  for (int h = 0; h < 24; h++) {
    if (hourlySchedule[h]) {
      if (count > 0) Serial.print(", ");
      Serial.print(String(h < 10 ? "0" : "") + String(h) + ":00");
      count++;
    }
  }

  if (count == 0) {
    Serial.println("No hours scheduled");
  } else {
    Serial.println(" (" + String(count) + " times/day)");
    Serial.println("- Total daily runtime: " + String(count * motorRunTime) + " seconds");
  }
}

void handleScheduledWakeup() {
  Serial.println("\n=== Scheduled Wake-up ===");
  Serial.println("Current time: " + rtc.getTime("%A, %B %d %Y %H:%M:%S"));
  Serial.println("Motor run time: " + String(motorRunTime) + " seconds");

  if (usingBackupSettings) {
    Serial.println("Running on backup settings from EEPROM");
  }

  runMotor();
  scheduleNextWakeup();
}

void runMotor() {
  Serial.println("Starting motor for " + String(motorRunTime) + " seconds...");

  digitalWrite(LED_PIN, HIGH);
  digitalWrite(MOTOR_PIN, HIGH);

  for (int i = motorRunTime; i > 0; i--) {
    Serial.println("Motor running... " + String(i) + "s remaining");
    delay(1000);

    int blinkInterval = (motorRunTime < 10) ? 1 : 5;
    if (i % blinkInterval == 0) {
      digitalWrite(LED_PIN, LOW);
      delay(100);
      digitalWrite(LED_PIN, HIGH);
    }
  }

  digitalWrite(MOTOR_PIN, LOW);
  digitalWrite(LED_PIN, LOW);
  Serial.println("Motor stopped.");

  // --- Send Telegram notification ---
  String msg = "Motor finished running for " + String(motorRunTime) + " seconds at " + rtc.getTime("%H:%M:%S %d/%m/%Y");
  sendTelegramMessage(msg);
}

void setupSleepWakeup() {
  // Setup timer wakeup
  esp_sleep_enable_timer_wakeup(3 * 3600 * uS_TO_S_FACTOR);

  // Setup GPIO wakeup for reset functionality
  esp_sleep_enable_ext0_wakeup(WAKEUP_GPIO, 1); // 1 = High trigger
  rtc_gpio_pullup_dis(WAKEUP_GPIO);
  rtc_gpio_pulldown_en(WAKEUP_GPIO);
  Serial.println("Setup ESP32 to wake up on GPIO14 trigger (reset mode)");
}

void scheduleNextWakeup() {
  struct tm timeinfo = rtc.getTimeStruct();
  int currentHour = timeinfo.tm_hour;
  int currentMinute = timeinfo.tm_min;

  unsigned long sleepTime = calculateSleepTime(currentHour, currentMinute);

  if (sleepTime > 0) {
    Serial.println("Next wake-up in " + String(sleepTime / 3600) + " hours and " +
                   String((sleepTime % 3600) / 60) + " minutes");

    esp_sleep_enable_timer_wakeup(sleepTime * uS_TO_S_FACTOR);

    // Always enable GPIO wakeup for reset functionality
    esp_sleep_enable_ext0_wakeup(WAKEUP_GPIO, 1);
    rtc_gpio_pullup_dis(WAKEUP_GPIO);
    rtc_gpio_pulldown_en(WAKEUP_GPIO);

    Serial.println("Entering deep sleep... (GPIO14 HIGH = reset)");
    Serial.flush();
    esp_deep_sleep_start();
  } else {
    Serial.println("No scheduled hours found - entering 24-hour sleep");
    esp_sleep_enable_timer_wakeup(24 * 3600 * uS_TO_S_FACTOR);

    esp_sleep_enable_ext0_wakeup(WAKEUP_GPIO, 1);
    rtc_gpio_pullup_dis(WAKEUP_GPIO);
    rtc_gpio_pulldown_en(WAKEUP_GPIO);

    esp_deep_sleep_start();
  }
}

unsigned long calculateSleepTime(int currentHour, int currentMinute) {
  int nextHour = -1;

  for (int h = currentHour + 1; h < 24; h++) {
    if (hourlySchedule[h]) {
      nextHour = h;
      break;
    }
  }

  if (nextHour == -1) {
    for (int h = 0; h < 24; h++) {
      if (hourlySchedule[h]) {
        nextHour = h + 24;
        break;
      }
    }
  }

  if (nextHour == -1) return 0;

  int currentTotalMinutes = currentHour * 60 + currentMinute;
  int nextTotalMinutes = (nextHour % 24) * 60;

  if (nextHour >= 24) {
    nextTotalMinutes += 24 * 60;
  }

  int sleepMinutes = nextTotalMinutes - currentTotalMinutes;
  return sleepMinutes * 60;
}

void setupWebServer() {
  Serial.println("\n=== Setting up Web Server for Configuration ===");
  Serial.println("Connect to WiFi network: " + String(ssid));
  Serial.println("Password: " + String(password));
  Serial.println("TIMEOUT: 4 minutes");
  Serial.println("RESET: Connect GPIO14 to 3.3V and reset ESP32");

  WiFi.softAP(ssid, password);
  IPAddress IP = WiFi.softAPIP();
  Serial.println("Web interface: http://" + IP.toString());
  server.begin();

  for (int i = 0; i < 10; i++) {
    digitalWrite(LED_PIN, HIGH);
    delay(200);
    digitalWrite(LED_PIN, LOW);
    delay(200);
  }
}

void handleWebClient() {
  WiFiClient client = server.available();

  if (client) {
    Serial.println("Client connected");
    String currentLine = "";

    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        if (c == '\n') {
          if (currentLine.length() == 0) {
            sendWebPage(client);
            break;
          } else {
            currentLine = "";
          }
        } else if (c != '\r') {
          currentLine += c;
        }

        if (currentLine.endsWith("POST /syncTime")) {
          handleTimeSyncRequest(client);
        } else if (currentLine.endsWith("POST /setRunTime")) {
          handleRunTimeRequest(client);
        } else if (currentLine.endsWith("POST /setSchedule")) {
          handleScheduleRequest(client);
        }
      }
    }
    client.stop();
  }
}

// Simplified web page (keeping core functionality)
void sendWebPage(WiFiClient &client) {
  unsigned long elapsed = millis() - webServerStartTime;
  unsigned long remaining = (240000 - elapsed) / 1000;

  client.println("HTTP/1.1 200 OK");
  client.println("Content-type:text/html");
  client.println();
  client.println("<!DOCTYPE html><html>");
  client.println("<head><title>ESP32 Motor Timer Setup</title>");
  client.println("<meta name='viewport' content='width=device-width, initial-scale=1'>");
  client.println("<style>");
  client.println("body{font-family:Arial;text-align:center;padding:20px;background:#f0f0f0;}");
  client.println(".container{max-width:600px;margin:0 auto;background:white;padding:30px;border-radius:10px;}");
  client.println("input,button{padding:10px;margin:5px;font-size:16px;border:1px solid #ddd;border-radius:5px;}");
  client.println("button{background:#4CAF50;color:white;border:none;cursor:pointer;padding:15px 30px;}");
  client.println(".timeout{color:red;font-weight:bold;}");
  client.println(".step{margin:20px 0;padding:15px;background:#f9f9f9;border-radius:5px;}");
  client.println(".schedule-grid{display:grid;grid-template-columns:repeat(4,1fr);gap:10px;margin:20px 0;}");
  client.println(".hour-checkbox{display:flex;align-items:center;padding:8px;background:white;border:1px solid #ddd;border-radius:5px;}");
  client.println(".reset-info{background:#FFE6E6;padding:10px;border-radius:5px;margin:10px 0;border:1px solid #FF9999;}");
  client.println("</style></head>");
  client.println("<body>");
  client.println("<div class='container'>");
  client.println("<h1>ESP32 Motor Timer Setup</h1>");

  client.println("<div class='reset-info'>");
  client.println("<strong>Reset Instructions:</strong><br>");
  client.println("To clear settings: Connect GPIO14 to 3.3V and reset ESP32");
  client.println("</div>");

  client.println("<div class='timeout'>Timeout: <span id='countdown'>" + String(remaining) + "</span> seconds</div>");

  // Step 1: Time sync
  client.println("<div class='step'>");
  client.println("<h3>Step 1: Set Current Time</h3>");
  if (timeWasSet) {
    client.println("<p>✅ Time set: " + rtc.getTime("%H:%M:%S %d/%m/%Y") + "</p>");
  } else {
    client.println("<h4 id='currentTime'></h4>");
    client.println("<form action='/syncTime' method='POST'>");
    client.println("<input type='hidden' name='epochTime' id='hiddenEpochTime'>");
    client.println("<button type='submit'>Sync Time</button>");
    client.println("</form>");
  }
  client.println("</div>");

  // Step 2: Motor run time
  client.println("<div class='step'>");
  client.println("<h3>Step 2: Set Motor Run Time</h3>");
  if (runTimeWasSet) {
    client.println("<p>✅ Run time set: " + String(motorRunTime) + " seconds</p>");
  } else {
    client.println("<form action='/setRunTime' method='POST'>");
    client.println("<input type='range' name='runTime' min='5' max='300' value='" + String(motorRunTime) + "'>");
    client.println("<span id='runTimeDisplay'>" + String(motorRunTime) + "s</span>");
    client.println("<button type='submit'>Set Run Time</button>");
    client.println("</form>");
  }
  client.println("</div>");

  // Step 3: Schedule
  client.println("<div class='step'>");
  client.println("<h3>Step 3: Select Operation Hours</h3>");
  if (scheduleWasSet) {
    client.println("<p>✅ Schedule set!</p>");
  } else {
    client.println("<form action='/setSchedule' method='POST'>");
    client.println("<div class='schedule-grid'>");
    for (int h = 0; h < 24; h++) {
      client.println("<div class='hour-checkbox'>");
      client.println("<input type='checkbox' name='hour" + String(h) + "' value='1'>");
      client.println("<label>" + String(h < 10 ? "0" : "") + String(h) + ":00</label>");
      client.println("</div>");
    }
    client.println("</div>");
    client.println("<button type='submit'>Set Schedule</button>");
    client.println("</form>");
  }
  client.println("</div>");

  if (timeWasSet && scheduleWasSet && runTimeWasSet) {
    client.println("<div class='step'>");
    client.println("<h3>✅ Setup Complete!</h3>");
    client.println("<p>ESP32 will now enter scheduled operation mode.</p>");
    client.println("<button onclick='startOperation()'>Start Operation</button>");
    client.println("</div>");
  }

  client.println("</div>");

  // Simplified JavaScript
  client.println("<script>");
  client.println("var countdown=" + String(remaining) + ";");
  client.println("function updateTime(){");
  client.println("var now=new Date();");
  client.println("if(document.getElementById('currentTime'))");
  client.println("document.getElementById('currentTime').innerHTML='Current Time: '+now.toLocaleString();");
  client.println("if(document.getElementById('hiddenEpochTime'))");
  client.println("document.getElementById('hiddenEpochTime').value=Math.floor(now.getTime()/1000);");
  client.println("}");
  client.println("function updateCountdown(){");
  client.println("countdown--;document.getElementById('countdown').innerHTML=countdown;");
  client.println("}");
  client.println("function startOperation(){");
  client.println("document.body.innerHTML='<h2>Starting operation...</h2>';");
  client.println("}");
  client.println("setInterval(updateTime,1000);setInterval(updateCountdown,1000);updateTime();");
  client.println("</script></body></html>");
}

void handleTimeSyncRequest(WiFiClient &client) {
  String requestBody = "";
  while (client.available()) {
    requestBody += (char)client.read();
  }

  int epochIndex = requestBody.indexOf("epochTime=");
  if (epochIndex != -1) {
    long epochTime = requestBody.substring(epochIndex + 10).toInt();
    rtc.setTime(epochTime);
    timeWasSet = true;
    Serial.println("Time synchronized: " + rtc.getTime("%A, %B %d %Y %H:%M:%S"));
  }

  client.println("HTTP/1.1 302 Found");
  client.println("Location: /");
  client.println();
}

void handleRunTimeRequest(WiFiClient &client) {
  String requestBody = "";
  while (client.available()) {
    requestBody += (char)client.read();
  }

  int runTimeIndex = requestBody.indexOf("runTime=");
  if (runTimeIndex != -1) {
    int newRunTime = requestBody.substring(runTimeIndex + 8).toInt();
    if (newRunTime >= MIN_MOTOR_ON_TIME && newRunTime <= MAX_MOTOR_ON_TIME) {
      motorRunTime = newRunTime;
      runTimeWasSet = true;
      Serial.println("Motor run time set to: " + String(motorRunTime) + " seconds");
    }
  }

  client.println("HTTP/1.1 302 Found");
  client.println("Location: /");
  client.println();
}

void handleScheduleRequest(WiFiClient &client) {
  String requestBody = "";
  while (client.available()) {
    requestBody += (char)client.read();
  }

  for (int h = 0; h < 24; h++) {
    hourlySchedule[h] = false;
  }

  for (int h = 0; h < 24; h++) {
    String hourParam = "hour" + String(h) + "=1";
    if (requestBody.indexOf(hourParam) != -1) {
      hourlySchedule[h] = true;
    }
  }

  scheduleWasSet = true;

  // Save to EEPROM when configuration is complete
  if (timeWasSet && scheduleWasSet && runTimeWasSet) {
    saveSettingsToEEPROM();
    delay(2000);
    scheduleNextWakeup();
  }

  client.println("HTTP/1.1 302 Found");
  client.println("Location: /");
  client.println();
}

void printWakeupReason() {
  esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();

  switch (wakeup_reason) {
    case ESP_SLEEP_WAKEUP_TIMER:
      Serial.println("Wake-up: Scheduled timer");
      break;
    case ESP_SLEEP_WAKEUP_EXT0:
      Serial.println("Wake-up: GPIO14 external signal (RESET MODE)");
      break;
    default:
      Serial.println("Wake-up: Power on or reset");
      break;
  }
}

// Helper: Connect to WiFi for Telegram
void connectToWiFiForTelegram() {
  if (WiFi.status() == WL_CONNECTED) return;
  WiFi.mode(WIFI_STA);
  WiFi.begin(TELEGRAM_WIFI_SSID, TELEGRAM_WIFI_PASSWORD);
  unsigned long startAttemptTime = millis();
  while (WiFi.status() != WL_CONNECTED && millis() - startAttemptTime < 15000) {
    delay(500);
  }
}

// Helper: Send Telegram message
void sendTelegramMessage(const String& message) {
  connectToWiFiForTelegram();
  secured_client.setInsecure(); // For ESP32, disables certificate validation
  bot.sendMessage(CHAT_ID, message, "");
}