esphome-ensto.yaml

substitutions:
  name: esphome-ensto
  devicename: ensto1
  ui_devicename: Ensto1
  mac: !secret ensto1_mac
  external_temperature_sensor: sensor.bedroom_temperature
  board: esp32doit-devkit-v1
  #board: esp32dev
  #board: esp32-c3-devkitm-1

esphome:
  name: $name

esp32:
  board: $board
  framework:
    type: esp-idf

# Enable logging. Note that too much logging will cause connections to break.
logger:
  logs:
    esp32_ble_tracker: INFO        # DEBUG to show discovered devices
    sensor: INFO                   # DEBUG to show sensor value updates to HA
    climate: INFO                  # DEBUG to show climate status updates to HA
    template.sensor: NONE          # CRITICAL to list sensors after WiFi connect
    template.binary_sensor: NONE   # CRITICAL to list sensors after WiFi connect
    esp32_ble_client: INFO         # WARN to not show service UUIDs
    esp32_ble_client.service: NONE # INFO to list ensto characteristics
    ble_client.automation: INFO    # DEBUG to show connections
    thermostat.climate: NONE       # CRITICAL to show default values
    ble_sensor: WARN               # INFO to show connected characteristics
    homeassistant.sensor: DEBUG    # INFO to not show updates from external temperature sensor
    ensto: INFO                    # DEBUG to show extra logging from this YAML
    ensto.adv: INFO                # DEBUG to show extra logging from this YAML about advertisements
    ensto.receive: INFO            # DEBUG to show extra logging from this YAML about received data from characteristics

ota:
  platform: esphome

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

#captive_portal:

# Add webserver on port 80
#web_server:
#  port: 80

time:
  id: ha_time
  platform: homeassistant
  timezone: "GMT0"

esp32_ble_tracker:
  id: ble_tracker
  scan_parameters:
    # Ensto sends one advertisement package every 200ms. With 320ms interval and 60ms window 
    # we will have a change to receive advertisement about once per second. That should be enough.
    # With defaults (320ms & 30ms) it would be once every 3 seconds.
    # update: 90ms works much-much better with some cheap esp32 dev boards.
    interval: 320ms
    window: 90ms
    active: false
  on_ble_advertise:
    - mac_address: ${mac}
      then:
        - lambda: |-
            ESP_LOGI("ensto.adv", "New BLE device");
            ESP_LOGD("ensto.adv", "  address: %s", x.address_str().c_str());
            ESP_LOGI("ensto.adv", "  Advertised manufacturer data:");
            auto man_datas = x.get_manufacturer_datas();
            for (auto man_data : man_datas) {
                ESP_LOGD("ensto.adv", "    - %s (length %i)", man_data.uuid.to_string().c_str(), man_data.data.size());
                if (man_data.uuid.get_uuid().uuid.uuid16 != 0x2806) {
                  continue;
                }
                auto data = man_data.data;
                ESP_LOGI("ensto.adv", "    - %s", &data[0]);
                if (data.size() < 3) {
                    continue;
                }
                std::string data_str = reinterpret_cast<const char *>(data.data() + 2);
                auto semi_pos = data_str.find_first_of(';');
                if (semi_pos == std::string::npos || semi_pos > data_str.length() - 1) {
                    continue;
                }
                id(${devicename}_is_pairing) = data_str[semi_pos + 1] == '1';
                ESP_LOGI("ensto.adv", "    - is pairing = %s", id(${devicename}_is_pairing) ? "true" : "false");
            }

globals:
  - id: ${devicename}_factory_reset_id
    type: uint32_t
    restore_value: yes
    initial_value: '0'
  - id: ${devicename}_is_pairing
    type: bool
    restore_value: no
# internal state machine states: 
# 0 = disconnected, don't try to read any characteristics
# 1 = read factory reset ID while device is in pairing mode
# 2 = write factory reset ID back to device. Write just received ID back during pairing or old one when not pairing.
# 3 = connected, free to read characteristics
# 4 = all characteristics have been read and sensor values are valid
  - id: ${devicename}_state
    type: uint32_t
    initial_value: '0' 
# interval count to filter what characteristics to read on each interval
  - id: ${devicename}_interval_count
    type: uint32_t
    initial_value: '0'
  - id: ${devicename}_previous_target_temperature
    type: float
    initial_value: "0.0"
  - id: ${devicename}_characterics_written_not_read
    type: uint32_t
    initial_value: "0"
  - id: ${devicename}_time_sync_needed
    type: bool

