tidy up satellite sensors, another ble fix, spino improvements and error sensors

Author: mikey0000

custom_components/mammotion/coordinator.py

@@ -110,6 +110,11 @@
 # the ``map_sync_status`` diagnostic ENUM sensor that surfaces it.
 MAP_SYNC_STATUSES = ("synced", "syncing", "out_of_sync")
 
+# Cloud response code returned by the stream-subscription endpoint when the
+# device is unreachable ("Device not responding. Please check the network
+# connection").  Treated as a device-offline signal.
+DEVICE_NOT_RESPONDING_CODE = 50504
+
 
 class MammotionBaseUpdateCoordinator[DataT](DataUpdateCoordinator[DataT]):  # type: ignore[misc]
     """Mammotion DataUpdateCoordinator."""
@@ -206,6 +211,21 @@ async def async_check_stream_expiry(
             self.set_stream_data(stream_data)
             self._stream_data_fetched_at = time.monotonic()
 
+            # A 50504 means the cloud couldn't reach the device — bail out
+            # cleanly rather than continuing on to the Agora setup with no data.
+            if (
+                stream_data is not None
+                and stream_data.code == DEVICE_NOT_RESPONDING_CODE
+            ):
+                LOGGER.warning(
+                    "Stream subscription for %s reports device not responding "
+                    "(code %s: %s)",
+                    self.device_name,
+                    stream_data.code,
+                    stream_data.msg,
+                )
+                return None, self._agora_response
+
             if stream_data is not None and stream_data.data is not None:
                 LOGGER.debug("Received stream data: %s", stream_data)
 
@@ -2433,6 +2453,47 @@ async def async_restore_data(self) -> None:
             if handle is not None:
                 handle.restore_device(empty)
 
+    def get_error_code(self) -> int:
+        """Return the absolute error code of the most recent fault, or 0."""
+        try:
+            return int(abs(self.data.pool_state.error_log[0].code))
+        except IndexError:
+            return 0
+
+    def get_error_time(self) -> datetime.datetime | None:
+        """Return the timestamp of the most recent fault as a UTC datetime, or None."""
+        try:
+            return datetime.datetime.fromtimestamp(
+                self.data.pool_state.error_log[0].timestamp, datetime.UTC
+            )
+        except IndexError:
+            return None
+
+    def get_error_message(self) -> str:
+        """Return a human-readable description of the most recent fault."""
+        try:
+            error_code = abs(self.data.pool_state.error_log[0].code)
+            error_info: ErrorInfo = self.data.errors.error_codes[f"{error_code}"]
+            implication = (
+                getattr(error_info, f"{self.hass.config.language}_implication")
+                if hasattr(error_info, f"{self.hass.config.language}_implication")
+                else error_info.en_implication
+            )
+            solution = (
+                getattr(error_info, f"{self.hass.config.language}_solution")
+                if hasattr(error_info, f"{self.hass.config.language}_solution")
+                else error_info.en_solution
+            )
+            if implication == "":
+                implication = error_info.en_implication
+            if solution == "":
+                solution = error_info.en_solution
+            return f"{error_info.module}: {implication}, {solution}"
+        except IndexError:
+            return "No Error"
+        except KeyError:
+            return "Error message not found"
+
     async def _async_update_data(self) -> PoolCleanerDevice:
         """Return current pool cleaner state from the device handle.
 
@@ -2454,6 +2515,8 @@ async def _async_update_data(self) -> PoolCleanerDevice:
                         for check_version in check_versions:
                             if check_version.device_id == self.device.iot_id:
                                 self.data.apply_version_check(check_version)
+                    if not self.data.errors.error_codes:
+                        self.data.errors.error_codes = await http.get_all_error_codes()
                 except ReLoginRequiredError as err:
                     raise ConfigEntryAuthFailed(
                         f"Re-authentication required for Mammotion account: {err}"

custom_components/mammotion/manifest.json

@@ -16,19 +16,11 @@
       "connectable": true
     }
   ],
-  "codeowners": [
-    "@mikey0000"
-  ],
+  "codeowners": ["@mikey0000"],
   "config_flow": true,
-  "dependencies": [
-    "bluetooth_adapters"
-  ],
+  "dependencies": ["bluetooth_adapters"],
   "documentation": "https://github.com/mikey0000/Mammotion-HA/wiki",
-  "loggers": [
-    "pymammotion"
-  ],
+  "loggers": ["pymammotion"],
   "iot_class": "local_push",
-  "requirements": [
-    "pymammotion==0.8.6"
-  ]
+  "requirements": ["pymammotion==0.8.7"]
 }

custom_components/mammotion/select.py

@@ -65,23 +65,41 @@ class MammotionSpinoSelectEntityDescription(SelectEntityDescription):
 SPINO_SELECT_ENTITIES: tuple[MammotionSpinoSelectEntityDescription, ...] = (
     MammotionSpinoSelectEntityDescription(
         key="spino_work_mode",
-        options=[mode.name for mode in SpinoWorkMode],
+        # Only real cleaning modes are selectable.  RECHARGE (0, return-to-charge)
+        # and UNKNOWN (-1, sentinel) are valid *reported* values — surfaced by the
+        # spino_work_mode sensor — but they're not modes a user can start, so they
+        # are excluded from the select's options.
+        options=[
+            mode.name
+            for mode in SpinoWorkMode
+            if mode not in (SpinoWorkMode.UNKNOWN, SpinoWorkMode.RECHARGE)
+        ],
         current_fn=lambda spino_data: spino_data.pool_state.work_mode.name,
         set_fn=lambda coordinator, value: coordinator.async_set_work_mode(
             SpinoWorkMode[value].value
         ),
     ),
     MammotionSpinoSelectEntityDescription(
         key="spino_wall_material",
-        options=[material.name for material in WallMaterial],
+        # UNKNOWN (-1) is a sentinel for an unreported value, not a user choice.
+        options=[
+            material.name
+            for material in WallMaterial
+            if material is not WallMaterial.UNKNOWN
+        ],
         current_fn=lambda spino_data: spino_data.pool_state.wall_material.name,
         set_fn=lambda coordinator, value: coordinator.async_set_wall_material(
             WallMaterial[value].value
         ),
     ),
     MammotionSpinoSelectEntityDescription(
         key="spino_bottom_type",
-        options=[bottom.name for bottom in PoolBottomType],
+        # UNKNOWN (-1) is a sentinel for an unreported value, not a user choice.
+        options=[
+            bottom.name
+            for bottom in PoolBottomType
+            if bottom is not PoolBottomType.UNKNOWN
+        ],
         current_fn=lambda spino_data: spino_data.pool_state.bottom_type.name,
         set_fn=lambda coordinator, value: coordinator.async_set_bottom_type(
             PoolBottomType[value].value

custom_components/mammotion/sensor.py

@@ -142,6 +142,13 @@ class MammotionErrorSensorEntityDescription(SensorEntityDescription):
     value_fn: Callable[[MammotionDeviceErrorUpdateCoordinator, MowingDevice], StateType]
 
 
+@dataclass(frozen=True, kw_only=True)
+class MammotionSpinoErrorSensorEntityDescription(SensorEntityDescription):
+    """Describes a Spino error-log sensor entity."""
+
+    value_fn: Callable[[MammotionSpinoCoordinator], StateType]
+
+
 LUBA_SENSOR_ONLY_TYPES: tuple[MammotionSensorEntityDescription, ...] = (
     MammotionSensorEntityDescription(
         key="blade_height",
@@ -326,21 +333,19 @@ class MammotionErrorSensorEntityDescription(SensorEntityDescription):
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     MammotionSensorEntityDescription(
-        key="l1_satellites",
+        key="pos_level",
         state_class=SensorStateClass.MEASUREMENT,
         device_class=None,
         native_unit_of_measurement=None,
-        value_fn=lambda mower_data: (mower_data.report_data.rtk.co_view_stars >> 0)
-        & 255,
+        value_fn=lambda mower_data: mower_data.report_data.rtk.pos_level,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     MammotionSensorEntityDescription(
-        key="l2_satellites",
+        key="age",
         state_class=SensorStateClass.MEASUREMENT,
-        device_class=None,
-        native_unit_of_measurement=None,
-        value_fn=lambda mower_data: (mower_data.report_data.rtk.co_view_stars >> 8)
-        & 255,
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.SECONDS,
+        value_fn=lambda mower_data: mower_data.report_data.rtk.age,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     # MammotionSensorEntityDescription(
@@ -441,6 +446,73 @@ class MammotionErrorSensorEntityDescription(SensorEntityDescription):
     ),
 )
 
+# Luba 2 / Yuka (non-RTK) only — APK refreshNonRtkDeviceUI shows these;
+# Luba 1 and standard RTK devices do not display them.
+LUBA_2_YUKA_SIGNAL_TYPES: tuple[MammotionSensorEntityDescription, ...] = (
+    MammotionSensorEntityDescription(
+        key="l1_satellites",
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=None,
+        native_unit_of_measurement=None,
+        value_fn=lambda mower_data: (mower_data.report_data.rtk.dis_status >> 16) & 255,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MammotionSensorEntityDescription(
+        key="l2_satellites",
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=None,
+        native_unit_of_measurement=None,
+        value_fn=lambda mower_data: (mower_data.report_data.rtk.dis_status >> 24) & 255,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MammotionSensorEntityDescription(
+        key="co_view_l1",
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=None,
+        native_unit_of_measurement=None,
+        value_fn=lambda mower_data: mower_data.report_data.rtk.co_view_stars & 255,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MammotionSensorEntityDescription(
+        key="co_view_l2",
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=None,
+        native_unit_of_measurement=None,
+        value_fn=lambda mower_data: (mower_data.report_data.rtk.co_view_stars >> 8)
+        & 255,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MammotionSensorEntityDescription(
+        key="rtk_signal",
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=None,
+        native_unit_of_measurement=None,
+        value_fn=lambda mower_data: (mower_data.report_data.rtk.dis_status >> 40) & 255,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MammotionSensorEntityDescription(
+        key="device_signal",
+        state_class=None,
+        device_class=SensorDeviceClass.ENUM,
+        native_unit_of_measurement=None,
+        value_fn=lambda mower_data: (mower_data.report_data.rtk.dis_status >> 32) & 255,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+)
+
+# Luba 1 only — APK refreshLuba1ModeUI shows base_link_status (connection_to_ref);
+# Luba 2 / Yuka and RTK devices hide it.
+LUBA_1_SIGNAL_TYPES: tuple[MammotionSensorEntityDescription, ...] = (
+    MammotionSensorEntityDescription(
+        key="base_link_status",
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=None,
+        native_unit_of_measurement=None,
+        value_fn=lambda mower_data: (mower_data.report_data.rtk.dis_status >> 48) & 255,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+)
+
 WORK_SENSOR_TYPES: tuple[MammotionWorkSensorEntityDescription, ...] = (
     MammotionWorkSensorEntityDescription(
         key="work_area",
@@ -548,6 +620,44 @@ class MammotionErrorSensorEntityDescription(SensorEntityDescription):
     ),
 )
 
+SPINO_ERROR_SENSOR_TYPES: tuple[MammotionSpinoErrorSensorEntityDescription, ...] = (
+    MammotionSpinoErrorSensorEntityDescription(
+        key="spino_error_time",
+        device_class=SensorDeviceClass.TIMESTAMP,
+        value_fn=lambda coordinator: coordinator.get_error_time(),
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MammotionSpinoErrorSensorEntityDescription(
+        key="spino_error_message",
+        state_class=None,
+        native_unit_of_measurement=None,
+        device_class=None,
+        value_fn=lambda coordinator: (
+            msg[:255] if (msg := coordinator.get_error_message()) is not None else None
+        ),
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MammotionSpinoErrorSensorEntityDescription(
+        key="spino_error_code",
+        state_class=None,
+        native_unit_of_measurement=None,
+        device_class=None,
+        value_fn=lambda coordinator: coordinator.get_error_code(),
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MammotionSpinoErrorSensorEntityDescription(
+        key="spino_mqtt_status",
+        state_class=None,
+        native_unit_of_measurement=None,
+        device_class=SensorDeviceClass.ENUM,
+        options=["online", "offline"],
+        value_fn=lambda coordinator: "online"
+        if coordinator.mqtt_device_online
+        else "offline",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+)
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -570,12 +680,25 @@ async def async_setup_entry(
                 MammotionSensorEntity(mower.reporting_coordinator, description)
                 for description in LUBA_2_YUKA_ONLY_TYPES
             )
-            if not DeviceType.is_yuka_mini(mower.device.device_name):
+            entities.extend(
+                MammotionSensorEntity(mower.reporting_coordinator, description)
+                for description in LUBA_2_YUKA_SIGNAL_TYPES
+            )
+            device_type = DeviceType.value_of_str(
+                mower.device.device_name, mower.device.product_key
+            )
+            if device_type.supports_battery_cycle_count():
                 entities.extend(
                     MammotionSensorEntity(mower.reporting_coordinator, description)
                     for description in MINI_SERIES_EXCLUDED_TYPES
                 )
 
+        if DeviceType.is_luba1(mower.device.device_name, mower.device.product_key):
+            entities.extend(
+                MammotionSensorEntity(mower.reporting_coordinator, description)
+                for description in LUBA_1_SIGNAL_TYPES
+            )
+
         entities.extend(
             MammotionSensorEntity(mower.reporting_coordinator, description)
             for description in SENSOR_TYPES
@@ -619,6 +742,10 @@ async def async_setup_entry(
             MammotionSpinoSensorEntity(spino.coordinator, description)
             for description in SPINO_SENSOR_TYPES
         )
+        entities.extend(
+            MammotionSpinoErrorSensorEntity(spino.coordinator, description)
+            for description in SPINO_ERROR_SENSOR_TYPES
+        )
 
     async_add_entities(entities)
 
@@ -687,6 +814,28 @@ def native_value(self) -> StateType:
         return self.entity_description.value_fn(self.coordinator.data)
 
 
+class MammotionSpinoErrorSensorEntity(MammotionBaseSpinoEntity, SensorEntity):
+    """Sensor entity for a single Spino error-log field (code, time, or message)."""
+
+    entity_description: MammotionSpinoErrorSensorEntityDescription
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: MammotionSpinoCoordinator,
+        entity_description: MammotionSpinoErrorSensorEntityDescription,
+    ) -> None:
+        """Set up MammotionSpinoErrorSensorEntity."""
+        super().__init__(coordinator, entity_description.key)
+        self.entity_description = entity_description
+        self._attr_translation_key = entity_description.key
+
+    @property
+    def native_value(self) -> StateType:
+        """Return the state of the sensor."""
+        return self.entity_description.value_fn(self.coordinator)
+
+
 class MammotionErrorSensorEntity(MammotionBaseEntity, SensorEntity):
     """Defining the Mammotion Error Sensor."""