############################################# ############################################# # DOWNSTAIRS BATHROOM HEATED TOWEL RAIL # Controlled by a Sonoff Basic # # V1.1 2025-04-12 Fixes to timers and offline modes # V1.0 2025-02-14 Initial Version # # INSTRUCTIONS # - It allows a heated towel rail device to work in a standalone operation # - On startup, it will turn on for (startup_duration) hours then go into timer mode (this allows you to just turn it on to get some heat immediately) # - The timer has a morning and evening time (but no weekday/weekend setting) # - Default values are 5am-7am and 9pm-Midnight (as this suits our use case) # - It uses SNTP for time setting (but obviously only if wifi & networking are working) # - It will default to an internal timer if no wifi. To reset internal timer, reboot the device at 12pm (noon) # - If on a network and there is a MQTT server, you can set the 4 on/off times via MQTT (See below commands) # - You can set 4 modes ON/OFF/TIMER/STARTUP via MQTT. That way, you can set to STARTUP for a short boost # - Any new timer times set via MQTT will be remembered though a reboot # - On a reboot, the device will always turn on for the Startup Duration (STARTUP mode, default 2 hours) # - TIMER mode will always be switched on after startup mode is complete # - If you need it ON continuously with no MQTT, toggle power ON/OFF 4 times within 30 seconds (with ~2 secs in between to allow it to boot) # # MQTT Commands # Values will be set in place on the update_interval time, not immediately # Use 00:00 in 24hr format for time setting. Note there is no weekday/weekend setting # mqtt_timer_topic/morning-on/06:00 : Time towel rail will go on # mqtt_timer_topic/morning-off/08:00 : Time towel rail will go off # mqtt_timer_topic/evening-on/09:00 : Time towel rail will go on # mqtt_timer_topic/evening-off/00:00 : Time towel rail will go off # mqtt_timer_topic/operation/ON : Towel rail permanently on # mqtt_timer_topic/operation/OFF : Towel rail permanently off # mqtt_timer_topic/operation/TIMER : Towel rail will obey timer settings # mqtt_timer_topic/operation/STARTUP : Turn on for (startup_duration) hours then TIMER (also on startup) # ############################################# ############################################# ############################################# # SPECIFIC DEVICE VARIABLE SUBSTITUTIONS # If NOT using a secrets file, just replace these with the passwords etc (in quotes) ############################################# substitutions: devicename: "esp-downstbathtowelrail" friendly_name: "Downstairs Bathroom Towelrail" description_comment: "Sonoff Basic controlling ON/OFF/Timer for the Heated Towel Rail in the Downstairs Bathroom" api_key: !secret esp-downstbathtowelrail_api_key # unfortunately you can't use substitutions inside secrets names ota_pass: !secret esp-downstbathtowelrail_ota_pass # unfortunately you can't use substitutions inside secrets names static_ip_address: !secret esp-downstbathtowelrail_ip log_level: "INFO" # Define logging level: NONE, ERROR, WARN, INFO, DEBUG (Default), VERBOSE, VERY_VERBOSE update_interval: "60s" # update time for for general sensors etc room: "Downstairs Bathroom" # Allows ESP device to be automatically linked to an 'Area' in Home Assistant. ############################################# # SPECIFIC PROJECT VARIABLE SUBSTITUTIONS ############################################# mqtt_timer_topic: "viewroad-commands/downstbath-towelrail" # Topics you will use to change stuff startup_duration: "120" # Minutes to stay ON in STARTUP mode before reverting to TIMER ############################################# # Included Common Packages # https://esphome.io/components/esphome.html ############################################# packages: common_wifi: !include file: common/network_common.yaml vars: local_static_ip_address: ${static_ip_address} local_ota_pass: ${ota_pass} common_api: !include file: common/api_common.yaml vars: local_api_key: ${api_key} # common_webportal: !include # file: common/webportal_common.yaml common_mqtt: !include file: common/mqtt_common.yaml common_sntp: !include file: common/sntp_common.yaml common_general_sensors: !include file: common/sensors_common.yaml vars: local_friendly_name: ${friendly_name} local_update_interval: ${update_interval} ############################################# # ESPHome # https://esphome.io/components/esphome.html ############################################# esphome: name: ${devicename} friendly_name: ${friendly_name} comment: ${description_comment} # Appears on the esphome page in HA area: "${room}" on_boot: priority: 900 # High priority to run after globals are initialized then: - lambda: |- // 1) Figure out the current time in "seconds from midnight" // using SNTP if available, otherwise current_mins * 60. bool have_sntp = id(sntp_time).now().is_valid(); int current_time_s = 0; if (have_sntp) { auto now = id(sntp_time).now(); current_time_s = now.hour * 3600 + now.minute * 60 + now.second; } else { // current_mins is in minutes; convert to seconds current_time_s = id(current_mins) * 60; } // 2) Compare with the last boot time int diff = current_time_s - id(last_boot_time_s); // If within 30 seconds, increment boot_count; otherwise reset to 1 if (diff >= 0 && diff <= 30) { id(boot_count)++; } else { id(boot_count) = 1; } // Update stored last boot time id(last_boot_time_s) = current_time_s; // 3) If we've booted 4+ times in 20s => force ON mode if (id(boot_count) >= 4) { id(operation_mode) = 1; // ON ESP_LOGI("power_cycle", "Detected 4 power cycles in 20s => Forcing ON mode"); } else { // Otherwise do your normal startup logic: id(operation_mode) = 3; // on_boot -> sets operation_mode = 3 (STARTUP) id(startup_timer) = 0; // and reset startup_timer = 0 (for time sync if no sntp) ESP_LOGI("power_cycle", "Boot count=%d => STARTUP mode", id(boot_count)); } ############################################# # ESP Platform and Framework # https://esphome.io/components/esp32.html ############################################# esp8266: board: esp01_1m # The original sonoff basic ############################################# # ESPHome Logging Enable # https://esphome.io/components/logger.html ############################################# logger: level: ${log_level} #INFO Level suggested, or DEBUG for testing #baud_rate: 0 #set to 0 for no logging via UART, needed if you are using it for other serial things (eg PZEM) #esp8266_store_log_strings_in_flash: false #tx_buffer_size: 64 ############################################# # Global Variables for use in automations etc # https://esphome.io/guides/automations.html?highlight=globals#global-variables ############################################# globals: # Tracks the time (in seconds from midnight) at the previous boot - id: last_boot_time_s type: int restore_value: true initial_value: "0" # Counts how many consecutive boots have occurred (within X seconds) - id: boot_count type: int restore_value: true initial_value: "0" # Morning On time (minutes from midnight), # default 07:00 => 420 - id: morning_on type: int restore_value: true initial_value: "420" # Morning Off time (minutes from midnight), # default 07:30 => 450 - id: morning_off type: int restore_value: true initial_value: "450" # Evening On time (minutes from midnight), # default 21:00 => 1260 - id: evening_on type: int restore_value: true initial_value: "1260" # Evening Off time (minutes from midnight), # default 22:00 => 1320 => treat as midnight - id: evening_off type: int restore_value: true initial_value: "1320" #################################################### # operation_mode: # 0 = OFF # 1 = ON # 2 = TIMER # 3 = STARTUP #################################################### - id: operation_mode type: int restore_value: false initial_value: "3" #################################################### # current_mins is set if SNTP is invalid. # We assume user powers on the device at 12:00 noon # => 12 * 60 = 720 minutes from midnight. # Not restored, so it resets each boot. #################################################### - id: current_mins type: int restore_value: false initial_value: "720" # 720 is 12:00 Noon #################################################### # startup_timer: counts minutes in STARTUP mode # After 'startup_duration' minutes, revert to TIMER. # Not restored, so each boot starts fresh at 0. #################################################### - id: startup_timer type: int restore_value: false initial_value: "0" ############################################# # Text Sensors # https://esphome.io/components/text_sensor/index.html ############################################# text_sensor: ############################ # MQTT Subscriptions ############################ #################################################### # Subscribe to the Morning On time, format "HH:MM" # We check x.size() == 5 and x[2] == ':', # then parse x.substr(0,2) and x.substr(3,2) # std::string uses 'substr', not 'substring'. #################################################### - platform: mqtt_subscribe name: "Morning On Time Setting" id: morning_on_topic topic: "${mqtt_timer_topic}/morning-on" # Stored in the format HH:MM internal: True on_value: then: - lambda: |- // Expect "HH:MM" => total length = 5, with ':' if (x.size() == 5 && x[2] == ':') { int hour = atoi(x.substr(0, 2).c_str()); // "HH" int minute = atoi(x.substr(3, 2).c_str()); // "MM" id(morning_on) = hour * 60 + minute; ESP_LOGI("timer","Received new Morning On: %02d:%02d", hour, minute); } else { ESP_LOGW("timer","Invalid Morning On format: %s", x.c_str()); } #################################################### # Morning Off time => "HH:MM" #################################################### - platform: mqtt_subscribe name: "Morning Off Time Setting" id: morning_off_topic topic: "${mqtt_timer_topic}/morning-off" # Stored in the format HH:MM internal: True # No need to show this in Home Assistant as there is a sensor that shows the set value on_value: then: - lambda: |- if (x.size() == 5 && x[2] == ':') { int hour = atoi(x.substr(0, 2).c_str()); int minute = atoi(x.substr(3, 2).c_str()); id(morning_off) = hour * 60 + minute; ESP_LOGI("timer","Received new Morning Off: %02d:%02d", hour, minute); } else { ESP_LOGW("timer","Invalid Morning Off format: %s", x.c_str()); } #################################################### # Evening On time => "HH:MM" #################################################### - platform: mqtt_subscribe name: "Evening On Time Setting" id: evening_on_topic topic: "${mqtt_timer_topic}/evening-on" # Stored in the format HH:MM internal: True # No need to show this in Home Assistant as there is a sensor that shows the set value on_value: then: - lambda: |- if (x.size() == 5 && x[2] == ':') { int hour = atoi(x.substr(0, 2).c_str()); int minute = atoi(x.substr(3, 2).c_str()); id(evening_on) = hour * 60 + minute; ESP_LOGI("timer","Received new Evening On: %02d:%02d", hour, minute); } else { ESP_LOGW("timer","Invalid Evening On format: %s", x.c_str()); } #################################################### # Evening Off time => "HH:MM" #################################################### - platform: mqtt_subscribe name: "Evening Off Time Setting" id: evening_off_topic topic: "${mqtt_timer_topic}/evening-off" # Stored in the format HH:MM internal: True # No need to show this in Home Assistant as there is a sensor that shows the set value on_value: then: - lambda: |- if (x.size() == 5 && x[2] == ':') { int hour = atoi(x.substr(0, 2).c_str()); int minute = atoi(x.substr(3, 2).c_str()); id(evening_off) = hour * 60 + minute; ESP_LOGI("timer","Received new Evening Off: %02d:%02d", hour, minute); } else { ESP_LOGW("timer","Invalid Evening Off format: %s", x.c_str()); } #################################################### # Subscribe to operation mode: # OFF, ON, TIMER, STARTUP # We do case-insensitive compare using strcasecmp # (Requires typically included in ESPHome) #################################################### - platform: mqtt_subscribe name: "Operation Mode Setting" id: timer_operation_mode_topic topic: "${mqtt_timer_topic}/operation" # STARTUP,ON,OFF,TIMER internal: True # No need to show this in Home Assistant as there is a sensor that shows the set value on_value: then: - lambda: |- /* * In standard C++ (ESPHome), no 'equalsIgnoreCase()'. * We use 'strcasecmp' for case-insensitive compare. * Returns 0 if they match ignoring case. */ if (strcasecmp(x.c_str(), "TIMER") == 0) { id(operation_mode) = 2; ESP_LOGI("timer","Operation mode set to TIMER"); } else if (strcasecmp(x.c_str(), "ON") == 0) { id(operation_mode) = 1; ESP_LOGI("timer","Operation mode set to ON"); } else if (strcasecmp(x.c_str(), "OFF") == 0) { id(operation_mode) = 0; ESP_LOGI("timer","Operation mode set to OFF"); } else if (strcasecmp(x.c_str(), "STARTUP") == 0) { id(operation_mode) = 3; id(startup_timer) = 0; // Reset the startup timer to zero ESP_LOGI("timer","Operation mode set to STARTUP"); } else { ESP_LOGW("timer","Invalid operation mode: %s", x.c_str()); } ###################################################### # Expose the current operation mode (OFF, ON, TIMER, STARTUP) ###################################################### - platform: template name: "Operation Mode State" lambda: |- // 0=OFF, 1=ON, 2=TIMER, 3=STARTUP switch (id(operation_mode)) { case 0: return {"OFF"}; case 1: return {"ON"}; case 2: return {"TIMER"}; case 3: return {"STARTUP"}; default: return {"UNKNOWN"}; } update_interval: ${update_interval} ###################################################### # Expose the "Morning On" time as a text (HH:MM) ###################################################### - platform: template name: "Timeclock: Morning On Time" lambda: |- int hour = id(morning_on) / 60; int minute = id(morning_on) % 60; // Increase to 16 for safety char buff[16]; snprintf(buff, sizeof(buff), "%02d:%02d", hour, minute); return { std::string(buff) }; update_interval: ${update_interval} ###################################################### # Expose the "Morning Off" time as a text (HH:MM) ###################################################### - platform: template name: "Timeclock: Morning Off Time" lambda: |- int hour = id(morning_off) / 60; int minute = id(morning_off) % 60; // Increase buffer size to 8 just to be safe // Increase to 16 for safety char buff[16]; snprintf(buff, sizeof(buff), "%02d:%02d", hour, minute); return { std::string(buff) }; update_interval: ${update_interval} ###################################################### # Expose the "Evening On" time as a text (HH:MM) ###################################################### - platform: template name: "Timeclock: Evening On Time" lambda: |- int hour = id(evening_on) / 60; int minute = id(evening_on) % 60; // Increase buffer size to 8 just to be safe // Increase to 16 for safety char buff[16]; snprintf(buff, sizeof(buff), "%02d:%02d", hour, minute); return { std::string(buff) }; update_interval: ${update_interval} ###################################################### # Expose the "Evening Off" time as a text (HH:MM) ###################################################### - platform: template name: "Timeclock: Evening Off Time" lambda: |- int hour = id(evening_off) / 60; int minute = id(evening_off) % 60; // Increase buffer size to 8 just to be safe // Increase to 16 for safety char buff[16]; snprintf(buff, sizeof(buff), "%02d:%02d", hour, minute); return { std::string(buff) }; update_interval: ${update_interval} ############################################# # Sensors # https://esphome.io/components/text_sensor/index.html ############################################# sensor: - platform: template name: "Mins from Midnight" unit_of_measurement: "mins" accuracy_decimals: 0 update_interval: ${update_interval} internal: True lambda: |- return id(current_mins); #################################################### # Relay Switch (Sonoff Basic Relay on GPIO12) #################################################### switch: - platform: gpio name: "Towel Rail Power" pin: GPIO12 id: relay restore_mode: RESTORE_DEFAULT_OFF #################################################### # Check every minute to decide relay state #################################################### interval: - interval: "1min" # Must be 1min as this is used to calculate times then: - lambda: |- // Do we have correct time from SNTP? If not... if (!id(time_sync).has_state()) { // Set minutes since midnight id(current_mins) = id(current_mins) +1 ; // wrap around at 1440 => next day if (id(current_mins) >= 1440) { id(current_mins) = 0; } // If we do have proper SNMP time... } else { // Use real time from SNTP auto now = id(sntp_time).now(); id(current_mins) = now.hour * 60 + now.minute; } // operation_mode: // 0 = OFF // 1 = ON // 2 = TIMER // 3 = STARTUP int mode = id(operation_mode); ////////////////////////////////////////////////// // STARTUP MODE: Relay ON for 'startup_duration' // minutes, then automatically revert to TIMER. ////////////////////////////////////////////////// if (mode == 3) { id(startup_timer) = id(startup_timer) + 1 ; // works as long as update_interval in seconds // Compare with the substitution startup_duration if (id(startup_timer) < (int) ${startup_duration}) { // Still within the STARTUP period => turn relay on id(relay).turn_on(); } else { // After 'startup_duration' minutes => switch to TIMER id(operation_mode) = 2; id(mqtt_client).publish("${mqtt_timer_topic}/operation", "TIMER"); } // Skip the rest of the logic ESP_LOGI("startup_timer", "startup_timer=%d", id(startup_timer)); return; } ////////////////////////////////////////////////// // OFF MODE => always off ////////////////////////////////////////////////// if (mode == 0) { id(relay).turn_off(); return; } ////////////////////////////////////////////////// // ON MODE => always on ////////////////////////////////////////////////// if (mode == 1) { id(relay).turn_on(); return; } ////////////////////////////////////////////////// // TIMER MODE => follow morning/evening schedule // using SNTP if valid, else current_mins ////////////////////////////////////////////////// if (mode == 2) { bool should_on = false; // Check morning window // Example: morning_on=360 => 06:00, morning_off=480 => 08:00 // If current_mins in [360..480), should_on = true if (id(current_mins) >= id(morning_on) && id(current_mins) < id(morning_off) ) { should_on = true; } // Check evening window // Example: evening_on=1260 => 21:00, evening_off=1440 => midnight if (id(current_mins) >= id(evening_on) && id(current_mins) < id(evening_off) ) { should_on = true; } // Final relay state based on schedule if (should_on) { id(relay).turn_on(); } else { id(relay).turn_off(); } }