esp32-JK-bluetooth.yaml

# Version info, for full change log:- https://github.com/Uksa007/esphome-jk-bms-can/discussions/2
# V1.13.3.1 Added Discharge slider
# V1.13.3 Improve compatibility with Deye and other inverters
# V1.13.2 Send Max Temperature of T1, T2 to inverter
# V1.13.1 Fix compile issues with new version of ESPhome 2023.4.0, set rebulk offset to 2.5
substitutions:
# --------------------------
# name that will appear in esphome and homeassistant.
  name: jk-bms-can
# --------------------------
# Number of Battery modules max 8. Each LX U5.4-L battery is 5.4kWh, select the number closest to your capactiy eg 3.2V * 280Ah * 16 = 14.3kWh
  batt_modules: "3"
# --------------------------------------
# Battery Charging setting:
# This is max charging amps eg 50A, for Bulk - Constant Current charging(CC), should be at least 10A less than BMS change current protection, 0.5C max 
  charge_a: "200"
# Absorption Voltage for Constant Voltage charging(CV). This is Absorption voltage you want the inverter to change with 55.2 eg 3.45v/cell for 16 cells 48V battery. 
  absorption_v: "57"
# Absorption time in minutes to hold charge voltage after charge voltage is reached eg 30
  absorption_time: "30"
# Rebulk offset, x Volts below absorption volatge battery will request rebulk, eg 55.2-3 = 52.5v, roughly 90% SOC.
  rebulk_offset: "3"
# --------------------------------------
# Battery Discharge setting:
# Max discharge amps eg 100, should be at least 10A less than BMS over dischange current protection, 0.5C max
  discharge_a: "200"
# Minimum discharge voltage eg 48v/16 = 3V per cell
  min_dischange_v: "40"
# --------------------------------------
# Battery State of Health (SOH) setting:
# Maximum charging cycles is used to calculate the battey SOH, LF280K=6000.0 LF280=3000.0 (decimal is required)
  max_cycles: "6000.0"
# --------------------------------------
# ESP32 CAN/Serail port pins:
# GPIO pins your CAN bus transceiver(TJA1050) is connected to the ESP, note! TX->TX and RX->RX. 
  can_tx_pin: GPIO23 #10
  can_rx_pin: GPIO22 #09
# GPIO pins your JK-BMS RS485(TTL) is connected to the ESP TX->RX and RX->TX. 
#  tx_pin: GPIO17
#  rx_pin: GPIO16
  
  mac_address: C8:47:80:06:00:70
  protocol_version: JK02
# --------------------------------------
#### Don't make changes below this ####
  external_components_source: github://jasgrif11/esphome-jk-bms-can@reverted

esphome:
  name: ${name}
  on_boot:
    then:
      - switch.turn_on: inverter_charging
      - switch.turn_on: inverter_discharging


esp32:
  board: esp32doit-devkit-v1
#  framework:
#    type: esp-idf
#    version: latest

external_components:
  - source: ${external_components_source}
    refresh: 0s

globals:
  - id: can_305_rx
    type: int
    restore_value: no
    initial_value: '0'
  - id: charge_status
    type: std::string
    restore_value: no
    initial_value: '"Startup"'

button:
  - platform: restart
    name: "Restart button"
    id: restart_button
    internal: true

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

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Jk-Bms-Can Fallback Hotspot"


captive_portal:

ota:
  password: "9781ec081ce225993c3f831e8ac93d9c"

logger:
#  level: DEBUG

# Please use the native `api` component instead of the `mqtt` section
# if you use Home Assistant. The native API is more lightweight.
api:
#  encryption:
#   key: "lYnzZH3tZ2oEtY1jTX79/gC42M20V4CMlqWt1dnZlv0="


# mqtt:
#  broker: !secret mqtt_host
#  username: !secret mqtt_username
#  password: !secret mqtt_password
#  id: mqtt_client

output:
  - platform: gpio
    pin: 2
    id: led
    inverted: true

light:
  - platform: binary
    output: led
    id: led_buitin
    name: "Builtin LED"
    internal: true


esp32_ble_tracker:

