Home ESS Setup

Click to open the raw file

type: custom:apexcharts-card
apex_config:
  chart:
    height: 300
  stroke:
    curve: stepline
header:
  title: Octopus Agile – Today’s Rates
  show: true
  show_states: true
  colorize_states: true
graph_span: 1d
span:
  start: day
now:
  show: true
yaxis:
  - min: 0
    decimals: 2
series:
  - entity: >-
      event.octopus_energy_electricity_xxx_xxx_current_day_rates
    name: Agile Price (p/kWh)
    type: line
    color: "#3399ff"
    show:
      in_header: false
      legend_value: false
    stroke_width: 2
    data_generator: |
      const rates = entity.attributes.rates || [];
      return rates.map(rate => {
        const ts = new Date(rate.start).getTime();
        return [ts, rate.value_inc_vat * 100];
      });
  - entity: sensor.octopus_energy_electricity_xxx_xxx_current_rate
    name: Current Rate
    type: line
    show:
      in_chart: false
    unit: p/kWh
    transform: return x * 100;
  - entity: >-
      event.octopus_energy_electricity_xxx_xxx_current_day_rates
    name: Cheapest 6 Slots
    type: column
    color: "#00cc66"
    show:
      in_header: false
      legend_value: false
    data_generator: >
      const rates = [...entity.attributes.rates || []];

      // Sort by price ascending

      const sorted = [...rates].sort((a, b) => a.value_inc_vat -
      b.value_inc_vat);

      const cheapest = sorted.slice(0, 6).map(r => r.start);


      return rates.map(rate => {
        const start = new Date(rate.start).getTime();
        const end = new Date(rate.end).getTime();
        const midpoint = (start + end) / 2;
        const isCheapest = cheapest.includes(rate.start);
        return [midpoint, isCheapest ? rate.value_inc_vat * 100 : null];
      });

Click to open the raw file

alias: Agile Rates Updated
description: >-
  Compute & store 6 cheapest half-hour slots (with full times & prices), notify
  on change
triggers:
  - event_type: octopus_energy_electricity_next_day_rates
    trigger: event
actions:
  - data:
      notification_id: battery_charge_times
      title: 🔋 Battery charge times update in progress
      message: |-
        🕓 Started at: 

        Calculating cheapest slots…
    action: persistent_notification.create
  - response_variable: ps_result
    action: python_script.store_battery_charge_times
    data: {}
  - choose:
      - conditions:
          - condition: template
            value_template: ""
        sequence:
          - data:
              notification_id: battery_charge_times
            action: persistent_notification.dismiss
    default:
      - variables:
          slot_msg: |-
             🚫 Next-day rates not available yet
      - data:
          notification_id: battery_charge_times
          title: 🔋 Battery charge times updated
          message: |-
            🕓 Ran at: 

            
        action: persistent_notification.create
      - data:
          title: Tomorrow’s Battery charge times 🔋
          message: |-
            🕓 Ran at: 

            
          data:
            clickAction: /energy-custom/4
        action: notify.mobile_app_device
variables:
  triggered_at: ""
mode: single

Click to open raw file

# python_scripts/store_battery_charge_times.py
# Processes next-day Octopus rates, stores cheapest slots, and returns change status

# Entity IDs and constants
NEXT_DAY_RATES_FROM_OCTOPUS = 'event.octopus_energy_electricity_19l2935327_2199998228556_next_day_rates'
CURRENT_DAY_RATES_FROM_OCTOPUS = 'event.octopus_energy_electricity_19l2935327_2199998228556_current_day_rates'
SENSOR_ENTITY = 'sensor.scheduled_battery_charge_times'
CHARGING_SLOTS_COUNT = 6

# Prepare output dict for automation
output = {}

def get_raw_rates_from_event(event):
    """Retrieve the rates event entity or log an error."""
    event_state = hass.states.get(event)
    if not event_state:
        logger.error(f"Rates event '{event}' not found")
    return event_state.attributes.get('rates', []) if event_state else []


