lytko-101-v2.yaml

substitutions:
  devicename:         "lytko101v2" # Host name, will be available as ${devicename}.local
  friendly_devicename:  "Bathroom" # UI visible name, will be added to all sensors and controls exposed to HA
  target_temperture_low:    "27.0" # Default low mark of the target temperature, can be changed from HA Thermostat GUI
  target_temperture_high:   "29.0" # Default high mark of the target temperature, can be changed from HA Thermostat GUI
                                   # Hysteresis is calculated as temperature_high - teplerature_low
                                   # Target temperature is calculated as the middle point between temperature_high and teplerature_low
                                   # Target temperture can be changed from Lytko screen
  # Compile time parameters
  min_temperature:           "5.0" # Minimal temperature in HA Thermostat GUI
  max_temperature:          "40.0" # Maximal temperature in HA Thermostat GUI
  temperature_step:          "0.5" # Temperature step in HA Thermostat GUI
  temperature_shift:         "0.0" # Constant shift (positive or negative) for the built in temperature sensor
  temperature_sensor:     int_ntc  # Name of a temperature sensor. int_ntc is a built-in NTC sensor. If you want to hookup
                                   # an external sensor using HA Sensor. See https://esphome.io/components/sensor/homeassistant.html
                                   # Example sensor can be found below in the 'sensor' section

  # NTC Thermistor Parameters, see thermistor manual for the detailed info
  ntc_beta_constant:        "3911" # NTC thermistor Beta coefficient
  ntc_ref_temperature:        "25" # Temperature when thermistor has the reference resistance, in C
  ntc_ref_resistance:      "10000" # Nominal / reference resistance of the attached thermistor in Ohms
  ntc_measurement_resistor: "2200" # Measurement resistor, board has 2.2kOhm resistor, if you add another 2.2kOms resistor as described
                                   # in the Lytko manual, it will have parallel connection to the board resistor, so
                                   # the value of 1100 should be put here. Calculate as parallely connected resistors in case another
                                   # nominal is used

  # Heating floor parameters
  floor_resistance:        "813.8" # Resistance of heating cable / matt in Ohm
  floor_mains_voltage:       "230" # Typical mains voltage of your system (better to use a value from smart meter via HA, see below

# This should point to the public location of this yaml file.
dashboard_import:
  package_import_url: github://anatoly-savchenkov/lytko-configs/lytko-101-v2.yaml@main
  import_full_config: true

esphome:
  name: ${devicename}
  name_add_mac_suffix: true

  platformio_options:
    board_build.f_cpu: 160000000L
  project:
    name: "Lytko.Thermostat-101-v1"
    version: "1.0"
  on_boot:
    priority: -100
    then:
      - lambda: |-
          id(boot_counter) += 1;

preferences:
  flash_write_interval: 1h

esp8266:
  board: nodemcuv2
  restore_from_flash: true
  board_flash_mode: dout
  early_pin_init: false

# Enable logging
logger:
  baud_rate: 0  # Disable UART logging, HW UART is for Nextion
  level: VERBOSE

uart:
  id: uart_nextion
  rx_pin: RX
  tx_pin: TX
  baud_rate: 9600

display:
  - platform: nextion
    id: disp
    uart_id: uart_nextion
