My setup to charge 2 cars with Predbat

[ppmt]

Below is what I did to be able to charge 2 cars via Predbat. So I thought I would share it,.

I would like to thanks @gcoan and @springfall2008 for their help and patience with me.

Hopefully there is not too many typos or mistakes. Please let me know if you have any questions.

We have 2 EVs (MG5 and Ioniq) that we charge through a "Project EV" charger. None of the cars have a 3rd party integration (so Predbat/HomeAssistant have no idea of the cars' current SoC)

The wall charger is integrated via the OCPP integration (https://github.com/lbbrhzn/ocpp) which allow us to know when a car is plugged in.
It gives us a few sensors but the one we are interested are:

• 'sensor.ev_charger_status_connector' that says if a car is connected or not
• 'switch.ev_charger_charge_control' that turn on and off the charging.
• 'sensor.ev_charger_energy_session' that tells Predbat how much energy the wall charger is providing.

In Home Assistant:

1/ Create a 'Dropdown' helper entity (Settings / Devices & Services / Helpers) that has two options 'mg5' and 'ioniq' (or whatever you call your cars):

This will allow to differentiate which car is plugged in:

• Car Charger Plugged in - input_select.car_charger_plugged_in

2/ Create a helper entity (Settings / Devices & Services / Helpers) of type 'Number' and set 'Unit of Measurement' to '%':
This is to initialise the starting SOC of the car ( what your car is at before starting the charge).

• Car Initial Charge - input_number.car_initial_charge

3/ Create a helper entity (Settings / Devices & Services / Helpers) of type 'Number' and set 'Unit of Measurement' to '%':
This will indicate how much you want to charge the battery

• Car Max Charge - input_number.car_max_charge

3/ Open the home assistant templates.yaml and create a new sensor. Copy the yaml code below in the file
It will turn on or off based on which car is connected to the charger. It will also contains the details of the car that was selected from the dropdown menu.
Adapt the data to your cars mainly name, model and battery size.
You will also need to adapt the "Available" statement depeding on your wall charger. For my EV charger when no car is connected the state is Available.

  - name: "MG5 Connected"                                                                                                   
    unique_id: "sensor_ev_mg5_connected"                                                                                    
    state: >                                                                                                                 
      {% if states('sensor.ev_charger_status_connector') != "Available" and states('input_select.car_selector') == 'mg5' %}       
        on                                                                                                                   
      {% else %}                                                                                                             
        off                                                                                                                  
      {% endif %}                                                                                                            
    attributes:                                                                                                              
      model: "MG5"                                                                                                           
      battery_size_kwh: >                                                                                                    
        61.1    

  - name: "Ioniq Connected"                                                                                                  
    unique_id: "sensor_ev_ioniq_connected"                                                                                   
    state: >                                                                                                                 
      {% if states('sensor.ev_charger_status_connector') != "Available" and states('input_select.car_selector') == 'ioniq' %}
        on                                                         
      {% else %}                                                                         
        off                                                        
      {% endif %}                                                  
    attributes:                                                    
      model: "Ioniq"                                               
      battery_size_kwh: >                                          
        40.4

4/ In the same template file copy the following code. It will be used by predbat to determine the size of your car battery.
The data is read from the sensor created above.

  - name: "MG5 Battery Size"                                                
    unique_id: "sensor_mg5_battery_size"                                
    state: >                                                                   
      {{ state_attr('sensor.mg5_connected','battery_size_kwh') }} 

  - name: "Ioniq Battery Size"
    unique_id: "sensor_ioniq_battery_size"
    state: >                        
      {{ state_attr('sensor.ioniq_connected','battery_size_kwh') }}

5/ I also created an optional sensor that follows the charging of the car. It is optional but helpful to visualize in your dashboard
Create a helper entity (Settings / Devices & Services / Helpers) of type 'Template'. I named it 'Car Current Capacity'

• Car Current Charge - sensor.car_current_charge

In the state section copy this template:

{% set car = states('input_select.car_selector') %}
{% set capacity = states('sensor.mg5_battery_size')|float(0) if car == 'mg5' 
             else states('sensor.ioniq_battery_size') |float(0)  if car == 'ioniq' 
             else 0 %} 
{% set car_soc = (states('input_number.predbat_car_charging_manual_soc_kwh') |float(0)) if car == 'mg5' 
            else (states('input_number.predbat_car_charging_manual_soc_kwh_1')|float(0))  if car == 'ioniq' 
            else 0 %} 
{{( (1 -(capacity - car_soc)/ capacity )*100) |round(0)}}

Set unit to %, device class to battery and state class to measurement

6/ Since I am doing everything manually I need to initialise the Predbat sensor that keep track of how much kwh are in your battery before charging.
Once the charging start Predbat will increase it accordingly until you reach the required charging level.

Create an automation to convert the SOC (read from your car dash in %) into kWh. It makes life easier by not having to calculate it yourself.
It is triggered when you change the car from the dropdown or when you change the initial SOC of your car.
The result is then assigned to the predbat_car_charging_manual_soc_kwh(_1) and will then later increase as the battery is being charged.

alias: Initial Charge One Car Config
description:  Calculate and update battery kWh based on percentage and car model
triggers:
  - entity_id: input_number.car_initial_charge
    trigger: state
  - entity_id:
      - input_select.car_selector
    trigger: state
conditions: []
actions:
  - if:
      - condition: state
        entity_id: input_select.car_selector
        state:
          - mg5
    then:
      - action: input_number.set_value
        metadata: {}
        data:
          value: |
            {% set capacity = 
             state_attr('sensor.mg5_connected','battery_size_kwh')  |float(0)
            %} {{
             (states('input_number.car_initial_charge') | float(0) / 100) * capacity
            }}
        target:
          entity_id: input_number.predbat_car_charging_manual_soc_kwh
    else:
      - action: input_number.set_value
        metadata: {}
        data:
          value: |
            {% set capacity = 
             state_attr('sensor.ioniq_connected','battery_size_kwh')  |float(0)
            %} {{
             (states('input_number.car_initial_charge') | float(0) / 100) * capacity
            }}
        target:
          entity_id: input_number.predbat_car_charging_manual_soc_kwh_1
mode: single

7/ Finally create one more automation that will decide to turn on and off the EV Charger so that it charges the car based on Predbat decision
You will need to the adjust the entity that controls the activation of the wall charger

alias: Car Charging Slot
description: Turn on and off the charging the car based on Predbat
triggers:
  - trigger: state
    entity_id:
      - binary_sensor.predbat_car_charging_slot
      - binary_sensor.predbat_car_charging_slot_1
actions:
  - if:
      - condition: and
        conditions:
          - condition: state
            entity_id: binary_sensor.predbat_car_charging_slot
            state: "off"
          - condition: state
            entity_id: binary_sensor.predbat_car_charging_slot_1
            state: "off"
    then:
      - action: switch.turn_off
        metadata: {}
        data: {}
        target:
          entity_id: switch.ev_charger_charge_control
  - if:
      - condition: or
        conditions:
          - condition: state
            entity_id: binary_sensor.predbat_car_charging_slot
            state: "on"
          - condition: state
            entity_id: binary_sensor.predbat_car_charging_slot_1
            state: "on"
    then:
      - action: switch.turn_on
        metadata: {}
        data: {}
        target:
          entity_id: switch.ev_charger_charge_control
mode: single

In PredBat's app editor:

Within the apps.yaml configuration file specify the following configuration settings:

1/ Find the line for num_cars and set it to 2

num_cars: 2

2/ Find car_charging_planned and replace the template Wallbox and Zappi regular expression with the sensor created earlier:

  car_charging_planned:
    - sensor.mg5_connected
    - sensor.ioniq_connected

3/ Find car_charging_planned_response and add 'on' to the list if not already there:

  car_charging_planned_response:
    - 'on'

4/ Comment out the section for 'car_charging_now' and 'car_charging_now_response'.
This is required so that Predbat can be in charge of your charger rather than your car or something else

5/ Find the line for car_charger_battery_size and enter the sensor created earlier:

  car_charging_battery_size:
    - sensor.mg5_battery_size
    - sensor.ioniq_battery_size

6/ Specify the car_charging_limit to use the Car Max Charge helper entity created earlier. You need one per car even if they are the same:

  car_charging_limit:
    - 'input_number.car_max_charge'
    - 'input_number.car_max_charge'

7/ Specify the car_charging_soc to use the Car Intiial Charge helper entity created earlier. You need one per car even if they are the same:

  car_charging_soc:
    - input_number.car_initial_charge
    - input_number.car_initial_charge

8/ Specify the car_charging_energy to use the entity provided by the wall charger.

car_charging_energy: sensor.ev_charger_energy_session

9/ Find 'car_charging_exclusive and set it as below. This indicates that only one car will/can charge at any one time.

  car_charging_exclusive:
    - True
    - True

Save the apps.yaml file and exit. This will restart Predbat.
Check the addon's log and config in the app to make sure everything is ok.

In the config section of the Predbat app make sure the following switches are set to True:
Consult Predbat documentation for a detailed explanation of each one.

    switch.predbat_car_charging_hold
    switch.predbat_car_charging_manual_soc
    switch.predbat_car_charging_manual_soc_1
    switch.predbat_car_charging_plan_smart

And turn off the Predbat control switch:

switch.predbat_octopus_intelligent_charging

Finally, for simplicity, add the below entities to your HA Dashboard so you can set them when needed.
I use mushroom cards but making nice dashboard is not my forte so please shares yours!

    Car Charger Plugged in - input_select.car_charger_plugged_in
    Car Initial Charge - input_number.car_initial_charge
    Car Max Charge - input_number.car_max_charge
    Car Current Charge - sensor.car_current_charge
    Car Manual SoC - input_number.predbat_car_charging_manual_soc_kwh
    Car Manual SoC_1 - input_number.predbat_car_charging_manual_soc_kwh_1

Once a car is plugged in the EV charger you just select the car you want to charge, enter the starting SOC and the target SOC.

Predbat will then plan and charge the car with the kW that are needed to reach the target SoC.

[ppmt]

Below is an extra section that will split the cost of charging per car.

Predbat is keeping the daily cost of charging the cars in one sensor but it doesn't specify the cost for each car.

The automations below will take care of it but first we need to create 2 new helpers to track the cost per car.

Create 2 helpers that will collect the cost per car

Predbat stores the cost in pence so adjust the max to whatever is good for you.
In my case I consider that 10000 pence (£10) should be more than enough to charge either car per day.

Create a helper entity (Settings / Devices & Services / Helpers) of type 'Number' called:

• input_number.car_mg5_cost_today
• input_number.car_ioniq_cost_today
  Min = 0
  Max = 10000
  Step = 0.01

alias: Allocate EV Charging Cost
description: ""
triggers:
  - entity_id:
      - predbat.cost_today_car
    trigger: state
actions:
  - variables:
      new_cost: "{{ trigger.to_state.state | float }}"
      old_cost: "{{ trigger.from_state.state | float }}"
      delta: "{{ new_cost - old_cost }}"
  - condition: template
    value_template: "{{ delta > 0 }}"
  - choose:
      - conditions:
          - condition: template
            value_template: "{{ is_state('sensor.mg5_connected', 'on') }}"
        sequence:
          - target:
              entity_id: input_number.car_mg5_cost_today
            data:
              value: >
                {{ (states('input_number.car_mg5_cost_today') | float) + delta
                }}
            action: input_number.set_value
      - conditions:
          - condition: template
            value_template: "{{ is_state('sensor.ioniq_connected', 'on') }}"
        sequence:
          - target:
              entity_id: input_number.car_ioniq_cost_today
            data:
              value: >
                {{ (states('input_number.car_ioniq_cost_today') | float) + delta
                }}
            action: input_number.set_value
mode: single

Create another automation that will reset both timer every day at midnight.

alias: Reset Daily EV Car Costs
description: ""
triggers:
  - at: "00:00:00"
    trigger: time
actions:
  - target:
      entity_id:
        - input_number.car_mg5_cost_today
        - input_number.car_ioniq_cost_today
    data:
      value: 0
    action: input_number.set_value
mode: single

You can then create more utility meters helper that will use these 2 sensors to have weekly, monthly or whatever you choose totals for each cars.