def merge_consecutive_slots(slots):
    """
    Given a list of slots sorted by start time, merge any where
    one slot’s end == the next slot’s start, and set the merged
    slot’s price to the average of all merged slots’ prices.
    """
    merged = []
    current_group = []

    for slot in slots:
        if current_group and slot['start'] == current_group[-1]['end']:
            # still consecutive—add to current run
            current_group.append(slot)
        else:
            # break in sequence: flush previous run (if any)
            if current_group:
                # compute the merged slot for that run
                start = current_group[0]['start']
                end   = current_group[-1]['end']
                avg_price = sum(s['price'] for s in current_group) / len(current_group)
                rounded_avg = round(avg_price, 3)
                merged.append({'start': start, 'end': end, 'price': rounded_avg})
            # start a new run
            current_group = [slot]

    # flush the final run
    if current_group:
        start = current_group[0]['start']
        end   = current_group[-1]['end']
        avg_price = sum(s['price'] for s in current_group) / len(current_group)
        rounded_avg = round(avg_price, 3)
        merged.append({'start': start, 'end': end, 'price': rounded_avg})

    return merged


def build_charging_slots(raw_rates, count):
    """Sort raw rates by price and build list of cheapest slots."""
    sorted_rates = sorted(raw_rates, key=lambda r: r['value_inc_vat'])
    cheapest_six = [
        {
            'start': r['start'],
            'end':   r['end'],
            'price': round(r['value_inc_vat'] * 100, 2)
        }
        for r in sorted_rates[:count]
    ]
    cheapest_six.sort(key=lambda s: s['start'])
    return merge_consecutive_slots(cheapest_six)


def get_old_slots():
    """Retrieve existing slots from the sensor, or None if not present."""
    old_slots_store = hass.states.get(SENSOR_ENTITY)
    return old_slots_store.attributes.get('charge_times') if old_slots_store else None


def get_and_store_old_slots_from_raw():
    raw_rates = get_raw_rates_from_event(CURRENT_DAY_RATES_FROM_OCTOPUS)
    slots = build_charging_slots(raw_rates, CHARGING_SLOTS_COUNT)
    store_new_slots(slots)
    return slots


def store_new_slots(new_slots):
    for slot in new_slots:
        if isinstance(slot['start'], datetime.datetime):
            slot['start'] = slot['start'].isoformat()
        if isinstance(slot['end'], datetime.datetime):
            slot['end'] = slot['end'].isoformat()

    hass.states.set(
        SENSOR_ENTITY,
        'ok',
        {'charge_times': new_slots}
    )


def previous_slots_in_progress(old_slots):
    if not old_slots:
        return False

    start_value = old_slots[0]['start']
    end_value = old_slots[-1]['end']

    start_dt = start_value if isinstance(start_value, datetime.datetime) else dt_util.parse_datetime(start_value)
    end_dt = end_value if isinstance(end_value, datetime.datetime) else dt_util.parse_datetime(end_value)

    now = dt_util.utcnow().astimezone(start_dt.tzinfo)
    return start_dt <= now < end_dt


def parse_slots(slots):
    parsed = []
    for s in slots or []:
        parsed.append({
            'start': dt_util.parse_datetime(s['start']),
            'end':   dt_util.parse_datetime(s['end']),
            'price': s['price']
        })
    return parsed


def main():
    # 1) Fetch and parse rates
    raw_rates = get_raw_rates_from_event(NEXT_DAY_RATES_FROM_OCTOPUS)
    old_slots = get_old_slots()
    if not old_slots:
        old_slots = get_and_store_old_slots_from_raw()

    if not old_slots:
        logger.error(f"Old Slots Not Found, something has gone wrong!")

    if raw_rates:
        output['rates_available'] = True
        # 2) Compute cheapest slots list
        new_slots = build_charging_slots(raw_rates, CHARGING_SLOTS_COUNT)
        old_slots_parsed = parse_slots(old_slots)

        # 3) Compare to old
        changed = (old_slots_parsed != new_slots)
        output['changed'] = changed
        output['new_slots'] = new_slots
        output['old_slots'] = old_slots

        if changed and new_slots:
            # if no previous slots, or last-old end ≤ now, then store
            if not previous_slots_in_progress(old_slots):
                store_new_slots(new_slots)
                output['slots'] = new_slots
            else:
                # last old slot still in future → skip write/notification
                output['slots'] = old_slots
                output['old_slots_in_progress'] = previous_slots_in_progress(old_slots)
    else:
        output['rates_available'] = False
        output['changed'] = False
        output['old_slots_in_progress'] = previous_slots_in_progress(old_slots)


# Execute
main()

Click to open the raw file

# templates.yaml

