- 12V battery report as None (and not -1) if not available in the data

- added additional elvehtargetcharge ALT1 + ALT2
- added location name to elvehtargetcharge select entity (name)
- elvehtargetcharge now a select

Author: marq24

custom_components/fordpass/__init__.py

@@ -3,7 +3,7 @@
 import logging
 # import threading
 from datetime import timedelta
-from typing import Final
+from typing import Final, Any
 
 import aiohttp
 import async_timeout
@@ -15,7 +15,7 @@
 from homeassistant.helpers.aiohttp_client import async_create_clientsession
 from homeassistant.helpers.entity import EntityDescription
 from homeassistant.helpers.event import async_track_time_interval
-from homeassistant.helpers.typing import UNDEFINED
+from homeassistant.helpers.typing import UNDEFINED, UndefinedType
 from homeassistant.helpers.update_coordinator import CoordinatorEntity, DataUpdateCoordinator, UpdateFailed
 from homeassistant.util.unit_system import UnitSystem
 
@@ -545,6 +545,7 @@ class FordPassEntity(CoordinatorEntity):
     """Defines a base FordPass entity."""
     _attr_should_poll = False
     _attr_has_entity_name = True
+    _attr_name_addon = None
 
     def __init__(self, a_tag: Tag, coordinator: FordPassDataUpdateCoordinator, description: EntityDescription | None = None):
         """Initialize the entity."""
@@ -558,10 +559,19 @@ def __init__(self, a_tag: Tag, coordinator: FordPassDataUpdateCoordinator, descr
             if hasattr(description, "translation_key") and description.translation_key is not None:
                 self._attr_translation_key = description.translation_key.lower()
 
+        if hasattr(description, "name_addon"):
+            self._attr_name_addon = description.name_addon
+
         self.coordinator: FordPassDataUpdateCoordinator = coordinator
         self.entity_id = f"{DOMAIN}.fordpass_{self.coordinator._vin.lower()}_{a_tag.key}"
         self._tag = a_tag
 
+    def _name_internal(self, device_class_name: str | None, platform_translations: dict[str, Any], ) -> str | UndefinedType | None:
+        tmp = super()._name_internal(device_class_name, platform_translations)
+        if self._attr_name_addon is not None:
+            return f"{self._attr_name_addon} {tmp}"
+        else:
+            return tmp
 
     @property
     def device_id(self):

custom_components/fordpass/const.py

@@ -176,6 +176,8 @@
 RCC_SEAT_OPTIONS_FULL: Final = ["off", "heated1", "heated2", "heated3", "cooled1", "cooled2", "cooled3"]
 RCC_SEAT_OPTIONS_HEAT_ONLY: Final = ["off", "heated1", "heated2", "heated3"]
 
+ELVEH_TARGET_CHARGE_OPTIONS: Final = ["50", "60", "70", "80", "85", "90", "95", "100"]
+
 VEHICLE_LOCK_STATE_LOCKED:      Final = "LOCKED"
 VEHICLE_LOCK_STATE_PARTLY:      Final = "PARTLY_LOCKED"
 VEHICLE_LOCK_STATE_UNLOCKED:    Final = "UNLOCKED"

custom_components/fordpass/const_tags.py

@@ -12,8 +12,8 @@
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from homeassistant.util.unit_system import UnitSystem
 
-from custom_components.fordpass.const import ZONE_LIGHTS_OPTIONS, RCC_SEAT_OPTIONS_FULL
-from custom_components.fordpass.fordpass_handler import FordpassDataHandler
+from custom_components.fordpass.const import ZONE_LIGHTS_OPTIONS, RCC_SEAT_OPTIONS_FULL, ELVEH_TARGET_CHARGE_OPTIONS
+from custom_components.fordpass.fordpass_handler import FordpassDataHandler, UNSUPPORTED
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -53,12 +53,16 @@ async def turn_on_off(self, data, vehicle, turn_on:bool) -> bool:
 
     async def async_select_option(self, data, vehicle, new_value: Any) -> bool:
         if self.select_fn:
-            return await self.select_fn(data, vehicle, new_value, self.get_state(data))
+            current_value = self.get_state(data)
+            if current_value is not UNSUPPORTED:
+                return await self.select_fn(data, vehicle, new_value, current_value)
         return None
 
     async def async_set_value(self, data, vehicle, new_value: str) -> bool:
         if self.select_fn:
-            return await self.select_fn(data, vehicle, new_value, self.get_state(data))
+            current_value = self.get_state(data)
+            if current_value is not UNSUPPORTED:
+                return await self.select_fn(data, vehicle, new_value, current_value)
         return None
 
     async def async_push(self, coordinator, vehicle) -> bool:
@@ -143,15 +147,22 @@ async def async_push(self, coordinator, vehicle) -> bool:
                                  state_fn=lambda data: FordpassDataHandler.get_rcc_state(data, rcc_key="RccRightFrontClimateSeat_Rq"),
                                  select_fn=FordpassDataHandler.set_rcc_RccRightFrontClimateSeat_Rq)
 