ble_client:
  - mac_address: ${mac}
    id: ${devicename}
    on_connect:
      then:
        - lambda: |-
            esphome::ble_client::BLEClient* client = id(${devicename});
            esp_ble_set_encryption(client->get_remote_bda(), ESP_BLE_SEC_ENCRYPT_MITM);
            if (id(${devicename}_is_pairing)) {
                ESP_LOGI("ensto", "Connected to ${devicename} (pairing) -> read factory reset ID");
                id(${devicename}_state) = 1; // read new factory reset ID
                return;
            }
            uint32_t key = id(${devicename}_factory_reset_id);
            if (key == 0) {
              ESP_LOGE("ensto", "Factory reset ID is not set. Must be paired first.");
              return;
            }
            ESP_LOGI("ensto", "Connected to ${devicename} -> write factory reset ID");
            id(${devicename}_state) = 2; // write old factory reset id
            
    on_disconnect:
      then:
        - lambda: |-
            ESP_LOGI("ensto", "Disconnected from ${devicename}");
            id(${devicename}_connection_state).publish_state(false);
            id(${devicename}_state) = 0; // disconnected

binary_sensor:
  - platform: template
    id: ${devicename}_connection_state
    name: "${ui_devicename} Connection status"
  - platform: template
    id: ${devicename}_relay_state
    name: "${ui_devicename} Relay state"
  - platform: template
    id: ${devicename}_boost_status
    name: "${ui_devicename} Boost status"
  # - platform: template
  #   id: ${devicename}_adaptive_temperature_control_status
  #   name: "${ui_devicename} Adaptive temperature control status"

sensor:
# Real-time information (temperatures, is heating relay active)
  - platform: ble_client
    type: characteristic
    ble_client_id: ${devicename}
    id: ${devicename}_real_time_indication_characteristic
    internal: true
    service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
    characteristic_uuid: 66AD3E6B-3135-4ADA-BB2B-8B22916B21D4
    notify: false
    update_interval: never
    lambda: |-
      ESP_LOGD("ensto.receive", "Real-time values received with %d bytes", x.size());
      if (x.size() < 20) return NAN;
      auto target_temp = (x[1] + 256 * x[2]) / 10.0f;
      auto room_temp = (int16_t)((x[4] + 256 * x[5])) / 10.0f;
      auto floor_temp = (int16_t)((x[6] + 256 * x[7])) / 10.0f;
      if (target_temp == 0 && room_temp == 0 && floor_temp == 0) {
          // security key was not written correctly -> don't update
          ESP_LOGW("ensto.receive", "Real-time values are zero");
          return NAN;
      }
      ESP_LOGI("ensto.receive", "Room: %.1f°C, Floor: %.1f°C, Target: %.1f°C", room_temp, floor_temp, target_temp);
      static bool is_publish_needed = true;
      static int last_publish_time = 0;
      int current_time = millis() / 1000;
      if (current_time - last_publish_time >= 60) { // update at least once per minute
          last_publish_time = current_time;
          is_publish_needed = true;
      } 
      // statics to update values to home-assistant only when they change
      static auto last_target_temp = target_temp;
      if (is_publish_needed || last_target_temp != target_temp) {
          last_target_temp = target_temp;
          id(${devicename}_target_temperature).publish_state(target_temp);
      }
      static auto last_room_temp = room_temp;
      if (is_publish_needed || last_room_temp != room_temp) {
          last_room_temp = room_temp;
          id(${devicename}_room_temperature).publish_state(room_temp);
      }
      static auto last_floor_temp = floor_temp;
      if (is_publish_needed || last_floor_temp != floor_temp) {
          last_floor_temp = floor_temp;
          id(${devicename}_floor_temperature).publish_state(floor_temp);
      }
      auto relay_state = x[8] != 0;
      static auto last_relay_state = relay_state;
      if (is_publish_needed || last_relay_state != relay_state) {
          last_relay_state = relay_state;
          id(${devicename}_relay_state).publish_state(relay_state);
      }
      /*
      uint8_t heating_mode = x[14];
      static uint8_t last_heating_mode = heating_mode;
      if (is_publish_needed || last_heating_mode != heating_mode) {
          last_heating_mode = heating_mode;
          id(${devicename}_heating_mode).publish_state(heating_mode);
      }
      */
      is_publish_needed = false;
      return NAN;

  - platform: template
    name: "${ui_devicename} Target temperature"
    id: ${devicename}_target_temperature
    unit_of_measurement: "°C"
    accuracy_decimals: 1
    state_class: measurement
    device_class: temperature
  - platform: template
    name: "${ui_devicename} Room temperature"
    id: ${devicename}_room_temperature
    unit_of_measurement: "°C"
    accuracy_decimals: 1
    state_class: measurement
    device_class: temperature
  - platform: template
    name: "${ui_devicename} Floor temperature"
    id: ${devicename}_floor_temperature
    unit_of_measurement: "°C"
    accuracy_decimals: 1
    state_class: measurement
    device_class: temperature
  # - platform: template
  #   name: "${ui_devicename} Heating mode"
  #   id: ${devicename}_heating_mode
  #   unit_of_measurement: "mode"

