Fallback sources for car SoC, plug state and location; unknown plug = not present (v3.0.3)

Fast MQTT car sensors (e.g. TeslaMate) stay unavailable after a Home
Assistant restart until the car reports again. The car then had no SoC (no
departure obligation could be planned) and an unknown plug state counted as
'maybe present'. Each of these inputs can now have a second source, the plug
state also understands text charge-status sensors ('disconnected',
'complete', ...), and an unknown plug state with a plug sensor configured
means not present, so no (possibly billed) command goes to an absent car.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: xchillxx

custom_components/surplus_pilot/config_flow.py

@@ -31,10 +31,13 @@
     CONF_CAR_PAUSE_ENTITY,
     CONF_CAR_PAUSE_STATE,
     CONF_CAR_PHASES,
+    CONF_CAR_PLUGGED_FALLBACK,
     CONF_CAR_PLUGGED_SENSOR,
     CONF_CAR_POWER_SENSOR,
+    CONF_CAR_SOC_FALLBACK,
     CONF_CAR_SOC_SENSOR,
     CONF_CAR_TRACKER,
+    CONF_CAR_TRACKER_FALLBACK,
     CONF_CAR_VOLTAGE,
     CONF_DEV_CLIMATE_MODE,
     CONF_DEV_DEPENDS_ON,
@@ -126,13 +129,16 @@ def car_schema(d: dict) -> vol.Schema:
         vol.Required(CONF_CAR_CHARGE_SWITCH, **_d(d, CONF_CAR_CHARGE_SWITCH)): _ent("switch"),
         vol.Optional(CONF_CAR_CURRENT_ENTITY, **_d(d, CONF_CAR_CURRENT_ENTITY)): _ent("number"),
         vol.Optional(CONF_CAR_SOC_SENSOR, **_d(d, CONF_CAR_SOC_SENSOR)): _ent("sensor"),
+        vol.Optional(CONF_CAR_SOC_FALLBACK, **_d(d, CONF_CAR_SOC_FALLBACK)): _ent("sensor"),
         vol.Optional(CONF_CAR_LIMIT_ENTITY, **_d(d, CONF_CAR_LIMIT_ENTITY)): _ent(["number", "sensor"]),
         vol.Required(CONF_CAR_LIMIT_DEFAULT, default=d.get(CONF_CAR_LIMIT_DEFAULT, DEFAULT_CAR_LIMIT)):
             _num(10, 100, 1, "%"),
         vol.Optional(CONF_CAR_PLUGGED_SENSOR, **_d(d, CONF_CAR_PLUGGED_SENSOR)): _ent(["binary_sensor", "sensor"]),
+        vol.Optional(CONF_CAR_PLUGGED_FALLBACK, **_d(d, CONF_CAR_PLUGGED_FALLBACK)): _ent(["binary_sensor", "sensor"]),
         vol.Optional(CONF_CAR_CHARGING_SENSOR, **_d(d, CONF_CAR_CHARGING_SENSOR)): _ent(["binary_sensor", "sensor"]),
         vol.Optional(CONF_CAR_POWER_SENSOR, **_d(d, CONF_CAR_POWER_SENSOR)): _ent("sensor"),
         vol.Optional(CONF_CAR_TRACKER, **_d(d, CONF_CAR_TRACKER)): _ent(["device_tracker", "person"]),
+        vol.Optional(CONF_CAR_TRACKER_FALLBACK, **_d(d, CONF_CAR_TRACKER_FALLBACK)): _ent(["device_tracker", "person"]),
         vol.Required(CONF_CAR_CAPACITY_KWH, default=d.get(CONF_CAR_CAPACITY_KWH, DEFAULT_CAR_CAPACITY_KWH)):
             _num(5, 250, 0.1, "kWh"),
         vol.Required(CONF_CAR_EFFICIENCY, default=d.get(CONF_CAR_EFFICIENCY, DEFAULT_CAR_EFFICIENCY)):

custom_components/surplus_pilot/const.py

