feat: Temperature/humidity sensors for H5109 and friends (#62)

Adds sensor entities backed by the devices.capabilities.property
sensorTemperature and sensorHumidity instances. Routing is capability-
based, so H5109 (the issue reporter's device), H5179, and any other
SKU in the same family pick up the entities without per-SKU logic.

Both common API state shapes are parsed: a plain number under
state.value, or the legacy {currentTemperature/currentHumidity} STRUCT
under state.value.

Leak-sensor support for H5054 is deferred — see the research doc;
follow-up needs diagnostics from the reporter to identify the actual
event capability instance.

Author: Tom Lasswell

custom_components/govee/manifest.json

@@ -24,6 +24,6 @@
     "cryptography>=41.0.0"
   ],
   "ssdp": [],
-  "version": "2026.5.1",
+  "version": "2026.5.2",
   "zeroconf": []
 }

custom_components/govee/models/device.py

@@ -59,6 +59,15 @@
 INSTANCE_HUMIDITY = "humidity"
 INSTANCE_WATER_FULL_EVENT = "waterFullEvent"
 
+# Read-only sensor property instances (devices.capabilities.property).
+# These appear on stand-alone sensors like H5179 (WiFi Thermometer) and
+# H5109 (Smart Temperature Sensor) — issue #62.
+INSTANCE_SENSOR_TEMPERATURE = "sensorTemperature"
+INSTANCE_SENSOR_HUMIDITY = "sensorHumidity"
+
+# Device type for stand-alone temperature/humidity sensors.
+DEVICE_TYPE_THERMOMETER = "devices.types.thermometer"
+
 
 @dataclass(frozen=True)
 class ColorTempRange:
@@ -345,6 +354,30 @@ def supports_water_full_event(self) -> bool:
             for cap in self.capabilities
         )
 
+    @property
+    def supports_temperature_sensor(self) -> bool:
+        """Check if device exposes a sensorTemperature property (e.g. H5109,
+        H5179). The capability is read-only — surfaced as an HA sensor."""
+        return any(
+            cap.type == CAPABILITY_PROPERTY
+            and cap.instance == INSTANCE_SENSOR_TEMPERATURE
+            for cap in self.capabilities
+        )
+
+    @property
+    def supports_humidity_sensor(self) -> bool:
+        """Check if device exposes a sensorHumidity property."""
+        return any(
+            cap.type == CAPABILITY_PROPERTY
+            and cap.instance == INSTANCE_SENSOR_HUMIDITY
+            for cap in self.capabilities
+        )
+
+    @property
+    def is_thermometer(self) -> bool:
+        """Check if device is a stand-alone thermometer/hygrometer."""
+        return self.device_type == DEVICE_TYPE_THERMOMETER
+
     def get_humidity_range(self) -> tuple[int, int]:
         """Extract target humidity range from the range.humidity capability.
 

custom_components/govee/models/state.py

@@ -123,6 +123,11 @@ class GoveeDeviceState:
     # ``work_mode``. Only the event flag needs its own field.
     water_full: bool | None = None  # Dehumidifier water-tank-full event
 
+    # Read-only sensor properties (devices.capabilities.property) for
+    # stand-alone sensors like H5109/H5179. None until first poll lands.
+    sensor_temperature: float | None = None  # Celsius (always; entity converts)
+    sensor_humidity: float | None = None  # Relative humidity 0-100 %
+
     # Last activated scene (for restoring after music mode off)
     last_scene_id: str | None = None
     last_scene_name: str | None = None
@@ -201,6 +206,34 @@ def update_from_api(self, data: dict[str, Any]) -> None:
                 if instance == "hdmiSource":
                     self.hdmi_source = int(value) if value is not None else None
 
+            elif cap_type == "devices.capabilities.property":
+                # Read-only sensor properties on devices like H5109 and
+                # H5179 (issue #62). The state shape varies by SKU — some
+                # return a plain number under "value", others return a
+                # STRUCT. Accept both, plus the legacy "currentX" field
+                # naming used by older WiFi sensors.
+                if instance in ("sensorTemperature", "sensorHumidity"):
+                    parsed: float | None = None
+                    if isinstance(value, (int, float)):
+                        parsed = float(value)
+                    elif isinstance(value, dict):
+                        for key in (
+                            "currentTemperature",
+                            "currentHumidity",
+                            "value",
+                            "temperature",
+                            "humidity",
+                        ):
+                            sub = value.get(key)
+                            if isinstance(sub, (int, float)):
+                                parsed = float(sub)
+                                break
+                    if parsed is not None:
+                        if instance == "sensorTemperature":
+                            self.sensor_temperature = parsed
+                        else:
+                            self.sensor_humidity = parsed
+
             elif cap_type == "devices.capabilities.event":
                 # Event capabilities (e.g. waterFullEvent) report a boolean-
                 # ish value when the event is active. Some backends also

custom_components/govee/sensor.py

@@ -3,6 +3,7 @@
 Provides sensor entities for:
 - Rate limit remaining (diagnostic)
 - MQTT connection status (diagnostic)
+- Temperature / humidity properties on stand-alone sensors (H5109, H5179)
 """
 
 from __future__ import annotations
