qolsys-controller 0.0.16__py3-none-any.whl → 0.0.19__py3-none-any.whl

qolsys_controller/plugin_remote.py

@@ -9,6 +9,7 @@ import uuid
 import aiomqtt
 
 from .enum import PartitionAlarmState, PartitionSystemStatus
+from .enum_zwave import ThermostatFanMode, ThermostatMode
 from .errors import QolsysMqttError, QolsysSslError
 from .mdns import QolsysMDNS
 from .mqtt_command_queue import QolsysMqttCommandQueue
@@ -197,15 +198,15 @@ class QolsysPluginRemote(QolsysPlugin):
                 await self.aiomqtt.subscribe("iq2meid")
 
                 # Subscribte to MQTT commands response
-                await self.aiomqtt.subscribe("response_" + self.settings.random_mac, qos=0)
+                await self.aiomqtt.subscribe("response_" + self.settings.random_mac, qos=self.settings.mqtt_qos)
 
                 # Only log mastermeid traffic for debug purposes
                 if self.log_mqtt_mesages:
                     # Subscribe to MQTT commands send to panel by other devices
-                    await self.aiomqtt.subscribe("mastermeid", qos=0)
+                    await self.aiomqtt.subscribe("mastermeid", qos=self.settings.mqtt_qos)
 
                     # Subscribe to all topics
-                    #await self.aiomqtt.subscribe("#", qos=0)
+                    await self.aiomqtt.subscribe("#", qos=self.settings.mqtt_qos)
 
                 # Start mqtt_listent_task and mqtt_ping_task
                 self._task_manager.cancel(self._mqtt_task_listen_label)
@@ -455,7 +456,7 @@ class QolsysPluginRemote(QolsysPlugin):
             LOGGER.error("MQTT Client not configured")
             raise QolsysMqttError
 
-        await self.aiomqtt.publish(topic=topic, payload=json.dumps(json_payload), qos=0)
+        await self.aiomqtt.publish(topic=topic, payload=json.dumps(json_payload), qos=self.settings.mqtt_qos)
         return await self._mqtt_command_queue.wait_for_response(request_id)
 
     async def command_connect(self) -> dict:
@@ -816,7 +817,6 @@ class QolsysPluginRemote(QolsysPlugin):
         mqtt_disarm_command = await get_mqtt_disarm_command(silent_disarming)
         LOGGER.debug("MQTT: Sending disarm command - check_user_code:%s", self.check_user_code_on_disarm)
 