#    update_interval: 60s
    on_setup:
      lambda: |-
        if (wifi::global_wifi_component->has_sta()) {
          id(disp).goto_page("loading_page");
        } else {
          id(disp).goto_page("config_wifi");
          id(qr_presented) = true;
        }
        id(disp).set_component_value("temperature.lock_mode", id(child_lock));

    on_page:
      lambda: |-
        if(x == 0x08) id(disp).set_backlight_brightness(id(locked_brightness).state/100.0f);
        else id(disp).set_backlight_brightness(1.0f);

        switch (x) {
          case 0x01: /* temperature */
            id(disp).set_component_value("signal_fill", id(wifi_level).state);
            /* fall thorugh */
          case 0x08: /* lock_page */ {
            ESP_LOGD("main","Display shows temperature / lock page");
            bool is_on = (id(lytko_therm).mode == CLIMATE_MODE_HEAT);
            bool is_heating = (id(lytko_therm).action == CLIMATE_ACTION_HEATING);
            id(disp).set_component_value("arrow_temp", is_heating);
            id(disp).set_component_value("H_active", is_on);
            id(disp).set_component_text_printf("degree_big", "%.1f", (id(lytko_therm).target_temperature_high + id(lytko_therm).target_temperature_low) / 2.0f);
            if (!std::isnan(id(lytko_therm).current_temperature)) {
              id(disp).set_component_text_printf("degree", "%.1f", id(lytko_therm).current_temperature);
            } else {
              id(disp).set_component_text("degree", "ERR");
            }
            break;
          }
          case 0x18: /* config_wifi */
            ESP_LOGD("main","Display shows WiFi config page");
            id(disp).set_component_text_printf("qr_wifi", "WIFI:T:nopass;S:%s;P:;;", wifi::global_wifi_component->get_ap().get_ssid().c_str());
            break;
          case 0x1C: { /* QR code for Web site, page name unknown */
            ESP_LOGD("main","Display shows web config page");
            auto ip = wifi::global_wifi_component->get_ip_address();
            id(disp).set_component_text_printf("qr_ip", "http://%s", ip.str().c_str());
            id(disp).set_component_text("label_ip", ip.str().c_str());
            break;
          }
          case 0x0F: /* debug_page */
            ESP_LOGD("main","Display shows debug page");
            id(disp).set_component_text("uptime", id(uptime_human).state.c_str());
            id(disp).set_component_text_printf("memory", "%uB / %u%% / %uB", (uint32_t)id(free_heap).state, (uint32_t)id(heap_frag).state, (uint32_t)id(max_heap_block).state);
            break;
          case 0x0D: /* temp_settings */
            ESP_LOGD("main","Display shows Settings: min/max temperature page");
            id(disp).set_component_text_printf("min_temp", "%.1f", id(lytko_therm).get_traits().get_visual_min_temperature());
            id(disp).set_component_text_printf("max_temp", "%.1f", id(lytko_therm).get_traits().get_visual_max_temperature());
            break;
          case 0x06: /* config_hyster */
            ESP_LOGD("main","Display shows Settings: temperature hysteresis/shift page");
            id(disp).set_component_text_printf("hysteresis", "%.1f", id(lytko_therm).target_temperature_high - id(lytko_therm).target_temperature_low);
            id(disp).set_component_text_printf("sensor_corr", "%.1f", ${temperature_shift});
            break;
          case 0x02: /* firmware_upd */
            ESP_LOGD("main","Display shows vesion info page");
            id(disp).set_component_text("esp_version", ("ESPHome " + id(esph_version).state).c_str());
            break;
          case 0x07: /* sensor_page */ {
            ESP_LOGD("main","Display shows Settings: sensor type page");
            uint16_t sensors[] = {3300, 5000, 6800, 10000, 12000, 15000, 14800, 20000, 33000, 47000};
            int16_t active_sensor = -1;
            for(int i = 0; i < sizeof(sensors)/sizeof(sensors[0]); i++) {
              if( 0.99f * sensors[i] <= ${ntc_ref_resistance} && ${ntc_ref_resistance} <= 1.01f * sensors[i]) { active_sensor = i + 1; break; }
            }
            if (active_sensor != -1) {
              id(disp).set_component_value("active_sensor", active_sensor);
            }
            break;
          }
          default:
            ESP_LOGD("main","Display shows new page %u", x);
            break;
        }

debug:
  update_interval: 5s

ota:
  on_begin:
    - lambda: |-
        id(disp).goto_page("upd_progress");
        id(disp).set_backlight_brightness(1.0f);
  on_progress:
    - lambda: |-
        id(disp).set_component_value("update", (uint32_t)x);
        id(disp).set_component_text_printf("percent", "%u", (uint32_t) roundf(x));
  on_end:
    - lambda: |-
        id(disp).set_component_value("update", 100);
        id(disp).set_component_text("percent", "100");
  on_error:
    - switch.turn_on: reboot

wifi:
  ap: {} # This spawns an AP with the device name and mac address with no password.
  on_connect:
    - lambda: |-
        id(disp).goto_page("temperature");
        id(qr_presented) = false;
  on_disconnect:
    - lambda: |-
        id(disp).goto_page("no_wifi_page");

mdns:
  disabled: false

captive_portal:

# Enable Home Assistant API
api:
  # Set timeout to none, as device can be used standalone
  reboot_timeout: 0s

time:
  - platform: homeassistant

