ESPHome configuration for the Ioniq EV 28kw with the MeatPi WiCAN interface

wican-ioniq28kw.yaml

substitutions:
  device_name: car
  charging_voltage_threshold: '13.0'
  low_voltage_threshold: '12.0'
  low_voltage_sleep_duration: 30min
  deep_sleep_duration: 3min # 5 * 60000
  first_boot_run_duration: '300000'
  abrp_key: !secret abrp_key
  abrp_token: !secret abrp_token
  hotspot1_ssid: !secret hotspot1_ssid
  hotspot2_ssid: !secret hotspot2_ssid
  hotspot3_ssid: !secret hotspot3_ssid
  hotspot4_ssid: !secret hotspot4_ssid
  hotspot1_password: !secret hotspot1_password
  hotspot2_password: !secret hotspot2_password
  hotspot3_password: !secret hotspot3_password
  hotspot4_password: !secret hotspot4_password

esp32:
  variant: ESP32C3
  board: esp32-c3-devkitm-1
  framework:
    type: arduino

globals:
  - id: sleep_mode_enabled
    type: 'bool'
    restore_value: yes
    initial_value: 'true'
  - id: added_wifi_hotspots
    type: 'bool'
    restore_value: no
    initial_value: 'false'
  - id: last_odometer_value
    type: 'float'
    restore_value: yes
  - id: pending_status_update
    type: 'bool'
    restore_value: no
    initial_value: 'false'
  - id: last_hv_charging_state
    type: 'bool'
    restore_value: yes
    initial_value: 'false'
  - id: last_ac_present_state
    type: 'bool'
    restore_value: yes
    initial_value: 'false'
  - id: last_state_of_charge
    type: uint8_t
    restore_value: yes
    initial_value: '0'
  - id: frame_received
    type: 'bool'
    restore_value: no
    initial_value: 'false'
  - id: received_data
    type: 'std::vector<uint8_t>'
    restore_value: no
    initial_value: 'std::vector<uint8_t>()'
  - id: expected_length
    type: 'int'
    restore_value: no
    initial_value: '0'
  - id: next_frame_seq
    type: 'uint8_t'
    restore_value: no
    initial_value: '0x21'  # Start wfith 0x21 after FF
  - id: can_soh_raw
    type: 'float'
    restore_value: no
    initial_value: 'NAN'
  - id: can_soh_display
    type: 'float'
    restore_value: no
    initial_value: 'NAN'
  - id: can_soc_bms
    type: 'float'
    restore_value: no
    initial_value: 'NAN'
  - id: can_battery_dc_voltage
    type: 'float'
    restore_value: no
    initial_value: '0'
  - id: can_battery_current_signed
    type: 'float'
    restore_value: no
    initial_value: '0'
  - id: can_battery_power
    type: 'float'
    restore_value: no
    initial_value: '0'
  - id: can_operating_hours_float
    type: 'float'
    restore_value: no
    initial_value: 'NAN'
  - id: can_speed_mph
    type: 'float'
    restore_value: no
    initial_value: 'NAN'
  - id: can_ignition_status
    type: 'bool'
    restore_value: no
    initial_value: 'NAN'
  - id: trip_startsoc 
    type: 'float'
    restore_value: no
    initial_value: '0'
  - id: trip_startodo
    type: 'float'
    restore_value: no
    initial_value: '0'
  - id: last_canbus_packet
    type: 'std::string'
    restore_value: no
    initial_value: '""'
  - id: is_manual_request
    type: 'bool'
    restore_value: no
    initial_value: 'false'
    