# # Adaptive temperature control status
#   - platform: ble_client
#     type: characteristic
#     ble_client_id: ${devicename}
#     id: ${devicename}_adaptive_temp_control_characteristic
#     internal: true
#     service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
#     characteristic_uuid: c2dc85e9-47bf-4968-9562-d2e1980ed4e4
#     notify: false
#     update_interval: never
#     lambda: |-
#       if (x.size() < 1) return NAN;
#       static bool is_publish_needed = true;
#       bool is_adaptive = x[0];
#       ESP_LOGI("ensto.receive", "Adaptive temp control mode: %d", x[0]);
#       static bool last_is_adaptive = is_adaptive;
#       if (is_publish_needed || last_is_adaptive != is_adaptive) {
#           is_publish_needed = false;
#           last_is_adaptive = is_adaptive;
#           id(${devicename}_adaptive_temperature_control_status).publish_state(is_adaptive);
#       }
#       return NAN;

# Temperature calibration
  - platform: ble_client
    type: characteristic
    ble_client_id: ${devicename}
    id: ${devicename}_temp_calibration_characteristic
    internal: true
    service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
    characteristic_uuid: 1eca4351-b264-4db6-9c59-af4341d6ce69
    notify: false
    update_interval: never
    lambda: |-
      ESP_LOGD("ensto.receive", "Temperature calibration characteristic received with %d bytes", x.size());
      if (x.size() < 2) return NAN;
      auto temp_cal = (int16_t)(256 * x[1] + x[0]);
      ESP_LOGI("ensto.receive", "Temperature calibration value: %.1f°C", temp_cal / 10.0f);
      static auto last_temp_cal = temp_cal;
      static bool is_publish_needed = true;
      static int last_publish_time = 0;
      int current_time = millis() / 1000;
      if (current_time - last_publish_time >= 60) { // update at least once per minute
          last_publish_time = current_time;
          is_publish_needed = true;
      } 
      if (is_publish_needed || last_temp_cal != temp_cal) {
          last_temp_cal = temp_cal;
          id(${devicename}_temp_calibration).publish_state(temp_cal / 10.0f);
      }
      is_publish_needed = false;
      return NAN;
  - platform: template
    name: "${ui_devicename} Temperature calibration value"
    id: ${devicename}_temp_calibration
    unit_of_measurement: "°C"
    accuracy_decimals: 1
    state_class: measurement
    device_class: temperature

# Temperature boost
  - platform: ble_client
    type: characteristic
    ble_client_id: ${devicename}
    id: ${devicename}_boost_characteristic
    internal: true
    service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
    characteristic_uuid: ca3c0685-b708-4cd4-a049-5badd10469e7
    notify: false
    update_interval: never
    lambda: |-
      ESP_LOGD("ensto.receive", "Boost characteristic received with %d bytes", x.size());
      if (x.size() < 8) return NAN;
      auto is_boost_on = x[0] != 0;
      static bool is_publish_needed = true;
      static int last_publish_time = 0;
      int current_time = millis() / 1000;
      if (current_time - last_publish_time >= 60) { // update at least once per minute
          last_publish_time = current_time;
          is_publish_needed = true;
      } 
      static auto last_is_boost_on = is_boost_on;
      if (is_publish_needed || last_is_boost_on != is_boost_on) {
          last_is_boost_on = is_boost_on;
          id(${devicename}_boost_status).publish_state(is_boost_on);
      }
      auto boost_offset = (int16_t)(256 * x[2] + x[1]);
      static auto last_boost_offset = boost_offset;
      if (is_publish_needed || last_boost_offset != boost_offset) {
          last_boost_offset = boost_offset;
          id(${devicename}_temp_boost_offset).publish_state(boost_offset / 100.0f);
      }
      auto boost_minutes_left = (uint16_t)(256 * x[7] + x[6]);
      ESP_LOGI("ensto.receive", "Boost: %s, offset: %.2f°C, minutes left: %d", (is_boost_on ? "ON" : "OFF"), boost_offset/100.0f, boost_minutes_left);
      static auto last_boost_minutes_left = boost_minutes_left;
      if (is_publish_needed || last_boost_minutes_left != boost_minutes_left) {
          last_boost_minutes_left = boost_minutes_left;
          id(${devicename}_temp_boost_minutes_left).publish_state(boost_minutes_left);
      }
      is_publish_needed = false;
      return NAN;
  - platform: template
    name: "${ui_devicename} Temperature boost offset"
    id: ${devicename}_temp_boost_offset
    unit_of_measurement: "°C"
    accuracy_decimals: 2
    state_class: measurement
    device_class: temperature
  - platform: template
    name: "${ui_devicename} Temperature boost minutes left"
    id: ${devicename}_temp_boost_minutes_left
    unit_of_measurement: "minutes"