#mqtt:
#  broker: 192.168.0.101
#  username: mqtt_user
#  password: mqtt_password
#  discovery: true
#  discovery_prefix: lytko/homeassistant
#  reboot_timeout: 60s
#  keepalive: 15s
#  log_topic: lytko/logs

globals:
 - id: boot_counter
   type: int
   restore_value: yes
   initial_value: '0'
 - id: child_lock
   type: bool
   restore_value: yes
   initial_value: 'false'
 - id: qr_presented
   type: bool
   restore_value: no
   initial_value: 'false'

web_server:
  port: 80
  version: 2
  local: true

interval:
  - interval: 10s
    then:
      - if:
          condition:
            for:
              time: 65s # rely on 60 seconds default ap_timeout value and add 5 seconds to start Fallback AP
              condition:
                not:
                  - wifi.connected:
          then:
            if:
              condition:
                - lambda: return !id(qr_presented);
              then:
              - logger.log: WiFi is not connected for 1 minute, show WiFi configuration QR code
              - lambda: |-
                  id(disp).goto_page("config_wifi");
                  id(qr_presented) = true;

switch:
  - platform: gpio
    pin: GPIO15
    id: heater
    restore_mode: ALWAYS_OFF
    internal: true

  - platform: restart
    name: ${friendly_devicename} Restart
    id: reboot

  - platform: factory_reset
    name: ${friendly_devicename} Factory Reset
    id: reset

binary_sensor:
  - platform: status
    name: ${friendly_devicename} Status
    entity_category: diagnostic

  - platform: nextion
    page_id: 0x01
    component_id: 0x0D
    internal: true
    id: n_temp_up
    on_press:
      - lambda: |-
          auto traits = id(lytko_therm).get_traits();
          float step = traits.get_visual_target_temperature_step();
          float max_temp = traits.get_visual_max_temperature();

          if (id(lytko_therm).target_temperature_high + step <= max_temp) {
            auto call = id(lytko_therm).make_call();
            call.set_target_temperature_high(id(lytko_therm).target_temperature_high + step);
            call.set_target_temperature_low(id(lytko_therm).target_temperature_low + step);
            call.perform();
          }
          id(n_temp_up).publish_state(false); /* Reset the state back to off */

  - platform: nextion
    page_id: 0x01
    component_id: 0x0E
    internal: true
    id: n_temp_down
    on_press:
      - lambda: |-
          auto traits = id(lytko_therm).get_traits();
          float step = traits.get_visual_target_temperature_step();
          float min_temp = traits.get_visual_min_temperature();

          if (id(lytko_therm).target_temperature_low - step >= min_temp) {
            auto call = id(lytko_therm).make_call();
            call.set_target_temperature_high(id(lytko_therm).target_temperature_high - step);
            call.set_target_temperature_low(id(lytko_therm).target_temperature_low - step);
            call.perform();
          }
          id(n_temp_down).publish_state(false); /* Reset the state back to off */

  - platform: nextion
    page_id: 0x01
    component_id: 0x11
    internal: true
    id: n_heat_on
    on_press:
      - lambda: |-
          auto call = id(lytko_therm).make_call();
          call.set_mode("HEAT");
          call.perform();
          id(n_heat_on).publish_state(false); /* Reset the state back to off */

  - platform: nextion
    page_id: 0x01
    component_id: 0x14
    internal: true
    id: n_heat_off
    on_press:
      - lambda: |-
          auto call = id(lytko_therm).make_call();
          call.set_mode("OFF");
          call.perform();
          id(n_heat_off).publish_state(false); /* Reset the state back to off */

  - platform: nextion
    page_id: 0x0A
    component_id: 0x01
    internal: true
    id: n_reset
    on_press:
      - switch.turn_on: reset

  - platform: nextion
    page_id: 0x06
    component_id: 0x03
    internal: true
    id: n_lock_on
    on_press:
      - lambda: |-
          id(child_lock) = true;
          id(n_lock_on).publish_state(false); /* Reset the state back to off */

  - platform: nextion
    page_id: 0x06
    component_id: 0x04
    internal: true
    id: n_lock_off
    on_press:
      - lambda: |-
          id(child_lock) = false;
          id(n_lock_off).publish_state(false); /* Reset the state back to off */

text_sensor:
  - platform: version
    hide_timestamp: true
    internal: true
    id: esph_version

  - platform: template
    name: ${friendly_devicename} Uptime
    id: uptime_human
    icon: mdi:clock-start
    entity_category: diagnostic
    update_interval: never
    on_value:
      lambda: |-
        id(disp).set_component_text("uptime", id(uptime_human).state.c_str());