esphome:
  name: car-wican
  on_shutdown:
    then:
      - if:
          condition:
            lambda: return id(state_of_charge_bms).has_state();
          then:
            globals.set:
              id: last_state_of_charge
              value: !lambda 'return round(id(state_of_charge_bms).state);' 
      - if:
          condition:
            lambda: return id(odometer).has_state();
          then:
            globals.set:
              id: last_odometer_value
              value: !lambda 'return id(odometer).state;'
      - if:
          condition:
            lambda: return id(ac_present).has_state();
          then:
            globals.set:
              id: last_ac_present_state
              value: !lambda 'return id(ac_present).state;'
      - if:
          condition:
            lambda: return id(hv_charging).has_state();
          then:
            globals.set:
              id: last_hv_charging_state
              value: !lambda 'return id(hv_charging).state;'
                    
  on_boot:
    priority: 210
    then:
      # Check if this is not a deep sleep wakeup
      - light.turn_on:
          id: blue_led
          effect: "sleeping"
      - script.execute: restore_sensor_values
      # - wireguard.disable
      - wait_until:
          # If the battery voltage indicates the car is running, or the canbus responds that the car is charging, then wake up:
          condition:
            lambda: |-
              return id(starter_battery_voltage).has_state();
          timeout: 6s
      - if:
          condition:
            and: # Deep sleep wakeup, check if we need to go back to sleep
              - binary_sensor.is_off: first_boot
              - sensor.in_range: # Low battery condition
                  id: starter_battery_voltage
                  below: '${low_voltage_threshold}'
          then:
            - logger.log: "Low voltage, going back to sleep."
            - deep_sleep.enter:
                id: deep_sleep_1
                sleep_duration: ${low_voltage_sleep_duration}
      - if:
          condition:
            binary_sensor.is_on: first_boot
          then:
            - lambda: id(deep_sleep_1)->set_run_duration(${first_boot_run_duration});
            - text_sensor.template.publish:
                id: boot_reason
                state: "First boot"
      - script.execute: update_car_sensors
      - script.wait: update_car_sensors
      - if: # Pending status update   
          condition: # If ignition is off, or has no state, 
            or:
              - lambda: return (id(ignition).has_state() && id(ignition).state);
              - lambda: return id(pending_status_update);
              - lambda: return id(first_boot).state;
          then:
            - wifi.enable:
            - light.turn_on:
                id: blue_led
                effect: "None"
            - light.turn_on:
                id: green_led
                effect: "searching"
            - script.execute: add_wifi_hotspots
            # - script.execute: update_bthome_broadcast

          else:
            - logger.log: "No updates to send, going back to sleep."
            - deep_sleep.enter:
                id: deep_sleep_1
                sleep_duration: ${deep_sleep_duration}



logger:
  level: DEBUG #NONE# ERROR #INFO #DEBUG  #VERBOSE
  baud_rate: 0 #to disable logging via UART
  # logs:
  #   text_sensor: ERROR
  #   homeassistant.sensor: ERROR
  #   canbus: INFO
  #   light: INFO

deep_sleep:
   id: deep_sleep_1
   run_duration: 50s
   sleep_duration: ${deep_sleep_duration}


api:
  reboot_timeout: 0s
  on_client_connected:
    - logger.log:
        format: "Client %s connected to API with IP %s"
        args: ["client_info.c_str()", "client_address.c_str()"]
  services:
    - service: send_manual_canbus_request
      variables:
        can_id: string
        data: string
      then:
        - logger.log:
            format: "Sending manual CAN bus request: can_id=0x%s, data=%s"
            args: [ 'can_id.c_str()', 'data.c_str()' ]
        - globals.set:
            id: is_manual_request
            value: 'true'
        - globals.set:
            id: frame_received
            value: 'false'
        - lambda: |-
            std::vector<uint8_t> data_vector;
            for (size_t i = 0; i < data.length(); i += 2) {
                uint8_t byte = strtol(data.substr(i, 2).c_str(), NULL, 16);
                data_vector.push_back(byte);
            }
            int can_id_int = strtol(can_id.c_str(), NULL, 16);
            id(can0)->send_data(can_id_int, false, data_vector);
        - wait_until:
            condition:
              lambda: return id(frame_received);
            timeout: 1sec
        - globals.set:
            id: is_manual_request
            value: 'false'

# esp32_ble:
#   enable_on_boot: false

# esp32_ble_server:
#  id: bleserver
#  manufacturer: "ESPHome"
#  model: "WiCAN"
#  manufacturer_data: [0x4C, 0, 0x23, 77, 0xF0]

time:
  - platform: homeassistant
    id: ha_time
  - platform: sntp
    id: sntp_time
    servers: 
      - 162.159.200.1
      - 192.168.178.1
      - 202.37.101.1
    timezone: Pacific/Auckland
    on_time_sync: 
      then:
        - script.execute: send_abrp_telemetry_script

text_sensor:
  - platform: template
    id: boot_reason
    name: "Wake reason"
    
  - platform: wifi_info
    ssid:
      name: Connected SSID
      id: connected_ssid

  - platform: template
    id: last_canbus_packet_sensor
    name: "Last CANBus packet"
    update_interval: 10s