+
+    ELVEH_TARGET_CHARGE = ApiKey(key="elVehTargetCharge",
+                                 state_fn=lambda data: FordpassDataHandler.get_elev_target_charge_state(data, 0),
+                                 select_fn=FordpassDataHandler.set_elev_target_charge)
+    ELVEH_TARGET_CHARGE_ALT1 = ApiKey(key="elVehTargetChargeAlt1",
+                                 state_fn=lambda data: FordpassDataHandler.get_elev_target_charge_state(data, 1),
+                                 select_fn=FordpassDataHandler.set_elev_target_charge_alt1)
+    ELVEH_TARGET_CHARGE_ALT2 = ApiKey(key="elVehTargetChargeAlt2",
+                                 state_fn=lambda data: FordpassDataHandler.get_elev_target_charge_state(data, 2),
+                                 select_fn=FordpassDataHandler.set_elev_target_charge_alt2)
+
     # NUMBERS
     RCC_TEMPERATURE     = ApiKey(key="rccTemperature",
                                  state_fn=lambda data: FordpassDataHandler.get_rcc_state(data, rcc_key="SetPointTemp_Rq"),
                                  select_fn=FordpassDataHandler.set_rcc_SetPointTemp_Rq)
 
-    ELVEH_TARGET_CHARGE = ApiKey(key="elVehTargetCharge",
-                                 state_fn=lambda data: FordpassDataHandler.get_elev_target_charge_state(data),
-                                 select_fn=FordpassDataHandler.set_elev_target_charge)
-
     # SENSORS
     ##################################################
     ODOMETER            = ApiKey(key="odometer",
@@ -161,7 +172,7 @@ async def async_push(self, coordinator, vehicle) -> bool:
                                  state_fn=FordpassDataHandler.get_fuel_state,
                                  attrs_fn=FordpassDataHandler.get_fuel_attrs)
     BATTERY             = ApiKey(key="battery",
-                                 state_fn=lambda data: round(FordpassDataHandler.get_value_for_metrics_key(data, "batteryStateOfCharge", -1)),
+                                 state_fn=FordpassDataHandler.get_battery_state,
                                  attrs_fn=FordpassDataHandler.get_battery_attrs)
     OIL                 = ApiKey(key="oil",
                                  state_fn=lambda data: FordpassDataHandler.get_value_for_metrics_key(data, "oilLifeRemaining", None),
@@ -293,19 +304,23 @@ async def async_push(self, coordinator, vehicle) -> bool:
 @dataclass(frozen=True)
 class ExtButtonEntityDescription(ButtonEntityDescription):
     tag: Tag | None = None
+    name_addon: str | None = None
 
 @dataclass(frozen=True)
 class ExtSensorEntityDescription(SensorEntityDescription):
     tag: Tag | None = None
     skip_existence_check: bool | None = None
+    name_addon: str | None = None
 
 @dataclass(frozen=True)
 class ExtSelectEntityDescription(SelectEntityDescription):
     tag: Tag | None = None
+    name_addon: str | None = None
 
 @dataclass(frozen=True)
 class ExtNumberEntityDescription(NumberEntityDescription):
     tag: Tag | None = None
+    name_addon: str | None = None
 
 
 SENSORS = [
@@ -705,6 +720,30 @@ class ExtNumberEntityDescription(NumberEntityDescription):
         options=RCC_SEAT_OPTIONS_FULL,
         has_entity_name=True,
     ),
+    ExtSelectEntityDescription(
+        tag=Tag.ELVEH_TARGET_CHARGE,
+        key=Tag.ELVEH_TARGET_CHARGE.key,
+        icon="mdi:battery-charging-high",
+        options=ELVEH_TARGET_CHARGE_OPTIONS,
+        has_entity_name=True,
+    ),
+    ExtSelectEntityDescription(
+        tag=Tag.ELVEH_TARGET_CHARGE_ALT1,
+        key=Tag.ELVEH_TARGET_CHARGE_ALT1.key,
+        icon="mdi:battery-charging-high",
+        options=ELVEH_TARGET_CHARGE_OPTIONS,
+        has_entity_name=True,
+        entity_registry_enabled_default=False,
+    ),
+    ExtSelectEntityDescription(
+        tag=Tag.ELVEH_TARGET_CHARGE_ALT2,
+        key=Tag.ELVEH_TARGET_CHARGE_ALT2.key,
+        icon="mdi:battery-charging-high",
+        options=ELVEH_TARGET_CHARGE_OPTIONS,
+        has_entity_name=True,
+        entity_registry_enabled_default=False,
+    ),
+
 ]
 NUMBERS = [
     ExtNumberEntityDescription(
@@ -717,16 +756,5 @@ class ExtNumberEntityDescription(NumberEntityDescription):
         native_step=0.5,
         mode=NumberMode.BOX,
         has_entity_name=True,
-    ),
-    ExtNumberEntityDescription(
-        tag=Tag.ELVEH_TARGET_CHARGE,
-        key=Tag.ELVEH_TARGET_CHARGE.key,
-        icon="mdi:battery-charging-high",
-        native_unit_of_measurement=PERCENTAGE,
-        native_min_value=20,
-        native_max_value=100,
-        native_step=5,
-        mode=NumberMode.SLIDER,
-        has_entity_name=True,
     )
 ]

