v1.2.7

Re added display and power off time
Added timezone settings for CGDN1
Hopefully fixed issue for CGDN1

Author: mash2k3

custom_components/qingping_cgs1/const.py

@@ -66,4 +66,5 @@
 CONF_NIGHT_MODE_START_TIME = "night_mode_start_time"
 CONF_NIGHT_MODE_END_TIME = "night_mode_end_time"
 CONF_AUTO_SLIDING_TIME = "auto_slideing_time"
-CONF_SCREENSAVER_TYPE = "screensaver_type"
+CONF_SCREENSAVER_TYPE = "screensaver_type"
+CONF_TIMEZONE = "timezone"

custom_components/qingping_cgs1/number.py

@@ -15,7 +15,7 @@
     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_AUTO_SLIDING_TIME, CONF_SCREENSAVER_TYPE,
+    CONF_AUTO_SLIDING_TIME, CONF_SCREENSAVER_TYPE, CONF_TIMEZONE,
     DEFAULT_SENSOR_OFFSET
 )
 
@@ -59,10 +59,11 @@ async def async_setup_entry(
         ])
     elif model == "CGDN1":
         entities.extend([
-            #QingpingCGSxTimeNumber(coordinator, config_entry, mac, name, "Power Off Time", CONF_POWER_OFF_TIME, device_info, 0, 60, 1, 30, "minutes"),
-            #QingpingCGSxTimeNumber(coordinator, config_entry, mac, name, "Display Off Time", CONF_DISPLAY_OFF_TIME, device_info, 0, 300, 1, 30, "seconds"),
-            QingpingCGSxTimeNumber(coordinator, config_entry, mac, name, "Auto Sliding Time", CONF_AUTO_SLIDING_TIME, device_info, 0, 180, 5, 30, "seconds"),
+            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),
+            QingpingCGSxTimezoneNumber(coordinator, config_entry, mac, name, device_info),
         ])
 
     async_add_entities(entities)
@@ -245,7 +246,7 @@ def _handle_coordinator_update(self) -> None:
 class QingpingCGSxTimeNumber(CoordinatorEntity, NumberEntity):
     """Representation of a Qingping CGSx time setting number input."""
 
-    def __init__(self, coordinator, config_entry, mac, name, time_name, time_key, device_info, min_val, max_val, step, default_val, unit):
+    def __init__(self, coordinator, config_entry, mac, name, time_name, time_key, device_info, min_val, max_val, step, default_val, unit, mode=NumberMode.BOX):
         """Initialize the number entity."""
         super().__init__(coordinator)
         self._config_entry = config_entry