# Power consumption
  - platform: ble_client
    type: characteristic
    ble_client_id: ${devicename}
    id: ${devicename}_power_consumption_characteristic
    internal: true
    service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
    characteristic_uuid: c1686f28-fa1b-4791-9eca-35523fb3597e
    notify: false
    update_interval: never
    lambda: |-
      // format (uint8_t): <header><current hour><current date><current month><current year> following 25x(<hour delta from current><consumption ratio>)
      // ESP_LOGD("ensto.receive", "Power consumption characteristic received with %d bytes: %s", x.size(), format_hex(x.data(), x.size()).c_str());
      if (x.size() < 9) return NAN;
      if (x[5] != 0) return NAN; // current hour offset should be 0
      if (x[7] != 1) return NAN; // previous hour offset should be 1

      ESP_LOGI("ensto.receive", "Power consumption ratio: %d%%, last hour: %d%%", x[6], x[8]);
      id(${devicename}_power_consumption_ratio_current_hour).publish_state(x[6]);
      id(${devicename}_power_consumption_ratio_previous_hour).publish_state(x[8]);

      if (!id(${devicename}_max_heating_power).has_state()) return NAN; // not updated yet
      uint32_t power = id(${devicename}_max_heating_power).get_state();
      id(${devicename}_power_consumption_current_hour).publish_state(x[6] * power / 1000.0 / 100.0);
      id(${devicename}_power_consumption_previous_hour).publish_state(x[8] * power / 1000.0 / 100.0);

      if (!id(${devicename}_price_per_kwh).has_state()) return NAN; // not updated yet
      auto price = id(${devicename}_price_per_kwh).get_state();
      id(${devicename}_price_current_hour).publish_state(x[6] * power / 1000.0 / 100.0 * price);
      id(${devicename}_price_previous_hour).publish_state(x[8] * power / 1000.0 / 100.0 * price);
      return NAN;
  - platform: template
    name: "${ui_devicename} Power consumption ratio current hour"
    id: ${devicename}_power_consumption_ratio_current_hour
    accuracy_decimals: 0
    unit_of_measurement: "%"
    device_class: power_factor
    state_class: total_increasing
  - platform: template
    name: "${ui_devicename} Power consumption ratio previous hour"
    id: ${devicename}_power_consumption_ratio_previous_hour
    accuracy_decimals: 0
    unit_of_measurement: "%"
    device_class: power_factor
    state_class: total
  - platform: template
    name: "${ui_devicename} Power consumption current hour (kWh)"
    id: ${devicename}_power_consumption_current_hour
    accuracy_decimals: 5
    unit_of_measurement: "kWh"
    device_class: energy
    state_class: total_increasing
  - platform: template
    name: "${ui_devicename} Power consumption previous hour (kWh)"
    id: ${devicename}_power_consumption_previous_hour
    accuracy_decimals: 5
    unit_of_measurement: "kWh"
    device_class: energy
    state_class: total
  - platform: template
    name: "${ui_devicename} Electricity price current hour"
    id: ${devicename}_price_current_hour
    accuracy_decimals: 5
    unit_of_measurement: "€" # hard-coded unit
    state_class: total_increasing
  - platform: template
    name: "${ui_devicename} Electricity price previous hour"
    id: ${devicename}_price_previous_hour
    accuracy_decimals: 5
    unit_of_measurement: "€" # hard-coded unit
    state_class: total

# Time (set from App)
  - platform: ble_client
    type: characteristic
    ble_client_id: ${devicename}
    id: ${devicename}_time_characteristic
    internal: true
    service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
    characteristic_uuid: b43f918a-b084-45c8-9b60-df648c4a4a1e
    notify: false
    update_interval: never
    lambda: |-
      if (x.size() < 7) return NAN;
      struct tm time_info = {};
      time_info.tm_year = static_cast<int>(256 * x[1] + x[0]) - 1900;
      time_info.tm_mon = static_cast<int>(x[2]) - 1;
      time_info.tm_mday = static_cast<int>(x[3]);
      time_info.tm_hour = static_cast<int>(x[4]);
      time_info.tm_min = static_cast<int>(x[5]);
      time_info.tm_sec = static_cast<int>(x[6]);
      time_t epoch = mktime(&time_info);
      if (id(ha_time).utcnow().is_valid()) {
          auto time = id(ha_time).utcnow();
          auto diff = static_cast<int>(fabs(difftime(epoch, time.timestamp)));
          // allow +-3 second difference from delays
          if (diff > 3) {
              ESP_LOGI("ble_client.receive", "Time sync needed!");
              id(${devicename}_time_sync_needed) = true;
          }
      }
      return NAN;