sensor:
# Report basic device information like it's reboot counter, Wi-Fi signal strength and uptime
  - platform: uptime
    internal: true
    id: uptime_sensor
    update_interval: 60s
    on_raw_value:
      - text_sensor.template.publish:
          id: uptime_human
          state: !lambda |-
            int seconds = round(id(uptime_sensor).raw_state);
            int days = seconds / (24 * 3600);
            seconds = seconds % (24 * 3600);
            int hours = seconds / 3600;
            seconds = seconds % 3600;
            int minutes = seconds /  60;
            seconds = seconds % 60;
            return (
              (days ? String(days) + "d " : "") +
              (hours ? String(hours) + "h " : "") +
              (minutes ? String(minutes) + "m" : "0m")
            ).c_str();


  - platform: template
    name: ${friendly_devicename} Boot Counter
    lambda: |-
      static int last_boot_counter = 0;
      if (last_boot_counter != id(boot_counter)) {
        last_boot_counter = id(boot_counter);
        return id(boot_counter);
      } else {
        return {};
      }
    update_interval: 60s
    state_class: total_increasing
    accuracy_decimals: 0
    entity_category: diagnostic

  - platform: template
    id: wifi_level
    entity_category: diagnostic
    internal: true
    update_interval: never
    filters:
      - delta: 1.0
    on_value:
      lambda: |-
        id(disp).set_component_value("signal_fill", x);

  - platform: wifi_signal
    name: ${friendly_devicename} WiFi Signal
    update_interval: 10s
    id: rssi_level
    entity_category: diagnostic
    filters:
      - delta: 1.0
    on_value:
      lambda: |-
        int32_t level;
        if (-1.0f > x && x >= -50.0f)       { level = 4; id(rssi_level).set_icon("mdi:wifi-strength-4");}
        else if (-50.0f > x && x >= -61.0f) { level = 3; id(rssi_level).set_icon("mdi:wifi-strength-3");}
        else if (-61.0f > x && x >= -72.0f) { level = 2; id(rssi_level).set_icon("mdi:wifi-strength-2");}
        else if (-72.0f > x && x >= -83.0f) { level = 1; id(rssi_level).set_icon("mdi:wifi-strength-1");}
        else if (-83.0f > x && x >= -94.0f) { level = 0; id(rssi_level).set_icon("mdi:wifi-strength-outline");}
        else                                { level =-1; id(rssi_level).set_icon("mdi:wifi-strength-off-outline");}
        id(wifi_level).publish_state(level);

  - platform: debug
    free:
      id: free_heap
      internal: true
#      on_value:
#        then:
#          lambda: |-
#            id(disp).set_component_text_printf("memory", "%uB / %u%% / %uB", (uint32_t)x, (uint32_t)id(heap_frag).state, (uint32_t)id(max_heap_block).state);
    fragmentation:
      id: heap_frag
      internal: true
#      on_value:
#        then:
#          lambda: |-
#            id(disp).set_component_text_printf("memory", "%uB / %u%% / %uB", (uint32_t)id(free_heap).state, (uint32_t)x, (uint32_t)id(max_heap_block).state);
    block:
      id: max_heap_block
      internal: true