ble_client:
  - mac_address: ${mac_address}
    id: client0

jk_bms_ble:
  - ble_client_id: client0
    protocol_version: ${protocol_version}
    throttle: 5s
    id: bms0

canbus:
  - platform: esp32_can
    tx_pin: ${can_tx_pin}
    rx_pin: ${can_rx_pin}
    can_id: 4
    bit_rate: 500kbps
    on_frame:
    - can_id: 0x305 # SMA/LG/Pylon/Goodwe reply
      then:
        - light.toggle:
            id: led_buitin
        - lambda: |-
            // ESP_LOGI("main", "received can id: 0x305 ACK");
            id(can_305_rx) = 0;
interval:
  - interval: 1000ms
    then:
      - canbus.send: # Warning, Alarms
          can_id: 0x359
          data: !lambda |-
            uint8_t can_mesg[] = {0, 0, 0, 0, 0, 0, 0, 0};
            int batt_mods = ${batt_modules};
            
            uint16_t jk_errormask = id(errors_bitmask).state;
            
            // Alarms
            if ((jk_errormask & 0x04) | (jk_errormask & 0x80) | (jk_errormask & 0x400)) { // Hight.Voltage.Alarm JK bit 2,7,10 
               can_mesg[0] = 0x02; // bit 1
            }
            if ((jk_errormask & 0x08) | (jk_errormask & 0x800)) { // Low.Voltage.Alarm JK bit 3,11 
               can_mesg[0] = can_mesg[0] | 0x04; // bit 2
            }
            if ((jk_errormask & 0x02) | (jk_errormask & 0x10) | (jk_errormask & 0x100)) { // Hight.Temp.Alarm JK bit 1,4,8
               can_mesg[0] = can_mesg[0] | 0x08; // bit 3
            }
            if (jk_errormask & 0x200) { // Low.Temp.Alarm JK bit 9
               can_mesg[0] = can_mesg[0] | 0x10; // bit 4
            }
            if (jk_errormask & 0x40) { // Discharge.Over.Current JK bit 6
               can_mesg[0] = can_mesg[0] | 0x80; // bit 7
            }
            if (jk_errormask & 0x20) { // Charge.Over.Current JK bit 5
               can_mesg[1] = 0x01; // bit 0
            }
            if ((jk_errormask & 0x1000) | (jk_errormask & 0x2000)) { // BMS Internal JK bit 12,13
               can_mesg[1] = can_mesg[1] | 0x08; // bit 3
            }
            if (jk_errormask & 0x80) { // Cell Imbalance JK bit 7
               can_mesg[1] = can_mesg[1] | 0x10; // bit 4 
            }
            
            /// Warnings
            can_mesg[2] = 0x00;
            can_mesg[3] = 0x00;
            /// Flags
            can_mesg[4] = batt_mods; // Module in parallel
            can_mesg[5] = 0x00;
            can_mesg[6] = 0x00;
            can_mesg[7] = 0x00; // DIP switches 1,3 10000100 0x84
            ESP_LOGI("main", "send can id: 0x359 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]);
            return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]};
      - delay: 10ms

      - canbus.send: # BMS instructs inverter: Charge Volts, Charge Amps, Discharge Amps, Min voltage
          can_id: 0x351
          data: !lambda |-
            uint8_t can_mesg[7];
            if ((!id(charging_switch).state) | (!id(inverter_charging).state)) {
              id(charge_status) = "Disabled";
            } else if (id(inverter_chg_on).state) {
                id(charge_status) = "Bulk Manually";
            } else if ((id(charging_switch).state) & (id(inverter_charging).state) & (id(charge_status) == "Disabled")) {
              id(charge_status) = "Wait";
            } else if ((!id(inverter_chg_on).state) & (id(charge_status) == "Bulk Manually")) {
               id(charge_status) = "Wait";
            } else if (id(total_voltage).state <= (id(charging_voltage).state - ${rebulk_offset})) { // Bulk Charge eg 53.6v 10% 
                if (id(absorption_script).is_running()) id(absorption_script).stop();
                id(charge_status) = "Bulk";
            } else if ((id(total_voltage).state > (id(charging_voltage).state - ${rebulk_offset})) & (id(total_voltage).state < (id(charging_voltage).state - 0.05))) { // If in startup rebulk
                     if (id(charge_status) == "Startup") {
                        id(charge_status) = "Bulk"; // If in startup, 10% low rebulk
                     }
            } else if (id(total_voltage).state >= (id(charging_voltage).state  - 0.05)) { // 10 % from top start absorption timer
                     if (id(charge_status) == "Bulk") {
                        id(charge_status) = "Absorption";
                        if (!id(absorption_script).is_running()) id(absorption_script).execute();
                    }
            } else {
                id(charge_status) = "Wait";
            }

            uint16_t packvoltage = uint16_t(id(total_voltage).state * 100);//hundreths
            uint16_t chargingvoltage = uint16_t(id(charging_voltage).state * 100); //hundreths
            uint16_t chargingcurrent = uint16_t(id(charging_current).state * 10); //tenths
            uint16_t chargeTaperVoltage = uint16_t(id(charge_taper_voltage).state * 100);
            
            if ((packvoltage >= (chargingvoltage-chargeTaperVoltage)) && (chargeTaperVoltage > 0)) // Within 2V of max in hundreths
            {
               chargingcurrent = chargingcurrent * (chargingvoltage-packvoltage)/chargeTaperVoltage;
            }
            
            
            
            if ((id(charge_status) == "Bulk") | (id(charge_status) == "Absorption") | (id(inverter_chg_on).state)) {
               can_mesg[0] = uint16_t(id(charging_voltage).state * 10) & 0xff;
               can_mesg[1] = uint16_t(id(charging_voltage).state * 10) >> 8 & 0xff;
               can_mesg[2] = chargingcurrent & 0xff;
               can_mesg[3] = chargingcurrent >> 8 & 0xff;
            } else {
               can_mesg[0] = uint16_t((id(charging_voltage).state - ${rebulk_offset}) * 10) & 0xff;
               can_mesg[1] = uint16_t((id(charging_voltage).state - ${rebulk_offset}) * 10) >> 8 & 0xff;
               can_mesg[2] = 0;
               can_mesg[3] = 0;
            }
            if ((!id(charging_switch).state) | (!id(inverter_charging).state)) { // Overides to disable charging
               can_mesg[0] = uint16_t((id(charging_voltage).state - ${rebulk_offset}) * 10) & 0xff;
               can_mesg[1] = uint16_t((id(charging_voltage).state - ${rebulk_offset}) * 10) >> 8 & 0xff;
               can_mesg[2] = 0;
               can_mesg[3] = 0;
            }
            if ((id(discharging_switch).state) & (id(inverter_discharging).state)) {
              
              uint16_t dischargeCurrent = uint16_t(id(discharging_current).state * 10);
              uint16_t taperVoltage = uint16_t(id(taper_voltage).state * 100);
              uint16_t taperVoltageBottom = taperVoltage - 300;
              
              if(packvoltage <= taperVoltage)
              {
                dischargeCurrent = dischargeCurrent * (packvoltage - taperVoltageBottom)/300;
                
                if(packvoltage <= taperVoltageBottom)
                {
                  dischargeCurrent = 0;
                }
                
              }
              
              can_mesg[4] = dischargeCurrent & 0xff;
              can_mesg[5] = dischargeCurrent >> 8 & 0xff;

              id(can_discharge_current).publish_state(dischargeCurrent / 10);
            } else {
              can_mesg[4] = 0x00;
              can_mesg[5] = 0x00;
              id(can_discharge_current).publish_state(0);
            }
            can_mesg[6] = uint16_t(${min_dischange_v} * 10) & 0xff;
            can_mesg[7] = uint16_t(${min_dischange_v} * 10) >> 8 & 0xff;
            id(charging_status).publish_state(id(charge_status));
            ESP_LOGI("main", "send can id: 0x351 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]);
            ESP_LOGI("main", "send can id: Charge Status %s", id(charge_status).c_str());
            return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]};
      - delay: 10ms

      - canbus.send: # Actual SOC, SOH
          can_id: 0x355
          data: !lambda |-
            int soh = round(((id(charging_cycles).state/${max_cycles})-1)*-100);
            uint8_t can_mesg[3];

            int soc = 0; 
            if(id(man_soc).state < 0)
            {
              soc = id(capacity_remaining).state;
            }
            else
            {
              soc = id(man_soc).state;
            }

            can_mesg[0] = soc & 0xff;
            can_mesg[1] = soc >> 8 & 0xff;
            can_mesg[2] = soh & 0xff;
            can_mesg[3] = soh >> 8 & 0xff;
            ESP_LOGI("main", "send can id: 0x355 hex: %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3]);
            return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3]};
      - delay: 10ms

      - canbus.send: # Actual Volts, Amps, Temp
          can_id: 0x356
          data: !lambda |-
            uint8_t can_mesg[5];
            can_mesg[0] = uint16_t(id(total_voltage).state * 100) & 0xff;
            can_mesg[1] = uint16_t(id(total_voltage).state * 100) >> 8 & 0xff;
            can_mesg[2] = int16_t(id(current).state * 10) & 0xff;
            can_mesg[3] = int16_t(id(current).state * 10) >> 8 & 0xff;
            can_mesg[4] = int16_t(id(temperature_sensor_1).state * 10) & 0xff;
            can_mesg[5] = int16_t(id(temperature_sensor_1).state * 10) >> 8 & 0xff;
            ESP_LOGI("main", "send can id: 0x356 hex: %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5]);
            return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5]};
      - delay: 10ms

      - canbus.send: # Request flag to Enable/Disable: Charge, Discharge
          can_id: 0x35C
          data: !lambda |-
            uint8_t can_mesg[1];
            if ((id(charging_switch).state) & (id(inverter_charging).state)) {
               can_mesg[0] = 0x80;
            } else {
               can_mesg[0] = 0x00;
            }
            if ((id(discharging_switch).state) & (id(inverter_discharging).state)) {
               can_mesg[0] = can_mesg[0] | 0x40;
            }
            can_mesg[1] = 0x00;
            ESP_LOGI("main", "send can id: 0x35C hex: %x %x", can_mesg[0], can_mesg[1]);
            return {can_mesg[0], can_mesg[1]};
      - delay: 10ms

      - canbus.send: # Actual Max Cell Temp, Min Cell Temp, Max Cell V, Min Cell V
          can_id: 0x70
          data: !lambda |-
            int max_cell_voltage_i = id(max_cell_voltage).state * 100.0;
            int min_cell_voltage_i = id(min_cell_voltage).state * 100.0;
            uint8_t can_mesg[7];
            can_mesg[0] = int16_t(id(temperature_sensor_1).state * 10) & 0xff;
            can_mesg[1] = int16_t(id(temperature_sensor_1).state * 10) >> 8 & 0xff;
            can_mesg[2] = int16_t(id(temperature_sensor_1).state * 10) & 0xff;
            can_mesg[3] = int16_t(id(temperature_sensor_1).state * 10) >> 8 & 0xff;
            can_mesg[4] = max_cell_voltage_i & 0xff;
            can_mesg[5] = max_cell_voltage_i >> 8 & 0xff;
            can_mesg[6] = min_cell_voltage_i & 0xff;
            can_mesg[7] = min_cell_voltage_i >> 8 & 0xff;
            ESP_LOGI("main", "send can id: 0x70 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]);
            return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]};
      - delay: 10ms

      - canbus.send: # Actual Max Cell Temp ID, Min Cell Temp ID, Max Cell V ID, Min Cell ID
          can_id: 0x371
          data: !lambda |-
            uint8_t can_mesg[7];
            can_mesg[0] = 0x01;
            can_mesg[1] = 0x00;
            can_mesg[2] = 0x02;
            can_mesg[3] = 0x00;
            can_mesg[4] = uint16_t(id(max_voltage_cell).state) & 0xff;
            can_mesg[5] = uint16_t(id(max_voltage_cell).state) >> 8 & 0xff;
            can_mesg[6] = uint16_t(id(min_voltage_cell).state) & 0xff;
            can_mesg[7] = uint16_t(id(min_voltage_cell).state) >> 8 & 0xff;
            ESP_LOGI("main", "send can id: 0x371 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]);
            return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]};
      - delay: 10ms

      - canbus.send: # GOODWE
          can_id: 0x35E
          data: [0x4A, 0x4B, 0x42, 0x4D, 0x53, 0x43, 0x41, 0x4E]
      - delay: 10ms

      - lambda: |- # Detect no CAN reply
          if (id(can_305_rx) > 30) {
            //ESP_LOGI("main", "No rx can 0x305 reply. Rebooting...");
            //id(restart_button).press();
          } else {
            id(can_305_rx) ++;
          }