wifi:
  id: wifi_component
  reboot_timeout: 0s
  fast_connect: true
  enable_on_boot: false
  on_connect:
    - light.turn_on:
        id: green_led
        effect: "None"
    - if:
        condition:
          and:
            - switch.is_on: send_abrp_telemetry
        then:
          - script.execute: send_abrp_telemetry_script
  on_disconnect:
    - light.turn_on:
        id: green_led
        effect: "searching"
  networks:
    - ssid: !secret wifi_ssid
      password: !secret wifi_password
      priority: 9
      manual_ip:
        static_ip: 192.168.178.210
        gateway: 192.168.178.1
        subnet: 255.255.255.0
        dns1: 192.168.178.1
        
output:
  - id: blue_led_output
    platform: gpio
    pin: 7
  - id: green_led_output
    platform: gpio
    pin: { number: 8, inverted: true }
  - id: yellow_led_output
    platform: gpio
    pin: { number: 9, inverted: true }

light:
  - platform: binary
    id: blue_led
    output: blue_led_output
    internal: True
    effects:
      - strobe:
          name: "sleeping"
          colors:
            - state: True
              duration: 500ms
            - state: False
              duration: 500ms
      - strobe:
          name: "sleep"
          colors:
            - state: True
              duration: 2000ms
            - state: False
              duration: 2000ms
    restore_mode: ALWAYS_ON
  - platform: binary
    id: green_led
    output: green_led_output
    effects:
      - strobe:
          name: "searching"
          colors:
            - state: True
              duration: 100ms
            - state: False
              duration: 3000ms
  - platform: binary
    id: yellow_led
    output: yellow_led_output

button:
  - platform: restart
    name: "${device_name} Restart"
  - platform: template
    name: Query Car Status
    id: query_status
    on_press:
      - script.execute: update_car_sensors

