EHLPClock.yaml

# My github: https://github.com/trip5
substitutions:
  name: led-pixelclock
  friendly_name: Led-PixelClock
  comment: "EHLPClock from Trip5"
  project_version: "2024.12.09"
  project_name: Trip5.EspHomeLedPixelClock
  waiting: " . EHLPClock . ." # shows when waiting for time

  # Time zone can be Olsen type ("Asia/Seoul") # Check https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
  # or POSIX format: (ie "KST-9" & "PST8PDT,M3.2.0/2:00:00,M11.1.0/2:00:00" & "AST4ADT,M3.2.0,M11.1.0")
  # Most can be viewed here: https://github.com/nayarsystems/posix_tz_db/blob/master/zones.csv
  # or here: https://support.cyberdata.net/portal/en/kb/articles/010d63c0cfce3676151e1f2d5442e311
  # If you need to make a custom POSIX format you can look here: https://developer.ibm.com/articles/au-aix-posix/)
  # or even better, use this POSIX Generator (courtesy of TopYuan): https://www.topyuan.top/posix
  time_zone: "AST4ADT,M3.2.0,M11.1.0"
    
  # time and date formats: https://esphome.io/components/time/?highlight=strftime#strftime and https://strftime.org/
  # time_format: "%H:%M" (13:25) / "%H:%M:%S" (13:25:59) / "%I:%M%p" (01:25PM) / "%l:%M%p" (1:25PM)
  time_format12: "%l:%M%p"
  time_format24: "%H:%M:%S"
  # date_format: "%m.%d" (02.28) / "%y.%m.%d" (23.02.28) / "%b %d" (Feb 08) / "%a %d" (Tue 08)
  date_format: "%b %d" # Jan 01
  # date_formatA, if turned on, will split the time of the date display with the main date (and occur before):
  date_formatA: "%a" # Mon
  # Special note that ESPHome can't seem to use any locale for time other than English. In the text_sensors section, you can find filters that allow substitutions.
  # Please be sure to add those needed characters to the glyphs as well, or those special characters will not be displayed!

  # Pins for Display
  clk_pin: GPIO14
  mosi_pin: GPIO13
  cs_pin: GPIO15
  # Pins for I2C RTC
  scl_pin: GPIO4
  sda_pin: GPIO5
  # Other Pins
  status_led_pin: GPIO2
  download_button_pin: GPIO0
  rotation_pin: GPIO16

esphome:
  name: ${name}
  comment: "${comment}"
  project:
    name: "${project_name}"
    version: "${project_version}"
  min_version: 2023.11.0
  on_boot:
    - priority: 600
      then:
        - ds1307.read_time:
    - priority: -100
      then:
        - wait_until:
            condition:
              - lambda: 'return (id(my_time).now().is_valid());'
        - ds1307.write_time:

esp8266:
  board: esp12e
  restore_from_flash: True

wifi:
  networks:
    - ssid: !secret wifi_ssid
      password: !secret wifi_password
  reboot_timeout: 0s # reboot if no wifi (must be disabled for wifi to be turned off)
  enable_on_boot: True
  id: wifi_id
  ap:
    ssid: ${name}
    password: !secret ap_password
    ap_timeout: 10s # this has to be short, especially if using Stop Seek Wifi
  on_connect:
    - logger.log: "Wifi connected"
    - light.turn_off: led1
    - delay: 1s
    - button.press: display_ip
    - lambda: |-
        id(wifi_stop_seek_time_count) = 0;
        id(my_time)->update();
  on_disconnect:
    - if:
        condition:
          - switch.is_on: wifi_stop_seek
        then:
          - logger.log: "Wifi disconnected - will be disabled soon (stop seek is on)..."
        else:
          - logger.log: "Wifi disconnected"
    - delay: 1s
    - button.press: display_ip

