Added battery SOC sensor, added session energy usage sensor, fixes for charge slots sensor, changes to accumulative energy sensor (#54)

* Fix dodgy next end time

* Fix bug with start time sensor

* Fix regressions

* Fix bug with charge slot list when charge in progress

* Bump version

* Fix end of last slot missing bug

* Over zealous rounding

* Don't show slots if charge finished

* Slot evaluation skip

* Add battery SOC sensor

* Initial implementation of live EnergyUsageSensor

* Fixes to energy usage and SOC

* Added session energy usage

* Revert accumulative usage sensor

* Allow state to drop to 0

* Use provisioning date for accumulative sensor start

* Don't let SOC go backwards

* Version bump

Author: dan-r

README.md

@@ -57,6 +57,8 @@ This integration exposes the following entities:
 * Sensors (Other)
     * CT Reading (Amps) - Reading from attached CT clamp
     * Accumulative Energy Usage (kWh) - Total energy used by the charger
+    * Session Energy Usage (kWh) - Energy used in the current session
+    * Battery State of Charge (%) - If your car is API connected this is read from the car, if not it is how much charge Ohme thinks it has added
 * Switches (Settings) - **Only options available to your charger model will show**
     * Lock Buttons - Locks buttons on charger
     * Require Approval - Require approval to start a charge
@@ -88,7 +90,7 @@ The coordinators are listed with their refresh intervals below. Relevant coordin
 * OhmeChargeSessionsCoordinator (30s refresh)
     * Binary Sensors: Car connected, car charging, pending approval and charge slot active
     * Buttons: Approve Charge
-    * Sensors: Power, current, voltage, charge slots and next slot (start & end)
+    * Sensors: Power, current, voltage, session energy usage, charge slots, and next slot (start & end)
     * Switches: Max charge, pause charge
     * Inputs: Target time, target percentage and preconditioning (If car connected)
 * OhmeAccountInfoCoordinator (1m refresh)

custom_components/ohme/api_client.py

@@ -27,6 +27,7 @@ def __init__(self, email, password):
         self._device_info = None
         self._capabilities = {}
         self._ct_connected = False
+        self._provision_date = None
 
         # Authentication
         self._token_birth = 0
@@ -312,13 +313,14 @@ async def async_update_device_info(self, is_retry=False):
         self._user_id = resp['user']['id']
         self._serial = device['id']
         self._device_info = info
+        self._provision_date = device['provisioningTs']
 
         return True
 
     async def async_get_charge_statistics(self):
         """Get charge statistics. Currently this is just for all time (well, Jan 2019)."""
         end_ts = self._last_second_of_month_timestamp()
-        resp = await self._get_request(f"/v1/chargeSessions/summary/users/{self._user_id}?&startTs=1546300800000&endTs={end_ts}&granularity=MONTH")
+        resp = await self._get_request(f"/v1/chargeSessions/summary/users/{self._user_id}?&startTs={self._provision_date}&endTs={end_ts}&granularity=MONTH")
 
         return resp['totalStats']
 

custom_components/ohme/const.py

@@ -1,7 +1,7 @@
 """Component constants"""
 DOMAIN = "ohme"
 USER_AGENT = "dan-r-homeassistant-ohme"
-INTEGRATION_VERSION = "0.5.1"
+INTEGRATION_VERSION = "0.6.0"
 CONFIG_VERSION = 1
 ENTITY_TYPES = ["sensor", "binary_sensor", "switch", "button", "number", "time"]
 

custom_components/ohme/sensor.py

@@ -6,15 +6,21 @@
     SensorStateClass,
     SensorEntity
 )