# Max heating power (set manually from App)
  - platform: ble_client
    type: characteristic
    ble_client_id: ${devicename}
    id: ${devicename}_heating_power_characteristic
    internal: true
    service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
    characteristic_uuid: 53b7bf87-6cf0-4790-839a-e72d3afbec44
    notify: false
    update_interval: never
    lambda: |-
      // format (all single byte): <header><current hour><current date><current month><current year> following 25x(<hour delta from current><consumption ratio>)
      ESP_LOGD("ensto.receive", "Heating Power characteristic received with %d bytes: %s", x.size(), format_hex(x.data(), x.size()).c_str());
      if (x.size() < 2) return NAN;
      ESP_LOGI("ensto.receive", "Heating Power: %dW", (int16_t)(256 * x[1] + x[0]));
      id(${devicename}_max_heating_power).publish_state((int16_t)(256 * x[1] + x[0]));
      return NAN;
  - platform: template
    name: "${ui_devicename} Max Heating Power"
    id: ${devicename}_max_heating_power
    accuracy_decimals: 0
    device_class: power
    unit_of_measurement: "W"

# # LED brightness
#   - platform: ble_client
#     type: characteristic
#     ble_client_id: ${devicename}
#     id: ${devicename}_led_brightness_characteristic
#     internal: true
#     service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
#     characteristic_uuid: 0bee30ff-ed95-4747-bf1b-01a60f5ff4fc
#     notify: false
#     update_interval: never
#     lambda: |-
#       if (x.size() < 3) return NAN;
#       auto red = x[0];
#       auto green = x[1];
#       auto blue = x[2];
#       ESP_LOGI("ensto.receive", "LED brightness: red=%d%%, green=%d%%, blue=%d%%", red, green, blue);
#       id(${devicename}_red_led_brightness).publish_state(red);
#       id(${devicename}_green_led_brightness).publish_state(green);
#       id(${devicename}_blue_led_brightness).publish_state(blue);
#       return NAN;
#   - platform: template
#     name: "${ui_devicename} Red LED brightness"
#     id: ${devicename}_red_led_brightness
#     accuracy_decimals: 0
#     unit_of_measurement: "%"
#   - platform: template
#     name: "${ui_devicename} Green LED brightness"
#     id: ${devicename}_green_led_brightness
#     accuracy_decimals: 0
#     unit_of_measurement: "%"
#   - platform: template
#     name: "${ui_devicename} Blue LED brightness"
#     id: ${devicename}_blue_led_brightness
#     accuracy_decimals: 0
#     unit_of_measurement: "%"

# Energy unit price (set manually from App)
  - platform: ble_client
    type: characteristic
    ble_client_id: ${devicename}
    id: ${devicename}_energy_unit_characteristic
    internal: true
    service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
    characteristic_uuid: ccf1fe7b-d928-45b1-abba-7a915f2f0c64
    notify: false
    update_interval: never
    lambda: |-
      if (x.size() < 4) return NAN;
      auto currency = x[0];
      auto price = (int16_t)(256 * x[3] + x[2]) / 10000.0f;
      std::string currency_str;
      if (currency == 1) currency_str = "€";
      if (currency == 2) currency_str = "SEK";
      if (currency == 3) currency_str = "NOK";
      if (currency == 4) currency_str = "RUB";
      if (currency == 5) currency_str = "$";
      ESP_LOGI("ensto.receive", "Energy unit: currency=%d (%s), price=%.4f", currency, currency_str.c_str(), price);
      id(${devicename}_currency_id).publish_state(currency);
      id(${devicename}_price_per_kwh).publish_state(price);
      return NAN;
  - platform: template
    name: "${ui_devicename} Currency ID"
    id: ${devicename}_currency_id
    accuracy_decimals: 0
  - platform: template
    name: "${ui_devicename} Price per kWh"
    id: ${devicename}_price_per_kwh
    accuracy_decimals: 4

# Factory reset ID
  - platform: ble_client
    type: characteristic
    ble_client_id: ${devicename}
    id: ${devicename}_security_key_characteristic
    internal: true
    service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
    characteristic_uuid: f366dddb-ebe2-43ee-83c0-472ded74c8fa
    notify: false
    update_interval: never
    lambda: |-
      if (x.size() < 4) return NAN;

      uint32_t key = x[0] | x[1] << 8 | x[2] << 16 | x[3] << 24;
      if (key == 0) {
          ESP_LOGW("ensto", "Reading ${devicename} factory reset ID failed");
          return NAN; // couldn't get pairing key
      }
      ESP_LOGD("ensto", "key read = %02x%02x%02x%02x", x[0], x[1], x[2], x[3]);
      id(${devicename}_factory_reset_id) = key;
      ESP_LOGI("ensto", "Factory reset ID read -> write factory reset ID");
      id(${devicename}_state) = 2; // write key back
      return NAN;

# External temperature sensor from Home Assistant for Climate Control
  - platform: homeassistant
    id: external_temperature_sensor
    entity_id: $external_temperature_sensor
    internal: true
    accuracy_decimals: 2
    # Optional filter in case original sensor requires filtering. Note that median filter will make reacting to temperature changes slower.
    # filters:
    #   - median:
    #       window_size: 7
    #       send_every: 1
    #       send_first_at: 1