font:
  # Get the fonts from https://github.com/trip5/MatrixClockFonts (but you can use others too!)
  # The glyphs must be present or you'll see boxes/blank spaces (no problem unless you edit the Display section below) - don't forget to include a space!
  # How to get an easy glyphs list? Click here and edit the s = string to your needs: https://www.onlinegdb.com/fork/zh1VszNT1
  # It's the Java code from here: https://www.geeksforgeeks.org/cpp-program-to-remove-duplicates-from-a-given-string/
  # ...to here (OnlineGDB's Java handles Unicode a bit better than the C++ compiler): https://www.onlinegdb.com/online_java_compiler
  - file: fonts/MatrixChunky8X.ttf
    id: default_font
    size: 8
    glyphs: |-
      0123456789:.Sun MoTesWdhFriatAPJbpylgOcNvD오후전일월화수목금토요
    # Above covers Sun Mon Tues Wed Thu Fri Sat AM PM Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec as well as Korean Dates
  - file: fonts/MatrixLight8X.ttf
    id: message_font
    size: 8
    glyphs: |-
      %0123456789 EHLPClock.DatenfWiONI:SpTAr
    # Above should cover the system messages: "EHLPClock . / Wifi Off / No Wifi / IP: / Date on / Date off / StopSeek / Seek... / OTA % / Done / Error"

time:
  - platform: sntp # use SNTP as a time source
    id: my_time
    timezone: "${time_zone}"
    update_interval: 24h # This seems like the longest safe amount of time - actual configured update happens in interval section
  - platform: ds1307 # even though it's a ds3231
    id: my_time_ds
    update_interval: never
    timezone: "${time_zone}"

script:
  - id: sync_the_time
    mode: restart
    then:
      - lambda: 'id(my_time)->update();'
      - ds1307.write_time:
  - id: display_off_activate
    mode: restart
    then:
      - lambda: |-
          id(display_off) = true;
  - id: display_off_deactivate
    mode: restart
    then:
      - lambda: |-
          id(display_off_time_count) = 0;
          id(display_off) = false;

# Enable Home Assistant API
api:
  # delete next 2 lines if not using HA API encryption
  encryption:
    key: !secret encryption_key
  reboot_timeout: 0s # Must be disabled to allow the Wifi enable/disable to function

mdns:
  disabled: False # needs to be on to connect to HA

logger:
  level: NONE
# Logging is disabled to save memory but you can easily enable logging (and stop the various sensors/switches from spamming the log) by deleting the above line and uncommening the lines below
# Note that increasing the level uses up memory (which this device has very little available) and may cause errors and/or crashing - please note it's also disabled in the web_server section
#  level: DEBUG
#  logs:
#    sensor: ERROR
#    text_sensor: NONE
#    switch: NONE
#    light: NONE
#    number: NONE

web_server:
  port: 80
  ota: True
  include_internal: False # True will expose more than needed to the Web UI
  version: 2 # version 3 is much larger but possible if local is False
  local: True # will download www.js and serve it directly from the clock
  log: False # disabling in the WebUI to save memory

ota:
  - platform: esphome
    password: !secret ota_password
    on_begin:
      then:
        - lambda: |-
            id(matrix)->clear();
            id(matrix)->print(0, 0, id(message_font), "OTA...");
            id(matrix)->loop();
        - logger.log: "OTA Update started."
    on_progress:
      then:
        - lambda: |-
            if (x > 9) {
              id(matrix)->clear();
              id(matrix)->printf(0, 0, id(message_font), "OTA %d%%", (int)x);
              id(matrix)->loop();
            }
        - logger.log:
            format: "OTA progress %0.1f%%"
            args: ["x"]
    on_end:
      then:
        - lambda: |-
            id(matrix)->clear();
            id(matrix)->print(0, 0, id(message_font), "OTA Done");
            id(matrix)->loop();
        - logger.log: "OTA end"
    on_error:
      then:
        - lambda: |-
            id(matrix)->clear();
            id(matrix)->print(0, 0, id(message_font), "Error!");
            id(matrix)->loop();
        - logger.log:
            format: "OTA update error %d"
            args: ["x"]

captive_portal:

text_sensor:
  - platform: version
    name: "${friendly_name} ESPHome Version"
    hide_timestamp: True
    entity_category: diagnostic
  - platform: wifi_info
    ip_address:
      id: wifi_ip
      name: "${friendly_name} IP Address"
      entity_category: diagnostic
    ssid:
      id: wifi_ssid
      name: "${friendly_name} SSID"
      entity_category: diagnostic
  - platform: template
    name: "${friendly_name} ${project_name} Version"
    lambda: 'return to_string("${project_version}");'
    entity_category: diagnostic
    update_interval: 1h
  - platform: template
    name: "${friendly_name} Time Zone"
    lambda: 'return {"${time_zone}"};'
    entity_category: diagnostic
    update_interval: 1h
  # Below this point are text sensors to hold time and date and allow for substitutions... you can delete/edit the filters, just don't delete the entire text sensor
  # The github repo should also contain methods to change the time into other localized formats.
  - platform: template
    id: time_text
    name: "${friendly_name} Replacement Time Text"
    entity_category: diagnostic
    update_interval: never
    internal: True
    filters:
      - lambda: |-
          // Korean generally puts the 오후/오전 before the time, so let's just use a different format entirely "%p%l%M" (PM1:25) and run a substitute on it
          if (id(hour12_mode).state == 1) {
            int offset = 0;
            if (id(tzoffset_on).state != 0) {
              offset = (int)(60 * 60 * (id(tzoffset).state));
            }
            std::time_t tz1time = (id(my_time).now().timestamp + offset);
            std::tm *tz1time_astm = localtime(&tz1time);
            char display_tmdt[20];
            strftime(display_tmdt, 20, "%p%l:%M", tz1time_astm);
            std::string tmdt(display_tmdt);
            return tmdt;
          } else {
            return x;
          }
      - append: ""
      - prepend: ""
      - substitute:
        - "AM -> 오전"
        - "PM -> 오후"
  - platform: template
    id: date_text
    name: "${friendly_name} Replacement Date Text"
    entity_category: diagnostic
    update_interval: never
    internal: True
    filters:
      - append: "일"
      - prepend: ""
      - substitute:
        - "Jan -> 1월"
        - "Feb -> 2월"
        - "Mar -> 3월"
        - "Apr -> 4월"
        - "May -> 5월"
        - "Jun -> 6월"
        - "Jul -> 7월"
        - "Aug -> 8월"
        - "Sep -> 9월"
        - "Oct -> 10월"
        - "Nov -> 11월"
        - "Dec -> 12월"
  - platform: template
    id: dateA_text
    name: "${friendly_name} Replacement Date A Text"
    entity_category: diagnostic
    update_interval: never
    internal: True
    filters:
      - append: ""
      - prepend: ""
      - substitute:
        - "Sun -> 일요일"
        - "Mon -> 월요일"
        - "Tue -> 화요일"
        - "Wed -> 수요일"
        - "Thu -> 목요일"
        - "Fri -> 금요일"
        - "Sat -> 토요일"

output:
  - platform: esp8266_pwm
    id: statusled
    pin:
      number: ${status_led_pin}
      inverted: True

light:
  - platform: monochromatic
    id: led1
    name: "${friendly_name} Status LED"
    output: statusled
    internal: True

preferences:
  flash_write_interval: 15s # 0 does immediate write to memory with no mem buffer (not recommended) (only saves when persistent variables have changed)

i2c:
  sda: ${sda_pin}
  scl: ${scl_pin}
  scan: True
  id: i2cbus

spi:
  clk_pin: ${clk_pin}
  mosi_pin: ${mosi_pin}

# Some info how to handle multi_click options: https://community.home-assistant.io/t/esphome-button-held-double-press/136083/10
binary_sensor:
  - platform: status
    name: "${friendly_name} Status"
  - platform: gpio
    pin: 
      number: ${download_button_pin}
      inverted: True
    name: "${friendly_name} Download Button"
    filters:
      - delayed_on: 10ms
      - delayed_off: 10ms
    on_multi_click:
      #Click will toggle Date display mode (or turn screen on again)
      - timing:
          - ON for at most 0.5s
          - OFF for at least 0.5s
        then:
          if:
            condition:
              - lambda: 'return id(display_off);'
            then:
              - script.execute: display_off_deactivate
            else:
              - switch.toggle: date_display_mode
      #Double-Click will toggle 12-hour mode (or turn screen on again)
      - timing:
          - ON for at most 1s
          - OFF for at most 0.5s
          - ON for at most 1s
          - OFF for at least 0.1s
        then:
          if:
            condition:
              - lambda: 'return id(display_off);'
            then:
              - script.execute: display_off_deactivate
            else:
              - switch.toggle: hour12_mode
      #Click once, then Hold will toggle TZ Offset (or turn screen on again)
      - timing:
          - ON for at most 1s
          - OFF for at most 0.5s
          - ON for at least 1s
        then:
          if:
            condition:
              - lambda: 'return id(display_off);'
            then:
              - script.execute: display_off_deactivate
            else:
              - switch.toggle: tzoffset_on
      #Hold 2s will show the IP (or other wifi status) (or turn screen on again)
      - timing:
          - ON for at least 2s
          - OFF for at least 0.5s
        then:
          if:
            condition:
              - lambda: 'return id(display_off);'
            then:
              - script.execute: display_off_deactivate
            else:
              - button.press: display_ip
      #Hold 5s will toggle the wifi timeout (or turn screen on again)
      - timing:
          - ON for at least 5s
        then:
          if:
            condition:
              - lambda: 'return id(display_off);'
            then:
              - script.execute: display_off_deactivate
            else:
              - switch.toggle: wifi_stop_seek
  - platform: gpio
    pin: 
      number: ${rotation_pin}
      inverted: True
    name: "${friendly_name} Rotation Mode"
    id: rotation_mode
    on_state:
      then:
        if:
          condition:
            - lambda: 'return id(display_off);'
          then:
            - script.execute: display_off_deactivate
  