binary_sensor:
  - platform: jk_bms_ble
    balancing:
      name: "${name} balancing"
    charging:
      name: "${name} charging"
    discharging:
      name: "${name} discharging"


sensor:
  - platform: jk_bms_ble
    min_cell_voltage:
      id: min_cell_voltage
      name: "${name} min cell voltage"
    max_cell_voltage:
      id: max_cell_voltage
      name: "${name} max cell voltage"
    min_voltage_cell:
      id: min_voltage_cell
      name: "${name} min voltage cell"
    max_voltage_cell:
      id: max_voltage_cell
      name: "${name} max voltage cell"
    delta_cell_voltage:
      name: "${name} delta cell voltage"
    average_cell_voltage:
      name: "${name} average cell voltage"
    cell_voltage_1:
      name: "${name} cell voltage 1"
    cell_voltage_2:
      name: "${name} cell voltage 2"
    cell_voltage_3:
      name: "${name} cell voltage 3"
    cell_voltage_4:
      name: "${name} cell voltage 4"
    cell_voltage_5:
      name: "${name} cell voltage 5"
    cell_voltage_6:
      name: "${name} cell voltage 6"
    cell_voltage_7:
      name: "${name} cell voltage 7"
    cell_voltage_8:
      name: "${name} cell voltage 8"
    cell_voltage_9:
      name: "${name} cell voltage 9"
    cell_voltage_10:
      name: "${name} cell voltage 10"
    cell_voltage_11:
      name: "${name} cell voltage 11"
    cell_voltage_12:
      name: "${name} cell voltage 12"
    cell_voltage_13:
      name: "${name} cell voltage 13"
    cell_voltage_14:
      name: "${name} cell voltage 14"
    cell_voltage_15:
      name: "${name} cell voltage 15"
    cell_voltage_16:
      name: "${name} cell voltage 16"