canbus:
  - platform: esp32_can
    id: can0
    tx_pin: 0
    rx_pin: 3
    bit_rate: 500kbps
    can_id: 0 # mandatory but we do not use it
    on_frame:
      - can_id: 0
        can_id_mask: 0
        then:
          - lambda: |-
              auto data_pretty = remote_transmission_request ? "n/a" : format_hex_pretty(x).c_str();
              ESP_LOGD("eup_dump", "can_id: 0x%08x, rtr: %d, length: %d, content: %s", can_id, remote_transmission_request, x.size(), data_pretty);

              uint8_t frame_type = (x[0] & 0xF0) >> 4;  // Extract the first 4 bits
              uint8_t frame_index = x[0] & 0x0F;  // Extract the next 4 bits

              if (frame_type == 0x00) {
                // This is a single-frame message
                id(expected_length) = x[0] & 0x0F;  // Extract the length from the first 4 bits
                id(received_data).clear();
                id(frame_received) = true;
                id(next_frame_seq) = 0x01;  // Reset for next multi-frame message

                // Append the data (excluding the first byte which contains the length)
                for (int i = 1; i < x.size(); i++) {
                    id(received_data).push_back(x[i]);
                }

                // Extract any single message data here
              } else if (frame_type == 0x01) {
                  // This is the start of a multi-frame message
                  // Extract the message length from the next 12 bits
                  id(expected_length) = ((x[0] & 0x0F) << 8) | x[1];

                  ESP_LOGD("eup_dump", "multi-frame message header, total frame length: %d", id(expected_length));
                  id(received_data).clear();
                  id(next_frame_seq) = 0x01;
                  id(frame_received) = false;

                  // Append the first part of the data (after the size bytes)
                  for (int i = 2; i < 8; i++) {
                      id(received_data).push_back(x[i]);
                  }

                  // Send Flow Control frame to request Consecutive Frames
                  id(can0)->send_data(can_id - 0x08, false, {0x30, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00});

              } else if (frame_type == 0x02) {
                ESP_LOGD("eup_dump", "Received frame_index: %02X, Expected next_frame_seq: %02X", frame_index, id(next_frame_seq));
                if (frame_index == id(next_frame_seq)) {
                  // This is a Consecutive Frame
                  for (int i = 1; i < 8; i++) {
                      id(received_data).push_back(x[i]);
                  }
                  id(next_frame_seq) = (id(next_frame_seq) == 0x0F) ? 0x00 : id(next_frame_seq) + 1;

                  // Check if reassembly is complete
                  if (id(received_data).size() >= id(expected_length)) {
                      // Convert the vector to a formatted string
                      std::string assembled_data;
                      for (uint8_t byte : id(received_data)) {
                          char buffer[4];
                          sprintf(buffer, "%02X.", byte);
                          assembled_data += buffer;
                      }

                      // Print the formatted string
                      ESP_LOGI("eup_dump", "Recieved completed canbus frame");
                      ESP_LOGD("AssembledFrame", "Complete Frame: %s", assembled_data.c_str());


                    if (id(is_manual_request)) {
                      id(last_canbus_packet) = assembled_data.c_str();
                      id(last_canbus_packet_sensor).publish_state(assembled_data.c_str());
                    }

                    if (can_id == 0x7EC && id(received_data)[1] == 0x05) {
                      if (id(received_data).size() >= 45) {
                        float soh_raw = ((id(received_data)[27] << 8) | id(received_data)[28]) / 10.0;
                        id(state_of_health).publish_state(soh_raw);
                      }
                      // State of Charge Display
                      float soc_display = (id(received_data).size() > 33) ? id(received_data)[33] / 2 : -1;
                      id(state_of_charge).publish_state(soc_display);
                    } 
                    else if (can_id == 0x7EC && id(received_data)[1] == 0x01) {
                      // State of Charge BMS
                      float soc_bms = (id(received_data).size() > 6) ? id(received_data)[6] / 2 : -1;
                      id(state_of_charge_bms).publish_state(soc_bms);
                      id(state_of_charge_bms_calibrated).publish_state(soc_bms);

                      if (id(trip_startsoc) == 0) {
                        id(trip_startodo) = soc_bms;
                      }

                      // HV Battery Voltage
                      id(can_battery_dc_voltage) = ((id(received_data)[14] * 256) + id(received_data)[15]) / 10.0;

                      // Battery Current
                      int signed_byte_k = (id(received_data)[12] < 128) ? id(received_data)[12] : id(received_data)[12] - 256;
                      id(can_battery_current_signed) = (signed_byte_k * 256 + id(received_data)[13]) / 10.0;

                      // Battery temperatures
                      int battery_max_temp = (id(received_data)[16] < 128) ? id(received_data)[16] : id(received_data)[16] - 256;
                      int battery_min_temp = (id(received_data)[17] < 128) ? id(received_data)[17] : id(received_data)[17] - 256;
                      id(battery_temperature).publish_state((battery_min_temp + battery_max_temp)/2);

                      // Charging Status
                      bool hv_charging_status = (id(received_data)[11] >> 7) & 1;
                      id(hv_charging).publish_state(hv_charging_status);
                      bool ac_present_status = (id(received_data)[11] >> 5) & 1;
                      id(ac_present).publish_state(ac_present_status);
                      // CCS charging port
                      bool fast_charging_status = (id(received_data)[11] >> 6) & 1;
                      id(fast_charging).publish_state(fast_charging_status);

                      // BMS Ignition (published at end of lambda)
                      id(can_ignition_status) = (id(received_data)[52] >> 2) & 1;

                      // Operating hours
                      float operating_hours_float = ((id(received_data)[48] << 24) | (id(received_data)[49] << 16) | (id(received_data)[50] << 8) | id(received_data)[51]) / 3600.0;
                      id(operating_hours).publish_state(operating_hours_float);

                      // Extract and publish Cumulative Energy Charged
                      if (id(received_data).size() > 48) {
                          float cumulative_energy_charged_kw = ((id(received_data)[40] << 24) | (id(received_data)[41] << 16) | (id(received_data)[42] << 8) | id(received_data)[43]) / 10.0;
                          float cumulative_energy_discharged_kw = ((id(received_data)[44] << 24) | (id(received_data)[45] << 16) | (id(received_data)[46] << 8) | id(received_data)[47]) / 10.0;
                          id(cumulative_energy_charged).publish_state(cumulative_energy_charged_kw);
                          id(cumulative_energy_discharged).publish_state(cumulative_energy_discharged_kw);
                      }

                      // Boot flags
                      if (soc_bms != id(last_state_of_charge) || hv_charging_status != id(last_hv_charging_state) || ac_present_status != id(last_ac_present_state)) {
                        id(pending_status_update) = true;
                        id(pending_status_update_sensor).publish_state(true);
                        id(last_state_of_charge) = soc_bms;
                      }
                    }
                    else if (can_id == 0x7EA && id(received_data)[1] == 0x01) {
                      // response from 7E2 (published end of lambda)
                      id(can_speed_mph) = ((signed int)(id(received_data)[16]) * 256 + id(received_data)[15]) / 100.0;
                    }
                    else if (can_id == 0x7EE && id(received_data)[1] == 0x80 && id(received_data).size() > 14) {
                      // response to 0x7E6, containing ambient temperature
                      float ambient_temperature_float = (((id(received_data)[14] < 128) ? id(received_data)[14] : id(received_data)[14] - 256) - 80) / 2.0; 
                      id(ambient_temperature).publish_state(ambient_temperature_float);
                    }
                    else if (can_id == 0x7CE && id(received_data)[1] == 0xB0 && id(received_data).size() > 11) {
                      // response to 7C6, containing odometer
                      uint32_t odometer_value = (static_cast<uint32_t>(id(received_data)[9]) << 16) | 
                              (static_cast<uint32_t>(id(received_data)[10]) << 8) | 
                               static_cast<uint32_t>(id(received_data)[11]);
                      id(odometer).publish_state(odometer_value);
                      if (id(trip_startodo) == 0) {
                        id(trip_startodo) = odometer_value;
                      }
                    }

                    id(next_frame_seq) = 0x01;  // Reset for next multi-frame message
                    id(frame_received) = true;
                  }
                }
              } else {
                ESP_LOGI("eup_dump", "Unexpected frame");
              }           

