qolsys-controller 0.0.76__tar.gz → 0.0.81__tar.gz

{qolsys_controller-0.0.76 → qolsys_controller-0.0.81}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qolsys-controller
-Version: 0.0.76
+Version: 0.0.81
 Summary: A Python module that emulates a virtual IQ Remote device, enabling full local control of a Qolsys IQ Panel
 Project-URL: Homepage, https://github.com/EHylands/QolsysController
 Project-URL: Issues, https://github.com/EHylands/QolsysController/issues

{qolsys_controller-0.0.76 → qolsys_controller-0.0.81}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qolsys-controller"
-version = "0.0.76"
+version = "0.0.81"
 authors = [
   { name="Eric Hylands", email="" },
 ]

{qolsys_controller-0.0.76 → qolsys_controller-0.0.81}/qolsys_controller/controller.py

@@ -18,6 +18,7 @@ from qolsys_controller.mqtt_command import (
     MQTTCommand_Panel,
     MQTTCommand_ZWave,
 )
+from qolsys_controller.zwave_thermostat import QolsysThermostat
 
 from .enum import PartitionAlarmState, PartitionArmingType, PartitionSystemStatus
 from .enum_zwave import ThermostatFanMode, ThermostatMode, ZwaveCommandClass, ZwaveDeviceClass
@@ -894,20 +895,103 @@ class QolsysController:
         return response
 
     async def command_zwave_thermostat_setpoint_set(
-        self, node_id: str, mode: ThermostatMode, setpoint: float
+        self, node_id: str, mode: ThermostatMode, setpoint: int
     ) -> dict[str, Any] | None:
-        LOGGER.debug(
-            "MQTT: Sending zwave_thermostat_setpoint_set - Node(%s) - Mode(%s) - Setpoint(%s)", node_id, mode, setpoint
-        )
-
         zwave_node = self.state.zwave_device(node_id)
         if not zwave_node:
             LOGGER.error("thermostat_setpoint_set - Invalid node_id %s", node_id)
             return None
 
-        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommandClass.ThermostatSetPoint, 1, mode, int(setpoint)])
+        if not isinstance(zwave_node, QolsysThermostat):
+            LOGGER.error("thermostat_setpoint_set - Z-Wane node is not a thermostat %s", node_id)
+            return None
+
+        scale: int = 0
+        if zwave_node.thermostat_device_temp_unit == "F":
+            scale = 1
+
+        precision: int = 1
+        size: int = 2
+        pss = (precision << 5) | (scale << 3) | size
+        temp_int = int(round(setpoint * (10**precision)))
+        temp_bytes = temp_int.to_bytes(size, byteorder="big", signed=True)
+
+        zwave_bytes: list[int] = [
+            0x43,  # Thermostat Setpoint
+            0x03,  # SET
+            mode.value,  # Heating
+            pss,
+        ] + list(temp_bytes)
+
+        zwave_bytes2: list[int] = [
+            0x43,  # Thermostat Setpoint
+            0x01,  # SET
+            mode.value,  # Heating
+            pss,
+        ] + list(temp_bytes)
+
+        zwave_bytes3: list[int] = [
+            0x43,  # Thermostat Setpoint
+            0x01,  # SET
+            0x03,  # Furnace
+            pss,
+        ] + list(temp_bytes)
+
+        zwave_bytes4: list[int] = [
+            0x43,  # Thermostat Setpoint
+            0x03,  # SET
+            0x03,  # Furnace
+            pss,
+        ] + list(temp_bytes)
+
+        LOGGER.debug(
+            "MQTT: Sending zwave_thermostat_setpoint_set 0x03 - Node(%s) - Mode(%s) - Setpoint(%s): %s",
+            node_id,
+            mode,
+            setpoint,
+            zwave_bytes,
+        )
+        command = MQTTCommand_ZWave(self, node_id, zwave_bytes)
         response = await command.send_command()