custom_components/fordpass/fordpass_bridge.py

@@ -24,7 +24,7 @@
     ROOT_MESSAGES,
     ROOT_VEHICLES,
     ROOT_REMOTE_CLIMATE_CONTROL,
-    ROOT_ENERGY_TRANSFER_STATUS,
+    ROOT_PREFERRED_CHARGE_TIMES,
     ROOT_UPDTIME
 )
 
@@ -130,7 +130,7 @@ class ConnectedFordPassVehicle:
     _LAST_MESSAGES_UPDATE: float = 0.0
     _last_ignition_state: str | None = None
     _ws_debounced_full_refresh_task: asyncio.Task | None = None
-
+    _ws_debounced_preferred_charge_times_refresh_task: asyncio.Task | None = None
     # when you have multiple vehicles, you need to set the vehicle log id
     # (v)ehicle (l)og (i)d
     vli: str = ""
@@ -190,13 +190,14 @@ def __init__(self, web_session, username, vin, region_key, coordinator: DataUpda
         self._cached_vehicles_data = {}
         self._remote_climate_control_supported = None
         self._cached_rcc_data = {}
-        self._energy_transfer_status_supported = None
-        self._cached_ets_data = {}
+        self._preferred_charge_times_supported = None
+        self._cached_pct_data = {}
         self.coordinator = coordinator
 
         # websocket connection related variables
         self._ws_debounced_update_task = None
         self._ws_debounced_full_refresh_task = None
+        self._ws_debounced_preferred_charge_times_refresh_task = None
         self._ws_in_use_access_token = None
         self.ws_connected = False
         self._ws_LAST_UPDATE = 0
@@ -866,7 +867,10 @@ def _ws_update_key(self, data_obj, a_root_key, collected_keys):
                                     # we have a special handling for the 'updateChargeProfilesCommand'
                                     # -> when we receive a 'success' state, we will update our
                                     # energy_transfer_object...
-                                    asyncio.create_task(self.update_energy_transfer_status_int())
+                                    if self._ws_debounced_preferred_charge_times_refresh_task is not None and not self._ws_debounced_preferred_charge_times_refresh_task.done():
+                                        self._ws_debounced_preferred_charge_times_refresh_task.cancel()
+                                    _LOGGER.debug(f"{self.vli}ws(): updateChargeProfilesCommand -> triggering 'preferred_charge_times' data update (will be started in 30sec)")
+                                    self._ws_debounced_preferred_charge_times_refresh_task = asyncio.create_task(self._ws_debounce_update_preferred_charge_times())
 
                         else:
                             _LOGGER.debug(f"{self.vli}ws(): new state (without toState) '{a_state_name}' arrived: {a_value_obj}")
@@ -1081,7 +1085,7 @@ async def update_all(self):
                                 self._remote_climate_control_supported = a_vehicle_profile["remoteClimateControl"]
 
                             if "showEVBatteryLevel" in a_vehicle_profile:
-                                self._energy_transfer_status_supported = a_vehicle_profile["showEVBatteryLevel"]
+                                self._preferred_charge_times_supported = a_vehicle_profile["showEVBatteryLevel"]
 
                             break
 
@@ -1095,13 +1099,13 @@ async def update_all(self):
                     data[ROOT_REMOTE_CLIMATE_CONTROL] = self._cached_rcc_data
 
             # only update energy-status if not present yet
-            if self._energy_transfer_status_supported:
-                if self._cached_ets_data is None or len(self._cached_ets_data) == 0:
-                    _LOGGER.debug(f"{self.vli}update_all(): request 'energy transfer status' data...")
-                    self._cached_ets_data = await self.req_energy_transfer_status()
+            if self._preferred_charge_times_supported:
+                if self._cached_pct_data is None or len(self._cached_pct_data) == 0:
+                    _LOGGER.debug(f"{self.vli}update_all(): request 'preferred_charge_times' data...")
+                    self._cached_pct_data = await self.req_preferred_charge_times()
 
-                if self._cached_ets_data is not None and len(self._cached_ets_data) > 0:
-                    data[ROOT_ENERGY_TRANSFER_STATUS] = self._cached_ets_data
+                if self._cached_pct_data is not None and len(self._cached_pct_data) > 0:
+                    data[ROOT_PREFERRED_CHARGE_TIMES] = self._cached_pct_data
 
 
             # ok finally store the data in our main data container...
@@ -1120,14 +1124,32 @@ async def update_remote_climate_int(self):
                 self._data_container[ROOT_REMOTE_CLIMATE_CONTROL] = self._cached_rcc_data
 
 
-    async def update_energy_transfer_status_int(self):
+    async def update_preferred_charge_times_int(self):
         # only update remote climate data if not present yet
-        if self._energy_transfer_status_supported:
-            _LOGGER.debug(f"{self.vli}update_energy_transfer_status_int(): request 'energy transfer status' data...")
-            self._cached_ets_data = await self.req_energy_transfer_status()
+        if self._preferred_charge_times_supported:
+            _LOGGER.debug(f"{self.vli}update_preferred_charge_times_int(): request 'energy transfer status' data...")
+            self._cached_pct_data = await self.req_preferred_charge_times()
+
+            if self._cached_pct_data is not None and len(self._cached_pct_data) > 0:
+                self._data_container[ROOT_PREFERRED_CHARGE_TIMES] = self._cached_pct_data
+                return True
+
+        return False
+
+    async def _ws_debounce_update_preferred_charge_times(self):
+        if self._preferred_charge_times_supported:
+            try:
+                _LOGGER.debug(f"{self.vli}_ws_debounce_update_preferred_charge_times(): started")
+                await asyncio.sleep(30)
+                _LOGGER.debug(f"{self.vli}_ws_debounce_update_preferred_charge_times(): starting the 'update_preferred_charge_times_int()' update now")
+                success = await self.update_preferred_charge_times_int()
+                if success and self.coordinator is not None:
+                    self.coordinator.async_set_updated_data(self._data_container)
 
-            if self._cached_ets_data is not None and len(self._cached_ets_data) > 0:
-                self._data_container[ROOT_ENERGY_TRANSFER_STATUS] = self._cached_ets_data
+            except CancelledError:
+                _LOGGER.debug(f"{self.vli}_ws_debounce_update_preferred_charge_times(): was canceled - all good")
+            except BaseException as ex:
+                _LOGGER.warning(f"{self.vli}_ws_debounce_update_preferred_charge_times(): Error during 'preferred_charge_times' data refresh - {type(ex)} - {ex}")
 
 
     async def req_status(self):
@@ -1384,7 +1406,79 @@ async def req_remote_climate(self):
             self._HAS_COM_ERROR = True
             return None
 
+    async def req_preferred_charge_times(self):
+        global _FOUR_NULL_ONE_COUNTER
+        try:
+            await self.__ensure_valid_tokens()
+            if self._HAS_COM_ERROR:
+                _LOGGER.debug(f"{self.vli}req_preferred_charge_times(): - COMM ERROR")
+                return None
+            else:
+                _LOGGER.debug(f"{self.vli}req_preferred_charge_times(): - access_token exist? {self.access_token is not None}")
+
+            # and the 'preferred-charge-times' request will get a 'vin' in the header
+            headers_veh = {
+                **apiHeaders,
+                "auth-token": self.access_token,
+                "Application-Id": self.app_id,
+                "vin": self.vin
+            }
+            response_pct = await self.session.get(
+                f"{FORD_VEHICLE_API}/electrification/experiences/v2/vehicles/preferred-charge-times",
+                headers=headers_veh,
+                timeout=self.timeout
+            )
+            if response_pct.status == 200:
+                # ok first resetting the counter for 401 errors (if we had any)
+                _FOUR_NULL_ONE_COUNTER[self.vin] = 0
+
+                result_pct = await response_pct.json()
+                if self._LOCAL_LOGGING:
+                    await self._local_logging("pct", result_pct)
+
+                # we are going to transform our result! - we create a dict with the 'location.id' as a key
+                if isinstance(result_pct, list):
+                    modified_result = {}
+                    for a_entry in result_pct:
+                        if "vin" in a_entry:
+                            if a_entry["vin"].upper() == self.vin.upper():
+                                modified_result[a_entry["location"]["id"]] = a_entry
+                    result_pct = modified_result
+                else:
+                    _LOGGER.warning(f"{self.vli}req_preferred_charge_times(): received unexpected data format: {type(result_pct)} - expected a list of entries")
+
+                #_LOGGER.error(f"--------------------------")
+                #_LOGGER.error(f"--------------------------")
+                #_LOGGER.error(f"{self.vli}req_preferred_charge_times(): received data: {result_pct}")
+                #_LOGGER.error(f"--------------------------")
+                #_LOGGER.error(f"--------------------------")
+                return result_pct
+
+            elif response_pct.status == 401:
+                _FOUR_NULL_ONE_COUNTER[self.vin] += 1
+                if _FOUR_NULL_ONE_COUNTER[self.vin] > MAX_401_RESPONSE_COUNT:
+                    _LOGGER.error(f"{self.vli}req_preferred_charge_times(): status_code: 401 - mark_re_auth_required()")
+                    self.mark_re_auth_required()
+                else:
+                    (_LOGGER.warning if _FOUR_NULL_ONE_COUNTER[self.vin] > 2 else _LOGGER.info)(f"{self.vli}req_preferred_charge_times(): status_code: 401 - counter: {_FOUR_NULL_ONE_COUNTER}")
+                    await asyncio.sleep(5)
+
+                return None
+            else:
+                _LOGGER.info(f"{self.vli}req_preferred_charge_times(): status_code: {response_pct.status} - {response_pct.real_url} - Received response: {await response_pct.text()}")
+                self._HAS_COM_ERROR = True
+                return None
+
+        except BaseException as e:
+            if not await self.__check_for_closed_session(e):
+                _LOGGER.warning(f"{self.vli}req_preferred_charge_times(): Error while '_request_token' for vehicle {self.vin} - {type(e)} - {e}")
+            else:
+                _LOGGER.info(f"{self.vli}req_preferred_charge_times(): RuntimeError - Session was closed occurred - but a new Session could be generated")
+            self._HAS_COM_ERROR = True
+            return None
+
     async def req_energy_transfer_status(self):
+        # this function will only return a valid object if the vehicle is located at a KNOWN charging location
         global _FOUR_NULL_ONE_COUNTER
         try:
             await self.__ensure_valid_tokens()
@@ -1440,7 +1534,6 @@ async def req_energy_transfer_status(self):
             self._HAS_COM_ERROR = True
             return None
 
-
     # ***********************************************************
     # ***********************************************************
     # ***********************************************************