+import json
+import hashlib
+import math
+import logging
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
-from homeassistant.const import UnitOfPower, UnitOfEnergy, UnitOfElectricCurrent, UnitOfElectricPotential
+from homeassistant.const import UnitOfPower, UnitOfEnergy, UnitOfElectricCurrent, UnitOfElectricPotential, PERCENTAGE
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity import generate_entity_id
 from homeassistant.util.dt import (utcnow)
 from .const import DOMAIN, DATA_CLIENT, DATA_COORDINATORS, COORDINATOR_CHARGESESSIONS, COORDINATOR_STATISTICS, COORDINATOR_ADVANCED
 from .coordinator import OhmeChargeSessionsCoordinator, OhmeStatisticsCoordinator, OhmeAdvancedSettingsCoordinator
 from .utils import charge_graph_next_slot, charge_graph_slot_list
 
+_LOGGER = logging.getLogger(__name__)
+
 async def async_setup_entry(
     hass: core.HomeAssistant,
     config_entry: config_entries.ConfigEntry,
@@ -32,10 +38,12 @@ async def async_setup_entry(
                CurrentDrawSensor(coordinator, hass, client),
                VoltageSensor(coordinator, hass, client),
                CTSensor(adv_coordinator, hass, client),
-               EnergyUsageSensor(stats_coordinator, hass, client),
+               EnergyUsageSensor(coordinator, hass, client),
+               AccumulativeEnergyUsageSensor(stats_coordinator, hass, client),
                NextSlotEndSensor(coordinator, hass, client),
                NextSlotStartSensor(coordinator, hass, client),
-               SlotListSensor(coordinator, hass, client)]
+               SlotListSensor(coordinator, hass, client),
+               BatterySOCSensor(coordinator, hass, client)]
 
     async_add_entities(sensors, update_before_add=True)
 
@@ -206,7 +214,7 @@ def native_value(self):
         return self.coordinator.data['clampAmps']
 
 
-class EnergyUsageSensor(CoordinatorEntity[OhmeStatisticsCoordinator], SensorEntity):
+class AccumulativeEnergyUsageSensor(CoordinatorEntity[OhmeStatisticsCoordinator], SensorEntity):
     """Sensor for total energy usage."""
     _attr_name = "Accumulative Energy Usage"
     _attr_native_unit_of_measurement = UnitOfEnergy.WATT_HOUR
@@ -252,6 +260,61 @@ def native_value(self):
         return None
 
 
+class EnergyUsageSensor(CoordinatorEntity[OhmeChargeSessionsCoordinator], SensorEntity):
+    """Sensor for total energy usage."""
+    _attr_name = "Session Energy Usage"
+    _attr_native_unit_of_measurement = UnitOfEnergy.WATT_HOUR
+    _attr_suggested_unit_of_measurement = UnitOfEnergy.KILO_WATT_HOUR
+    _attr_suggested_display_precision = 1
+    _attr_device_class = SensorDeviceClass.ENERGY
+    _attr_state_class = SensorStateClass.TOTAL
+
+    def __init__(
+            self,
+            coordinator,
+            hass: HomeAssistant,
+            client):
+        super().__init__(coordinator=coordinator)
+
+        self._state = None
+
+        self._attributes = {}
+        self._client = client
+
+        self.entity_id = generate_entity_id(
+            "sensor.{}", "ohme_session_energy", hass=hass)
+
+        self._attr_device_info = hass.data[DOMAIN][DATA_CLIENT].get_device_info()
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        # Ensure we have data, then ensure value is going up and above 0
+        if self.coordinator.data and self.coordinator.data['batterySoc']:
+            new_state = self.coordinator.data['batterySoc']['wh']
+
+            # Let the state reset to 0, but not drop otherwise
+            if new_state <= 0:
+                self._state = 0
+            else:
+                self._state = max(0, self._state or 0, new_state)
+
+            self.async_write_ha_state()
+
+    @property
+    def unique_id(self) -> str:
+        """Return the unique ID of the sensor."""
+        return self._client.get_unique_id("session_energy")
+
+    @property
+    def icon(self):
+        """Icon of the sensor."""
+        return "mdi:lightning-bolt-circle"
+
+    @property
+    def native_value(self):
+        return self._state
+
+
 class NextSlotStartSensor(CoordinatorEntity[OhmeChargeSessionsCoordinator], SensorEntity):
     """Sensor for next smart charge slot start time."""
     _attr_name = "Next Charge Slot Start"
