v.1.2.8

### Major Features:
- ✅ Added support for TLV binary protocol devices
- ✅ Automatic report mode switching based on USB power state
- ✅ Device-specific configuration entities (offsets, intervals, modes)
- ✅ Dynamic offline timeouts (5min real-time, 15min historic)
- ✅ Improved device discovery for both JSON and TLV devices
- ✅ Temperature unit switching via MQTT
- ✅ CO₂ ASC and calibration controls

### Supported Device Expansion:
- Added CGP22W, CGP23W, CGP22C, CGR1AD

### Bug Fixes:
- [#46](#46) Type 13 reports to be ignored on JSON devices. Changed DEFAULT_DURATION to 6 hours from 24.
- [#45](#45) Devices classes will now be set dynamically based unit measurement.
- Fixed battery sensor for TLV devices
- Fixed pressure unit conversion (displays in kPa)
- Improved historical data handling (always uses most recent reading)

Author: mash2k3

custom_components/qingping_cgs1/button.py

@@ -1,21 +1,17 @@
 """Support for Qingping CGSx button entities."""
 from __future__ import annotations
 
-import json
-import logging
-
-from homeassistant.components import mqtt
 from homeassistant.components.button import ButtonEntity
+from homeassistant.components import mqtt
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_NAME, CONF_MAC, CONF_MODEL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from homeassistant.helpers.entity import EntityCategory
-from homeassistant.exceptions import HomeAssistantError
 
-from .const import DOMAIN, MQTT_TOPIC_PREFIX
-
-_LOGGER = logging.getLogger(__name__)
+from .const import DOMAIN, TLV_MODELS
+from .tlv_encoder import tlv_encode
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -26,6 +22,7 @@ async def async_setup_entry(
     mac = config_entry.data[CONF_MAC]
     name = config_entry.data[CONF_NAME]
     model = config_entry.data[CONF_MODEL]
+    coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
 
     device_info = {
         "identifiers": {(DOMAIN, mac)},
@@ -34,40 +31,40 @@ async def async_setup_entry(
         "model": model,
     }
 
-    buttons = []
+    entities = []
 
-    # CGDN1-specific buttons
-    if model == "CGDN1":
-        buttons.append(
-            QingpingCGSxManualCalibrationButton(config_entry, mac, name, device_info)
+    # Add CO2 calibration button for TLV devices with CO2 sensor
+    if model in TLV_MODELS and model in ["CGP22C", "CGR1AD"]:
+        entities.append(
+            QingpingTLVCO2CalibrationButton(coordinator, config_entry, mac, name, device_info)
         )
 
-    if buttons:
-        async_add_entities(buttons)
+    if entities:
+        async_add_entities(entities)
 
 
-class QingpingCGSxManualCalibrationButton(ButtonEntity):
-    """Button to trigger manual CO2 calibration."""
+class QingpingTLVCO2CalibrationButton(CoordinatorEntity, ButtonEntity):
+    """Representation of a Qingping TLV device CO2 calibration button."""
 
-    def __init__(self, config_entry, mac, name, device_info):
+    def __init__(self, coordinator, config_entry, mac, name, device_info):
         """Initialize the button."""
+        super().__init__(coordinator)
         self._config_entry = config_entry
         self._mac = mac
-        self._attr_name = f"{name} Manual Calibration"
-        self._attr_unique_id = f"{mac}_manual_calibration"
+        self._attr_name = f"{name} CO2 Calibration"
+        self._attr_unique_id = f"{mac}_co2_calibration"
         self._attr_device_info = device_info
         self._attr_entity_category = EntityCategory.CONFIG
-        self._attr_icon = "mdi:tune-vertical"
+        self._attr_icon = "mdi:tune-vertical-variant"
 
     async def async_press(self) -> None:
         """Handle the button press."""
-        try:
-            payload = {"type": "29"}
-            topic = f"{MQTT_TOPIC_PREFIX}/{self._mac}/down"
-            
-            _LOGGER.info("Triggering manual calibration for %s", self._mac)
-            await mqtt.async_publish(self.hass, topic, json.dumps(payload))
-            
-        except Exception as err:
-            _LOGGER.error("Failed to trigger manual calibration: %s", err)
-            raise HomeAssistantError(f"Failed to trigger calibration: {err}")
+        # Send TLV command to device (KEY 0x41)
+        # 1 = Perform calibration
+        packets = {
+            0x41: bytes([1])
+        }
+        payload = tlv_encode(0x32, packets)
+
+        topic = f"qingping/{self._mac}/down"
+        await mqtt.async_publish(self.hass, topic, payload)

custom_components/qingping_cgs1/config_flow.py

@@ -1,4 +1,4 @@
-"""Config flow for Qingping CGSx integration."""
+"""Config flow for Qingping CGxx integration."""
 from __future__ import annotations
 
 import voluptuous as vol
@@ -22,7 +22,7 @@ def clean_mac_address(mac: str) -> str:
     return mac.replace(":", "")
 
 class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Qingping CGSx."""
+    """Handle a config flow for Qingping CGxx."""
 
     VERSION = 1
 
@@ -77,7 +77,7 @@ async def async_step_user(
             return self.async_create_entry(title=validated_data[CONF_NAME], data=validated_data)
 
         except Exception as ex:
-            _LOGGER.error("Unexpected exception in Qingping CGSx config flow: %s", ex)
+            _LOGGER.error("Unexpected exception in Qingping CGxx config flow: %s", ex)
             errors["base"] = "unknown"
             return self.async_show_form(
                 step_id="user",
@@ -145,7 +145,7 @@ async def async_step_manual(
             )
 
     async def _async_discover_devices(self):
-        """Discover available Qingping CGSx devices via MQTT."""
+        """Discover available Qingping CGxx devices via MQTT."""
         try:
             # Get list of already configured devices
             configured_devices = {
@@ -155,25 +155,36 @@ async def _async_discover_devices(self):
             def _handle_message(msg):
                 """Handle received MQTT messages."""
                 try:
-                    # Extract MAC address from the topic
-                    mac = clean_mac_address(msg.topic.split('/')[-2])
-                    if mac and mac not in configured_devices and mac not in self._discovered_devices:
-                        self._discovered_devices[mac] = f"Qingping CGSx ({mac})"
+                    # Extract MAC address from the topic (works for both JSON and TLV)
+                    # Topic format: qingping/{MAC}/up
+                    topic_parts = msg.topic.split('/')
+                    if len(topic_parts) >= 2:
+                        mac = clean_mac_address(topic_parts[-2])
+                        if mac and mac not in configured_devices and mac not in self._discovered_devices:
+                            # Check if it's TLV format (binary starting with 'CG')
+                            if msg.payload[:2] == b'CG':
+                                device_name = f"Qingping TLV Device ({mac})"
+                            else:
+                                # JSON format
+                                device_name = f"Qingping JSON ({mac})"
+                            
+                            self._discovered_devices[mac] = device_name
+                            _LOGGER.info(f"Discovered device: {device_name}")
                 except Exception as ex:
                     _LOGGER.error("Error handling MQTT message: %s", ex)
 
             # Subscribe to the MQTT topic
             await mqtt.async_subscribe(
-                self.hass, f"{MQTT_TOPIC_PREFIX}/#", _handle_message
+                self.hass, f"{MQTT_TOPIC_PREFIX}/#", _handle_message, 1, encoding=None
             )
 
             # Wait for a short time to collect messages
-            await asyncio.sleep(10)  # Increased to 10 seconds for better discovery
+            await asyncio.sleep(10)  # Wait 10 seconds to collect messages
 
-            _LOGGER.info(f"Discovered {len(self._discovered_devices)} new Qingping CGSx devices")
+            _LOGGER.info(f"Discovered {len(self._discovered_devices)} new Qingping devices (JSON + TLV)")
 
         except HomeAssistantError as ex:
-            _LOGGER.error("Error discovering Qingping CGSx devices: %s", ex)
+            _LOGGER.error("Error discovering Qingping devices: %s", ex)
         except Exception as ex:
             _LOGGER.error("Unexpected error in device discovery: %s", ex)
 

custom_components/qingping_cgs1/const.py

@@ -1,4 +1,4 @@
-"""Constants for the Qingping CGSx integration."""
+"""Constants for the Qingping integration."""
 
 DOMAIN = "qingping_cgs1"
 CONF_MAC = "mac"
@@ -14,6 +14,7 @@
 SENSOR_TEMPERATURE = "temperature"
 SENSOR_TVOC = "tvoc"
 SENSOR_ETVOC = "tvoc_index"
+SENSOR_TLV_ETVOC = "tvoc"
 SENSOR_NOISE = "noise"
 
 # Unit of measurement
@@ -23,12 +24,22 @@
 PPB = "ppb"
 DB = "dB"
 CONF_TVOC_UNIT = "tvoc_unit"
+CONF_TEMPERATURE_UNIT = "temperature_unit"
 CONF_ETVOC_UNIT = "etvoc_unit"
+CONF_PRESSURE_OFFSET = "pressure_offset"
+CONF_LED_INDICATOR = "led_indicator"
 
 # Offsets
 CONF_TEMPERATURE_OFFSET = "temperature_offset"
 CONF_HUMIDITY_OFFSET = "humidity_offset"
 CONF_UPDATE_INTERVAL = "update_interval"
+# TLV device intervals
+CONF_REPORT_INTERVAL = "report_interval"  # Minutes (KEY 0x04)
+CONF_SAMPLE_INTERVAL = "sample_interval"  # Seconds (KEY 0x05)
+# TLV device report modes
+CONF_REPORT_MODE = "report_mode"
+REPORT_MODE_HISTORIC = "historic"
+REPORT_MODE_REALTIME = "realtime"
 
 # Default values for offsets and update interval
 DEFAULT_OFFSET = 0
@@ -43,13 +54,31 @@
 ATTR_DURATION = "duration"
 
 DEFAULT_TYPE = "12"
-DEFAULT_DURATION = "86400"
+DEFAULT_DURATION = "21600"
 
-QP_MODELS = ["CGS1", "CGS2", "CGDN1"]
+SENSOR_PRESSURE = "pressure"
+SENSOR_LIGHT = "light"
+SENSOR_SIGNAL_STRENGTH = "signal_strength"
+# Device models
+# JSON format devices (old protocol)
+JSON_MODELS = ["CGS1", "CGS2", "CGDN1"]
+# TLV binary format devices (new protocol)
+TLV_MODELS = ["CGP22C", "CGP23W", "CGP22W", "CGR1AD"]
+# All supported models
+QP_MODELS = JSON_MODELS + TLV_MODELS
 DEFAULT_MODEL = "CGS1"
 
+# Model to Product ID mapping (for TLV devices)
+MODEL_PRODUCT_IDS = {
+    "CGP22C": 93,  # CO₂ & Temp & RH Monitor
+    "CGP23W": 38,  # Temp & RH Barometer Pro S
+    "CGP22W": 92,  # Temp & RH Monitor Pro S
+    "CGR1AD": 96,  # Indoor Environment Monitor
+}
+
 # Device-specific settings
 CONF_CO2_ASC = "co2_asc"
+CONF_CO2_CALIBRATION = "co2_calibration"
 CONF_CO2_OFFSET = "co2_offset"
 CONF_PM25_OFFSET = "pm25_offset"
 CONF_PM10_OFFSET = "pm10_offset"

custom_components/qingping_cgs1/manifest.json

@@ -1,12 +1,12 @@
 {
   "domain": "qingping_cgs1",
-  "name": "Qingping Pro AQM",
+  "name": "Qingping",
   "codeowners": ["@mash2k3"],
   "config_flow": true,
   "dependencies": ["mqtt"],
   "documentation": "https://github.com/mash2k3/qingping_cgs1",
   "iot_class": "local_push",
   "issue_tracker": "https://github.com/mash2k3/qingping_cgs1/issues",
   "requirements": [],
-  "version": "1.2.7"
+  "version": "1.2.8"
 }