switch:
  - platform: gpio
    id: can_enabled
    name: "Enable CAN Interface"
    pin:
      number: 6
      inverted: true
    restore_mode: ALWAYS_ON

  - platform: template
    id: sleep_mode
    name: "${device_name} Sleep Mode"
    optimistic: true
    restore_mode: RESTORE_DEFAULT_ON
    on_turn_on:
      - logger.log: "Sleep mode: ON"
    on_turn_off:
      - logger.log: "Sleep mode: OFF"

  - platform: template
    id: send_abrp_telemetry
    name: "Send ABRP telemetry"
    optimistic: true
    restore_mode: RESTORE_DEFAULT_OFF

  - platform: template
    id: advertise_bthome
    name: "Advertise BLE Home packets"
    optimistic: true
    restore_mode: RESTORE_DEFAULT_ON
    # on_turn_off: 
    #   then:
    #     if: 
    #       condition:
    #         ble.enabled
    #       then:
    #         ble.disable

interval:
  # every 10 seconds while driving
  - interval: 9s
    then:
      - if:
          condition:
            and:
              - wifi.connected:
              - binary_sensor.is_on: ignition
              - switch.is_on: send_abrp_telemetry
              - lambda: 'return !id(is_manual_request);'
          then:
            - script.execute: update_car_sensors
            - script.wait: update_car_sensors
            - script.execute: send_abrp_telemetry_script

  - interval: 60s
    then: 
      - script.execute: update_car_sensors
      - script.wait: update_car_sensors
      # - script.execute: update_bthome_broadcast
      - if:
          condition:
            and:
              - wifi.connected:
              - switch.is_on: send_abrp_telemetry
          then:
            - script.execute: send_abrp_telemetry_script

  - interval: 5min
    then:
  #     - script.execute: update_bthome_broadcast
      - if: 
          condition:
            - wifi.connected:
          then:
            - script.execute: send_home_assistant_webhook