display:
  - platform: max7219digit
    id: matrix
    cs_pin: ${cs_pin}
    num_chips: 4
    update_interval: 1s
    reverse_enable: True # true for button-side up / false for down (be warned that if you change these 2 settings you may get a garbled display)
    rotate_chip: 0 # 0 for button-side up (default) / 180 for down (you could switch them but then I would recommend go change the inverted settting for the gpio)
    scroll_mode: continuous
    lambda: |-
      // Display the message if all conditions are met
      if (id(my_time).now().is_valid() && !id(display_off)) {
        if ((id(message_alive_time) != 0) && (id(message_clock_time_count) >= id(message_clock_time))) {
          ESP_LOGD("main", "Showing Message");
          id(message_display_time_count) += 1;
          id(message_alive_time_count) += 1;
          std::string message_text = id(message);
          it.print(0, 0, id(message_font), message_text.c_str());
          if (id(message_display_time_count) >= id(message_display_time)) {
            id(message_display_time_count) = 0;
            id(message_clock_time_count) = 0;
            if (id(message_alive_time_count) >= id(message_alive_time)) {
              id(message_alive_time_count) = 0;
              id(message_alive_time) = 0;
              ESP_LOGD("main", "Message Alive Time finished.");
            }
          }
        } else {
            if ((id(message_alive_time) != 0) && (id(message_clock_time) != 0)) {
              id(message_clock_time_count) += 1;
              id(message_alive_time_count) += 1;
            }
            // apply offset if needed https://community.home-assistant.io/t/multiple-time-zones/435315/12
            int offset = 0;
            if (id(tzoffset_on).state != false) {
              offset = (int)(60 * 60 * (id(tzoffset).state));
            }
            std::time_t tz1time = (id(my_time).now().timestamp + offset);
            std::tm *tz1time_astm = localtime(&tz1time);
            char display_tmdt[20];
            // check if the date should be displayed
            if ((id(time_display_count) >= (id(time_display_time).state)) && (id(date_display_mode).state != false)) {
              id(date_display_count) += 1;
              // if date_formatA is on, display it for 50% of the time first, after the 1st...
              if ((id(date_A_mode).state == true) && (id(date_display_count) <= (id(date_display_time).state / 2))) {
                strftime(display_tmdt, 20, "${date_formatA}", tz1time_astm);
                // check if Date A text replacement should be made
                if (id(replace_mode_auto).state == true) {
                  std::string tmdt(display_tmdt);
                  id(dateA_text).publish_state(tmdt);
                  strcpy(display_tmdt, id(dateA_text).state.c_str());
                }
              } else {
                strftime(display_tmdt, 20, "${date_format}", tz1time_astm);
                // check if Date text replacement should be made
                if (id(replace_mode_auto).state == true) {
                  std::string tmdt(display_tmdt);
                  id(date_text).publish_state(tmdt);
                  strcpy(display_tmdt, id(date_text).state.c_str());
                }
              }
            } else {
              id(date_display_count) = 0;
              id(time_display_count) += 1;
              // choose which time format to display
              if (id(hour12_mode).state == true) {
                strftime(display_tmdt, 20, "${time_format12}", tz1time_astm);
              } else {
                strftime(display_tmdt, 20, "${time_format24}", tz1time_astm);
              }
              // check if Time text replacement should be made
              if (id(replace_mode_auto).state == true) {
                std::string tmdt(display_tmdt);
                id(time_text).publish_state(tmdt);
                strcpy(display_tmdt, id(time_text).state.c_str());
              }
            }
            // print the date / time
            it.printf((32 / 2), (8 / 2), id(default_font), TextAlign::CENTER, "%s", display_tmdt);
            if (((id(date_display_count) >= id(date_display_time).state) && (id(date_display_mode).state != false)) || ((id(time_display_count) >= id(time_display_time).state) && (id(date_display_mode).state == false))) {
              id(time_display_count) = 0;
              // check if Replace Interval is active, count or reset, when date display is finished - or after the interval, depending
              if (id(replace_interval).state > 0) {
                id(replace_interval_count) += 1;
                if (id(replace_interval_count) >= id(replace_interval).state) {
                  id(replace_interval_count) = 0;
                  id(replace_mode_auto).toggle();
              }
            }
          }
        }
      } else {
        if (!id(display_off)) {
          it.print(0, 0, id(message_font), "${waiting}");
        }
      }
      // This next bit handles the display_off stuff
      if (id(display_off)) {
        it.clear();
      } else {
        it.intensity(id(brightness).state);
      }
      // This next section allows the rotation sensor to work - need to directly change settings in the component: https://esphome.io/api/max7219_8h
      if (id(rotation_mode).state == true) {
        it.set_reverse(0);
        it.set_chip_orientation(2);
      } else {
        it.set_reverse(1);
        it.set_chip_orientation(0);
      }

