TISControlProtocol 0.0.4__tar.gz

tiscontrolprotocol-0.0.4/.gitignore

@@ -0,0 +1 @@
+.env

tiscontrolprotocol-0.0.4/.pypirc

@@ -0,0 +1,3 @@
+[pypi]
+  username = __token__
+  password = pypi-AgEIcHlwaS5vcmcCJGNhNmI1MjUyLTk3ZjUtNGMyOS05MTU5LTBlZTNmNTU3YzBkMAACKlszLCI3NTZmYWQ1MC0xZDAwLTQwN2QtOTI2MC03MDZmYzVjMTlmMjAiXQAABiCtQBdnR6dtdmpuwD-X_wUk-TkZfzd3A17jrKSNFis_aQ

tiscontrolprotocol-0.0.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tiscontrolprotocol-0.0.4/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.3
+Name: TISControlProtocol
+Version: 0.0.4
+Summary: A small example package
+Project-URL: Homepage, https://github.com/pypa/sampleproject
+Project-URL: Issues, https://github.com/pypa/sampleproject/issues
+Author-email: Mostafa Ashraf <mustafaashraf744@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Example Package
+
+This is a simple example package. You can use
+[GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
+to write your content.

tiscontrolprotocol-0.0.4/README.md

@@ -0,0 +1,5 @@
+# Example Package
+
+This is a simple example package. You can use
+[GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
+to write your content.

tiscontrolprotocol-0.0.4/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+[project]
+name = "TISControlProtocol"
+version = "0.0.4"
+authors = [{ name = "Mostafa Ashraf", email = "mustafaashraf744@gmail.com" }]
+description = "A small example package"
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+]
+
+[project.urls]
+Homepage = "https://github.com/pypa/sampleproject"
+Issues = "https://github.com/pypa/sampleproject/issues"
+
+
+# [testpypi]

tiscontrolprotocol-0.0.4/src/TISControlProtocol/BytesHelper.py

@@ -0,0 +1,65 @@
+import binascii
+from TISControlProtocol.crc import checkCRC, packCRC
+
+
+def bytes2hex(data, rtype=[]):
+    """A helper function to parse bytes to hex
+
+    :param data: the raw bytes array
+    :type data: bytes array
+    :param rtype: determine return type whether list of ints or single hex str, defaults to []
+    :type rtype: list, optional
+    :return: list of ints or hex string
+    :rtype: list | str
+    """
+    hex_string = binascii.hexlify(data).decode()
+    hex_list = [int(hex_string[i : i + 2], 16) for i in range(0, len(hex_string), 2)]
+    if isinstance(rtype, list):
+        return hex_list
+    else:
+        return hex_string
+
+
+def build_packet(
+    operation_code: list,
+    ip_address: str,
+    destination_mac: str,
+    source_mac: str = "CB:CB:CB:CB:CB:CB:CB:CB",
+    device_id: list = [],
+    source_device_id: list = [0x01, 0xFE],
+    additional_packets: list = [],
+    header="SMARTCLOUD",
+):
+
+    # test if all params are loaded
+    ip_bytes = [int(part) for part in ip_address.split(".")]
+    header_bytes = [ord(char) for char in header]
+    source_mac = [int(part, 16) for part in source_mac.split(":")]
+    destination_mac = [int(part, 16) for part in destination_mac.split(":")]
+    # TODO: modify length
+    # length = 21 + len(additional_packets)
+    length = 11 + len(additional_packets)
+    packet = (
+        ip_bytes
+        + header_bytes
+        + [0xAA, 0xAA]
+        + [length]
+        # + source_mac
+        + source_device_id
+        + [0xFF, 0xFE]
+        + operation_code
+        # + destination_mac
+        + device_id
+        + additional_packets
+    )
+    packet = packCRC(packet)
+    return packet
+
+
+def decode_mac(mac: list):
+    return ":".join([f"{byte:02X}" for byte in mac])
+
+
+def int_to_8_bit_binary(number):
+    binary_string = bin(number)[2:]
+    return binary_string.zfill(8)[::-1]

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/__init__.py

@@ -0,0 +1,18 @@
+from asyncio import get_event_loop, AbstractEventLoop
+import socket
+from TISControlProtocol.Protocols.udp.PacketProtocol import PacketProtocol
+
+loop = get_event_loop()
+
+
+async def setup_udp_protocol(
+    sock: socket, loop: AbstractEventLoop, udp_ip, udp_port, local_ip, hass
+) -> tuple[socket.socket, PacketProtocol]:
+    transport, protocol = await loop.create_datagram_endpoint(
+        lambda: PacketProtocol(sock, udp_ip, udp_port, hass),
+        remote_addr=(udp_ip, udp_port),
+        local_addr=("0.0.0.0", udp_port),
+        allow_broadcast=True,
+        reuse_port=True,
+    )
+    return transport, protocol

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/AckCoordinator.py

@@ -0,0 +1,50 @@
+import asyncio
+from TISControlProtocol.shared import ack_events
+from typing import Union
+
+
+class AckCoordinator:
+    def __init__(self):
+        self.ack_events = ack_events
+
+    def create_ack_event(self, unique_id: Union[str, tuple]) -> asyncio.Event:
+        print(f"creating ack event for {unique_id}")
+        event = asyncio.Event()
+        self.ack_events[unique_id] = event
+        return event
+
+    def get_ack_event(self, unique_id: Union[str, tuple]) -> Union[asyncio.Event, None]:
+        return self.ack_events.get(unique_id)
+
+    def remove_ack_event(self, unique_id: Union[str, tuple]) -> None:
+        if unique_id in self.ack_events:
+            del self.ack_events[unique_id]
+
+    # async def create_ack_task(
+    #     self,
+    #     sender,
+    #     packet,
+    #     packet_dict=None,
+    #     channel_number=None,
+    #     attempts=3,
+    #     timeout=5.0,
+    # ) -> bool:
+    #     unique_id = (
+    #         (tuple(packet_dict["device_id"])),
+    #         packet_dict["operation_code"],
+    #         channel_number,
+    #     )
+    #     event = self.create_ack_event(unique_id)
+
+    #     for attempt in range(attempts):
+    #         sender.send_packet(packet)
+    #         try:
+    #             await asyncio.wait_for(event.wait(), timeout)
+    #             self.remove_ack_event(unique_id)
+    #             return True
+    #         except asyncio.TimeoutError:
+    #             print(
+    #                 f"ack not received within {timeout} seconds, attempt {attempt + 1}"
+    #             )
+
+    #     return False

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/PacketDispatcher.py

@@ -0,0 +1,16 @@
+from homeassistant.core import HomeAssistant  # type: ignore
+
+
+class PacketDispatcher:
+    def __init__(self, hass: HomeAssistant, OPERATIONS_DICT: dict):
+        self.hass = hass
+        self.operations_dict = OPERATIONS_DICT
+
+    async def dispatch_packet(self, info):
+        packet_handler = self.operations_dict.get(
+            tuple(info["operation_code"]), "unknown operation"
+        )
+        if packet_handler != "unknown operation":
+            await packet_handler(self.hass, info)
+        else:
+            print(f"unknown operation code: {info['operation_code']}")

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/PacketExtractor.py

@@ -0,0 +1,19 @@
+from TISControlProtocol.BytesHelper import checkCRC
+
+
+# PacketExtractor.py
+class PacketExtractor:
+    @staticmethod
+    def extract_info(packet: list):
+        packet_check = checkCRC(packet)
+        info = {}
+        if packet_check:
+            print("correct packet")
+            info["device_id"] = packet[17:19]
+            info["device_type"] = packet[19:21]
+            info["operation_code"] = packet[21:23]
+            info["additional_bytes"] = packet[25:-2]
+
+        else:
+            print("wrong packet")
+        return info

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/PacketHandlers/AutoBinaryFeedbackHandler.py

@@ -0,0 +1,18 @@
+from homeassistant.core import HomeAssistant  # type: ignore
+import logging
+
+
+async def handle_auto_binary_feedback(hass: HomeAssistant, info: dict):
+    logging.error(f"Auto Binary Feedback: {info}")
+    channels_number: int = info["additional_bytes"][0]
+    channels_values: list = info["additional_bytes"][-1 * channels_number :]
+
+    event_data = {
+        "device_id": info["device_id"],
+        "feedback_type": "auto_binary_feedback",
+        "channels_values": channels_values,
+    }
+    try:
+        hass.bus.async_fire(str(info["device_id"]), event_data)
+    except Exception as e:
+        logging.error(f"error in firing event: {e}")

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/PacketHandlers/BinaryFeedbackHandler.py

@@ -0,0 +1,17 @@
+from homeassistant.core import HomeAssistant  # type: ignore
+import logging
+
+
+async def handle_binary_feedback(hass: HomeAssistant, info: dict):
+    # remove auxilary bytes which represents number of scenarios
+    len_aux = info["additional_bytes"][0]
+    info["additional_bytes"] = info["additional_bytes"][len_aux + 1 :]
+    event_data = {
+        "device_id": info["device_id"],
+        "feedback_type": "binary_feedback",
+        "additional_bytes": info["additional_bytes"],
+    }
+    try:
+        hass.bus.async_fire(str(info["device_id"]), event_data)
+    except Exception as e:
+        logging.error(f"error in firing event: {e}")

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/PacketHandlers/ClimateFeedbackHandler.py

@@ -0,0 +1,9 @@
+from TISControlProtocol.shared import ack_events
+import asyncio
+from homeassistant.core import HomeAssistant
+
+import logging
+
+
+async def handle_climate_feedback(hass: HomeAssistant, info: dict):
+    logging.error(f"got ac feedback {info}")

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/PacketHandlers/ControlResponseHandler.py

@@ -0,0 +1,34 @@
+from homeassistant.core import HomeAssistant
+
+import logging
+import asyncio
+from TISControlProtocol.shared import ack_events
+
+
+async def handle_control_response(hass: HomeAssistant, info: dict):
+    channel_number = info["additional_bytes"][0]
+    # await target_appliance.handle_packet(info["additional_bytes"], "control")
+    event_data = {
+        "device_id": info["device_id"],
+        "channel_number": channel_number,
+        "feedback_type": "control_response",
+        "additional_bytes": info["additional_bytes"],
+    }
+    try:
+        hass.bus.async_fire(str(info["device_id"]), event_data)
+    except Exception as e:
+        logging.error(f"error in firing even for feedbackt: {e}")
+
+    try:
+        event: asyncio.Event = ack_events.get(
+            (
+                tuple(info["device_id"]),
+                (0x00, 0x31),
+                channel_number,
+            )
+        )
+        if event is not None:
+            print("setting event")
+            event.set()
+    except Exception as e:
+        print(e)

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/PacketHandlers/DiscoveryFeedbackHandler.py

@@ -0,0 +1,10 @@
+from homeassistant.core import HomeAssistant  # type: ignore
+
+
+async def handle_discovery_feedback(hass: HomeAssistant, info: dict):
+    # check if the record already exists if not add it
+    if not any(
+        device["device_id"] == info["device_id"]
+        for device in hass.data["tis_control"]["discovered_devices"]
+    ):
+        hass.data["tis_control"]["discovered_devices"].append(info)

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/PacketHandlers/SearchResponseHandler.py

@@ -0,0 +1,9 @@
+
+async def handle_search_response(self, info: dict):
+    print(f"got search response packet from {info['device_id']}")
+    self.discovered_devices.append(
+        {
+            "mac": info["device_id"],
+            "device_type": DEVICES_DICT[tuple(info["additional_bytes"])],
+        }
+    )

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/PacketHandlers/__init__.py

@@ -0,0 +1 @@
+# TODO: implement all handlers here

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/PacketProtocol.py

@@ -0,0 +1,56 @@
+from TISControlProtocol.BytesHelper import *  # noqa: F403
+from TISControlProtocol.Protocols.udp.PacketSender import PacketSender
+from TISControlProtocol.Protocols.udp.PacketReceiver import PacketReceiver
+from TISControlProtocol.Protocols.udp.AckCoordinator import AckCoordinator
+
+from TISControlProtocol.shared import ack_events
+
+from homeassistant.core import HomeAssistant  # type: ignore
+from .PacketHandlers.BinaryFeedbackHandler import handle_binary_feedback
+from .PacketHandlers.ControlResponseHandler import handle_control_response
+
+from .PacketHandlers.AutoBinaryFeedbackHandler import handle_auto_binary_feedback
+
+from .PacketHandlers.ClimateFeedbackHandler import handle_climate_feedback
+from .PacketHandlers.DiscoveryFeedbackHandler import handle_discovery_feedback
+
+import socket as Socket
+
+OPERATIONS_DICT = {
+    (0x00, 0x32): handle_control_response,
+    (0xEF, 0xFF): handle_binary_feedback,
+    (0xDC, 0x22): handle_auto_binary_feedback,
+    (0xE0, 0xED): handle_climate_feedback,
+    (0x00, 0x0F): handle_discovery_feedback,
+}
+# 1C 01 30 1B BA DC 22 FF FF 08 02 02 02 02 02 02 02 02 00 01 01 01 01 01 01 01 57 62
+
+
+class PacketProtocol:
+    def __init__(
+        self,
+        socket: Socket.socket,
+        UDP_IP,
+        UDP_PORT,
+        hass: HomeAssistant,
+    ):
+        self.UDP_IP = UDP_IP
+        self.UDP_PORT = UDP_PORT
+        self.socket = socket
+        self.searching = False
+        self.search_results = []
+        self.discovered_devices = []
+        self.hass = hass
+
+        self.ack_events = ack_events
+        self.coordinator = AckCoordinator()
+        self.sender = PacketSender(
+            socket=self.socket,
+            coordinator=self.coordinator,
+            UDP_IP=self.UDP_IP,
+            UDP_PORT=self.UDP_PORT,
+        )
+        self.receiver = PacketReceiver(self.socket, OPERATIONS_DICT, self.hass)
+
+        self.connection_made = self.receiver.connection_made
+        self.datagram_received = self.receiver.datagram_received

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/PacketReceiver.py

@@ -0,0 +1,37 @@
+from TISControlProtocol.BytesHelper import *  # noqa: F403
+from socket import socket
+from TISControlProtocol.Protocols.udp.PacketExtractor import PacketExtractor
+from TISControlProtocol.Protocols.udp.PacketDispatcher import PacketDispatcher
+import logging
+from homeassistant.core import HomeAssistant  # type: ignore
+
+
+# PacketReceiver.py
+class PacketReceiver:
+    def __init__(
+        self,
+        socket: socket,
+        OPERATIONS_DICT: dict,
+        hass: HomeAssistant,
+    ):
+        self.socket = socket
+        self._hass = hass
+        self.dispatcher = PacketDispatcher(self._hass, OPERATIONS_DICT)
+        self.transport = None
+        self
+
+    def connection_made(self, transport):
+        self.transport = transport
+        logging.error("connection made")
+
+    def datagram_received(self, data, addr):
+        # logging.error(f"datagram received {data} from {addr}")
+        try:
+            hex = bytes2hex(data, [])  # noqa: F405
+            logging.warning(f"recieved packet {hex}")
+            info = PacketExtractor.extract_info(hex)
+            # dispatch the packet to the appropriate method according to the info
+            self._hass.async_create_task(self.dispatcher.dispatch_packet(info))
+
+        except Exception as e:
+            logging.error(f"Error in datagram_received: {e}, info: {info}")

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/PacketSender.py

@@ -0,0 +1,92 @@
+from socket import socket
+from TISControlProtocol.Protocols.udp.AckCoordinator import AckCoordinator
+import asyncio
+from abc import ABC, abstractmethod
+from TISControlProtocol.shared import ack_events  # noqa: F401
+import logging
+
+
+class IPacketSender(ABC):
+    @abstractmethod
+    async def send_packet(self, packet):
+        pass
+
+    @abstractmethod
+    async def send_packet_with_ack(
+        self,
+        packet: list,
+        packet_dict: dict = None,
+        channel_number: int = None,
+        attempts: int = 3,
+        timeout: float = 5.0,
+    ):
+        pass
+
+
+# PacketSender.py
+class PacketSender:
+    def __init__(self, socket: socket, coordinator: AckCoordinator, UDP_IP, UDP_PORT):
+        self.UDP_IP = UDP_IP
+        self.UDP_PORT = UDP_PORT
+        self.socket = socket
+        self.coordinator = coordinator
+        self.command_stacks = {}  # Holds the command stacks
+        self.last_command_times = {}  # Holds the last command times for debouncing
+
+    async def send_packet(self, packet: list):
+        print(f"sending {packet}")
+        self.socket.sendto(bytes(packet), (self.UDP_IP, self.UDP_PORT))
+
+    async def send_packet_with_ack(
+        self,
+        packet: list,
+        packet_dict: dict = None,
+        channel_number: int = None,
+        attempts: int = 10,
+        timeout: float = 0.5,
+        debounce_time: float = 0.5,  # The debounce time in seconds
+    ):
+        unique_id = (
+            tuple(packet_dict["device_id"]),
+            tuple(packet_dict["operation_code"]),
+            channel_number,
+        )
+
+        # Add the command to the stack for this unique ID
+        if unique_id not in self.command_stacks:
+            self.command_stacks[unique_id] = []
+        self.command_stacks[unique_id].append(packet)
+
+        # Only process the last command in the stack
+        if packet != self.command_stacks[unique_id][-1]:
+            return
+
+        # If the command is being called too quickly after the last one, ignore it
+        if (
+            unique_id in self.last_command_times
+            and asyncio.get_event_loop().time() - self.last_command_times[unique_id]
+            < debounce_time
+        ):
+            return
+
+        self.last_command_times[unique_id] = asyncio.get_event_loop().time()
+
+        event = self.coordinator.create_ack_event(unique_id)
+
+        for attempt in range(attempts):
+            await self.send_packet(packet)
+            try:
+                await asyncio.wait_for(event.wait(), timeout)
+                logging.error(f"ack received for {unique_id}")
+                # Remove the command from the stack after it's processed
+                self.command_stacks[unique_id].remove(packet)
+                return True
+            except asyncio.TimeoutError:
+                print(
+                    f"ack not received within {timeout} seconds, attempt {attempt + 1}"
+                )
+                logging.error(f"ack not received within {timeout} seconds")
+
+        self.coordinator.remove_ack_event(unique_id)
+        logging.error(f"ack not received after {attempts} attempts")
+        return False

tiscontrolprotocol-0.0.4/src/TISControlProtocol/Protocols/udp/__init__.py

@@ -0,0 +1,6 @@
+from TISControlProtocol.Protocols.udp.PacketHandlers.BinaryFeedbackHandler import (
+    handle_binary_feedback,  # noqa: F401
+)
+from TISControlProtocol.Protocols.udp.PacketHandlers.ControlResponseHandler import (
+    handle_control_response,  # noqa: F401
+)

tiscontrolprotocol-0.0.4/src/TISControlProtocol/crc.py

@@ -0,0 +1,306 @@
+from ctypes import *
+
+# -------------------------------------- #
+CRC_TAB = [
+    0x0000,
+    0x1021,
+    0x2042,
+    0x3063,
+    0x4084,
+    0x50A5,
+    0x60C6,
+    0x70E7,
+    0x8108,
+    0x9129,
+    0xA14A,
+    0xB16B,
+    0xC18C,
+    0xD1AD,
+    0xE1CE,
+    0xF1EF,
+    0x1231,
+    0x0210,
+    0x3273,
+    0x2252,
+    0x52B5,
+    0x4294,
+    0x72F7,
+    0x62D6,
+    0x9339,
+    0x8318,
+    0xB37B,
+    0xA35A,
+    0xD3BD,
+    0xC39C,
+    0xF3FF,
+    0xE3DE,
+    0x2462,
+    0x3443,
+    0x0420,
+    0x1401,
+    0x64E6,
+    0x74C7,
+    0x44A4,
+    0x5485,
+    0xA56A,
+    0xB54B,
+    0x8528,
+    0x9509,
+    0xE5EE,
+    0xF5CF,
+    0xC5AC,
+    0xD58D,
+    0x3653,
+    0x2672,
+    0x1611,
+    0x0630,
+    0x76D7,
+    0x66F6,
+    0x5695,
+    0x46B4,
+    0xB75B,
+    0xA77A,
+    0x9719,
+    0x8738,
+    0xF7DF,
+    0xE7FE,
+    0xD79D,
+    0xC7BC,
+    0x48C4,
+    0x58E5,
+    0x6886,
+    0x78A7,
+    0x0840,
+    0x1861,
+    0x2802,
+    0x3823,
+    0xC9CC,
+    0xD9ED,
+    0xE98E,
+    0xF9AF,
+    0x8948,
+    0x9969,
+    0xA90A,
+    0xB92B,
+    0x5AF5,
+    0x4AD4,
+    0x7AB7,
+    0x6A96,
+    0x1A71,
+    0x0A50,
+    0x3A33,
+    0x2A12,
+    0xDBFD,
+    0xCBDC,
+    0xFBBF,
+    0xEB9E,
+    0x9B79,
+    0x8B58,
+    0xBB3B,
+    0xAB1A,
+    0x6CA6,
+    0x7C87,
+    0x4CE4,
+    0x5CC5,
+    0x2C22,
+    0x3C03,
+    0x0C60,
+    0x1C41,
+    0xEDAE,
+    0xFD8F,
+    0xCDEC,
+    0xDDCD,
+    0xAD2A,
+    0xBD0B,
+    0x8D68,
+    0x9D49,
+    0x7E97,
+    0x6EB6,
+    0x5ED5,
+    0x4EF4,
+    0x3E13,
+    0x2E32,
+    0x1E51,
+    0x0E70,
+    0xFF9F,
+    0xEFBE,
+    0xDFDD,
+    0xCFFC,
+    0xBF1B,
+    0xAF3A,
+    0x9F59,
+    0x8F78,
+    0x9188,
+    0x81A9,
+    0xB1CA,
+    0xA1EB,
+    0xD10C,
+    0xC12D,
+    0xF14E,
+    0xE16F,
+    0x1080,
+    0x00A1,
+    0x30C2,
+    0x20E3,
+    0x5004,
+    0x4025,
+    0x7046,
+    0x6067,
+    0x83B9,
+    0x9398,
+    0xA3FB,
+    0xB3DA,
+    0xC33D,
+    0xD31C,
+    0xE37F,
+    0xF35E,
+    0x02B1,
+    0x1290,
+    0x22F3,
+    0x32D2,
+    0x4235,
+    0x5214,
+    0x6277,
+    0x7256,
+    0xB5EA,
+    0xA5CB,
+    0x95A8,
+    0x8589,
+    0xF56E,
+    0xE54F,
+    0xD52C,
+    0xC50D,
+    0x34E2,
+    0x24C3,
+    0x14A0,
+    0x0481,
+    0x7466,
+    0x6447,
+    0x5424,
+    0x4405,
+    0xA7DB,
+    0xB7FA,
+    0x8799,
+    0x97B8,
+    0xE75F,
+    0xF77E,
+    0xC71D,
+    0xD73C,
+    0x26D3,
+    0x36F2,
+    0x0691,
+    0x16B0,
+    0x6657,
+    0x7676,
+    0x4615,
+    0x5634,
+    0xD94C,
+    0xC96D,
+    0xF90E,
+    0xE92F,
+    0x99C8,
+    0x89E9,
+    0xB98A,
+    0xA9AB,
+    0x5844,
+    0x4865,
+    0x7806,
+    0x6827,
+    0x18C0,
+    0x08E1,
+    0x3882,
+    0x28A3,
+    0xCB7D,
+    0xDB5C,
+    0xEB3F,
+    0xFB1E,
+    0x8BF9,
+    0x9BD8,
+    0xABBB,
+    0xBB9A,
+    0x4A75,
+    0x5A54,
+    0x6A37,
+    0x7A16,
+    0x0AF1,
+    0x1AD0,
+    0x2AB3,
+    0x3A92,
+    0xFD2E,
+    0xED0F,
+    0xDD6C,
+    0xCD4D,
+    0xBDAA,
+    0xAD8B,
+    0x9DE8,
+    0x8DC9,
+    0x7C26,
+    0x6C07,
+    0x5C64,
+    0x4C45,
+    0x3CA2,
+    0x2C83,
+    0x1CE0,
+    0x0CC1,
+    0xEF1F,
+    0xFF3E,
+    0xCF5D,
+    0xDF7C,
+    0xAF9B,
+    0xBFBA,
+    0x8FD9,
+    0x9FF8,
+    0x6E17,
+    0x7E36,
+    0x4E55,
+    0x5E74,
+    0x2E93,
+    0x3EB2,
+    0x0ED1,
+    0x1EF0,
+]
+
+
+# -------------------------------------- #
+def bytes(intParam):
+    return divmod(intParam, 0x100)
+
+
+# -------------------------------------- #
+def packCRC(ptr):
+    crc = c_ushort(0)
+    for i in range(len(ptr) - 16):
+        data = c_ubyte(crc.value >> 8)
+        crc.value <<= 8
+        reg = c_ubyte(data.value ^ ptr[i + 16])
+        crc = c_ushort(crc.value ^ CRC_TAB[reg.value])
+    crcValueH, crcValueL = bytes(crc.value)
+    ptr.append(crcValueH)
+    ptr.append(crcValueL)
+    return ptr
+
+
+# -------------------------------------- #
+def checkCRC(ptr):
+    crcValueL = ptr.pop()
+    crcValueH = ptr.pop()
+    targPtr = packCRC(ptr)
+    if (targPtr[len(targPtr) - 1] == crcValueL) and (
+        targPtr[len(targPtr) - 2] == crcValueH
+    ):
+        return True
+    else:
+        return False
+
+
+# -------------------------------------- #
+# toPack = [0x0f,0x01,0xfe,0xff,0xfe,0x00,0x31,0x01,0x1f,0x01,0x64,0x00,0x00] # ,0x5d ,0x8f]
+# toCheck = [0x0f,0x01,0xfe,0xff,0xfe,0x00,0x31,0x01,0x1f,0x01,0x64,0x00,0x00, 0x5d,0x8f]
+# toPack = [0x0F, 0xBB, 0xBB, 0xCC, 0xB1, 0x00, 0x31, 0x01, 0x2b, 0x02, 0x64, 0x00, 0x00]
+# toCheck = [0x0F, 0xBB, 0xBB, 0xCC, 0xB1, 0x00, 0x31, 0x01, 0x2b, 0x02, 0x64, 0x00, 0x00, 0xBB, 0xAA]
+# checkCRC(toCheck)
+# toPack = [0x0f,0xbb,0xbb,0xcc,0xb1,0x00,0x31,0x01,0x2b,0x03,0x64,0x00,0x00]
+# toCheck = [0x0f,0xbb,0xbb,0xcc,0xb1,0x00,0x31,0x01,0x2b,0x03,0x64,0x00,0x00,0xcd,0x1e]
+# toCheck = [0xc0,0xa8,0x01,0x05,0x53,0x4d,0x41,0x52,0x54,0x43,0x4c,0x4f,0x55,0x44,0xaa,0xaa,0x0f,0xbb,0xbb,0xcc,0xb1,0x00,0x31,0x01,0x2b,0x03,0x64,0x00,0x00,0xcd,0x1e]
+# checkCRC(toCheck)
+# -------------------------------------- #

tiscontrolprotocol-0.0.4/src/TISControlProtocol/shared.py

@@ -0,0 +1,21 @@
+appliances_dict = {}
+mqtt_appliances_dict = {}
+ack_events = {}
+loggers = {}
+
+
+def get_appliance(device_id: tuple, channel: tuple, appliances_dict: dict):
+    # appliance key form is ((device_id),(channels))
+    try:
+        device_appliances = [
+            a
+            for k, a in appliances_dict.items()
+            if k[0] == device_id and channel in k[1]
+        ]
+        return tuple(device_appliances)[0]
+    except IndexError:
+        print(f"No appliances found for key {(device_id,channel)}")
+        return None
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return None

tiscontrolprotocol-0.0.4/tests/test.py

@@ -0,0 +1,13 @@
+from TISControlProtocol.BytesHelper import build_packet
+
+x = build_packet(
+    [0x01, 0x01],
+    "1111.111.1.1",
+    "11:11:11:11:11:11:11:11",
+    "11:11:11:11:11:11:11:11",
+    [0x01, 0x01],
+    [0x01, 0x01],
+    [0x01, 0x01],
+)
+
+print(x)