#    cell_voltage_17:
#      name: "${name} cell voltage 17"
#    cell_voltage_18:
#      name: "${name} cell voltage 18"
#    cell_voltage_19:
#      name: "${name} cell voltage 19"
#    cell_voltage_20:
#      name: "${name} cell voltage 20"
#    cell_voltage_21:
#      name: "${name} cell voltage 21"
#    cell_voltage_22:
#      name: "${name} cell voltage 22"
#    cell_voltage_23:
#      name: "${name} cell voltage 23"
#    cell_voltage_24:
#      name: "${name} cell voltage 24"
    power_tube_temperature:
      id: power_tube_temperature
      name: "${name} power tube temperature"
    temperature_sensor_1:
      id: temperature_sensor_1
      name: "${name} temperature sensor 1"
    temperature_sensor_2:
      id: temperature_sensor_2
      name: "${name} temperature sensor 2"
    total_voltage:
      id: total_voltage
      name: "${name} total voltage"
    current:
      id: current
      name: "${name} current"
    power:
      name: "${name} power"
    charging_power:
      name: "${name} charging power"
    discharging_power:
      name: "${name} discharging power"
    capacity_remaining:
      
      name: "${name} capacity remaining"
    charging_cycles:
      name: "${name} charging cycles"
      id: charging_cycles
    total_charging_cycle_capacity:
      name: "${name} total charging cycle capacity"
    errors_bitmask:
      id: errors_bitmask
      name: "${name} errors bitmask"
    state_of_charge:
      name: "${name} state of charge"
      id: capacity_remaining