@@ -359,6 +422,7 @@ def _handle_coordinator_update(self) -> None:
 class SlotListSensor(CoordinatorEntity[OhmeChargeSessionsCoordinator], SensorEntity):
     """Sensor for next smart charge slot end time."""
     _attr_name = "Charge Slots"
+    _last_hash = None
 
     def __init__(
             self,
@@ -393,12 +457,26 @@ def native_value(self):
         """Return pre-calculated state."""
         return self._state
 
+    def _hash_rule(self):
+        """Generate a hashed representation of the current charge rule."""
+        serial = json.dumps(self.coordinator.data['appliedRule'], sort_keys=True)
+        sha1 = hashlib.sha1(serial.encode('utf-8')).hexdigest()
+        return sha1
+
     @callback
     def _handle_coordinator_update(self) -> None:
         """Get a list of charge slots."""
-        if self.coordinator.data is None or self.coordinator.data["mode"] == "DISCONNECTED":
+        if self.coordinator.data is None or self.coordinator.data["mode"] == "DISCONNECTED" or self.coordinator.data["mode"] == "FINISHED_CHARGE":
             self._state = None
+            self._last_hash = None
         else:
+            rule_hash = self._hash_rule()
+
+            # Rule has not changed, no point evaluating slots again
+            if rule_hash == self._last_hash:
+                _LOGGER.debug("Slot evaluation skipped - rule has not changed")
+                return
+            
             slots = charge_graph_slot_list(
                 self.coordinator.data['startTime'], self.coordinator.data['chargeGraph']['points'])
 
@@ -407,6 +485,66 @@ def _handle_coordinator_update(self) -> None:
 
             # Make sure we return None/Unknown if the list is empty
             self._state = None if self._state == "" else self._state
+
+            # Store hash of the last rule
+            self._last_hash = self._hash_rule()
 
         self._last_updated = utcnow()
         self.async_write_ha_state()
+
+
+class BatterySOCSensor(CoordinatorEntity[OhmeChargeSessionsCoordinator], SensorEntity):
+    """Sensor for car battery SOC."""
+    _attr_name = "Battery SOC"
+    _attr_native_unit_of_measurement = PERCENTAGE
+    _attr_device_class = SensorDeviceClass.BATTERY
+    _attr_suggested_display_precision = 0
+
+    def __init__(
+            self,
+            coordinator: OhmeChargeSessionsCoordinator,
+            hass: HomeAssistant,
+            client):
+        super().__init__(coordinator=coordinator)
+
+        self._state = None
+        self._attributes = {}
+        self._last_updated = None
+        self._client = client
+
+        self.entity_id = generate_entity_id(
+            "sensor.{}", "ohme_battery_soc", hass=hass)
+
+        self._attr_device_info = hass.data[DOMAIN][DATA_CLIENT].get_device_info()
+
+    @property
+    def unique_id(self) -> str:
+        """Return the unique ID of the sensor."""
+        return self._client.get_unique_id("battery_soc")
+
+    @property
+    def icon(self):
+        """Icon of the sensor. Round up to the nearest 10% icon."""
+        nearest = math.ceil((self._state or 0) / 10.0) * 10
+        if nearest == 0:
+            return "mdi:battery-outline"
+        elif nearest == 100:
+            return "mdi:battery"
+        else:
+            return "mdi:battery-" + str(nearest)
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Get value from data returned from API by coordinator"""
+        if self.coordinator.data and self.coordinator.data['car'] and self.coordinator.data['car']['batterySoc']:
+            new_state = self.coordinator.data['car']['batterySoc']['percent'] or self.coordinator.data['batterySoc']['percent']
+
+            # Don't let it go backwards unless to 0
+            self._state = 0 if new_state == 0 else max(new_state, self._state or 0)
+
+            self._last_updated = utcnow()
+            self.async_write_ha_state()
+
+    @property
+    def native_value(self):
+        return self._state