sensor:
  - platform: template
    id: state_of_health
    name: "State of Health"
    unit_of_measurement: "%"
    accuracy_decimals: 2
    state_class: measurement
    filters:
      - filter_out: nan

  - platform: template
    id: state_of_charge
    name: "State of Charge (Display)"
    unit_of_measurement: "%"
    accuracy_decimals: 0
    device_class: battery
    state_class: measurement
    filters:
      - filter_out: nan
      - delta: 1.0

  - platform: template
    id: state_of_charge_bms
    name: "State of Charge (BMS)"
    unit_of_measurement: "%"
    accuracy_decimals: 1
    device_class: battery
    state_class: measurement
    filters:
      - filter_out: nan
      - delta: 0.5

  - platform: template
    id: state_of_charge_bms_calibrated
    name: "State of Charge"
    unit_of_measurement: "%"
    accuracy_decimals: 0
    device_class: battery
    state_class: measurement
    filters:
      - filter_out: nan
      - delta: 0.5
      - calibrate_linear:
         method: least_squares
         datapoints:
          # Map 0.0 (from sensor) to 1.0 (true value)
          - 12 -> 11
          - 95 -> 99
      - clamp:
          max_value: 100.0

  - platform: template
    id: cumulative_energy_charged
    name: "Cumulative Energy Charged"
    unit_of_measurement: "kWh"
    accuracy_decimals: 0
    device_class: energy
    state_class: total_increasing
    filters:
      - filter_out: nan
      - delta: 1.0

  - platform: template
    id: cumulative_energy_discharged
    name: "Cumulative Energy Discharged"
    unit_of_measurement: "kWh"
    accuracy_decimals: 0
    device_class: energy
    state_class: total_increasing
    filters:
      - filter_out: nan
      - delta: 1.0

  - platform: template
    id: battery_current
    name: "Battery Current"
    unit_of_measurement: "A"
    accuracy_decimals: 2
    device_class: current
    state_class: measurement
    filters:
      - filter_out: nan
      - delta: 0.2

  - platform: template
    id: battery_power
    name: "Battery Power"
    unit_of_measurement: "kW"
    accuracy_decimals: 2
    device_class: power
    state_class: measurement
    filters:
      - filter_out: nan

  - platform: template
    id: hv_battery_voltage
    name: "HV Battery Voltage"
    unit_of_measurement: "V"
    accuracy_decimals: 0
    device_class: voltage
    state_class: measurement
    filters:
      - filter_out: nan
      - delta: 1


  - platform: template
    id: real_vehicle_speed
    name: "Real Vehicle Speed"
    unit_of_measurement: "km/h"
    accuracy_decimals: 0
    device_class: speed
    state_class: measurement
    filters:
      - filter_out: nan
      - clamp: 
          min_value: 0
          max_value: 140
          ignore_out_of_range: true

  - platform: template
    id: operating_hours
    name: "Operating hours"
    unit_of_measurement: "h"
    accuracy_decimals: 0
    device_class: duration
    state_class: total_increasing
    update_interval: 5min
    filters:
      - filter_out: nan

  - platform: template
    id: odometer
    name: "Odometer"
    unit_of_measurement: "km"
    accuracy_decimals: 0
    device_class: distance
    state_class: total_increasing
    filters:
      - filter_out: nan
    # on_value: 
    #   then:
    #     lambda: |-
    #       if (id(trip_start) >= 1) {
    #         return 1;
    #       }

  - platform: template
    id: ambient_temperature
    name: "Ambient temperature"
    unit_of_measurement: "°C"
    device_class: temperature
    state_class: measurement
    update_interval: 1min
    filters:
      - filter_out: nan

  - platform: adc
    id: starter_battery_voltage
    name: "${device_name} Battery Voltage"
    pin: 4
    attenuation: 11db # https://github.com/meatpiHQ/wican-fw/blob/bf212132f8e506f2c520e917daf86e53a1070302/main/sleep_mode.c#L234
    filters:
      - lambda: return x * 116 / 16; # https://github.com/meatpiHQ/wican-fw/blob/bf212132f8e506f2c520e917daf86e53a1070302/main/sleep_mode.c#L397
      - sliding_window_moving_average:
          window_size: 5   # Number of samples to average
          send_every: 5    # How often to send the averaged value
          send_first_at: 1 # When to send the first averaged value
    update_interval: 5s  # How often to update the sensor reading
    unit_of_measurement: V
    accuracy_decimals: 1
    device_class: voltage
    state_class: measurement

  - platform: template
    id: battery_temperature
    name: "Average battery temperature"
    unit_of_measurement: "°C"
    device_class: temperature
    accuracy_decimals: 1
    state_class: measurement
    filters:
      - filter_out: nan

  - platform: template
    id: last_state_of_charge_sensor
    name: "Last state of charge value"
    lambda: |-
      return id(last_state_of_charge);