# ——————————————————————————————————————————————
# Battery Charging Window Active
# ——————————————————————————————————————————————
- binary_sensor:
    - name: "Battery Charging Window Active"
      device_class: power

      # ON if now() falls inside any slot
      state: >
        {{ state_attr('binary_sensor.battery_charging_window_active','in_charge_window') }}

      attributes:
        current_slot_start: >
          {%- set slots  = state_attr('sensor.scheduled_battery_charge_times','charge_times') or [] -%}
          {%- set now_ts = as_timestamp(now())                                  -%}
          {%- for slot in slots                                                 -%}
            {%- set start_ts = as_timestamp(slot.start)                         -%}
            {%- set end_ts   = as_timestamp(slot.end)                           -%}
            {%- if start_ts <= now_ts <= end_ts                                  %}
              {{ slot.start }}
              {%- break                                                         -%}
            {%- endif                                                           -%}
          {%- endfor                                                            -%}

        current_slot_end: >
          {%- set slots  = state_attr('sensor.scheduled_battery_charge_times','charge_times') or [] -%}
          {%- set now_ts = as_timestamp(now())                                  -%}
          {%- for slot in slots                                                 -%}
            {%- set start_ts = as_timestamp(slot.start)                         -%}
            {%- set end_ts   = as_timestamp(slot.end)                           -%}
            {%- if start_ts <= now_ts <= end_ts                                  %}
              {{ slot.end }}
              {%- break                                                         -%}
            {%- endif                                                           -%}
          {%- endfor                                                            -%}

        next_slot_start: >
          {%- set slots  = state_attr('sensor.scheduled_battery_charge_times','charge_times') or [] -%}
          {%- set now_ts = as_timestamp(now())                                  -%}
          {%- set ns = namespace(next='')                                       -%}
          {%- for slot in slots | sort(attribute='start')                       -%}
            {%- set start_ts = as_timestamp(slot.start)                         -%}
            {%- if start_ts > now_ts                                            -%}
              {%- set ns.next = slot.start                                      -%}
              {%- break                                                         -%}
            {%- endif                                                           -%}
          {%- endfor                                                            -%}
          {{ ns.next if ns.next else "No Future Slots" }}

        next_slot_end: >
          {%- set slots  = state_attr('sensor.scheduled_battery_charge_times','charge_times') or [] -%}
          {%- set now_ts = as_timestamp(now())                                  -%}
          {%- set ns = namespace(next='')                                       -%}
          {%- for slot in slots | sort(attribute='start')                       -%}
            {%- set start_ts = as_timestamp(slot.start)                         -%}
            {%- if start_ts > now_ts                                            -%}
              {%- set ns.next = slot.end                                        -%}
              {%- break                                                         -%}
            {%- endif                                                           -%}
          {%- endfor                                                            -%}
          {{ ns.next if ns.next else "No Future Slots" }}

        now: >
          {{ now() }}

        in_charge_window: >
          {{ state_attr('binary_sensor.battery_charging_window_active','current_slot_start') | default('') | length > 0 }}

        all_slots_today: >
          {{ state_attr('sensor.scheduled_battery_charge_times','charge_times') }}

Click to open the raw file

alias: Battery Charging Scheduler
description: ""
triggers:
  - minutes: /1
    trigger: time_pattern
