countdown-clock.yaml

substitutions:
  device_name: "countdown-clock"
  device_friendly_name: "Countdown clock"
  device_description: "Cute Astronaut prop"
  time_timezone: "Europe/Amsterdam"

globals:
  # ESPHome sensor (float) is too small to accurately
  # represent time in seconds, so we need a global
  - id: duration_ticks
    type: int
    restore_value: no
    initial_value: '0'
  - id: brightness_delay
    type: int
    restore_value: no
    initial_value: '500'
  - id: shift_register_delay
    type: int
    restore_value: no
    initial_value: '10'
  # Segments that need to be lit for [0-9] and :
  - id: digitCodeMap
    type: uint8_t[11]
    restore_value: no
    #   GFEDCBA
    initial_value: '{
      0b0111111,
      0b0000110,
      0b1011011,
      0b1001111,
      0b1100110,
      0b1101101,
      0b1111101,
      0b0000111,
      0b1111111,
      0b1101111,
      0b1110000}'
  # Maps which segment (1-7) need to be lit for which module (1-11)
  - id: segmentMap
    type: uint16_t[7]
    restore_value: no
    # 1110987654321
    initial_value: '{
      0b00000000000,
      0b00000000000,
      0b00000000000,
      0b00000000000,
      0b00000000000,
      0b00000000000,
      0b00000000000}'

esphome:
  name: $device_name
  friendly_name: $device_friendly_name
  comment: $device_description
  includes:
    - my_custom_output.h

esp32:
  board: esp32doit-devkit-v1

# Enable logging
logger:
  level: DEBUG
  # Disable logging via UART
  baud_rate: 0

# Enable Home Assistant API
api:
  encryption:
    key: !secret home_assistant_key

# Secure Over The Air updates
ota:
  password: !secret ota_password 

ethernet:
  type: LAN8720
  mdc_pin: GPIO23
  mdio_pin: GPIO18
  clk_mode: GPIO17_OUT
  phy_addr: 0
  power_pin: GPIO5
 # Optional manual IP
#  manual_ip:
#    static_ip: 10.0.0.2
#    gateway: 10.0.0.1
#    subnet: 255.255.255.0
#  use_address: 10.0.0.2

# Configure segments, directly connected to GPIO
output:
  - platform: gpio
    pin: GPIO14
    id: 'segment_A'
  - platform: gpio
    pin: GPIO13
    id: 'segment_B'
  - platform: gpio
    pin: GPIO32
    id: 'segment_C'
  - platform: gpio
    pin: GPIO12
    id: 'segment_D'
  - platform: gpio
    pin: GPIO16
    id: 'segment_E'
  - platform: gpio
    pin: GPIO33
    id: 'segment_F'
  - platform: gpio
    pin: GPIO15
    id: 'segment_G'

  # Configure shift registers
  - platform: gpio
    pin: GPIO4
    id: 'shift_clock'
  - platform: gpio
    pin: GPIO0
    id: 'shift_latch'
  - platform: gpio
    pin: GPIO2
    id: 'shift_data'

  # Output for display light, allow us to set the brightness
  # Using delay, but RMT seems a good future candidate
  - platform: template
    id: display_brightness
    type: float
    write_action:
    - lambda: id(brightness_delay) = state * 500;
  
  # Output that blinks the status LED
  - platform: template
    id: status_output
    type: binary
    write_action:
    - if:
        condition:
          lambda: return (state);
        then:
          # Enable the PM led
          - lambda: |-
              id(preload_modules)->execute(0b00000100000);
              id(shift_latch).turn_on();
              delayMicroseconds(id(shift_register_delay));
              id(shift_latch).turn_off();
              id(segment_A).turn_on();
        else:
          # Disable the PM led
          - lambda: |-
              id(segment_A).turn_off();
    
  # A custom output to change the CPU frequency
  - platform: custom
    type: binary
    lambda: |-
      auto my_high_frequency_loop = new HighFrequencyLoop();
      App.register_component(my_high_frequency_loop);
      return {my_high_frequency_loop};
    outputs:
      id: high_frequency_loop
  
select:
  # Select the mode for clock functions
  - platform: template
    name: Mode
    id: mode
    optimistic: true
    icon: "mdi:history"
    options:
     - pause
     - countdown
     - countup
    initial_option: pause
    set_action:
      - logger.log:
          level: INFO
          format: "Mode: %s"
          args: ["x.c_str()"]