-        LOGGER.debug("MQTT: Receiving zwave_thermostat_mode_set command")
+        LOGGER.debug("MQTT: Receiving zwave_thermostat_mode_set command:%s", response)
+
+        await asyncio.sleep(3)
+
+        LOGGER.debug(
+            "MQTT: Sending zwave_thermostat_setpoint_set 0x01 - Node(%s) - Mode(%s) - Setpoint(%s): %s",
+            node_id,
+            mode,
+            setpoint,
+            zwave_bytes2,
+        )
+        command2 = MQTTCommand_ZWave(self, node_id, zwave_bytes2)
+        response2 = await command2.send_command()
+        LOGGER.debug("MQTT: Receiving zwave_thermostat_mode_set command:%s", response2)
+
+        await asyncio.sleep(3)
+
+        LOGGER.debug(
+            "MQTT: Sending zwave_thermostat_setpoint_set 0x01 - Node(%s) - Mode(0x03) - Setpoint(%s): %s",
+            node_id,
+            setpoint,
+            zwave_bytes3,
+        )
+        command2 = MQTTCommand_ZWave(self, node_id, zwave_bytes2)
+        response2 = await command2.send_command()
+        LOGGER.debug("MQTT: Receiving zwave_thermostat_mode_set command:%s", response2)
+
+        await asyncio.sleep(3)
+
+        LOGGER.debug(
+            "MQTT: Sending zwave_thermostat_setpoint_set 0x03 - Node(%s) - Mode(0x3) - Setpoint(%s): %s",
+            node_id,
+            setpoint,
+            zwave_bytes4,
+        )
+        command2 = MQTTCommand_ZWave(self, node_id, zwave_bytes2)
+        response2 = await command2.send_command()
+        LOGGER.debug("MQTT: Receiving zwave_thermostat_mode_set command:%s", response2)
+
         return response
 
     async def command_zwave_thermostat_mode_set(self, node_id: str, mode: ThermostatMode) -> dict[str, Any] | None:

{qolsys_controller-0.0.76 → qolsys_controller-0.0.81}/qolsys_controller/database/table_thermostat.py

@@ -49,6 +49,7 @@ class QolsysTableThermostat(QolsysTable):
             "paired_status",
             "configuration_parameter",
             "operating_state",
+            "fan_state",
         ]
 
         self._create_table()

{qolsys_controller-0.0.76 → qolsys_controller-0.0.81}/qolsys_controller/database/table_zwave_node.py

@@ -80,6 +80,8 @@ class QolsysTableZwaveNode(QolsysTable):
             "long_range_nodeid",
             "hide_device_info",
             "meter_capabilities",
+            "multisensor_capabilities",
+            "central_scene_supported",
         ]
 
         self._create_table()

{qolsys_controller-0.0.76 → qolsys_controller-0.0.81}/qolsys_controller/enum.py

@@ -64,6 +64,7 @@ class ZoneStatus(StrEnum):
     FAILURE = "Failure"
     NOT_NETWORKED = "Not Networked"
     DISARM = "Disarm"
+    ARM_AWAY = "Arm-Away"
 
 
 class DeviceCapability(StrEnum):

{qolsys_controller-0.0.76 → qolsys_controller-0.0.81}/qolsys_controller/enum_zwave.py

@@ -18,6 +18,28 @@ class MeterRateType(IntEnum):
     RESERVED = 0x03
 
 
+class ZWaveMultilevelSensorScale(Enum):
+    TEMPERATURE_CELSIUS = "temperature_celsius"
+    TEMPERATURE_FAHRENHEIT = "temperature_fahrenheit"
+    RELATIVE_HUMIDITY = "relative_humidity"
+    WIND_DIRECTION = "wind_direction"
+    BAROMETRIC_PRESSURE = "barometric_pressure"
+    DEW_POINT = "dew_point"
+    RAIN_RATE = "rain_rate"
+    TIDE_LEVEL = "tide_level"
+    WEIGHT = "weight"
+    VOLTS = "volts"
+    AMPS = "amps"
+    WATTS = "watts"
+    DISTANCE = "distance"
+    ANGLE_POSITION = "angle_position"
+    ROTATION = "rotation"
+    WATER_TEMPERATURE_CELSIUS = "water_temperature_celsius"
+    WATER_TEMPERATURE_FAHRENHEIT = "water_temperature_fahrenheit"
+    LUMINOSITY_LUX = "luminosity_lux"
+    UNKNOWN = "unknown"
+
+
 class ZWaveUnknownMeterScale(IntEnum):
     UNKNOWN = 0
 

