v1.2.7

Author: mash2k3

custom_components/qingping_cgs1/number.py

@@ -14,7 +14,7 @@
     CONF_UPDATE_INTERVAL, DEFAULT_UPDATE_INTERVAL,
     CONF_CO2_OFFSET, CONF_PM25_OFFSET, CONF_PM10_OFFSET, 
     CONF_NOISE_OFFSET, CONF_TVOC_OFFSET, CONF_TVOC_INDEX_OFFSET,
-    CONF_POWER_OFF_TIME, CONF_DISPLAY_OFF_TIME, CONF_NIGHT_MODE_START_TIME, CONF_NIGHT_MODE_END_TIME,
+    CONF_POWER_OFF_TIME,
     CONF_AUTO_SLIDING_TIME, CONF_SCREENSAVER_TYPE, CONF_TIMEZONE,
     DEFAULT_SENSOR_OFFSET
 )
@@ -30,6 +30,10 @@ async def async_setup_entry(
     model = config_entry.data[CONF_MODEL]
     coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
     native_temp_unit = hass.config.units.temperature_unit
+    if native_temp_unit == UnitOfTemperature.FAHRENHEIT:
+            step = 0.1
+    else:
+            step = 1
 
     device_info = {
         "identifiers": {(DOMAIN, mac)},
@@ -39,8 +43,8 @@ async def async_setup_entry(
     }
 
     entities = [
-        QingpingCGSxOffsetNumber(coordinator, config_entry, mac, name, "Temp Offset", CONF_TEMPERATURE_OFFSET, device_info, native_temp_unit),
-        QingpingCGSxOffsetNumber(coordinator, config_entry, mac, name, "Humidity Offset", CONF_HUMIDITY_OFFSET, device_info, "%"),
+        QingpingCGSxOffsetNumber(coordinator, config_entry, mac, name, "Temp Offset", CONF_TEMPERATURE_OFFSET, device_info, native_temp_unit, step),
+        QingpingCGSxOffsetNumber(coordinator, config_entry, mac, name, "Humidity Offset", CONF_HUMIDITY_OFFSET, device_info, "%", step),
         QingpingCGSxUpdateIntervalNumber(coordinator, config_entry, mac, name, device_info),
         QingpingCGSxSensorOffsetNumber(coordinator, config_entry, mac, name, "CO2 Offset", CONF_CO2_OFFSET, device_info, "ppm"),
         QingpingCGSxSensorOffsetNumber(coordinator, config_entry, mac, name, "PM2.5 Offset", CONF_PM25_OFFSET, device_info, "µg/m³"),
@@ -62,7 +66,7 @@ async def async_setup_entry(
             QingpingCGSxTimeNumber(coordinator, config_entry, mac, name, "Power Off Time", CONF_POWER_OFF_TIME, device_info, 0, 60, 1, 30, "minutes", NumberMode.SLIDER),
             #QingpingCGSxTimeNumber(coordinator, config_entry, mac, name, "Display Off Time", CONF_DISPLAY_OFF_TIME, device_info, 0, 300, 1, 30, "seconds", NumberMode.SLIDER),
             QingpingCGSxTimeNumber(coordinator, config_entry, mac, name, "Auto Sliding Time", CONF_AUTO_SLIDING_TIME, device_info, 0, 180, 5, 30, "seconds", NumberMode.SLIDER),
-            QingpingCGSxScreensaverTypeNumber(coordinator, config_entry, mac, name, device_info),
+            #QingpingCGSxScreensaverTypeNumber(coordinator, config_entry, mac, name, device_info),
             QingpingCGSxTimezoneNumber(coordinator, config_entry, mac, name, device_info),
         ])
 
@@ -71,7 +75,7 @@ async def async_setup_entry(
 class QingpingCGSxOffsetNumber(CoordinatorEntity, NumberEntity):
     """Representation of a Qingping CGSx offset number input."""
 
-    def __init__(self, coordinator, config_entry, mac, name, offset_name, offset_key, device_info, unit_of_measurement):
+    def __init__(self, coordinator, config_entry, mac, name, offset_name, offset_key, device_info, unit_of_measurement, step):
         """Initialize the number entity."""
         super().__init__(coordinator)
         self._config_entry = config_entry
@@ -82,7 +86,7 @@ def __init__(self, coordinator, config_entry, mac, name, offset_name, offset_key
         self._attr_device_info = device_info
         self._attr_native_min_value = -10
         self._attr_native_max_value = 10
-        self._attr_native_step = 1
+        self._attr_native_step = step
         self._attr_native_unit_of_measurement = unit_of_measurement
         self._attr_entity_category = EntityCategory.CONFIG
         self._attr_mode = NumberMode.BOX  # Use number box instead of slider

custom_components/qingping_cgs1/select.py

@@ -4,16 +4,27 @@
 from homeassistant.components.select import SelectEntity
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_NAME, CONF_MAC, CONF_MODEL
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from homeassistant.helpers.entity import EntityCategory
 
-from .const import DOMAIN, CONF_TVOC_UNIT, CONF_ETVOC_UNIT
+from .const import DOMAIN, CONF_TVOC_UNIT, CONF_ETVOC_UNIT, CONF_SCREENSAVER_TYPE
 
 TVOC_UNIT_OPTIONS = ["ppb", "ppm", "mg/m³"]
 ETVOC_UNIT_OPTIONS = ["index", "ppb", "mg/m³"]
 
+# Mapping between display names and values for screensaver types
+SCREENSAVER_OPTIONS = {
+    "All sensors": 0,
+    "Current sensor": 1,
+    "Clock and all sensors": 2,
+    "Clock and current sensor": 3,
+}
+
+# Reverse mapping for looking up names from values
+SCREENSAVER_VALUES = {v: k for k, v in SCREENSAVER_OPTIONS.items()}
+
 async def async_setup_entry(
     hass: HomeAssistant,
     config_entry: ConfigEntry,
@@ -32,15 +43,23 @@ async def async_setup_entry(
         "model": model,
     }
 
+    entities = []
+
     if model == "CGS1":
-        async_add_entities([
-            QingpingCGSxTVOCUnitSelect(coordinator, config_entry, mac, name, device_info, CONF_TVOC_UNIT, TVOC_UNIT_OPTIONS),
-        ])
+        entities.append(
+            QingpingCGSxTVOCUnitSelect(coordinator, config_entry, mac, name, device_info, CONF_TVOC_UNIT, TVOC_UNIT_OPTIONS)
+        )
     elif model == "CGS2":
-        async_add_entities([
-            QingpingCGSxTVOCUnitSelect(coordinator, config_entry, mac, name, device_info, CONF_ETVOC_UNIT, ETVOC_UNIT_OPTIONS),
-        ])
-    # CGDN1 does not have TVOC sensor, so no select entity needed
+        entities.append(
+            QingpingCGSxTVOCUnitSelect(coordinator, config_entry, mac, name, device_info, CONF_ETVOC_UNIT, ETVOC_UNIT_OPTIONS)
+        )
+    elif model == "CGDN1":
+        entities.append(
+            QingpingCGSxScreensaverTypeSelect(coordinator, config_entry, mac, name, device_info)
+        )
+
+    if entities:
+        async_add_entities(entities)
 
 class QingpingCGSxTVOCUnitSelect(CoordinatorEntity, SelectEntity):
     """Representation of a Qingping CGSx TVOC unit select entity."""
@@ -84,4 +103,56 @@ def _handle_coordinator_update(self) -> None:
         """Handle updated data from the coordinator."""
         if CONF_TVOC_UNIT not in self.coordinator.data:
             self.coordinator.data[self._conf_unit] = self._config_entry.data.get(self._conf_unit, self._unit_options[0])
+        self.async_write_ha_state()
+
+class QingpingCGSxScreensaverTypeSelect(CoordinatorEntity, SelectEntity):
+    """Representation of a Qingping CGSx screensaver type select input."""
+
+    def __init__(self, coordinator, config_entry, mac, name, device_info):
+        """Initialize the select entity."""
+        super().__init__(coordinator)
+        self._config_entry = config_entry
+        self._mac = mac
+        self._attr_name = f"{name} Screensaver Type"
+        self._attr_unique_id = f"{mac}_screensaver_type"
+        self._attr_device_info = device_info
+        self._attr_entity_category = EntityCategory.CONFIG
+        self._attr_options = list(SCREENSAVER_OPTIONS.keys())
+
+    @property
+    def current_option(self) -> str:
+        """Return the current option."""
+        value = self.coordinator.data.get(CONF_SCREENSAVER_TYPE, 1)
+        return SCREENSAVER_VALUES.get(value, "Current sensor")
+
+    async def async_select_option(self, option: str) -> None:
+        """Update the current option."""
+        value = SCREENSAVER_OPTIONS.get(option)
+        if value is None:
+            return
+        
+        self.coordinator.data[CONF_SCREENSAVER_TYPE] = value
+        self.async_write_ha_state()
+        
+        # Update config entry
+        new_data = dict(self._config_entry.data)
+        new_data[CONF_SCREENSAVER_TYPE] = value
+        self.hass.config_entries.async_update_entry(self._config_entry, data=new_data)
+        
+        await self.coordinator.async_request_refresh()
+        
+        # Publish setting change to device
+        from .sensor import publish_setting_change
+        await publish_setting_change(self.hass, self._mac, CONF_SCREENSAVER_TYPE, int(value))
+
+    async def async_added_to_hass(self) -> None:
+        """Run when entity about to be added to hass."""
+        await super().async_added_to_hass()
+        self._handle_coordinator_update()
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        if CONF_SCREENSAVER_TYPE not in self.coordinator.data:
+            self.coordinator.data[CONF_SCREENSAVER_TYPE] = self._config_entry.data.get(CONF_SCREENSAVER_TYPE, 1)
         self.async_write_ha_state()

custom_components/qingping_cgs1/sensor.py

@@ -97,12 +97,17 @@ async def _update_settings_from_device(hass: HomeAssistant, config_entry: Config
     )
 
     coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
+    native_temp_unit = hass.config.units.temperature_unit
+    if native_temp_unit == UnitOfTemperature.FAHRENHEIT:
+            unit_based_calc = (CONF_TEMPERATURE_OFFSET, lambda x: round((x / 100) * 9/5, 1))
+    else:
+            unit_based_calc = (CONF_TEMPERATURE_OFFSET, lambda x: round(x / 100, 1))
     updated = False
 
     # Map device settings to HA entity keys and conversion functions
     setting_mappings = {
         # Temperature offset: device sends value * 100, we need to divide by 100
-        "temperature_offset": (CONF_TEMPERATURE_OFFSET, lambda x: round(x / 100, 1)),
+        "temperature_offset": unit_based_calc,
         # Humidity offset: device sends value * 10, we need to divide by 10
         "humidity_offset": (CONF_HUMIDITY_OFFSET, lambda x: round(x / 10, 1)),
         # Other offsets: direct integer values