binary_sensor:
  # - platform: wireguard
  #   status:
  #     name: 'WireGuard Status'
  - platform: template
    id: pending_status_update_on_wake
    name: "Pending Status Update on Wakeup"
  - platform: template
    id: first_boot
    name: "First boot"
  - platform: template
    id: pending_status_update_sensor
    name: "Pending Status Update"
    lambda: |-
      return id(pending_status_update);
  - platform: template
    id: wake
    name: "Wake sensor"
    filters:
      - delayed_off: 2min
    lambda: |-
      if (id(ignition).has_state() || id(fast_charging).has_state() || !id(sleep_mode).state) {
        return (id(ignition).state || id(fast_charging).state || !id(sleep_mode).state);
      } else {
        return {};
      }
    on_state:
      then:
        if:
          condition:
            and:
            - binary_sensor.is_on: wake
            - or:
                - lambda: return (id(starter_battery_voltage).state >= ${charging_voltage_threshold});
                - switch.is_off: sleep_mode
          then:
            - logger.log: "Wake sensor is on, preventing deep sleep"
            - deep_sleep.prevent: deep_sleep_1
          else:
            - deep_sleep.allow: deep_sleep_1

  - platform: status
    id: statussensor
  - platform: homeassistant
    entity_id: input_boolean.disable_car_sleep
    id: disable_sleep
    publish_initial_state: true     # This is important!
    on_state:
      then:
        if:
          condition:
            lambda: return x;
          then:
            - switch.turn_off: sleep_mode

  - platform: template
    id: hv_charging
    name: "High Voltage Battery Charging"

  - platform: template
    id: ac_present
    name: "AC charger present"

  - platform: template
    id: fast_charging
    name: "DC charger present"

  - platform: template
    id: ignition
    name: "Ignition"
  
  - platform: template
    id: normal_voltage
    name: "Starter battery normal voltage"
    lambda: |-
      return id(starter_battery_voltage).has_state() && id(starter_battery_voltage).state >= ${low_voltage_threshold};