number:
  # Sets the duration of the timer
  - platform: template
    name: "Duration Days"
    id: duration_days
    unit_of_measurement: d
    mode: box
    icon: "mdi:clock-digital"
    optimistic: true
    min_value: 0
    max_value: 999
    step: 1
    on_value:
      then:
        - script.execute: update_duration

  - platform: template
    name: "Duration Hours"
    id: duration_hours
    unit_of_measurement: h
    mode: box
    icon: "mdi:clock-digital"
    optimistic: true
    min_value: 0
    max_value: 24
    step: 1
    on_value:
      then:
        - script.execute: update_duration

  - platform: template
    name: "Duration Minutes"
    id: duration_minutes
    unit_of_measurement: min
    mode: box
    icon: "mdi:clock-digital"
    optimistic: true
    min_value: 0
    max_value: 60
    step: 1
    on_value:
      then:
        - script.execute: update_duration

  - platform: template
    name: "Duration Seconds"
    id: duration_seconds
    unit_of_measurement: s
    mode: box
    icon: "mdi:clock-digital"
    optimistic: true
    min_value: 0
    max_value: 60
    step: 1
    on_value:
      then:
        - script.execute: update_duration

  - platform: template
    name: "Auto pause time"
    id: auto_pause_seconds
    unit_of_measurement: s
    mode: box
    icon: "mdi:timer-pause-outline"
    optimistic: true
    min_value: 0
    max_value: 3600
    step: 1

switch:
  # Set the ESP32 clock speed to high
  - platform: output
    name: "High Speed"
    output: 'high_frequency_loop'
    restore_mode: RESTORE_DEFAULT_ON
    entity_category: "config"
    disabled_by_default: True

  - platform: template
    name: "Auto Pause"
    icon: "mdi:cog-pause"
    id: auto_pause
    optimistic: True
    restore_mode: RESTORE_DEFAULT_OFF

button:
  # Boot in safe mode
  - platform: safe_mode
    name: Safe Mode Boot
    entity_category: diagnostic

time:
  # Get the time from HA, so we can use it for uptime
  - platform: homeassistant
    id: time_homeassistant
    timezone: "${time_timezone}"
    on_time_sync:
      - component.update: sensor_uptime_timestamp

sensor:
  # Uptime is used internally only
  - platform: uptime
    id: sensor_uptime
  # This sensor is an alternative for the uptime sensor, which only sends the
  # startup timestamp of the device to home assistant once
  - platform: template
    id: sensor_uptime_timestamp
    name: "Uptime"
    entity_category: diagnostic
    device_class: "timestamp"
    accuracy_decimals: 0
    update_interval: never
    lambda: |-
      static float timestamp = (
        id(time_homeassistant).utcnow().timestamp - id(sensor_uptime).state
      );
      return timestamp;

text_sensor:
  - platform: ethernet_info
    ip_address:
      name: IP Address

light:
  # Enable status LED
  - platform: status_led
    output: status_output
    name: "Status Led"
    internal: True

  # Switch off the display and change its brightness
  - platform: monochromatic
    name: "Display"
    id: display
    output: display_brightness
    default_transition_length: 0s
    restore_mode: ALWAYS_OFF

interval:
  # Refresh the screen as fast as possible.
  - interval: 0s
    then:
      - if:
          condition:
            light.is_on: display
          then:
            - script.execute: 
                id: draw_display

  # Modes: Countup/down/pause
  - interval: 1s
    then:
      - lambda: |-
          if(id(mode).state != "pause") {
            if(id(mode).state == "countdown") {
              if(id(duration_ticks) > 0)
                id(duration_ticks) -= 1;
              else {
                // Reached 0, switch to counting up
                auto call = id(mode).make_call();
                call.set_option("countup");
                call.perform();
                id(duration_ticks) += 1;
              }
            }
            else if(id(mode).state == "countup")
              id(duration_ticks) += 1;

            id(update_display)->execute(id(duration_ticks));
            
            // Auto pause
            if(id(auto_pause).state && id(auto_pause_seconds).state == id(duration_ticks))
              id(mode).make_call().set_option("pause").perform();
          }