# state machine loop. Do actions every 5 second
interval:
  - interval: 5s
    then: 
      - lambda: !lambda 'id(${devicename}_interval_count) = id(${devicename}_interval_count) + 1;'
      # 1 = pairing, read factory reset ID
      - if:
          condition:
            lambda: !lambda 'return id(${devicename}_state) == 1;'
          then:
            - lambda: !lambda 'id(${devicename}_security_key_characteristic).update();'
      # 2 = write factory reset ID (if it is not zero)
      - if:
          condition:
            lambda: |-
              uint32_t key = id(${devicename}_factory_reset_id);
              return id(${devicename}_state) == 2 && key != 0;
          then:
            - ble_client.ble_write:
                id: ${devicename}
                service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
                characteristic_uuid: f366dddb-ebe2-43ee-83c0-472ded74c8fa
                value: !lambda |-
                    uint32_t key = id(${devicename}_factory_reset_id);
                    uint8_t newVal[4] = {
                        (uint8_t)(key & 0xff),
                        (uint8_t)((key >> 8) & 0xff),
                        (uint8_t)((key >> 16) & 0xff),
                        (uint8_t)((key >> 24) & 0xff),
                    };
                    ESP_LOGI("ensto", "Factory reset ID written -> Connected");
                    id(${devicename}_connection_state).publish_state(true);
                    id(${devicename}_state) = 3; // connected
                    return {newVal[0], newVal[1], newVal[2], newVal[3]};
      # 3+ = connected, read characteristics once in a while
      - if:
          condition:
            lambda: !lambda 'return id(${devicename}_state) >= 3;'
          then:
            - lambda: |-
                // Ensto disconnects if some characteristic is not read for 30 seconds
                // every 10 seconds OR when needed
                if (id(${devicename}_interval_count) % 2 == 0 || id(${devicename}_characterics_written_not_read) == 1) { 
                    id(${devicename}_boost_characteristic).update();
                    id(${devicename}_real_time_indication_characteristic).update();
                    id(${devicename}_characterics_written_not_read) = 0;
                    id(${devicename}_state) = 4;
                }
                if (id(${devicename}_interval_count) % 3 == 0) {
                    // update if sensor values are not valid after reconnect
                    /*
                    if (!id(${devicename}_adaptive_temperature_control_status).has_state()) {
                        id(${devicename}_adaptive_temp_control_characteristic).update();
                    }
                    */
                    if (!id(${devicename}_temp_calibration).has_state()) {
                        id(${devicename}_temp_calibration_characteristic).update();
                    }
                    if (!id(${devicename}_max_heating_power).has_state()) {
                        id(${devicename}_heating_power_characteristic).update();
                    }
                    if (!id(${devicename}_price_current_hour).has_state()) {
                        id(${devicename}_power_consumption_characteristic).update();
                    }
                    if (!id(${devicename}_price_per_kwh).has_state()) {
                        id(${devicename}_energy_unit_characteristic).update();
                    }
                    /*
                    if (!id(${devicename}_red_led_brightness).has_state()) {
                        id(${devicename}_led_brightness_characteristic).update();
                    }
                    */
                }
                if (id(${devicename}_interval_count) % 12 == 0) { // every 60 seconds
                    id(${devicename}_power_consumption_characteristic).update();
                    id(${devicename}_energy_unit_characteristic).update();
                    id(${devicename}_time_characteristic).update();
                }
                if (id(${devicename}_interval_count) % 13 == 0) { // every 65 seconds
                    // id(${devicename}_adaptive_temp_control_characteristic).update();
                    id(${devicename}_temp_calibration_characteristic).update();
                    // id(${devicename}_led_brightness_characteristic).update();
                }
                if (id(${devicename}_interval_count) % 61 == 0) { // every ~5 minutes
                    id(${devicename}_heating_power_characteristic).update();                    
                }
      # 3+ = connected and thermostat time out of sync
      - if:
          condition:
            lambda: |-
                return id(${devicename}_state) >= 3 && id(${devicename}_time_sync_needed) && id(ha_time).utcnow().is_valid();
          then:
            - ble_client.ble_write:
                id: ${devicename}
                service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
                characteristic_uuid: b43f918a-b084-45c8-9b60-df648c4a4a1e
                value: !lambda |-
                    auto now = id(ha_time).utcnow();
                    uint8_t val[7] = {
                        (uint8_t)(now.year & 0xff),
                        (uint8_t)((now.year >> 8) & 0xff),
                        (uint8_t)(now.month & 0xff),
                        (uint8_t)(now.day_of_month & 0xff),
                        (uint8_t)(now.hour & 0xff),
                        (uint8_t)(now.minute & 0xff),
                        (uint8_t)(now.second & 0xff),
                    };
                    char buf[20];
                    now.strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S");
                    ESP_LOGI("ensto", "Time set to %s (UTC)", buf);
                    id(${devicename}_time_sync_needed) = false;
                    return {val[0], val[1], val[2], val[3], val[4], val[5], val[6]};

      # 4 = Climate Controller boost
      - if:
          condition:
            lambda: |-
                return id(${devicename}_state) >= 4 &&
                       (
                        // 2 minute minimum delay between updates, if the target temperature has not changed.
                        id(${devicename}_thermostat).target_temperature != id(${devicename}_previous_target_temperature) || 
                        id(${devicename}_interval_count) % 24 == 0 
                       )  
                       && (
                         id(${devicename}_thermostat).mode != ClimateMode::CLIMATE_MODE_OFF &&
                         id(${devicename}_temp_boost_minutes_left).has_state() &&
                         id(${devicename}_temp_boost_offset).has_state() &&
                         id(external_temperature_sensor).has_state() &&
                         id(${devicename}_target_temperature).has_state() &&
                         id(${devicename}_temp_calibration).has_state()
                       );
          then:
            - ble_client.ble_write:
                id: ${devicename}
                service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
                characteristic_uuid: ca3c0685-b708-4cd4-a049-5badd10469e7
                value: !lambda |-
                    auto target = id(${devicename}_thermostat).target_temperature;
                    auto thermos_diff = target - id(external_temperature_sensor).get_state();
                    auto boost = id(${devicename}_temp_boost_offset).get_state();
                    auto device_target = id(${devicename}_target_temperature).get_state();
                    auto device_base = device_target - boost;

                    // safe for next iteration
                    id(${devicename}_previous_target_temperature) = target;                     
                    id(${devicename}_characterics_written_not_read) = 1;
                    
                    // first add boost to compensate difference between ensto's internal and our external temperature sensor
                    auto needed_boost = (target - device_base); 

                    // then add difference of thermostat's set and current temperatures
                    needed_boost += thermos_diff;

                    // add also calibration value
                    needed_boost += id(${devicename}_temp_calibration).get_state();

                    // finally overcompensate needed boost so that target temperature is actually reached
                    // These formulas could be improved
                    if (thermos_diff < -1 * id(${devicename}_thermostat).heat_overrun()) {
                        // above and not close to target (e.g. >0.5 from target) -> big negative boost to turn heating completely off
                        needed_boost += -5;
                    } else if (thermos_diff > id(${devicename}_thermostat).heat_deadband()) {
                        // below and not close to target (e.g. <0.5 from target) -> boost more than needed
                        needed_boost += 2;
                    } else {
                        // close to target -> try to keep it here
                        needed_boost += thermos_diff * 1.5;
                    }

                    int16_t value = round(needed_boost * 100);
                    value = std::max<int16_t>(-2000, std::min<int16_t>(value, 2000));

                    uint16_t minutes = 15; // TODO: hardcoded
                    // uint16_t minutes = std::max(0, std::min(length_minutes, 255));
                    ESP_LOGI("ensto", "New climate boost offset set to %.2f°C for %u minutes", value/100.0f, minutes);
                    return {
                        1, // enable
                        (uint8_t)(value & 0xff), (uint8_t)((value >> 8) & 0xff), // int16_t offset
                        0, // boost offset percentage (not used)
                        (uint8_t)(minutes & 0xff), (uint8_t)((minutes >> 8) & 0xff) // uint16_t boost time set point in minutes
                    };