@@ -260,6 +261,7 @@ def __init__(self, coordinator, config_entry, mac, name, time_name, time_key, de
         self._attr_native_step = step
         self._attr_entity_category = EntityCategory.CONFIG
         self._attr_native_unit_of_measurement = unit
+        self._attr_mode = mode
 
     @property
     def native_value(self) -> int:
@@ -342,4 +344,55 @@ 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()
+
+class QingpingCGSxTimezoneNumber(CoordinatorEntity, NumberEntity):
+    """Representation of a Qingping CGSx timezone setting number input."""
+
+    def __init__(self, coordinator, config_entry, mac, name, device_info):
+        """Initialize the number entity."""
+        super().__init__(coordinator)
+        self._config_entry = config_entry
+        self._mac = mac
+        self._attr_name = f"{name} Time Zone"
+        self._attr_unique_id = f"{mac}_timezone"
+        self._attr_device_info = device_info
+        self._attr_native_min_value = -12
+        self._attr_native_max_value = 14
+        self._attr_native_step = 0.5
+        self._attr_entity_category = EntityCategory.CONFIG
+        self._attr_mode = NumberMode.BOX
+
+    @property
+    def native_value(self) -> float:
+        """Return the current value."""
+        return self.coordinator.data.get(CONF_TIMEZONE, 0)
+
+    async def async_set_native_value(self, value: float) -> None:
+        """Update the current value."""
+        self.coordinator.data[CONF_TIMEZONE] = value
+        self.async_write_ha_state()
+        
+        # Update config entry
+        new_data = dict(self._config_entry.data)
+        new_data[CONF_TIMEZONE] = 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 (value * 10 for device)
+        from .sensor import publish_setting_change
+        device_value = int(value * 10)
+        await publish_setting_change(self.hass, self._mac, CONF_TIMEZONE, device_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_TIMEZONE not in self.coordinator.data:
+            self.coordinator.data[CONF_TIMEZONE] = self._config_entry.data.get(CONF_TIMEZONE, 0)
         self.async_write_ha_state()

custom_components/qingping_cgs1/sensor.py

@@ -219,10 +219,7 @@ async def async_update_data():
     def message_received(message):
         """Handle new MQTT messages."""
         try:
-            _LOGGER.warning("=== MQTT MESSAGE RECEIVED === Topic: %s", message.topic)
-            
             payload = json.loads(message.payload)
-            _LOGGER.warning("Payload type: %s", type(payload))
 
             if not isinstance(payload, dict):
                 _LOGGER.error("Payload is not a dictionary")
@@ -235,15 +232,13 @@ def message_received(message):
             received_mac = payload.get("mac", "").replace(":", "").upper()
             expected_mac = mac.replace(":", "").upper()
 
-            _LOGGER.warning("Received MAC: %s, Expected MAC: %s, Type: %s", received_mac, expected_mac, message_type)
-            
-            # Skip MAC check for type 28 (settings) messages as they don't include MAC
+            # Skip MAC check for messages without MAC (type 28, 13, 10, 17, etc.)
             # We're subscribed to this device's specific topic, so we know it's for us
             if received_mac and received_mac != expected_mac:
                 _LOGGER.debug("Received message for a different device. Expected: %s, Got: %s", expected_mac, received_mac)
                 return
 
-            _LOGGER.warning("Processing MQTT message for device %s", mac)
+            _LOGGER.debug("Processing MQTT message type %s for device %s", message_type, mac)
 
             # Update timestamp first - any message from device means it's online
             # Always use current system time, not device's timestamp which may be unreliable
@@ -267,18 +262,13 @@ def message_received(message):
                     mac_sensor.update_mac(mac_address)
 
             # Handle type 28 messages (device settings update) - Check BEFORE sensorData
-            _LOGGER.warning("=== MESSAGE TYPE: %s ===", message_type)
-            
             if message_type == 28 or message_type == "28":
-                _LOGGER.error("!!! TYPE 28 SETTINGS UPDATE DETECTED !!!")
-                _LOGGER.error("Full payload: %s", json.dumps(payload, indent=2))
+                _LOGGER.info("Type 28 settings update received for device %s", mac)
                 settings = payload.get("setting", {})
-                _LOGGER.error("Settings extracted: %s", settings)
                 if settings:
-                    _LOGGER.error("!!! CREATING TASK TO UPDATE SETTINGS !!!")
                     hass.async_create_task(_update_settings_from_device(hass, config_entry, settings, model))
                 else:
-                    _LOGGER.error("!!! TYPE 28 HAS NO SETTINGS DICT !!!")
+                    _LOGGER.warning("Type 28 message has no settings dict")
                 return  # Don't process as sensor data
 
             sensor_data = payload.get("sensorData")
@@ -336,34 +326,7 @@ def message_received(message):
     await mqtt.async_subscribe(
         hass, f"{MQTT_TOPIC_PREFIX}/{mac}/up", message_received, 1
     )
-    _LOGGER.warning("=== SUBSCRIBED TO: %s/%s/up ===", MQTT_TOPIC_PREFIX, mac)
-
-    # CGDN1-specific: Subscribe to any message for this device to detect when it comes online
-    # CGDN1 doesn't always send full sensor data on power-on like CGS1/CGS2
-    if model == "CGDN1":
-        @callback
-        def device_alive_check(message):
-            """Detect any MQTT activity from CGDN1 device."""
-            try:
-                # Skip the main /up topic as it's already handled
-                if message.topic.endswith("/up"):
-                    return
-                    
-                _LOGGER.debug("CGDN1 device activity detected on topic: %s", message.topic)
-                # Any MQTT activity from this device means it's alive
-                if status_sensor.hass:
-                    current_time = int(time.time())
-                    if status_sensor._last_timestamp == 0 or (current_time - status_sensor._last_timestamp) > 60:
-                        _LOGGER.info("CGDN1 device %s appears to be online, updating status", mac)
-                        status_sensor.update_timestamp(current_time)
-                        # Trigger a config publish to get fresh data
-                        asyncio.create_task(sensors[5].publish_config())
-            except Exception as e:
-                _LOGGER.error("Error in CGDN1 device alive check: %s", str(e))
-        
-        await mqtt.async_subscribe(
-            hass, f"{MQTT_TOPIC_PREFIX}/{mac}/#", device_alive_check, 1
-        )
+    _LOGGER.info("Subscribed to MQTT topic: %s/%s/up", MQTT_TOPIC_PREFIX, mac)
 
     # Set up timer for periodic publishing
     async def publish_config_wrapper(*args):
@@ -720,4 +683,4 @@ async def async_will_remove_from_hass(self) -> None:
             remove_timer = self.hass.data[DOMAIN][self._config_entry.entry_id].get("remove_timer")
             if remove_timer:
                 remove_timer()
-        await super().async_will_remove_from_hass()
+        await super().async_will_remove_from_hass()