script:
  # Updates the duration to the numbers inputs
  - id: update_duration
    then:
      - lambda: |-
          id(duration_ticks) = static_cast<int>(id(duration_seconds).state);
          id(duration_ticks) += static_cast<int>(id(duration_minutes).state)*60;
          id(duration_ticks) += static_cast<int>(id(duration_hours).state)*3600;
          id(duration_ticks) += static_cast<int>(id(duration_days).state)*86400;
      - script.execute:
          id: update_display
          duration: !lambda return id(duration_ticks);
            
  # Update the display segmentMap with the current output_string
  - id: update_display
    mode: single
    parameters:
      duration: int
    then:
      - lambda: |- 
          // Get the amount of segments in the display
          int segments = sizeof(id(segmentMap)) / sizeof(uint16_t);

          // Build the string to display on the screen
          std::string str = str_sprintf("%03d%02d:%02d:%02d", duration/86400, duration/3600 % 24, duration/60 % 60, duration % 60);
          // Reverse the string
          reverse(str.begin(), str.end());

          // Convert the string to binary map
          for (int digit: str) {
            int digitLookup = digit - 48;
            for (int i = (segments - 1); i >= 0; i--) {
              id(segmentMap)[i] = (id(segmentMap)[i] << 1) | ((id(digitCodeMap)[digitLookup] >> i)& 0x01);
            }
           }

  # Draws the display
  - id: draw_display
    mode: single
    then:
      # Draw the characters per segment
      # We can't abstract this into a loop because ESPHome can't handle dynamic id's
      - lambda: |-
          id(shift_latch).turn_on();
          delayMicroseconds(id(shift_register_delay));
          id(shift_latch).turn_off();
          id(segment_A).turn_on();
          id(preload_modules)->execute(id(segmentMap)[1]);
          delayMicroseconds(id(brightness_delay));
          id(segment_A).turn_off();
          
          id(shift_latch).turn_on();
          delayMicroseconds(id(shift_register_delay));
          id(shift_latch).turn_off();
          id(segment_B).turn_on();
          id(preload_modules)->execute(id(segmentMap)[2]);
          delayMicroseconds(id(brightness_delay));
          id(segment_B).turn_off();

          id(shift_latch).turn_on();
          delayMicroseconds(id(shift_register_delay));
          id(shift_latch).turn_off();
          id(segment_C).turn_on();
          id(preload_modules)->execute(id(segmentMap)[3]);
          delayMicroseconds(id(brightness_delay));
          id(segment_C).turn_off();

          id(shift_latch).turn_on();
          delayMicroseconds(id(shift_register_delay));
          id(shift_latch).turn_off();
          id(segment_D).turn_on();
          id(preload_modules)->execute(id(segmentMap)[4]);
          delayMicroseconds(id(brightness_delay));
          id(segment_D).turn_off();

          id(shift_latch).turn_on();
          delayMicroseconds(id(shift_register_delay));
          id(shift_latch).turn_off();
          id(segment_E).turn_on();
          id(preload_modules)->execute(id(segmentMap)[5]);
          delayMicroseconds(id(brightness_delay));
          id(segment_E).turn_off();

          id(shift_latch).turn_on();
          delayMicroseconds(id(shift_register_delay));
          id(shift_latch).turn_off();
          id(segment_F).turn_on();
          id(preload_modules)->execute(id(segmentMap)[6]);
          delayMicroseconds(id(brightness_delay));
          id(segment_F).turn_off();

          id(shift_latch).turn_on();
          delayMicroseconds(id(shift_register_delay));
          id(shift_latch).turn_off();
          id(segment_G).turn_on();
          id(preload_modules)->execute(id(segmentMap)[0]);
          delayMicroseconds(id(brightness_delay));
          id(segment_G).turn_off();
 
   
  # Preloads the shift register
  - id: preload_modules
    parameters:
      modules: int
    mode: single
    then:
      - lambda: |-
          uint16_t outputs = 0;
          
          // Map the register outputs to the LED modules
          outputs = (outputs << 0) | ((modules >> 5)& 0x01);	// PM (segment A) and first divider (segment G and E)
          outputs = (outputs << 2) | ((modules >> 6)& 0x01);	// Digit Minutes_1
          outputs = (outputs << 1) | ((modules >> 7)& 0x01);	// Digit Minutes_2
          outputs = (outputs << 1) | ((modules >> 8)& 0x01);	// Second divider (segment F and G)
          outputs = (outputs << 1) | ((modules >> 9)& 0x01);	// Digit Seconds_1
          outputs = (outputs << 1) | ((modules >> 10)& 0x01);	// Digit Seconds_2
          outputs = (outputs << 2) | ((modules >> 0)& 0x01);	// Digit Days_1
          outputs = (outputs << 1) | ((modules >> 3)& 0x01);	// Digit Hours_1
          outputs = (outputs << 1) | ((modules >> 4)& 0x01);	// Digit Hours_2
          outputs = (outputs << 1) | ((modules >> 2)& 0x01);	// Digit Days_3
          outputs = (outputs << 1) | ((modules >> 1)& 0x01);	// Digit Days_2
          outputs = (outputs << 2);

          // Clock the register
          for(int i = 0, mask = 1; i < 16; i++, mask = mask << 1)
          {
            if (outputs & mask) {
              id(shift_data).turn_on();
            }
            else
              id(shift_data).turn_off();
            delayMicroseconds(id(shift_register_delay));
            id(shift_clock).turn_on();
            delayMicroseconds(id(shift_register_delay));
            id(shift_clock).turn_off();              
          }