@@ -38,12 +38,15 @@
 CONF_CAR_CHARGE_SWITCH = "charge_switch"
 CONF_CAR_CURRENT_ENTITY = "current_entity"
 CONF_CAR_SOC_SENSOR = "soc_sensor"
+CONF_CAR_SOC_FALLBACK = "soc_fallback_sensor"
 CONF_CAR_LIMIT_ENTITY = "limit_entity"
 CONF_CAR_LIMIT_DEFAULT = "limit_default"
 CONF_CAR_PLUGGED_SENSOR = "plugged_sensor"
+CONF_CAR_PLUGGED_FALLBACK = "plugged_fallback_sensor"
 CONF_CAR_CHARGING_SENSOR = "charging_sensor"
 CONF_CAR_POWER_SENSOR = "power_sensor"
 CONF_CAR_TRACKER = "tracker"
+CONF_CAR_TRACKER_FALLBACK = "tracker_fallback"
 CONF_CAR_CAPACITY_KWH = "capacity_kwh"
 CONF_CAR_EFFICIENCY = "efficiency"
 CONF_CAR_MIN_A = "min_amps"

custom_components/surplus_pilot/coordinator.py

@@ -34,10 +34,13 @@
     CONF_CAR_LIMIT_ENTITY,
     CONF_CAR_PAUSE_ENTITY,
     CONF_CAR_PAUSE_STATE,
+    CONF_CAR_PLUGGED_FALLBACK,
     CONF_CAR_PLUGGED_SENSOR,
     CONF_CAR_POWER_SENSOR,
+    CONF_CAR_SOC_FALLBACK,
     CONF_CAR_SOC_SENSOR,
     CONF_CAR_TRACKER,
+    CONF_CAR_TRACKER_FALLBACK,
     CONF_DEV_CLIMATE_MODE,
     CONF_DEV_DEPENDS_ON,
     CONF_DEV_ENTITY,
@@ -89,6 +92,7 @@
     async_tibber_prices,
     is_on,
     number,
+    plugged as plugged_state,
     power_kw,
     sensor_prices,
     tracker_home,
@@ -369,10 +373,22 @@ async def _async_update_data(self) -> dict:
             charging = bool(ch) if ch is not None else (car_kw > 0.3 or self.car.switch_on())
             if c.get(CONF_CAR_POWER_SENSOR) is None and charging and c.get(CONF_CAR_CURRENT_ENTITY):
                 car_kw = (number(self.hass, c[CONF_CAR_CURRENT_ENTITY]) or 0) * self.car.kw_per_a
-            plugged = is_on(self.hass, c.get(CONF_CAR_PLUGGED_SENSOR))
+            plugged = plugged_state(self.hass, c.get(CONF_CAR_PLUGGED_SENSOR))
+            if plugged is None:
+                plugged = plugged_state(self.hass, c.get(CONF_CAR_PLUGGED_FALLBACK))
             home = tracker_home(self.hass, c.get(CONF_CAR_TRACKER))
-            present = (plugged is not False) and (home is not False)
+            if home is None:
+                home = tracker_home(self.hass, c.get(CONF_CAR_TRACKER_FALLBACK))
+            has_plug_sensor = bool(c.get(CONF_CAR_PLUGGED_SENSOR) or c.get(CONF_CAR_PLUGGED_FALLBACK))
+            # unknown plug state with a plug sensor configured = not present:
+            # never send (possibly billed) commands to a car that may be away
+            plug_ok = plugged is True or (plugged is None and (not has_plug_sensor or charging))
+            present = plug_ok and (home is not False)
+            # a second source covers the primary one being empty (e.g. a fast
+            # MQTT sensor that only refills when the car reports again)
             car_soc = number(self.hass, c.get(CONF_CAR_SOC_SENSOR))
+            if car_soc is None:
+                car_soc = number(self.hass, c.get(CONF_CAR_SOC_FALLBACK))
             limit = number(self.hass, c.get(CONF_CAR_LIMIT_ENTITY)) or float(
                 c.get(CONF_CAR_LIMIT_DEFAULT, DEFAULT_CAR_LIMIT))
             car_in = P.CarInput(present=present, soc=car_soc, limit_soc=limit,

custom_components/surplus_pilot/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/xchillxx/surplus-pilot/issues",
   "requirements": [],
-  "version": "3.0.2"
+  "version": "3.0.3"
 }