interval:
  - interval: 1min # check if the time should be synced, and if so, do it
    then:
      - lambda: |-
          id(sync_time_count) += 1;
          if (id(sync_time_count) >= (id(sync_time).state * 60)) {
            id(sync_time_count) = 0;
            id(sync_the_time).execute();
          }
  - interval: 1s # check if the wifi should be turned off, and if so, do it (or turn on if stop seek has been disabled) and blink led while seeking wifi, and check if display off should be activated
    then:
      - lambda: |-
          if (id(wifi_stop_seek).state == true && !id(wifi_id).is_connected() && !id(wifi_id).is_disabled()){
            id(wifi_stop_seek_time_count) += 1;
            if (id(wifi_stop_seek_time_count) >= id(wifi_stop_seek_time).state) {
              id(wifi_stop_seek_time_count) = 0;
              id(wifi_id)->disable();
              id(display_ip).press();
            }
          }
          if (id(wifi_stop_seek).state == false && id(wifi_id).is_disabled()) {
            id(wifi_stop_seek_time_count) = 0;
            id(wifi_id)->enable();
            id(display_ip).press();
          }
          if (!id(wifi_id).is_connected() && !id(wifi_id).is_disabled()) {
            id(seek_blink_led) += 1;
            if (id(wifi_stop_seek).state == false) {
              if (id(seek_blink_led) % 1 == 0) {
                auto call = id(led1).toggle();
                call.perform();
              }
            } else {
              if (id(seek_blink_led) % 2 == 0) {
                auto call = id(led1).toggle();
                call.perform();
              }
            }
          }
          if (id(led1).current_values.is_on() && (id(wifi_id).is_connected() || id(wifi_id).is_disabled())) {
              auto call = id(led1).turn_off();
              call.perform();
          }
          if (id(my_time).now().is_valid() && !id(display_off)) {
            if (id(display_off_no_wifi_time).state != 0 || id(display_off_time).state != 0) {
              id(display_off_time_count) = id(display_off_time_count) + 1;
            }
            if ((id(display_off_time).state != 0 && id(display_off_time_count) >= (id(display_off_time).state * 60)) || (id(display_off_no_wifi_time).state != 0 && id(display_off_time_count) >= id(display_off_no_wifi_time).state && (!id(wifi_id).is_connected() || id(wifi_id).is_disabled()))) {
              id(display_off_activate).execute();
            }
          }

globals:
  - id: replace_interval_count
    type: uint8_t
    restore_value: False
    initial_value: '0'
  - id: message
    type: std::string
    restore_value: False
    initial_value: ''
  - id: message_display_time
    type: uint8_t
    restore_value: False
    initial_value: '0'
  - id: message_clock_time
    type: uint8_t
    restore_value: False
    initial_value: '0'
  - id: message_alive_time
    type: uint8_t
    restore_value: False
    initial_value: '0'
  - id: message_display_time_count
    type: uint8_t
    restore_value: False
    initial_value: '0'
  - id: message_clock_time_count
    type: uint8_t
    restore_value: False
    initial_value: '0'
  - id: message_alive_time_count
    type: uint8_t
    restore_value: False
    initial_value: '0'
  - id: time_display_count
    type: uint8_t
    restore_value: False
    initial_value: '0'
  - id: date_display_count
    type: uint8_t
    restore_value: False
    initial_value: '0'
  - id: sync_time_count
    type: uint8_t
    restore_value: False
    initial_value: '0'