@@ -15,14 +16,20 @@
     SensorStateClass,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import EntityCategory
+from homeassistant.const import (
+    EntityCategory,
+    PERCENTAGE,
+    UnitOfTemperature,
+)
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity import DeviceInfo  # type: ignore[attr-defined]
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
 from .coordinator import GoveeCoordinator
+from .entity import GoveeEntity
+from .models import GoveeDevice
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -43,6 +50,18 @@ async def async_setup_entry(
     if coordinator.mqtt_client is not None:
         entities.append(GoveeMqttStatusSensor(coordinator, entry.entry_id))
 
+    # Per-device temperature / humidity sensors for stand-alone sensors
+    # like H5109 and H5179 (issue #62). Anything that exposes the
+    # corresponding `property` capability gets the entity, regardless of
+    # device_type — the integration shouldn't have to know about every SKU.
+    for device in coordinator.devices.values():
+        if device.is_group:
+            continue
+        if device.supports_temperature_sensor:
+            entities.append(GoveeTemperatureSensor(coordinator, device))
+        if device.supports_humidity_sensor:
+            entities.append(GoveeHumiditySensor(coordinator, device))
+
     async_add_entities(entities)
     _LOGGER.debug("Set up %d Govee sensor entities", len(entities))
 
@@ -134,3 +153,54 @@ def native_value(self) -> str:
         if mqtt_client is None:
             return "unavailable"
         return "connected" if mqtt_client.connected else "disconnected"
+
+
+class GoveeTemperatureSensor(GoveeEntity, SensorEntity):
+    """Read-only temperature reading from devices like H5109 and H5179.
+
+    Backed by the ``devices.capabilities.property`` / ``sensorTemperature``
+    capability. Values are pushed through the standard coordinator state
+    flow so MQTT updates and API polls both feed it.
+    """
+
+    _attr_has_entity_name = True
+    _attr_translation_key = "sensor_temperature"
+    _attr_device_class = SensorDeviceClass.TEMPERATURE
+    _attr_state_class = SensorStateClass.MEASUREMENT
+    _attr_native_unit_of_measurement = UnitOfTemperature.CELSIUS
+
+    def __init__(
+        self,
+        coordinator: GoveeCoordinator,
+        device: GoveeDevice,
+    ) -> None:
+        super().__init__(coordinator, device)
+        self._attr_unique_id = f"{device.device_id}_temperature"
+
+    @property
+    def native_value(self) -> float | None:
+        state = self.device_state
+        return state.sensor_temperature if state else None
+
+
+class GoveeHumiditySensor(GoveeEntity, SensorEntity):
+    """Read-only humidity reading from devices like H5109 and H5179."""
+
+    _attr_has_entity_name = True
+    _attr_translation_key = "sensor_humidity"
+    _attr_device_class = SensorDeviceClass.HUMIDITY
+    _attr_state_class = SensorStateClass.MEASUREMENT
+    _attr_native_unit_of_measurement = PERCENTAGE
+
+    def __init__(
+        self,
+        coordinator: GoveeCoordinator,
+        device: GoveeDevice,
+    ) -> None:
+        super().__init__(coordinator, device)
+        self._attr_unique_id = f"{device.device_id}_humidity"
+
+    @property
+    def native_value(self) -> float | None:
+        state = self.device_state
+        return state.sensor_humidity if state else None

custom_components/govee/strings.json

@@ -161,6 +161,12 @@
       },
       "mqtt_status": {
         "name": "MQTT Status"
+      },
+      "sensor_temperature": {
+        "name": "Temperature"
+      },
+      "sensor_humidity": {
+        "name": "Humidity"
       }
     },
     "binary_sensor": {

custom_components/govee/translations/en.json

@@ -161,6 +161,12 @@
       },
       "mqtt_status": {
         "name": "MQTT Status"
+      },
+      "sensor_temperature": {
+        "name": "Temperature"
+      },
+      "sensor_humidity": {
+        "name": "Humidity"
       }
     },
     "binary_sensor": {

docs/_research/2026-05-01_issue-62-temperature-humidity-sensors.md

@@ -0,0 +1,52 @@
+# Issue #62 — Temperature/humidity + leak sensor support
+
+**Date**: 2026-05-01
+**Type**: Feature implementation (partial) + open follow-up
+**Issue**: [#62](https://github.com/lasswellt/govee-homeassistant/issues/62)
+**Reporter**: steamer70 — wants H5054 (water detector) and H5109 (smart temperature sensor) support.
+
+---
+
+## Summary
+
+Two devices, two different capability shapes. Implemented the well-documented half (temperature/humidity via the standard `devices.capabilities.property` capability — covers H5109, H5179, and any future SKU that exposes the same instances). Deferred the leak-detector half (H5054) pending diagnostics from the reporter — without ground truth on what the cloud API returns, the right binary-sensor instance name is a guess, and PR #56 is already negotiating the related but distinct hub-LoRa H5058 path.
+
+## H5109 — implemented
+
+Per `docs/govee-protocol-reference.md` §8.5 the canonical thermometer SKU is H5179, which exposes:
+
+```json
+{"capabilities": [
+  {"type": "devices.capabilities.property", "instance": "sensorTemperature"},
+  {"type": "devices.capabilities.property", "instance": "sensorHumidity"}
+]}
+```
+
+H5109 is the "Smart Temperature Sensor" in the same family and is expected to expose the same capability shape. The integration now:
+
+- Adds `INSTANCE_SENSOR_TEMPERATURE` / `INSTANCE_SENSOR_HUMIDITY` constants (`models/device.py`).
+- Adds `DEVICE_TYPE_THERMOMETER` and `is_thermometer` for completeness, but routing is **capability-based, not SKU-based** — anything that exposes those property instances picks up the entities, regardless of `device_type`.
+- Adds `supports_temperature_sensor` / `supports_humidity_sensor` on `GoveeDevice`.
+- Adds `sensor_temperature` / `sensor_humidity` fields on `GoveeDeviceState` and parses them in `update_from_api`. The parser handles both shapes seen in the wild — `state.value` as a plain number, and the legacy `state.value.currentTemperature` / `state.value.currentHumidity` STRUCT.
+- Adds `GoveeTemperatureSensor` / `GoveeHumiditySensor` entities in `sensor.py`, each gated on the matching `supports_*` predicate so they don't appear on light devices that happen to share the platform.
+- Translation strings updated in `strings.json` and `translations/en.json`.
+- Tests in `tests/test_thermometer.py` exercise both the H5109 and H5179 device shapes plus both API state-payload variants.
+
+Because the gating is capability-based, this also covers any other Govee SKU that exposes the same instances — H5074, H5075, H5101, H5102, etc. — for free.
+
+## H5054 — deferred
+
+The H5054 is a stand-alone water sensor with a different lineage from H5058. PR #56 hardcodes `LEAK_SENSOR_SKUS = {"H5058", "H5054", "H5055"}` but routes everything through the H5043 hub's LoRa multiSync MQTT path — that's correct for H5058 but speculative for H5054, which (per Govee's product pages) does not advertise as a hub-paired sensor.
+
+Without a diagnostics dump from the reporter we don't know:
+- The actual `device_type` returned by `/device/list/v1`.
+- Whether the leak signal is exposed as `devices.capabilities.event` (and under which instance name — `leakEvent`? `waterDetectionEvent`? something else) or as a `property`.
+- Whether battery is exposed at all.
+
+Action: comment on the issue asking for diagnostics, then add a generic event-driven leak binary sensor once we have a real payload. The temperature/humidity work shipping today is decoupled and doesn't block this follow-up.
+
+## Tests
+
+- `tests/test_thermometer.py` (8 tests) — capability detection, state parsing both shapes, missing-value safety, light device must not pick up sensors.
+
+Full suite: 697 → 705 passing. Mypy clean. Flake8 clean.