custom_components/surplus_pilot/sources.py

@@ -56,6 +56,22 @@ def is_on(hass: HomeAssistant, entity_id: str | None) -> bool | None:
     return st.state in ("on", "home", "true", "charging", "connected")
 
 
+_UNPLUGGED = {"off", "false", "disconnected", "unplugged", "not_connected", "no car connected", "none",
+              "no_power", "nopower"}
+
+
+def plugged(hass: HomeAssistant, entity_id: str | None) -> bool | None:
+    """Plugged-in from a binary sensor (on/off) or a text sensor whose state
+    names the cable/charge status (e.g. 'disconnected', 'complete',
+    'charging'). None = unknown."""
+    if not entity_id:
+        return None
+    st = hass.states.get(entity_id)
+    if st is None or st.state in BAD:
+        return None
+    return st.state.strip().lower() not in _UNPLUGGED
+
+
 def age_minutes(hass: HomeAssistant, entity_id: str | None) -> float | None:
     """Minutes since the sensor last reported (last_updated, not
     last_changed: a constant value that is still being reported is fresh)."""

custom_components/surplus_pilot/strings.json

@@ -81,12 +81,15 @@
           "charge_switch": "Charging on/off switch",
           "current_entity": "Charging current (number)",
           "soc_sensor": "Car state of charge",
+          "soc_fallback_sensor": "Car state of charge — fallback (optional)",
           "limit_entity": "Car charge limit (optional)",
           "limit_default": "Charge limit (fallback)",
           "plugged_sensor": "Plugged in",
+          "plugged_fallback_sensor": "Plugged in — fallback (optional)",
           "charging_sensor": "Is charging",
           "power_sensor": "Charging power",
           "tracker": "Location (optional)",
+          "tracker_fallback": "Location — fallback (optional)",
           "capacity_kwh": "Car battery capacity",
           "efficiency": "Charging efficiency",
           "min_amps": "Minimum current",
@@ -102,6 +105,8 @@
           "charge_switch": "On the car or on the wallbox.",
           "current_entity": "Ampere entity on the car or wallbox.",
           "soc_sensor": "Without it the car charges on surplus only, no departure targets.",
+          "soc_fallback_sensor": "Used while the first one is unavailable (e.g. after a restart).",
+          "plugged_fallback_sensor": "Binary sensor or a charge-status text sensor (e.g. 'disconnected' / 'complete').",
           "tracker": "Car only counts as present when 'home'.",
           "allow_grid": "Charge from the grid (cheapest slots, late) when PV can't reach a departure target.",
           "max_commands_per_day": "For paid vehicle APIs.",

custom_components/surplus_pilot/translations/de.json

@@ -81,12 +81,15 @@
           "charge_switch": "Laden an/aus (Schalter)",
           "current_entity": "Ladestrom (Zahl)",
           "soc_sensor": "Auto-Ladestand",
+          "soc_fallback_sensor": "Auto-Ladestand — Ersatzquelle (optional)",
           "limit_entity": "Ladelimit des Autos (optional)",
           "limit_default": "Ladelimit (Ersatzwert)",
           "plugged_sensor": "Angesteckt",
+          "plugged_fallback_sensor": "Angesteckt — Ersatzquelle (optional)",
           "charging_sensor": "Lädt gerade",
           "power_sensor": "Ladeleistung",
           "tracker": "Standort (optional)",
+          "tracker_fallback": "Standort — Ersatzquelle (optional)",
           "capacity_kwh": "Akkukapazität Auto",
           "efficiency": "Ladewirkungsgrad",
           "min_amps": "Mindeststrom",
@@ -102,6 +105,8 @@
           "charge_switch": "Am Auto oder an der Wallbox.",
           "current_entity": "Ampere-Entität am Auto oder an der Wallbox.",
           "soc_sensor": "Ohne ihn lädt das Auto nur Überschuss, ohne Abfahrtsziele.",