# Enable Home Assistant API
api:
  services:
# Temperature calibration value has range of -5.0..5.0C written as -50..50 to Ensto.
    - service: set_${devicename}_temperature_calibration
      variables:
        temperature_offset: float
      then:
        - if:
            condition:
              lambda: !lambda 'return id(${devicename}_connection_state).has_state() && id(${devicename}_connection_state).state;'
            then:
              - ble_client.ble_write:
                  id: ${devicename}
                  service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
                  characteristic_uuid: 1eca4351-b264-4db6-9c59-af4341d6ce69
                  value: !lambda |-
                      int16_t value = round(temperature_offset * 10);
                      // ensure it is within limits
                      value = std::max<int16_t>(-50, std::min<int16_t>(value, 50));
                      ESP_LOGI("ensto", "New temperature calibration value set to %d", value);
                      return {(uint8_t)(value & 0xff), (uint8_t)((value >> 8) & 0xff)};
# Temperature boost offset has valid range of -20.00..20.00C written as -2000..2000 to Ensto.
# Boost length has valid range of 0..300 minutes.
    - service: set_${devicename}_temperature_boost_offset
      variables:
        boost_offset: float
        length_minutes: int
      then:
        - if:
            condition:
              lambda: !lambda 'return id(${devicename}_connection_state).has_state() && id(${devicename}_connection_state).state;'
            then:
              - ble_client.ble_write:
                  id: ${devicename}
                  service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
                  characteristic_uuid: ca3c0685-b708-4cd4-a049-5badd10469e7
                  value: !lambda |-
                      int16_t value = round(boost_offset * 100);
                      value = std::max<int16_t>(-2000, std::min<int16_t>(value, 2000));
                      uint16_t minutes = std::max<int>(0, std::min<int>(length_minutes, 300));
                      ESP_LOGI("ensto", "New temperature boost offset set to %d for %u minutes", value, minutes);
                      return {
                          1, // enable
                          (uint8_t)(value & 0xff), (uint8_t)((value >> 8) & 0xff), // int16_t offset
                          0, // boost offset percentage (not used)
                          (uint8_t)(minutes & 0xff), (uint8_t)((minutes >> 8) & 0xff) // uint16_t boost time set point in minutes
                      };