-
         disarm_command = {
             "operation_name": mqtt_disarm_command,
             "userID": user_id,
@@ -851,8 +851,161 @@ class QolsysPluginRemote(QolsysPlugin):
 
         return True
 
-    async def command_zwave_switch_multi_level(self, node_id: int, level: int) -> None:
+    async def command_zwave_thermostat_setpoint_set(self, node_id: int, mode:ThermostatMode, setpoint:float) -> None:
+        # Command 67
+        LOGGER.debug("MQTT: Sending zwave_thermostat_setpoint_set command: EXPERIMENTAL")
+        LOGGER.debug("MQTT: Sending zwave_thermostat_setpoint_set command")
+        ipcRequest = [{
+                "dataType": "int",
+                "dataValue": node_id,
+            },
+            {
+                "dataType": "int",
+                "dataValue": 0,
+            },
+            {
+                "dataType": "byteArray",
+                "dataValue": [67,1,mode,setpoint],
+            },
+            {
+                "dataType": "int",
+                "dataValue": 0,
+            },
+            {
+                "dataType": "int",
+                "dataValue": 106,
+            },
+            {
+                "dataType": "byteArray",
+                "dataValue": [0],
+            },
+        ]
+
+        topic = "mastermeid"
+        eventName = "ipcCall"
+        ipcServiceName = "qzwaveservice"
+        ipcInterfaceName = "android.os.IQZwaveService"
+        ipcTransactionID = 47
+        requestID = str(uuid.uuid4())
+        remoteMacAddress = self.settings.random_mac
+        responseTopic = "response_" + self.settings.random_mac
+
+        payload = {"eventName": eventName,
+                   "ipcServiceName": ipcServiceName,
+                   "ipcInterfaceName": ipcInterfaceName,
+                   "ipcTransactionID": ipcTransactionID,
+                   "ipcRequest": ipcRequest,
+                   "requestID": requestID,
+                   "responseTopic": responseTopic,
+                   "remoteMacAddress": remoteMacAddress}
+
+        await self.send_command(topic, payload, requestID)
+        LOGGER.debug("MQTT: Receiving zwave_thermostat_mode_set command")
+
+    async def command_zwave_thermostat_mode_set(self, node_id: int, mode:ThermostatMode) -> None:
+        # Command 64
+        LOGGER.debug("MQTT: Sending zwave_thermostat_mode_set command: EXPERIMENTAL")
+        LOGGER.debug("MQTT: Sending zwave_thermostat_mode_set command")
+        ipcRequest = [{
+                "dataType": "int",
+                "dataValue": node_id,
+            },
+            {
+                "dataType": "int",
+                "dataValue": 0,
+            },
+            {
+                "dataType": "byteArray",
+                "dataValue": [64,1,mode],
+            },
+            {
+                "dataType": "int",
+                "dataValue": 0,
+            },
+            {
+                "dataType": "int",
+                "dataValue": 106,
+            },
+            {
+                "dataType": "byteArray",
+                "dataValue": [0],
+            },
+        ]
+
+        topic = "mastermeid"
+        eventName = "ipcCall"
+        ipcServiceName = "qzwaveservice"
+        ipcInterfaceName = "android.os.IQZwaveService"
+        ipcTransactionID = 47
+        requestID = str(uuid.uuid4())
+        remoteMacAddress = self.settings.random_mac
+        responseTopic = "response_" + self.settings.random_mac
+
+        payload = {"eventName": eventName,
+                   "ipcServiceName": ipcServiceName,
+                   "ipcInterfaceName": ipcInterfaceName,
+                   "ipcTransactionID": ipcTransactionID,
+                   "ipcRequest": ipcRequest,
+                   "requestID": requestID,
+                   "responseTopic": responseTopic,
+                   "remoteMacAddress": remoteMacAddress}
+
+        await self.send_command(topic, payload, requestID)
+        LOGGER.debug("MQTT: Receiving zwave_thermostat_mode_set command")
+
+    async def command_zwave_thermostat_fan_mode_set(self, node_id: int, fan_mode:ThermostatFanMode) -> None:
+        # Command 68
+        LOGGER.debug("MQTT: Sending zwave_thermostat_fan_mode_set command: EXPERIMENTAL")
+        LOGGER.debug("MQTT: Sending zwave_thermostat_fan_mode_set command")
+        ipcRequest = [{
+                "dataType": "int",
+                "dataValue": node_id,
+            },
+            {
+                "dataType": "int",
+                "dataValue": 0,
+            },
+            {
+                "dataType": "byteArray",
+                "dataValue": [68,1,fan_mode],
+            },
+            {
+                "dataType": "int",
+                "dataValue": 0,
+            },
+            {
+                "dataType": "int",
+                "dataValue": 106,
+            },
+            {
+                "dataType": "byteArray",
+                "dataValue": [0],
+            },
+        ]
+
+        topic = "mastermeid"
+        eventName = "ipcCall"
+        ipcServiceName = "qzwaveservice"
+        ipcInterfaceName = "android.os.IQZwaveService"
+        ipcTransactionID = 47
+        requestID = str(uuid.uuid4())
+        remoteMacAddress = self.settings.random_mac
+        responseTopic = "response_" + self.settings.random_mac
+
+        payload = {"eventName": eventName,
+                   "ipcServiceName": ipcServiceName,
+                   "ipcInterfaceName": ipcInterfaceName,
+                   "ipcTransactionID": ipcTransactionID,
+                   "ipcRequest": ipcRequest,
+                   "requestID": requestID,
+                   "responseTopic": responseTopic,
+                   "remoteMacAddress": remoteMacAddress}
+
+        await self.send_command(topic, payload, requestID)
+        LOGGER.debug("MQTT: Receiving zwave_thermostat_fan_mode_set command")
 
+    async def command_zwave_switch_multi_level(self, node_id: int, level: int) -> None:
+        LOGGER.debug("MQTT: Sending zwave_switch_multi_level command")
         ipcRequest = [{
                 "dataType": "int",  # Node ID
                 "dataValue": node_id,
@@ -862,8 +1015,9 @@ class QolsysPluginRemote(QolsysPlugin):
                 "dataValue": 0,
             },
             {
-                "dataType": "byteArray",  # ZWAVE MULTILEVELSWITCH COMMAND
-                "dataValue": [38, 1, level],
+                # [38,1,level] ZWAVE MULTILEVELSWITCH SET (level 255 to set to previous state)
+                "dataType": "byteArray",
+                "dataValue": [38,1,level],
             },
             {
                 "dataType": "int",  # ?
@@ -898,6 +1052,62 @@ class QolsysPluginRemote(QolsysPlugin):
                    "remoteMacAddress": remoteMacAddress}
 
         await self.send_command(topic, payload, requestID)
+        LOGGER.debug("MQTT: Receiving zwave_switch_multi_level command")
+
+    async def command_zwave_switch_binary(self, node_id: int, status:bool) -> None:
+        LOGGER.debug("MQTT:Sending zwave_switch_binary command")
+
+        level = 0
+        if status:
+            level = 99
+
+        ipcRequest = [{
+                "dataType": "int",
+                "dataValue": node_id,
+            },
+            {
+                "dataType": "int",
+                "dataValue": 0,
+            },
+            {
+                "dataType": "byteArray",
+                "dataValue": [37,1,level],
+            },
+            {
+                "dataType": "int",
+                "dataValue": 0,
+            },
+            {
+                "dataType": "int",
+                "dataValue": 106,
+            },
+            {
+                "dataType": "byteArray",
+                "dataValue": [0],
+            },
+        ]
+
+        topic = "mastermeid"
+        eventName = "ipcCall"
+        ipcServiceName = "qzwaveservice"
+        ipcInterfaceName = "android.os.IQZwaveService"
+        ipcTransactionID = 47
+        requestID = str(uuid.uuid4())
+        remoteMacAddress = self.settings.random_mac
+        responseTopic = "response_" + self.settings.random_mac
+
+        payload = {"eventName": eventName,
+                   "ipcServiceName": ipcServiceName,
+                   "ipcInterfaceName": ipcInterfaceName,
+                   "ipcTransactionID": ipcTransactionID,
+                   "ipcRequest": ipcRequest,
+                   "requestID": requestID,
+                   "responseTopic": responseTopic,
+                   "remoteMacAddress": remoteMacAddress}
+
+        await self.send_command(topic, payload, requestID)
+        LOGGER.debug("MQTT:Receiving zwave_switch_binary command")
+
 
     async def command_arm(self, partition_id: str, arming_type: str, user_code: str = "", exit_sounds: bool = False,
                           instant_arm: bool = False) -> bool:
@@ -979,3 +1189,46 @@ class QolsysPluginRemote(QolsysPlugin):
         await self.send_command(topic, payload, requestID)
 
         return True
+
+    async def command_execute_scene(self,scene_id:str) -> bool:
+        LOGGER.debug("MQTT: Sending execute_scene command")
+
+        scene = self.state.scene(scene_id)
+        if not scene:
+            LOGGER.debug("MQTT: command_execute_scene Erro - Unknow Scene: %s", scene_id)
+            return False
+
+        scene_command = {
+            "operation_name": "execute_scene",
+            "scene_id": scene.scene_id,
+            "operation_source": 1,
+            "macAddress": self.settings.random_mac,
+        }
+
+        topic = "mastermeid"
+        eventName = "ipcCall"
+        ipcServiceName = "qinternalservice"
+        ipcInterfaceName = "android.os.IQInternalService"
+        ipcTransactionID = 7
+        requestID = str(uuid.uuid4())
+        remoteMacAddress = self.settings.random_mac
+        responseTopic = "response_" + self.settings.random_mac
+
+        payload = {
+            "eventName": eventName,
+            "ipcServiceName": ipcServiceName,
+            "ipcInterfaceName": ipcInterfaceName,
+            "ipcTransactionID": ipcTransactionID,
+            "ipcRequest": [{
+                "dataType": "string",
+                "dataValue":  json.dumps(scene_command),
+            }],
+            "requestID": requestID,
+            "responseTopic": responseTopic,
+            "remoteMacAddress": remoteMacAddress,
+        }
+
+        await self.send_command(topic, payload, requestID)
+        LOGGER.debug("MQTT: Receiving execute_scene command")
+
+        return False

qolsys_controller/scene.py

@@ -0,0 +1,79 @@
+import logging
+
+from .observable import QolsysObservable
+
+LOGGER = logging.getLogger(__name__)
+
+
+class QolsysScene(QolsysObservable):
+
+    def __init__(self, data: dict) -> None:
+        super().__init__()
+
+        self._scene_id = data.get("scene_id", "")
+        self._name = data.get("name", "")
+        self._icon = data.get("icon", "")
+        self._color = data.get("color", "")
+
+    def update(self, data: dict) -> None:
+
+        scene_id_update = data.get("scene_id", "")
+        if scene_id_update != self._scene_id:
+            LOGGER.error("Updating Scene%s (%s) with Scene%s (different id)", self._scene_id, self.sensorname, scene_id_update)
+            return
+
+        self.start_batch_update()
+
+        # Update name
+        if "name" in data:
+            self.sensorname = data.get("name")
+
+        if "color" in data:
+            self.color = data.get("color")
+
+        if "icon" in data:
+            self.icon = data.get("icon")
+
+        self.end_batch_update()
+
+    @property
+    def scene_id(self) -> str:
+        return self._scene_id
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def icon(self) -> str:
+        return self._icon
+
+    @property
+    def color(self) -> str:
+        return self._color
+
+    @name.setter
+    def name(self, value: str) -> None: 
+        if self._name != value:
+            self._name = value
+            self.notify()
+
+    @icon.setter
+    def icon(self, value: str) -> None:
+        if self._icon != value:
+            self._icon = value
+            self.notify()
+
+    @color.setter
+    def color(self, value: str) -> None:
+        if self._color != value:
+            self._color = value
+            self.notify()
+
+    def to_dict(self) -> dict:
+        return {
+            "scene_id": self.scene_id,
+            "name": self.name,
+            "color": self.color,
+            "icon": self.icon,
+        }

qolsys_controller/settings.py

@@ -25,6 +25,7 @@ class QolsysSettings:
         # MQTT
         self._mqtt_timeout: int = 30
         self._mqtt_ping: int = 600
+        self._mqtt_qos:int = 0
         self._mqtt_remote_client_id = ""
 
     @property
@@ -94,6 +95,10 @@ class QolsysSettings:
     def mqtt_ping(self, ping:int) -> None:
         self._mqtt_ping = ping
 
+    @property
+    def mqtt_qos(self) -> int:
+        return self._mqtt_qos
+
     @property
     def mqtt_remote_client_id(self) -> str:
         return self._mqtt_remote_client_id

qolsys_controller/state.py

@@ -2,6 +2,7 @@ import logging
 
 from .observable import QolsysObservable
 from .partition import QolsysPartition
+from .scene import QolsysScene
 from .zone import QolsysZone
 from .zwave_device import QolsysZWaveDevice
 from .zwave_dimmer import QolsysDimmer
@@ -20,10 +21,12 @@ class QolsysState(QolsysObservable):
         self._partitions = []
         self._zones = []
         self._zwave_devices = []
+        self._scenes = []
 
         self._state_partition_observer = QolsysObservable()
         self._state_zone_observer = QolsysObservable()
         self._state_zwave_observer = QolsysObservable()
+        self._state_scene_observer = QolsysObservable()
 
     @property
     def partitions(self) -> list[QolsysPartition]:
@@ -37,6 +40,10 @@ class QolsysState(QolsysObservable):
     def zones(self) -> list[QolsysZone]:
         return self._zones
 
+    @property
+    def scenes(self) -> list[QolsysScene]:
+        return self._scenes
+
     @property
     def zwave_dimmers(self) -> list[QolsysDimmer]:
         dimmers = []
@@ -76,6 +83,10 @@ class QolsysState(QolsysObservable):
     def state_zwave_observer(self) -> QolsysObservable:
         return self._state_zwave_observer
 
+    @property
+    def state_scene_observer(self) -> QolsysObservable:
+        return self._state_scene_observer
+
     def partition(self, partition_id: str) -> QolsysPartition:
         for partition in self.partitions:
             if partition.id == partition_id:
@@ -103,6 +114,32 @@ class QolsysState(QolsysObservable):
         self.partitions.remove(partition)
         self.state_partition_observer.notify()
 
+    def scene(self, scene_id: str) -> QolsysScene:
+        for scene in self.scenes:
+            if scene.scene_id == scene_id:
+                return scene
+
+        return None
+
+    def scene_add(self, new_scene: QolsysScene) -> None:
+        for scene in self.scenes:
+            if new_scene.scene_id == scene.scene_id:
+                LOGGER.debug("Adding Scene to State, Scene%s (%s) - Allready in Scene List", new_scene.scene_id, scene.name )
+                return
+
+        self.scenes.append(new_scene)
+        self.state_scene_observer.notify()
+
+    def scene_delete(self, scene_id: str) -> None:
+        scene = self.scene(scene_id)
+
+        if scene is None:
+            LOGGER.debug("Deleting Scene from State, Scene%s not found", scene_id)
+            return
+
+        self.scenes.remove(scene)
+        self.state_scene_observer.notify()
+
     def zone(self, zone_id: str) -> QolsysZone:
         for zone in self.zones:
             if zone.zone_id == zone_id:
@@ -212,6 +249,36 @@ class QolsysState(QolsysObservable):
                 LOGGER.debug("sync_data - delete ZWave%s", state_zwave.none_id)
                 self.zwave_delete(int(state_zwave.node_id))
 
+    def sync_scenes_data(self, db_scenes: list[QolsysScene]) -> None:
+        db_scene_list = []
+        for db_scene in db_scenes:
+            db_scene_list.append(db_scene.scene_id)
+
+        state_scene_list = []
+        for state_scene in self.scenes:
+            state_scene_list.append(state_scene.scene_id)
+
+        # Update existing scenes
+        for state_scene in self.scenes:
+            if state_scene.scene_id in db_scene_list:
+                for db_scene in db_scenes:
+                    if state_scene.scene_id == db_scene.scene_id:
+                        LOGGER.debug("sync_data - update Scene%s", state_scene.scene_id)
+                        state_scene.update(db_scene.to_dict())
+                        break
+
+        # Delete scenes
+        for state_scene in self.scenes:
+            if state_scene.scene_id not in db_scene_list:
+                LOGGER.debug("sync_data - delete Scene%s", state_scene.scene_id)
+                self.scene_delete(int(state_scene.scene_id))
+
+        # Add new scene
+        for db_scene in db_scenes:
+            if db_scene.scene_id not in state_scene_list:
+                LOGGER.debug("sync_data - add Scene%s", db_scene.scene_id)
+                self.scene_add(db_scene)
+
     def sync_zones_data(self, db_zones: list[QolsysZone]) -> None:  # noqa: C901
         db_zone_list = []
         for db_zone in db_zones:
@@ -338,3 +405,8 @@ class QolsysState(QolsysObservable):
                 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)
                 continue
+
+        for scene in self.scenes:
+            sid = scene.scene_id
+            name = scene.name
+            LOGGER.debug("Scene%s (%s)",sid, name)

qolsys_controller/zone.py

@@ -245,7 +245,7 @@ class QolsysZone(QolsysObservable):
     @time.setter
     def time(self, value: str) -> None:
         if self._time != value:
-            LOGGER.debug("Zone%s (%s) - time: %s", self.zone_id, self.sensorname, value)
+            #LOGGER.debug("Zone%s (%s) - time: %s", self.zone_id, self.sensorname, value)
             self._time = value
             self.notify()
 

qolsys_controller/zwave_thermostat.py

@@ -1,5 +1,6 @@
 import logging
 
+from .enum_zwave import ThermostatFanMode, ThermostatMode
 from .zwave_device import QolsysZWaveDevice
 
 LOGGER = logging.getLogger(__name__)
@@ -249,3 +250,57 @@ class QolsysThermostat(QolsysZWaveDevice):
             "endpoint": self._thermostat_endpoint,
             "configuration_parameter": self._thermostat_configuration_parameter,
         }