+          "soc_fallback_sensor": "Wird genutzt, solange der erste nicht verfügbar ist (z. B. nach einem Neustart).",
+          "plugged_fallback_sensor": "Binärsensor oder Ladestatus-Text (z. B. 'disconnected' / 'complete').",
           "tracker": "Auto zählt nur als da, wenn 'home'.",
           "allow_grid": "Aus dem Netz laden (günstigste Zeit, spät), wenn PV ein Abfahrtsziel nicht schafft.",
           "max_commands_per_day": "Für kostenpflichtige Fahrzeug-APIs.",

custom_components/surplus_pilot/translations/en.json

@@ -81,12 +81,15 @@
           "charge_switch": "Charging on/off switch",
           "current_entity": "Charging current (number)",
           "soc_sensor": "Car state of charge",
+          "soc_fallback_sensor": "Car state of charge — fallback (optional)",
           "limit_entity": "Car charge limit (optional)",
           "limit_default": "Charge limit (fallback)",
           "plugged_sensor": "Plugged in",
+          "plugged_fallback_sensor": "Plugged in — fallback (optional)",
           "charging_sensor": "Is charging",
           "power_sensor": "Charging power",
           "tracker": "Location (optional)",
+          "tracker_fallback": "Location — fallback (optional)",
           "capacity_kwh": "Car battery capacity",
           "efficiency": "Charging efficiency",
           "min_amps": "Minimum current",
@@ -102,6 +105,8 @@
           "charge_switch": "On the car or on the wallbox.",
           "current_entity": "Ampere entity on the car or wallbox.",
           "soc_sensor": "Without it the car charges on surplus only, no departure targets.",
+          "soc_fallback_sensor": "Used while the first one is unavailable (e.g. after a restart).",
+          "plugged_fallback_sensor": "Binary sensor or a charge-status text sensor (e.g. 'disconnected' / 'complete').",
           "tracker": "Car only counts as present when 'home'.",
           "allow_grid": "Charge from the grid (cheapest slots, late) when PV can't reach a departure target.",
           "max_commands_per_day": "For paid vehicle APIs.",

tests/test_integration.py

@@ -117,3 +117,28 @@ async def test_config_flow(hass: HomeAssistant):
     assert r["type"] == "create_entry", r
     await hass.async_block_till_done()
     assert entry.data["devices"][0]["name"] == "Boiler"
+
+
+async def test_unknown_plug_state_means_not_present(hass: HomeAssistant, freezer):
+    set_world(hass, pv=9.0, load=0.6, soc=96, car_soc=50)
+    hass.states.async_set("binary_sensor.car_plugged", "unavailable")
+    hass.states.async_set("sensor.car_soc", "unavailable")
+    hass.states.async_set("sensor.car_soc_fleet", 55)
+    hass.states.async_set("sensor.car_cable", "complete")
+    for e in ("switch.car_charge", "switch.miner", "switch.pump", "climate.pool"):
+        hass.states.async_set(e, "off")
+    entry = MockConfigEntry(domain=DOMAIN, data=DATA)
+    entry.add_to_hass(hass)
+    assert await hass.config_entries.async_setup(entry.entry_id)
+    await hass.async_block_till_done()
+    co = hass.data[DOMAIN][entry.entry_id]
+    assert co.status["auto_da"] is False          # plug state unknown -> no commands
+    car = {**DATA["car"], "soc_fallback_sensor": "sensor.car_soc_fleet", "plugged_fallback_sensor": "sensor.car_cable"}
+    hass.config_entries.async_update_entry(entry, data={**DATA, "car": car})
+    await hass.async_block_till_done()
+    co = hass.data[DOMAIN][entry.entry_id]
+    await co.async_refresh()
+    assert co.status["auto_da"] is True and co.status["auto_soc"] == 55.0
+    hass.states.async_set("sensor.car_cable", "disconnected")
+    await co.async_refresh()
+    assert co.status["auto_da"] is False