# Max heating power of the device (e.g. 1000W).
    - service: set_${devicename}_max_power
      variables:
        max_power: int
      then:
        - if:
            condition:
              lambda: !lambda 'return id(${devicename}_connection_state).has_state() && id(${devicename}_connection_state).state;'
            then:
              - ble_client.ble_write:
                  id: ${devicename}
                  service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
                  characteristic_uuid: 53b7bf87-6cf0-4790-839a-e72d3afbec44
                  value: !lambda |-
                      // ensure it is within limits
                      uint16_t value = std::max<int32_t>(0, std::min<int32_t>(max_power, std::numeric_limits<uint16_t>::max()));
                      ESP_LOGI("ensto", "New max heating power value set to %dW", value);
                      return {(uint8_t)(value & 0xff), (uint8_t)((value >> 8) & 0xff)};
# Price of electricity per kWh (e.g. 0.0925€). Energy unit IDs: use_previous=0, EUR=1, SEK=2, NOK=3, RUB=4, USD=5
    - service: set_${devicename}_kwh_price
      variables:
        energy_unit_id: int
        price_per_kwh: float
      then:
        - if:
            condition:
              lambda: !lambda 'return id(${devicename}_connection_state).has_state() && id(${devicename}_connection_state).state && (energy_unit_id >= 0 && energy_unit_id <= 5);'
            then:
              - ble_client.ble_write:
                  id: ${devicename}
                  service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
                  characteristic_uuid: ccf1fe7b-d928-45b1-abba-7a915f2f0c64
                  value: !lambda |-
                      auto unit_id = energy_unit_id;
                      if (unit_id == 0 && id(${devicename}_currency_id).has_state()) unit_id = id(${devicename}_currency_id).get_state();
                      uint16_t value = std::max<uint16_t>(0, std::min<uint16_t>(price_per_kwh * 10000, std::numeric_limits<uint16_t>::max()));
                      ESP_LOGI("ensto", "New price of electricity per kWh set to %.4f (unit ID=%d)", price_per_kwh, unit_id);
                      return {(uint8_t)(unit_id & 0xff), 0, (uint8_t)(value & 0xff), (uint8_t)((value >> 8) & 0xff)};

# # Led brightness percentage (0-100)
#     - service: set_${devicename}_led_brightness_percentage
#       variables:
#         red: int
#         green: int
#         blue: int
#       then:
#         - if:
#             condition:
#               lambda: !lambda 'return id(${devicename}_connection_state).has_state() && id(${devicename}_connection_state).state;'
#             then:
#               - ble_client.ble_write:
#                   id: ${devicename}
#                   service_uuid: F49CEFD5-209B-4531-99BD-89FE2909931A
#                   characteristic_uuid: 0bee30ff-ed95-4747-bf1b-01a60f5ff4fc
#                   value: !lambda |-
#                       ESP_LOGI("ensto", "New LED brightness values set to: red=%d, green=%d, blue=%d", red, green, blue);
#                       return {(uint8_t)(std::max(0, std::min(red, 100)) & 0xff), 
#                               (uint8_t)(std::max(0, std::min(green, 100)) & 0xff),
#                               (uint8_t)(std::max(0, std::min(blue, 100)) & 0xff)};

climate:
  - platform: thermostat
    name: "${ui_devicename} Thermostat"
    id: ${devicename}_thermostat
    sensor: external_temperature_sensor
    preset:
      - name: home  # default
        default_target_temperature_low: 20.0°C
        mode: heat
    # these 2 are used in state machine above
    heat_deadband: 0.5°C     # The minimum temperature differential (temperature below the set point) before engaging extra heating
    heat_overrun: 0.5°C      # The minimum temperature differential (temperature above the set point) before disengaging heat
    min_idle_time: 5s        # not really used, required field
    min_heating_off_time: 5s # not really used, required field
    min_heating_run_time: 5s # not really used, required field
    heat_action:
      - lambda: !lambda ';' # heating control is handled in state machine
    idle_action:
      - lambda: !lambda ';' # idle control is handled in state machine