#      on_value:
#        then:
#          lambda: |-
#            id(disp).set_component_text_printf("memory", "%uB / %u%% / %uB", (uint32_t)id(free_heap).state, (uint32_t)id(heap_frag).state, (uint32_t)x);


  - platform: ntc
    sensor: resistance_sensor
    calibration:
      b_constant: ${ntc_beta_constant}
      reference_temperature: ${ntc_ref_temperature}°C
      reference_resistance: ${ntc_ref_resistance}Ohm
    name: ${friendly_devicename} Temperature
    accuracy_decimals: 1
    state_class: measurement
    device_class: temperature
    unit_of_measurement: "°C"
    id: int_ntc
    filters:
      - delta: 0.1 # Prevent repetitive actions using the same value
      - offset: ${temperature_shift}

  - platform: resistance
    id: resistance_sensor
    sensor: voltage_sensor
    configuration: UPSTREAM
    resistor: ${ntc_measurement_resistor}
    internal: true

  - platform: adc
    id: voltage_sensor
    pin: A0
    update_interval: 1s
    internal: true
    filters:
      - lambda: |-
          /* 10 bit ADC, readouts below 10 (1%) are considered noise, NTC is not connected */
          return (x < 10.0f/1024 ? NAN : x );
      - exponential_moving_average:
          alpha: 0.1
          send_every: 10
          send_first_at: 1

  - platform: template
    name: ${friendly_devicename} NTC Reference Resistance
    accuracy_decimals: 0
    unit_of_measurement: "Ω"
    update_interval: 60s
    icon: "mdi:flash"
    lambda: |-
      return ${ntc_ref_resistance};
    filters:
      - delta: 0.1 # Prevent repetitive actions using the same value

  - platform: template
    name: ${friendly_devicename} Heating Resistance
    accuracy_decimals: 1
    unit_of_measurement: "Ω"
    update_interval: 60s
    icon: "mdi:heat-wave"
    lambda: |-
      return ${floor_resistance};
    filters:
      - delta: 0.1 # Prevent repetitive actions using the same value

  - platform: template
    update_interval: 1s
    internal: true
    id: mains_voltage
    state_class: measurement
    device_class: voltage
    icon: "mdi:flash"
    lambda: |-
      return ${floor_mains_voltage};
    filters:
      - delta: 0.01 # Prevent repetitive actions using the same value

# If Smart Meter is available, uncomment the sensor below and comment out template sensor above
# Get current mains voltage from a smart meter
#  - platform: homeassistant
#    id: mains_voltage
#    entity_id: sensor.pzem_004t_v3_voltage
#    internal: true
#    filters:
#      - filter_out: nan
#      - delta: 0.01 # Prevent repetitive actions using the same value

  - platform: template
    update_interval: 1s
    internal: true
    name: ${friendly_devicename} Power
    id: floor_power
    state_class: measurement
    device_class: power
    accuracy_decimals: 0
    unit_of_measurement: "W"
    icon: "mdi:flash"
    lambda: |-
      return id(heater).state * id(mains_voltage).state * id(mains_voltage).state / (float)${floor_resistance};

  - platform: integration
    name: ${friendly_devicename} Energy
    sensor: floor_power
    time_unit: h
    integration_method: left
    restore: true
    accuracy_decimals: 3
    unit_of_measurement: "kWh"
    icon: "mdi:flash"
    device_class: energy
    state_class: total_increasing
    filters:
      - multiply: 0.001 # Wh to kWh

output:
  - platform: esp8266_pwm
    pin:
      number: GPIO2
      inverted: true
    frequency: 1000 Hz
    id: pwm_output

light:
  - platform: monochromatic
    output: pwm_output
    restore_mode: ALWAYS_OFF
    id: blue_led
    internal: true

climate:
  - platform: bang_bang
    name: ${friendly_devicename} Heating Controller
    sensor: ${temperature_sensor}
    default_target_temperature_low: ${target_temperture_low} °C
    default_target_temperature_high: ${target_temperture_high} °C
    id: lytko_therm
    visual:
      min_temperature: ${min_temperature} °C
      max_temperature: ${max_temperature} °C
      temperature_step: ${temperature_step} °C

    heat_action:
      - switch.turn_on: heater
      - light.turn_on: blue_led

    idle_action:
      - switch.turn_off: heater
      - light.turn_off: blue_led

    on_state:
      - lambda: |-
          bool is_on = (id(lytko_therm).mode == CLIMATE_MODE_HEAT);
          bool is_heating = (id(lytko_therm).action == CLIMATE_ACTION_HEATING);
          id(disp).set_component_value("arrow_temp", is_heating);
          id(disp).set_component_value("H_active", is_on);
          id(disp).set_component_text_printf("degree_big", "%.1f", (id(lytko_therm).target_temperature_high + id(lytko_therm).target_temperature_low) / 2.0f);
          if (!std::isnan(id(lytko_therm).current_temperature)) {
            id(disp).set_component_text_printf("degree", "%.1f", id(lytko_therm).current_temperature);
          } else {
            id(disp).set_component_text("degree", "ERR");
          }

number:
  - platform: template
    name: ${friendly_devicename} Locked Screen Brightness
    id: locked_brightness
    min_value: 0
    max_value: 100
    step: 1
    icon: mdi:brightness-percent
    optimistic: true
    restore_value: true
    entity_category: config
    unit_of_measurement: '%'
    mode: slider