actions:
  - target:
      entity_id: binary_sensor.battery_charging_window_active
    action: homeassistant.update_entity
    data: {}
  - variables:
      new_state: "{{ states('binary_sensor.battery_charging_window_active') }}"
  - choose:
      - conditions:
          - condition: template
            alias: If in new charging window, but battery is above 80%
            value_template: |
              {{ previous_state != new_state
                 and new_state == 'on'
                 and (states('sensor.victron_battery_soc')|float >= 80) }}
        sequence:
          - data:
              title: 🔋 Charge Session Skipped
              message: >
                Battery charge session skipped at {{ now() | as_timestamp  |
                timestamp_custom('%I:%M:%S %p') }}  because SoC={{
                states('sensor.victron_battery_soc') }}%.
            action: persistent_notification.create
          - data:
              title: 🔋 Charge Session Skipped
              message: >
                Battery charge session skipped at {{ now() | as_timestamp  |
                timestamp_custom('%I:%M:%S %p') }}  because SoC={{
                states('sensor.victron_battery_soc') }}%.
            action: notify.mobile_app_device
      - conditions:
          - condition: template
            alias: >-
              In charging window and (state has changed or battery is not
              already charging) and battery is below 80%
            value_template: |
              {{ new_state == 'on'
                 and (previous_state != new_state or states('sensor.victron_system_battery_state') != 'CHARGING')
                 and (states('sensor.victron_battery_soc')|float < 80) }}
        sequence:
          - data:
              topic: >-
                victron/W/xxx/settings/0/Settings/CGwacs/BatteryLife/Schedule/Charge/4/Day
              payload: "{\"value\":7}"
            action: mqtt.publish
          - data:
              notification_id: battery_charging_scheduler
              title: 🔋 Battery charging started
              message: >
                Started at {{ now() | as_timestamp  | timestamp_custom('%I:%M:%S
                %p') }}
            action: persistent_notification.create
      - conditions:
          - condition: template
            alias: >-
              Out of charging window and (state has changed or battery is not
              discharging)
            value_template: |
              {{ new_state == 'off'
                 and (previous_state != new_state or states('sensor.victron_system_battery_state') != 'DISCHARGING') }}
        sequence:
          - data:
              topic: >-
                victron/W/xxx/settings/0/Settings/CGwacs/BatteryLife/Schedule/Charge/4/Day
              payload: "{\"value\":-7}"
            action: mqtt.publish
          - data:
              notification_id: battery_charging_scheduler
              title: 🔋 Battery charging ended
              message: >
                Ended at {{ now() | as_timestamp  | timestamp_custom('%I:%M:%S
                %p') }}
            action: persistent_notification.create
variables:
  previous_state: "{{ states('binary_sensor.battery_charging_window_active') }}"
mode: single

Click to open the raw file

alias: Battery Charge Session Tracker
description: Track when charging starts and ends, log it, and send a mobile notification.
triggers:
  - entity_id: sensor.victron_system_battery_state
    to: CHARGING
    trigger: state
  - entity_id: sensor.victron_system_battery_state
    from: CHARGING
    trigger: state
actions:
  - choose:
      - conditions:
          - condition: template
            value_template: >
              {{ trigger.to_state is defined and trigger.to_state.state ==
              'CHARGING' }}
            alias: If charging has started
        sequence:
          - variables:
              start_ts: "{{ as_timestamp(now()) }}"
              start_soc: "{{ states('sensor.victron_battery_soc') | float }}"
          - data:
              name: Battery
              message: >
                Charge started at {{ start_ts | timestamp_custom('%H:%M') }}
                (SoC {{ start_soc }}%).
            action: logbook.log
          - data:
              notification_id: battery_charge_session_tracker_{{start_ts}}
              title: Battery Charging Started 🪫✅
              message: >
                Charge started at {{ start_ts | timestamp_custom('%H:%M') }}
                (SoC {{ start_soc }}%).
            action: persistent_notification.create
          - data:
              entity_id: input_text.current_battery_charge_session
              value: |
                {{ { 'start': start_ts,
                     'start_soc': start_soc } | to_json }}
            action: input_text.set_value
      - conditions:
          - condition: template
            value_template: >
              {{ trigger.from_state is defined and trigger.from_state.state ==
              'CHARGING' }}
            alias: If charging has finished
        sequence:
          - variables:
              end_ts: "{{ as_timestamp(now()) }}"
              end_soc: "{{ states('sensor.victron_battery_soc') | float }}"
              session: >-
                {{ states('input_text.current_battery_charge_session') |
                from_json }}
              start_ts: "{{ session.start }}"
              start_soc: "{{ session.start_soc }}"
              notification_id: battery_charge_session_tracker_{{start_ts}}
              notification_message: >
                Charged from {{ start_ts | timestamp_custom('%H:%M') }} (SoC {{
                start_soc }}%) to {{ end_ts | timestamp_custom('%H:%M') }} (SoC
                {{ end_soc }}%).
          - choose:
              - conditions:
                  - condition: template
                    value_template: |
                      {{ (end_ts - start_ts) > 300 }}
                sequence:
                  - data:
                      name: Battery
                      message: >
                        Charge ended at {{ end_ts | timestamp_custom('%H:%M') }}
                        (SoC {{ end_soc }}%).
                    action: logbook.log
                  - data:
                      notification_id: "{{ notification_id }}"
                      title: Battery Charging Ended🔋🏁
                      message: "{{ notification_message }}"
                    action: persistent_notification.create
                  - data:
                      title: Battery Charging Ended🔋🏁
                      message: "{{ notification_message }}"
                    action: notify.mobile_app_phil_s24u
                alias: If charging lasted more than 5 minutes
            default:
              - data:
                  notification_id: "{{ notification_id }}"
                action: persistent_notification.dismiss
mode: single