{qolsys_controller-0.0.76 → qolsys_controller-0.0.81}/qolsys_controller/mqtt_command.py

@@ -91,26 +91,32 @@ class MQTTCommand_ZWave(MQTTCommand_IpcCall):
 
         ipc_request: list[dict[str, Any]] = [
             {
+                # Node ID
                 "dataType": "int",
                 "dataValue": int(node_id),
             },
             {
+                # End Point
                 "dataType": "int",
                 "dataValue": 0,
             },
             {
+                # Z-Wave Payload
                 "dataType": "byteArray",
                 "dataValue": zwave_command,
             },
             {
+                # Transmit option ?
                 "dataType": "int",
                 "dataValue": 0,
             },
             {
+                # Priority
                 "dataType": "int",
                 "dataValue": 106,
             },
             {
+                # Callback ?
                 "dataType": "byteArray",
                 "dataValue": [0],
             },

{qolsys_controller-0.0.76 → qolsys_controller-0.0.81}/qolsys_controller/panel.py

@@ -6,7 +6,7 @@ import logging
 from typing import TYPE_CHECKING, Any
 
 from qolsys_controller.adc_device import QolsysAdcDevice
-from qolsys_controller.zwave_meter import QolsysMeterDevice
+from qolsys_controller.zwave_energy_clamp import QolsysEnergyClamp
 from qolsys_controller.zwave_thermometer import QolsysThermometer
 
 from .database.db import QolsysDB
@@ -427,12 +427,12 @@ class QolsysPanel(QolsysObservable):
     def parse_zwave_message(self, data: dict[str, Any]) -> None:
         zwave = data.get("ZWAVE_RESPONSE", "")
         payload = base64.b64decode(zwave.get("ZWAVE_PAYLOAD", "")).hex()
-        LOGGER.debug(
-            "Z-Wave Response: Node(%s) - Status(%s) - Payload(%s)",
-            zwave.get("NODE_ID", ""),
-            zwave.get("ZWAVE_COMMAND_STATUS", ""),
-            payload,
-        )
+        # LOGGER.debug(
+        #    "Z-Wave Response: Node(%s) - Status(%s) - Payload(%s)",
+        #    zwave.get("NODE_ID", ""),
+        #    zwave.get("ZWAVE_COMMAND_STATUS", ""),
+        #    payload,
+        # )
 
         node_id: str = str(zwave.get("NODE_ID", 0))
         node = self._controller.state.zwave_device(node_id)
@@ -900,8 +900,8 @@ class QolsysPanel(QolsysObservable):
 
             # Check if z-wave device is an Energy Clamp
             if device.get("node_type", "") == "Energy Clamp":
-                qolsys_meter_device = QolsysMeterDevice(device)
-                qolsys_meter_device.create_generic_electric_meter()
+                LOGGER.debug(device)
+                qolsys_meter_device = QolsysEnergyClamp(device)
                 devices.append(qolsys_meter_device)
                 device_added = True
 

{qolsys_controller-0.0.76 → qolsys_controller-0.0.81}/qolsys_controller/state.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
 import logging
-from enum import IntEnum
 from typing import TYPE_CHECKING
 
 from qolsys_controller.adc_service import QolsysAdcService
 from qolsys_controller.adc_service_garagedoor import QolsysAdcGarageDoorService
-from qolsys_controller.zwave_meter import QolsysMeterDevice
+from qolsys_controller.zwave_energy_clamp import QolsysEnergyClamp
 from qolsys_controller.zwave_thermometer import QolsysThermometer
 
 from .adc_device import QolsysAdcDevice
@@ -96,10 +95,10 @@ class QolsysState(QolsysObservable):
         return thermostats
 
     @property
-    def zwave_meters(self) -> list[QolsysMeterDevice]:
+    def zwave_meters(self) -> list[QolsysEnergyClamp]:
         meters = []
         for device in self.zwave_devices:
-            if isinstance(device, QolsysMeterDevice):
+            if isinstance(device, QolsysEnergyClamp):
                 meters.append(device)
         return meters
 
@@ -351,10 +350,9 @@ class QolsysState(QolsysObservable):
                             state_zwave.update_lock(db_zwave.to_dict_lock())
                             break
 
-                        # Update Meter
-                        if isinstance(state_zwave, QolsysMeterDevice) and isinstance(db_zwave, QolsysMeterDevice):
-                            # Meter state not store in database
-                            # Keep old value instact
+                        # Update Energy Clamp
+                        if isinstance(state_zwave, QolsysEnergyClamp) and isinstance(db_zwave, QolsysEnergyClamp):
+                            state_zwave.update_base(db_zwave.to_dict_base())
                             break
 
                         # Generic Z-Wave Device
@@ -473,6 +471,29 @@ class QolsysState(QolsysObservable):
     def dump(self) -> None:  # noqa: PLR0912, PLR0915
         LOGGER.debug("*** Device Information ***")
 
+        def dump_meter(self: QolsysState, device: QolsysZWaveDevice) -> None:
+            for endpoint in device.meter_endpoints:
+                for meter_sensor in endpoint.sensors:
+                    LOGGER.debug(
+                        " Meter%s Endpoint%s - %s - value: %.2f (%s)",
+                        device.node_id,
+                        endpoint.endpoint,
+                        endpoint._meter_type.name,
+                        meter_sensor.value,
+                        meter_sensor.scale.name,
+                    )
+
+        def dump_multilevelsensor(self: QolsysState, device: QolsysZWaveDevice) -> None:
+            for endpoint in device.multilevelsensor_endpoints:
+                for sensor in endpoint.sensors:
+                    LOGGER.debug(
+                        " Multilevelsensor%s Endpoint%s - value: %.2f (%s)",
+                        device.node_id,
+                        endpoint.endpoint,
+                        sensor.value,
+                        sensor.unit.name,
+                    )
+
         for partition in self.partitions:
             pid = partition.id
             name = partition.name
@@ -513,6 +534,8 @@ class QolsysState(QolsysObservable):
                 LOGGER.debug("Dimmer%s (%s) - node_status: %s", nid, name, zwave.node_status)
                 LOGGER.debug("Dimmer%s (%s) - battery_level: %s", nid, name, zwave.node_battery_level)
                 LOGGER.debug("Dimmer%s (%s) - battery_level_value: %s", nid, name, zwave.node_battery_level_value)
+                dump_meter(self, zwave)
+                dump_multilevelsensor(self, zwave)
                 continue
 
             if isinstance(zwave, QolsysThermostat):
@@ -525,34 +548,33 @@ class QolsysState(QolsysObservable):
                 LOGGER.debug("Thermostat%s (%s) - target_cool_temp: %s", zid, name, zwave.thermostat_target_cool_temp)
                 LOGGER.debug("Thermostat%s (%s) - target_heat_temp: %s", zid, name, zwave.thermostat_target_heat_temp)
                 LOGGER.debug("Thermostat%s (%s) - set_point_mode: %s", zid, name, zwave.thermostat_set_point_mode)
+                dump_meter(self, zwave)
+                dump_multilevelsensor(self, zwave)
                 continue
 
             if isinstance(zwave, QolsysLock):
                 zid = zwave.lock_node_id
                 name = zwave.lock_name
                 LOGGER.debug("Lock%s (%s) - lock_status: %s", zid, name, zwave.lock_status)
+                dump_meter(self, zwave)
+                dump_multilevelsensor(self, zwave)
                 continue
 
-            if isinstance(zwave, QolsysMeterDevice):
+            if isinstance(zwave, QolsysEnergyClamp):
                 nid = zwave.node_id
                 name = zwave.node_name
-                LOGGER.debug("Meter%s (%s)", nid, name)
-
-                for meter_sensor in zwave.meters:
-                    scale_type: type[IntEnum] = zwave.scale_for_meter_type(meter_sensor.meter_type)
-
-                    LOGGER.debug(
-                        " Sensor%s (%s) - value: %s (%s)",
-                        meter_sensor.meter_type,
-                        meter_sensor.meter_type.name,
-                        meter_sensor.value,
-                        scale_type(meter_sensor.scale).name,
-                    )
+                LOGGER.debug("EnergyClamp%s (%s)", nid, name)
+                dump_meter(self, zwave)
+                dump_multilevelsensor(self, zwave)
+                continue
 
             if isinstance(zwave, QolsysThermometer):
                 nid = zwave.node_id
                 name = zwave.node_name
                 LOGGER.debug("Thermometer%s (%s)", nid, name)
+                dump_meter(self, zwave)
+                dump_multilevelsensor(self, zwave)
+                continue
 
             if isinstance(zwave, QolsysGeneric):
                 zid = zwave.node_id
@@ -561,6 +583,8 @@ class QolsysState(QolsysObservable):
                 LOGGER.debug("Generic%s (%s) - status: %s", zid, name, zwave.node_status)
                 LOGGER.debug("Generic%s (%s) - battery_level: %s", zid, name, zwave.node_battery_level)
                 LOGGER.debug("Generic%s (%s) - battery_level_vale: %s", zid, name, zwave.node_battery_level_value)
+                dump_meter(self, zwave)
+                dump_multilevelsensor(self, zwave)
                 continue
 
         LOGGER.debug("Other Z-Wave devices information")

{qolsys_controller-0.0.76 → qolsys_controller-0.0.81}/qolsys_controller/zwave_device.py

@@ -1,5 +1,9 @@
+import json
 import logging
 
+from qolsys_controller.zwave_service_meter import QolsysZwaveServiceMeter
+from qolsys_controller.zwave_service_multilevelsensor import QolsysZwaveServiceMultilevelSensor
+
 from .enum_zwave import ZwaveDeviceClass
 from .observable import QolsysObservable
 
@@ -35,8 +39,14 @@ class QolsysZWaveDevice(QolsysObservable):
         self._is_device_hidden: str = zwave_dict.get("is_device_hidden", "")
         self._last_updated_date: str = zwave_dict.get("last_updated_date", "")
         self._command_class_list: str = zwave_dict.get("command_class_list", "")
-        self._multisensor_capabilities: str = zwave_dict.get("multisensor_capabilities", "")
-        self._meter_capabilities: str = zwave_dict.get("meter_capabilities", "")
+        self._meter_capabilities: str = ""
+        self._multisensor_capabilities: str = ""
+
+        # Set Meter and MutilevelSensor Services if available
+        self._meter_endpoints: list[QolsysZwaveServiceMeter] = []
+        self._multilevelsensor_endpoints: list[QolsysZwaveServiceMultilevelSensor] = []
+        self.meter_capabilities = zwave_dict.get("meter_capabilities", "")
+        self.multisensor_capabilities = zwave_dict.get("multisensor_capabilities", "")
 
     def update_raw(self, payload: bytes) -> None:
         LOGGER.debug("Raw Update (node%s) - payload: %s", self.node_id, payload.hex())
@@ -106,7 +116,7 @@ class QolsysZWaveDevice(QolsysObservable):
         if "multisensor_capabilities" in data:
             self.multisensor_capabilities = data.get("multisensor_capabilities", "")
         if "meter_capabilities" in data:
-            self._meter_capabilities = data.get("meter_capabilities", "")
+            self.meter_capabilities = data.get("meter_capabilities", "")
 
         self.end_batch_update()
 
@@ -151,9 +161,30 @@ class QolsysZWaveDevice(QolsysObservable):
     @meter_capabilities.setter
     def meter_capabilities(self, value: str) -> None:
         if self._meter_capabilities != value:
-            LOGGER.debug("ZWave%s (%s) - meter_capabilities: %s", self.node_id, self.node_name, value)
+            # LOGGER.debug("ZWave%s (%s) - meter_capabilities: %s", self.node_id, self.node_name, value)
             self._meter_capabilities = value
-            self.notify()
+
+            # Update Meter Service
+            try:
+                meter_services = json.loads(value)
+                for endpoint, service in meter_services.items():
+                    # Check if we already have this meter service
+                    meter_endpoint = None
+                    for meter in self._meter_endpoints:
+                        if meter.endpoint == endpoint:
+                            meter_endpoint = meter
+                            meter_endpoint.update_iq2medi(service)
+                            break
+
+                    # Create new meter service if not found
+                    if meter_endpoint is None:
+                        LOGGER.debug("ZWave%s (%s) - Adding new meter endpoint: %s", self.node_id, self.node_name, endpoint)
+                        meter_endpoint = QolsysZwaveServiceMeter(self, endpoint, service)
+                        self._meter_endpoints.append(meter_endpoint)
+
+            except json.JSONDecodeError:
+                LOGGER.error("ZWave%s (%s) - Error parsing meter_capabilities:%s", self.node_id, self.node_name, value)
+                return
 
     @property
     def multisensor_capabilities(self) -> str:
@@ -162,9 +193,36 @@ class QolsysZWaveDevice(QolsysObservable):
     @multisensor_capabilities.setter
     def multisensor_capabilities(self, value: str) -> None:
         if self._multisensor_capabilities != value:
-            LOGGER.debug("ZWave%s (%s) - multisensor_capabilities: %s", self.node_id, self.node_name, value)
+            # LOGGER.debug("ZWave%s (%s) - multisensor_capabilities: %s", self.node_id, self.node_name, value)
             self._multisensor_capabilities = value
-            self.notify()
+
+            # Update Multilevel Sensor Service
+            try:
+                sensor_services = json.loads(value)
+                for endpoint, service in sensor_services.items():
+                    # Check if we already have this meter service
+                    sensor_endpoint = None
+                    for sensor in self._multilevelsensor_endpoints:
+                        if sensor.endpoint == endpoint:
+                            sensor_endpoint = sensor
+                            sensor_endpoint.update_iq2medi(service)
+                            break
+
+                    # Create new meter service if not found
+                    if sensor_endpoint is None:
+                        LOGGER.debug(
+                            "ZWave%s (%s) - Adding new multilevelsensor endpoint: %s", self.node_id, self.node_name, endpoint
+                        )
+                        LOGGER.debug("create sensor service")
+                        sensor_endpoint = QolsysZwaveServiceMultilevelSensor(self, endpoint, service)
+                        self.multilevelsensor_endpoints.append(sensor_endpoint)
+                        LOGGER.debug(sensor_endpoint.sensors)
+
+            except json.JSONDecodeError:
+                LOGGER.error(
+                    "ZWave%s (%s) - Error parsing multilevelsensor_capabilities:%s", self.node_id, self.node_name, value
+                )
+                return
 
     @property
     def node_battery_level_value(self) -> int | None:
@@ -229,6 +287,14 @@ class QolsysZWaveDevice(QolsysObservable):
             self._partition_id = value
             self.notify()
 
+    @property
+    def meter_endpoints(self) -> list[QolsysZwaveServiceMeter]:
+        return self._meter_endpoints
+
+    @property
+    def multilevelsensor_endpoints(self) -> list[QolsysZwaveServiceMultilevelSensor]:
+        return self._multilevelsensor_endpoints
+
     @property
     def generic_device_type(self) -> ZwaveDeviceClass:
         try:
@@ -239,6 +305,12 @@ class QolsysZWaveDevice(QolsysObservable):
     def is_battery_enabled(self) -> bool:
         return self.node_battery_level_value is not None
 
+    def is_service_meter_enabled(self) -> bool:
+        return self._meter_endpoints != []
+
+    def is_service_multilevelsensor_enabled(self) -> bool:
+        return self._multilevelsensor_endpoints != []
+
     def to_dict_base(self) -> dict[str, str]:
         return {
             "_id": self._id,

{qolsys_controller-0.0.76 → qolsys_controller-0.0.81}/qolsys_controller/zwave_dimmer.py

@@ -70,7 +70,7 @@ class QolsysDimmer(QolsysZWaveDevice):
             self.notify()
 
     def update_raw(self, payload: bytes) -> None:
-        LOGGER.debug("Raw Update (node%s) - payload: %s", self.node_id, payload.hex())
+        pass
 
     def update_dimmer(self, content_values: dict[str, str]) -> None:  # noqa: PLR0912
         # Check if we are updating same none_id

qolsys_controller-0.0.81/qolsys_controller/zwave_energy_clamp.py

@@ -0,0 +1,15 @@
+import logging
+
+from .zwave_device import QolsysZWaveDevice
+
+LOGGER = logging.getLogger(__name__)
+
+
+class QolsysEnergyClamp(QolsysZWaveDevice):
+    def __init__(self, zwave_dict: dict[str, str]) -> None:
+        super().__init__(zwave_dict)
+
+    # Energy clamp only enables meter seter in base zwave_device class
+
+    def update_raw(self, payload: bytes) -> None:
+        pass