script:
  - id: restore_sensor_values
    mode: single
    then:
      - lambda: id(first_boot).publish_state(esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_UNDEFINED);
      - lambda: id(odometer).publish_state(id(last_odometer_value));
      - lambda: id(ac_present).publish_state(id(last_ac_present_state));
      - lambda: id(state_of_charge_bms).publish_state(id(last_state_of_charge));
      - lambda: id(state_of_charge_bms_calibrated).publish_state(id(last_state_of_charge));
      # Restore pending status update to a sensor so we can determine the boot reason
      - lambda: id(pending_status_update_on_wake).publish_state(id(pending_status_update));


  - id: add_wifi_hotspots
    mode: single
    then:
      - lambda: |-
          auto wific = id(wifi_component);
          esphome::wifi::WiFiAP hotspot1;
          hotspot1.set_ssid("${hotspot1_ssid}");
          hotspot1.set_password("${hotspot1_password}");
          hotspot1.set_priority(5.0f);
          esphome::wifi::WiFiAP hotspot2;
          hotspot2.set_ssid("${hotspot2_ssid}");
          hotspot2.set_password("${hotspot2_password}");
          hotspot2.set_priority(3.0f);
          esphome::wifi::WiFiAP hotspot3;
          hotspot3.set_ssid("${hotspot3_ssid}");
          hotspot3.set_password("${hotspot3_password}");
          hotspot3.set_priority(1.0f);
          wific->add_sta(hotspot1);
          wific->add_sta(hotspot2);
          wific->add_sta(hotspot3);
          wific->set_fast_connect(false);
  
  - id: update_car_sensors
    mode: single
    then: 
      - logger.log:
          format: "Sending canbus status request"
          level: INFO
      - globals.set:
          id: frame_received
          value: 'false'
      - lambda: |-
          id(can_battery_current_signed) = 0;
          id(can_battery_power) = 0;
          id(can_ignition_status) = false;
          id(can_speed_mph) = 0;
          id(can_battery_dc_voltage) = 0;
      - canbus.send:
          # 7E4 - 2101, returns on 7EC - 
          can_id: 0x7E4 
          data: [0x02, 0x21, 0x01, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA]
      - wait_until:
          condition:
            lambda: return id(frame_received);
          timeout: 1sec
      - globals.set:
          id: frame_received
          value: 'false'
      - canbus.send:
          # 7E4 - 2105, returns on 7EC
          can_id: 0x7E4 
          data: [0x02, 0x21, 0x05, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA]
      - wait_until:
          condition:
            lambda: return id(frame_received);
          timeout: 1sec
      - lambda: |-
          // Update sensors
          id(ignition).publish_state(id(can_ignition_status));
          id(battery_current).publish_state(id(can_battery_current_signed));
          id(battery_power).publish_state((id(can_battery_dc_voltage) * id(can_battery_current_signed))/1000);
          id(hv_battery_voltage).publish_state(id(can_battery_dc_voltage));   
      - if:
          condition:
            binary_sensor.is_on: ignition
          then:
            - globals.set:
                id: frame_received
                value: 'false'
            - canbus.send:
                # 7E2 - 2101, Real vehicle speed, returns on 7EA
                can_id: 0x7E2
                data: [0x02, 0x21, 0x01, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA]
            - wait_until:
                condition:
                  lambda: return id(frame_received);
                timeout: 1sec
            - globals.set:
                id: frame_received
                value: 'false'
            - canbus.send:
                # Ambient temperature returns on 7EE
                can_id: 0x7E6
                data: [0x02, 0x21, 0x80, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA]
            - wait_until:
                condition:
                  lambda: return id(frame_received);
                timeout: 1sec
            - globals.set:
                id: frame_received
                value: 'false'
            - canbus.send:
                # Odometer
                can_id: 0x7C6  # Returns on 7CE
                data: [0x03, 0x22, 0xB0, 0x02, 0xAA, 0xAA, 0xAA, 0xAA]
            - wait_until:
                condition:
                  lambda: return id(frame_received);
                timeout: 1sec
            - lambda: |- 
                id(real_vehicle_speed).publish_state(id(can_speed_mph) * 1.60934);



  - id: send_abrp_telemetry_script
    mode: single
    then:
      - if:
          condition:
            and:
              - wifi.connected:
              - time.has_time: 
          then:
            - logger.log:
                format: "Sending ABRP telemetry"
                level: INFO
            - http_request.post:
                url: "https://api.iternio.com/1/tlm/send"
                headers:
                  Content-Type: application/json
                  Authorization: !secret abrp_key
                json: |-
                  root["tlm"]["utc"] = id(sntp_time).now().is_valid() ? id(sntp_time).now().timestamp : id(ha_time).now().timestamp;
                  root["tlm"]["soc"] = id(state_of_charge_bms_calibrated).has_state() ? id(state_of_charge_bms_calibrated).state : 0;
                  root["tlm"]["power"] = id(battery_power).state;
                  root["tlm"]["speed"] = id(real_vehicle_speed).state;
                  root["tlm"]["is_charging"] = id(hv_charging).state;
                  root["tlm"]["batt_temp"] = id(battery_temperature).state;
                  root["tlm"]["is_dcfc"] = id(fast_charging).state;
                  root["tlm"]["kwh_charged"] = id(cumulative_energy_charged).state;
                  root["tlm"]["odometer"] = id(odometer).has_state() ? id(odometer).state : id(last_odometer_value); 
                  root["tlm"]["ext_temp"] = id(ambient_temperature).state;
                  root["tlm"]["voltage"] = id(hv_battery_voltage).state;
                  root["tlm"]["current"] = id(battery_current).state;
                  root["tlm"]["soh"] = id(state_of_health).state;
                  root["token"] = "${abrp_token}";
                verify_ssl: false

  - id: send_home_assistant_webhook
    mode: single
    then:
      if:
        condition:
          and:
            - wifi.connected:
        then:
          http_request.post:
            headers:
              Content-Type: application/json
            url: !secret car_webhook_url
            verify_ssl: false
            json: |-
              root["soc"] = id(state_of_charge_bms_calibrated).has_state() ? id(state_of_charge_bms_calibrated).state : id(last_state_of_charge);
              root["is_charging"] = id(hv_charging).state;
              root["is_dcfc"] = id(fast_charging).state;
              root["speed"] = id(real_vehicle_speed).has_state() ? id(real_vehicle_speed).state : 0;
              root["ac_present"] = id(ac_present).state;    
              root["power"] = id(battery_power).state;
              root["odometer"] = id(odometer).has_state() ? id(odometer).state : id(last_odometer_value); 

http_request:
  useragent: esphome-wican
  timeout: 3s

Todo:

• get odometer working
• consider disabling sleep mode while the vehicle is charging rather than just using 12V battery voltage.
• finish ABRP telemetry integration
• test out using a personal hotspot
• test out broadcasting charge status over Bluetooth LE rather than relying on wifi
• flash yellow LED on canbus activity
• add metrics for calculate estimated range etc if available

Can't get BTHome BLE advertisements working.. seems to need to go in the service data field instead of manufacturer data.

Looks very interesting. Having a Hyundai Kona, which uses other PID's, and all responses are multi-frames. Do you think it is possible to mod your code to support my car? Where shall i focus?

Ported it to my Kona (some finetuning left), works fine except for the webhooks to HA. Seems like HA doesnt like webhooks outside the LAN. How did you solve this?

Glad to hear you got it working! Is your Home Assistant behind a proxy - i.e Cloudflare? I had to add some config because of that (XFF headers), but not aware of needing to make any other changes.

would you like to share your config?
Edit: got it working