+
+    def thermostat_mode(self) -> ThermostatMode:
+        thermostat_mode = int(self._thermostat_mode)
+        for mode in ThermostatMode:
+            if thermostat_mode == mode:
+                return mode
+        return None
+
+    def available_thermostat_mode(self) -> list[ThermostatMode]:
+
+        int_list = [int(x) for x in self._thermostat_mode_bitmask.split(",")]
+        byte_array = bytes(int_list)
+        bitmask = int.from_bytes(byte_array, byteorder="little")
+
+        mode_array = []
+        for mode in ThermostatMode:
+            if mode.value & bitmask:
+                mode_array.append(mode)
+
+        return mode_array
+
+    def thermostat_fan_mode(self) -> ThermostatFanMode:
+        thermostat_fan_mode = int(self._thermostat_fan_mode)
+        for mode in ThermostatMode:
+            if thermostat_fan_mode == mode:
+                return mode
+        return None
+
+    def available_thermostat_fan_mode(self) -> list[ThermostatFanMode]:
+
+        int_list = [int(x) for x in self._thermostat_fan_mode_bitmask.split(",")]
+        byte_array = bytes(int_list)
+        bitmask = int.from_bytes(byte_array, byteorder="little")
+
+        fan_mode_array = []
+        for mode in ThermostatFanMode:
+            if mode.value & bitmask:
+                fan_mode_array.append(mode)
+
+        return fan_mode_array
+
+    def available_thermostat_set_point_mode(self) -> list[ThermostatMode]:
+
+        int_list = [int(x) for x in self._thermostat_set_point_mode_bitmask.split(",")]
+        byte_array = bytes(int_list)
+        bitmask = int.from_bytes(byte_array, byteorder="little")
+
+        set_point_mode_array = []
+        for mode in ThermostatMode:
+            if mode.value & bitmask:
+                set_point_mode_array.append(mode)
+
+        return set_point_mode_array
+

{qolsys_controller-0.0.16.dist-info → qolsys_controller-0.0.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qolsys-controller
-Version: 0.0.16
+Version: 0.0.19
 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
@@ -35,6 +35,7 @@ A Python module that emulates a virtual IQ Remote device, enabling full **local
 | **Partitions**       | Arming status                    | ✅ |
 |                      | Set Exit sounds                  | ✅            |
 |                      | Home Instant arming              | ✅            |
+|                      | Home Silent Disarm               | ✅            |
 |                      | Alarm state and type             | ✅            |
 |                      | Disarm pictures             | 🛠️ WIP            |
 |---|---|---|