#    alarm_low_volume:
#      name: "${name} alarm low volume"
#    manufacturing_date:
#      name: "${name} manufacturing date"
    total_runtime:
      name: "${name} total runtime"
#    start_current_calibration:
#      name: "${name} start current calibration"
    total_battery_capacity_setting:
      name: "${name} actual battery capacity"
#    protocol_version:
#      name: "${name} protocol version"
# Uptime sensor
  - platform: uptime
    name: ${name} Uptime Sensor
    id: uptime_sensor
    update_interval: 60s
    on_raw_value:
      then:
        - 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 ? to_string(days) + "d " : "") +
                (hours ? to_string(hours) + "h " : "") +
                (minutes ? to_string(minutes) + "m " : "") +
                (to_string(seconds) + "s")
              ).c_str();
              
  - platform: template
    name: "${name} CAN Discharge Current"
    id: "can_discharge_current"
    unit_of_measurement: A
    icon: mdi:current-dc
    
    
text_sensor:
  - platform: jk_bms_ble
    errors:
      name: "${name} errors"
    operation_status:
      name: "${name} operation mode"
    total_runtime_formatted:
      name: "${name} total runtime formatted"
# Template text sensors
  - platform: template
    name: ${name} Uptime Human Readable
    id: uptime_human
    icon: mdi:clock-start
  - platform: template
    name: "${name} Charging Status"
    id: charging_status