# Wifi Stop Seek Variables
  - id: wifi_stop_seek_time_count
    type: uint8_t
    restore_value: False
    initial_value: '0'
  - id: seek_blink_led
    type: uint8_t
    restore_value: False
    initial_value: '0'
# Display Off Variables
  - id: display_off
    type: bool
    restore_value: False
    initial_value: 'false'
  - id: display_off_time_count
    type: uint16_t
    restore_value: False
    initial_value: '0'

button:
  - platform: restart
    id: restart_button
    name: "${friendly_name} Restart"
    entity_category: diagnostic
  - platform: template
    id: display_ip
    name: "Display IP Address"
    internal: True
    entity_category: diagnostic
    on_press:
      - if:
          condition:
            not:
              wifi.connected:
          then:
            - lambda: |-
                if (id(wifi_id).is_disabled()) {
                  id(message) = ("Wifi Off");
                } else {
                  id(message) = ("No Wifi");
                }
                id(message_alive_time) = 3;
                id(message_display_time) = 3;
                id(message_clock_time) = 0;
          else:
            - lambda: |-
                id(message) = (" IP : " + id(wifi_ip).state + " . . . . ");
                id(message_alive_time) = 9;
                id(message_display_time) = 9;
                id(message_clock_time) = 0;

switch:
  - platform: template
    name: "${friendly_name} 12 Hour Mode"
    id: hour12_mode
    restore_mode: RESTORE_DEFAULT_OFF
    optimistic: True
    turn_on_action:
        - lambda: |-
            ESP_LOGD("main", "12 Hour Mode On");
    turn_off_action:
        - lambda: |-
            ESP_LOGD("main", "12 Hour Mode Off");
  - platform: template
    name: "${friendly_name} Date A Mode"
    id: date_A_mode
    restore_mode: RESTORE_DEFAULT_OFF
    turn_on_action:
        - lambda: |-
            ESP_LOGD("main", "Date A Mode On");
    turn_off_action:
        - lambda: |-
  - platform: template
    name: "${friendly_name} Replacement Mode"
    id: replace_mode
    restore_mode: RESTORE_DEFAULT_OFF
    optimistic: True
    turn_on_action:
        - lambda: |-
            ESP_LOGD("main", "Replace Mode On");
            id(replace_mode_auto).turn_on();
            auto call = id(replace_interval).make_call();
            call.set_value(0);
            call.perform();
    turn_off_action:
        - lambda: |-
            ESP_LOGD("main", "Replace Mode Off");
            id(replace_mode_auto).turn_off();
  - platform: template
    id: replace_mode_auto
    restore_mode: RESTORE_DEFAULT_OFF
    optimistic: True
    internal: True
    turn_on_action:
        - lambda: |-
            ESP_LOGD("main", "Replace Mode Auto On");
    turn_off_action:
        - lambda: |-
            ESP_LOGD("main", "Replace Mode Auto Off");
  - platform: template
    name: "${friendly_name} Time Zone Offset On"
    id: tzoffset_on
    restore_mode: RESTORE_DEFAULT_OFF
    optimistic: True
    turn_on_action:
        - lambda: |-
            ESP_LOGD("main", "TZ Offset On");
    turn_off_action:
        - lambda: |-
            ESP_LOGD("main", "TZ Offset Off");
  - platform: template
    name: "${friendly_name} Date Display Mode"
    id: date_display_mode
    restore_mode: RESTORE_DEFAULT_OFF
    optimistic: True
    turn_on_action:
        - lambda: |-
            ESP_LOGD("main", "Date on");
            id(message) = ("Date on");
            id(message_alive_time) = 1;
            id(message_display_time) = 1;
            id(message_clock_time) = 0;
    turn_off_action:
        - lambda: |-
            ESP_LOGD("main", "Date off");
            id(message) = ("Date off");
            id(message_alive_time) = 1;
            id(message_display_time) = 1;
            id(message_clock_time) = 0;
  - platform: template
    name: "${friendly_name} Wifi Stop Seek"
    id: wifi_stop_seek
    restore_mode: RESTORE_DEFAULT_OFF
    optimistic: True
    turn_on_action:
        - delay: 1s
        - lambda: |-
            ESP_LOGD("main", "Wifi Stop Seek on");
            id(message) = ("StopSeek");
            id(message_alive_time) = 1;
            id(message_display_time) = 1;
            id(message_clock_time) = 0;
    turn_off_action:
        - delay: 1s
        - lambda: |-
            ESP_LOGD("main", "Wifi Stop Seek off");
            id(message) = ("Seek...");
            id(message_alive_time) = 1;
            id(message_display_time) = 1;
            id(message_clock_time) = 0;

number:
  - platform: template
    name: "${friendly_name} Brightness"
    id: brightness
    restore_value: True
    optimistic: True
    step: 1
    min_value: 0
    max_value: 15
    initial_value: 1
    mode: slider
    set_action:
      then:
        - lambda: |-
            ESP_LOGD("main", "Brightness: %.0f", x);
  - platform: template
    name: "${friendly_name} Time Display Time"
    id: time_display_time
    restore_value: True
    optimistic: True
    step: 1
    min_value: 1
    max_value: 60
    initial_value: 8
    mode: box
    unit_of_measurement: seconds
    set_action:
      then:
        - lambda: |-
            ESP_LOGD("main", "Time Display Time: %.0f seconds", x);
  - platform: template
    name: "${friendly_name} Date Display Time"
    id: date_display_time
    restore_value: True
    optimistic: True
    step: 1
    min_value: 1
    max_value: 60
    initial_value: 2
    mode: box
    unit_of_measurement: seconds
    set_action:
      then:
        - lambda: |-
            ESP_LOGD("main", "Date Display Time: %.0f seconds", x);
  - platform: template
    name: "${friendly_name} Auto Replacement Interval"
    id: replace_interval
    restore_value: True
    optimistic: True
    step: 1
    min_value: 0
    max_value: 10
    initial_value: 0
    mode: box
    unit_of_measurement: intervals
    set_action:
      then:
        - lambda: |-
            ESP_LOGD("main", "Auto Replacement Interval: %.0f", x);
            if (x > 0) {
              id(replace_mode).turn_off();
            }
  - platform: template
    name: "${friendly_name} Time Zone Offset"
    id: tzoffset
    restore_value: True
    optimistic: True
    step: 0.25
    min_value: -26
    max_value: 26
    initial_value: 0
    mode: box
    unit_of_measurement: hours
    set_action:
      then:
        - lambda: |-
            ESP_LOGD("main", "Time Zone Offset: %.2f hours", x);
  - platform: template
    name: "${friendly_name} Time Sync Interval"
    id: sync_time
    restore_value: True
    optimistic: True
    step: 1
    min_value: 1
    max_value: 24
    initial_value: 8
    mode: box
    unit_of_measurement: hours
    set_action:
      then:
        - lambda: |-
            ESP_LOGD("main", "Time Sync Interval: %.0f hours", x);
  - platform: template
    name: "${friendly_name} Wifi Stop Seek Time"
    id: wifi_stop_seek_time
    restore_value: True
    optimistic: True
    step: 1
    min_value: 1
    max_value: 60
    initial_value: 180
    mode: box
    unit_of_measurement: seconds
    set_action:
      then:
        - lambda: |-
            ESP_LOGD("main", "Wifi Stop Seek Time: %.0f seconds", x);
  - platform: template
    name: "${friendly_name} Display Off Time (0 Disable)"
    id: display_off_time
    restore_value: True
    optimistic: True
    step: 5
    min_value: 0
    max_value: 60
    initial_value: 0
    mode: box
    unit_of_measurement: minutes
    set_action:
      then:
        - lambda: |-
            ESP_LOGD("main", "Display Off Time: %.0f minutes", x);
        - script.execute: display_off_deactivate
  - platform: template
    name: "${friendly_name} Display Off When No Wifi Time (seconds) (0 Disable)"
    id: display_off_no_wifi_time
    restore_value: True
    optimistic: True
    step: 5
    min_value: 0
    max_value: 180
    initial_value: 60
    mode: box
    unit_of_measurement: seconds
    set_action:
      then:
        - lambda: |-
            ESP_LOGD("main", "Display Off No Wifi Time: %.0f seconds", x);
        - script.execute: display_off_deactivate