# Slider
number:
  - platform: template
    name: "${name} Absorption voltage"
    id: "charging_voltage"
    step: 0.1
    min_value: 48
    max_value: 58.5
    mode: slider
    initial_value: "${absorption_v}"
    unit_of_measurement: V
    icon: mdi:battery-charging
    optimistic: true
  - platform: template
    name: "${name} Mininium voltage"
    id: "mininium_voltage"
    step: 0.1
    min_value: 35
    max_value: 50
    mode: slider
    initial_value: "${min_dischange_v}"
    unit_of_measurement: V
    icon: mdi:battery-charging
    optimistic: true
  - platform: template
    name: "${name} Charging current max"
    id: "charging_current"
    step: 1
    min_value: 2
    max_value: 200
    mode: slider
    initial_value: "${charge_a}"
    unit_of_measurement: A
    icon: mdi:current-dc
    optimistic: true
  - platform: template
    name: "${name} Discharging current max"
    id: "discharging_current"
    step: 1
    min_value: 2
    max_value: 200
    mode: slider
    initial_value: "${discharge_a}"
    unit_of_measurement: A
    icon: mdi:current-dc
    optimistic: true
  - platform: template
    name: "${name} Discharge Taper Voltage"
    id: "taper_voltage"
    step: 1
    min_value: 32
    max_value: 55
    mode: slider
    initial_value: 32
    unit_of_measurement: V
    icon: mdi:battery-charging
    optimistic: true
    
  - platform: template
    name: "${name} Charge Taper Voltage"
    id: "charge_taper_voltage"
    step: 0.1
    min_value: 0
    max_value: 4
    mode: slider
    initial_value: 0
    unit_of_measurement: V
    icon: mdi:battery-charging
    optimistic: true

  - platform: template
    name: "${name} Manual SOC"
    id: "man_soc"
    step: 1
    min_value: -1
    max_value: 100
    mode: slider
    initial_value: -1
    unit_of_measurement: "%"
    icon: mdi:battery-charging
    optimistic: true


script:
  - id: absorption_script
    then:
      - lambda: id(charge_status) = "Absorption";
      - delay: ${absorption_time}min
      - lambda: id(charge_status) = "Wait";

switch:
  - platform: template
    name: ${name} Charging enabled
    id: inverter_charging
    optimistic: true
  - platform: template
    name: ${name} Discharge enabled
    id: inverter_discharging
    optimistic: true
  - platform: template
    name: ${name} Charging manually (top bal)
    id: inverter_chg_on
    optimistic: true
  - platform: jk_bms_ble
    charging:
      name: "${name} charging"
      id: charging_switch
    discharging:
      name: "${name} discharging"
      id: discharging_switch
    balancer:
      name: "${name} balancer"