pygryfsmart 0.1.0__tar.gz

pygryfsmart-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Gryf Smart
+
+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.

pygryfsmart-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE
+include README.md

pygryfsmart-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.2
+Name: pygryfsmart
+Version: 0.1.0
+Summary: Library for the GryfSmart system
+Home-page: https://github.com/karlowiczpl/pygryfsmart
+Author: @karlowiczpl
+Author-email: k.karlowski@outlook.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: pyserial
+Requires-Dist: pyserial-asyncio
+
+#Gryf smart system lib
+

pygryfsmart-0.1.0/README.md

@@ -0,0 +1,2 @@
+#Gryf smart system lib
+

pygryfsmart-0.1.0/pygryfsmart/__init__.py

@@ -0,0 +1 @@
+"""GRYF SMART LIB"""

pygryfsmart-0.1.0/pygryfsmart/const.py

@@ -0,0 +1,38 @@
+from enum import IntEnum
+
+BAUDRATE = 115200
+
+class OUTPUT_STATES(IntEnum):
+    ON = 1
+    OFF = 2
+    TOGGLE = 3
+
+class SCHUTTER_STATES(IntEnum):
+    CLOSE = 1
+    OPEN = 2
+    STOP = 3
+    STEP_MODE = 4
+
+class KEY_MODE(IntEnum):
+    NO = 0
+    NC = 1
+
+COMMAND_FUNCTION_IN = "I"
+COMMAND_FUNCTION_OUT = "O"
+COMMAND_FUNCTION_PWM = "LED"
+COMMAND_FUNCTION_COVER = "R"
+COMMAND_FUNCTION_FIND = "AT+FIND"
+COMMAND_FUNCTION_PONG = "PONG"
+COMMAND_FUNCTION_PRESS_SHORT = "PS"
+COMMAND_FUNCTION_PRESS_LONG = "PL"
+COMMAND_FUNCTION_TEMP = "T"
+
+COMMAND_FUNCTION_GET_IN_STATE = "AT+StanIN"
+COMMAND_FUNCTION_GET_OUT_STATE = "AT+StanOUT"
+COMMAND_FUNCTION_SET_OUT = "AT+SetOut"
+COMMAND_FUNCTION_SET_COVER = "AT+SetRol"
+COMMAND_FUNCTION_SET_PWM = "AT+SetLED"
+COMMAND_FUNCTION_PING = "PING"
+COMMAND_FUNCTION_SET_PRESS_TIME = "AT+Key"
+COMMADN_FUNCTION_SEARCH_MODULE = "AT+Search"
+COMMAND_FUNCTION_RESET = "AT+RST"

pygryfsmart-0.1.0/pygryfsmart/device.py

@@ -0,0 +1,164 @@
+from pygryfsmart.feedback import Feedback
+from pygryfsmart.rs232 import RS232Handler
+from pygryfsmart.const import (
+    BAUDRATE,
+    KEY_MODE,
+    OUTPUT_STATES,
+    SCHUTTER_STATES,
+
+    COMMAND_FUNCTION_IN,
+    COMMAND_FUNCTION_OUT,
+
+    COMMAND_FUNCTION_GET_IN_STATE,
+    COMMAND_FUNCTION_GET_OUT_STATE,
+    COMMAND_FUNCTION_SET_OUT,
+    COMMAND_FUNCTION_SET_COVER,
+    COMMAND_FUNCTION_SET_PWM,
+    COMMAND_FUNCTION_PING,
+    COMMAND_FUNCTION_SET_PRESS_TIME,
+    COMMADN_FUNCTION_SEARCH_MODULE,
+)
+
+import asyncio
+import logging
+
+
+_LOGGER = logging.getLogger(__name__)
+
+class Device(RS232Handler):
+    def __init__(self, port , callback = None):
+        super().__init__(port, BAUDRATE)
+        self.feedback = Feedback(callback=callback)
+
+        self._update_task = None
+        self._connection_task = None
+        self._last_ping = 0
+
+    def set_callback(self , callback):
+        self.feedback.callback = callback
+
+    async def stop_connection(self):
+        if self._connection_task:
+            self._connection_task.cancel()
+            try:
+                await self._connection_task
+            except asyncio.CancelledError:
+                _LOGGER.debug("Connection task was cancelled.")
+        if self._update_task:
+            self._update_task.cancel()
+            try:
+                await self._update_task
+            except asyncio.CancelledError:
+                _LOGGER.debug("Update task was cancelled.")
+        await self.close_connection()
+        _LOGGER.debug("Connection closed.")
+
+    async def __connection_task(self):
+        try:
+            while True:
+                line = await super().read_data()
+                _LOGGER.debug(f"Received data: {line}")
+                await self.feedback.input_data(line)
+        except asyncio.CancelledError:
+            _LOGGER.info("Connection task cancelled.")
+            await self.close_connection()
+            raise
+        except Exception as e:
+            _LOGGER.error(f"Error in connection task: {e}")
+            await self.close_connection()
+            raise
+
+    async def start_connection(self):
+        await super().open_connection()
+        self._connection_task = asyncio.create_task(self.__connection_task())
+        _LOGGER.info("Connection task started.")
+
+    async def send_data(self, data):
+        await super().send_data(data)
+
+    async def set_out(self, id: int, pin: int , state: OUTPUT_STATES | int):
+        states = ["0"] * 8 if pin > 6 else ["0"] * 6
+        states[pin - 1] = str(state)
+
+        command = f"{COMMAND_FUNCTION_SET_OUT}={id}," + ",".join(states) + "\n\r"
+        await self.send_data(command)
+
+    async def set_key_time(self , ps_time: int , pl_time: int , id: int , pin: int , type: KEY_MODE | int):
+        command = f"{COMMAND_FUNCTION_SET_PRESS_TIME}={id},{pin},{ps_time},{pl_time},{type}\n\r"
+        await self.send_data(command)
+
+    async def search_module(self , id: int):
+        if id != 0:
+            command = f"{COMMADN_FUNCTION_SEARCH_MODULE}=0,{id}\n\r"
+            await self.send_data(command)
+
+    async def search_modules(self , last_module: int):
+        for i in range(last_module):
+            command = f"{COMMADN_FUNCTION_SEARCH_MODULE}=0,{i + 1}\n\r"
+            await self.send_data(command)
+
+    async def ping(self , module_id: int):
+        command = f"{COMMAND_FUNCTION_PING}={module_id}\n\r"
+        await self.send_data(command)
+        await asyncio.sleep(0.05)
+        if self._last_ping == module_id:
+            self._last_ping = 0
+            return True
+        self._last_ping = 0
+        return False
+    
+    async def set_pwm(self , id: int , pin: int , level: int):
+        command = f"{COMMAND_FUNCTION_SET_PWM}={id},{pin},{level}\n\r"
+        await self.send_data(command)
+
+    async def set_cover(self , id: int , pin: int , time: int , operation: SCHUTTER_STATES | int):
+        if operation in {SCHUTTER_STATES.CLOSE , SCHUTTER_STATES.OPEN , SCHUTTER_STATES.STOP , SCHUTTER_STATES.STEP_MODE} and pin in {1 , 2 , 3 , 4}:
+            states = ["0"] * 4
+            states[pin - 1] = str(operation)
+            control_sum = id + time + int(states[0]) + int(states[1]) + int(states[2]) + int(states[3])
+
+            command = f"{COMMAND_FUNCTION_SET_COVER}={id},{time},{states[0]},{states[1]},{states[2]},{states[3]},{control_sum}\n\r"
+            await self.send_data(command)
+        else:
+            raise ValueError(f"Argument out of scope: id: {id} , pin: {pin} , time: {time}, operation: {operation}")
+
+    async def reset(self , module_id: int , update_states: bool):
+        if module_id == 0:
+            command = "AT+RST=0\n\r"
+            await self.send_data(command)
+            if update_states == True:
+                module_count = len(self.feedback.data[COMMAND_FUNCTION_OUT])
+                await asyncio.sleep(2)
+                states = self.feedback.data[COMMAND_FUNCTION_OUT]
+                for i in range(module_count):
+                    tabble = list(self.feedback.data[COMMAND_FUNCTION_OUT][i+1].values())
+                    states = ",".join(map(str, tabble))
+                    command = f"AT+SetOut={i+1},{states}\n\r"
+                    await self.send_data(command)
+
+    def start_update_interval(self, time: int):
+        if not self._update_task:
+            self._update_task = asyncio.create_task(self.__states_update_interval(time))
+            _LOGGER.info("Update interval task started.")
+
+    async def __states_update_interval(self, time: int):
+        try:
+            while True:
+                module_count = max(len(self.feedback.data[COMMAND_FUNCTION_IN]), len(self.feedback.data[COMMAND_FUNCTION_OUT]))
+
+                for i in range(module_count):
+                    try:
+                        command = f"{COMMAND_FUNCTION_GET_IN_STATE}={i + 1}\n\r"
+                        await self.send_data(command)
+                        await asyncio.sleep(0.1)
+
+                        command = f"{COMMAND_FUNCTION_GET_OUT_STATE}={i + 1}\n\r"
+                        await self.send_data(command)
+                    except Exception as e:
+                        _LOGGER.error(f"Error updating module {i + 1}: {e}")
+
+                await asyncio.sleep(time)
+        except asyncio.CancelledError:
+            _LOGGER.info("Update interval task cancelled.")
+        except Exception as e:
+            _LOGGER.error(f"Error in update interval: {e}")

pygryfsmart-0.1.0/pygryfsmart/feedback.py

@@ -0,0 +1,130 @@
+import logging
+from datetime import datetime
+
+from pygryfsmart.const import (
+    COMMAND_FUNCTION_IN,
+    COMMAND_FUNCTION_OUT,
+    COMMAND_FUNCTION_PWM,
+    COMMAND_FUNCTION_COVER,
+    COMMAND_FUNCTION_FIND,
+    COMMAND_FUNCTION_PONG,
+    COMMAND_FUNCTION_PRESS_SHORT,
+    COMMAND_FUNCTION_PRESS_LONG,
+    COMMAND_FUNCTION_TEMP,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+class Feedback:
+    def __init__(self , callback=None) -> None:
+        self.callback = callback
+        self._data = {
+            COMMAND_FUNCTION_IN: {},
+            COMMAND_FUNCTION_OUT: {},
+            COMMAND_FUNCTION_PWM: {},
+            COMMAND_FUNCTION_COVER: {},
+            COMMAND_FUNCTION_FIND: {},
+            COMMAND_FUNCTION_PONG: {},
+            COMMAND_FUNCTION_TEMP: {},
+        }
+    
+    @property
+    def data(self):
+        return self._data
+
+    async def __parse_metod_1(self , parsed_states , line: str , function: str):
+        if len(parsed_states) not in {7 , 9}:
+            raise ValueError(f"Invalid number of arguments: {line}")
+
+        for i in range(1, len(parsed_states)):
+            if parsed_states[i] not in {"0" , "1"}:
+                raise ValueError(f"Wrong parameter value: {line}")
+
+            pin = int(parsed_states[0])
+            if pin not in self._data[function]:
+                self._data[function][pin] = {}
+            self._data[function][pin][i] = int(parsed_states[i])                   
+
+    async def __parse_metod_2(self , parsed_states , line: str , function: str , prefix: int):
+        if parsed_states[0] not in {"1" , "2" , "3" , "4" , "5" , "6" , "7" , "8"}:
+            raise ValueError(f"Argument out of scope: {line}")
+
+        pin = int(parsed_states[1])
+        id = int(parsed_states[0])
+        if id not in self._data[function]:
+            self._data[function][id] = {}
+        self._data[function][id][pin] = prefix
+
+    async def __parse_metod_3(self , parsed_states , line: str , function: str):
+        if parsed_states[0] not in {"1" , "2" , "3" , "4" , "5" , "6" , "7" , "8"}:
+            raise ValueError(f"Argument out of scope: {line}")
+
+        pin = int(parsed_states[1])
+        id = int(parsed_states[0])
+        if id not in self._data[function]:
+            self._data[function][id] = {}
+        self._data[function][id][pin] = parsed_states[2]
+
+    async def __parse_cover(self , parsed_states , line: str , function: str):
+        if len(parsed_states) != 5:
+            raise ValueError(f"Invalid number of arguments: {line}")
+
+        for i in range(1, len(parsed_states)):
+            if parsed_states[i] not in {"0" , "1"}:
+                raise ValueError(f"Wrong parameter value: {line}")
+
+            pin = int(parsed_states[0])
+            if pin not in self._data[function]:
+                self._data[function][pin] = {}
+            self._data[function][pin][i] = int(parsed_states[i])                   
+
+    async def __parse_temp(self , parsed_states , line: str):
+        if parsed_states[0] not in {"1" , "2" , "3" , "4" , "5" , "6" , "7" , "8"}:
+            raise ValueError(f"Argument out of scope: {line}")
+
+        pin = int(parsed_states[1])
+        id = int(parsed_states[0])
+        if id not in self._data[COMMAND_FUNCTION_TEMP]:
+            self._data[COMMAND_FUNCTION_TEMP][id] = {}
+        self._data[COMMAND_FUNCTION_TEMP][id][pin] = float(f"{parsed_states[2]}.{parsed_states[3]}")
+
+    async def __parse_find(self , parsed_states):
+        id = int(parsed_states[0])
+        self._data[COMMAND_FUNCTION_FIND][id] = float(f"{parsed_states[1]}.{parsed_states[2]}")
+
+    async def __parse_pong(self , parsed_states):
+        now = datetime.now()
+
+        id = int(parsed_states[0])
+        self._data[COMMAND_FUNCTION_PONG][id] = now.strftime("%H:%M")
+
+
+    async def input_data(self , line):
+        if line == "??????????":
+            return
+        try:
+            parts = line.split('=')
+            parsed_states = parts[1].split(',')
+            last_state = parsed_states[-1].split(';')
+            parsed_states[-1] = last_state[0]
+            _LOGGER.debug(f"{parsed_states}")
+
+            COMMAND_MAPPER = {
+                COMMAND_FUNCTION_IN: lambda states , line : self.__parse_metod_1(states , line , COMMAND_FUNCTION_IN),
+                COMMAND_FUNCTION_OUT: lambda states , line : self.__parse_metod_1(states , line , COMMAND_FUNCTION_OUT),
+                COMMAND_FUNCTION_PRESS_SHORT: lambda states , line : self.__parse_metod_2(states , line , COMMAND_FUNCTION_IN , 2),
+                COMMAND_FUNCTION_PRESS_LONG: lambda states , line : self.__parse_metod_2(states , line , COMMAND_FUNCTION_IN , 3),
+                COMMAND_FUNCTION_TEMP: lambda states , line : self.__parse_temp(states , line),
+                COMMAND_FUNCTION_PWM: lambda states , line : self.__parse_metod_3(states , line , COMMAND_FUNCTION_PWM),
+                COMMAND_FUNCTION_COVER: lambda states , line : self.__parse_cover(states , line , COMMAND_FUNCTION_COVER),
+                COMMAND_FUNCTION_FIND: lambda states , line: self.__parse_find(states),
+                COMMAND_FUNCTION_PONG: lambda states , line: self.__parse_pong(states),
+            }
+
+            if str(parts[0]).upper() in COMMAND_MAPPER:
+                await COMMAND_MAPPER[str(parts[0]).upper()](parsed_states , line)
+
+            if self.callback:
+                await self.callback(self._data) 
+        except Exception as e:
+            _LOGGER.error(f"ERROR parsing data: {e}")

pygryfsmart-0.1.0/pygryfsmart/rs232.py

@@ -0,0 +1,55 @@
+import logging
+from serial_asyncio import open_serial_connection
+
+_LOGGER = logging.getLogger(__name__)
+
+class RS232Handler:
+    def __init__(self, port, baudrate):
+        self.port = port
+        self.baudrate = baudrate
+        self.reader = None
+        self.writer = None
+
+    async def open_connection(self):
+        try:
+            self.reader, self.writer = await open_serial_connection(url=self.port, baudrate=self.baudrate)
+            _LOGGER.info(f"Connection opened on port {self.port} with baudrate {self.baudrate}")
+        except Exception as e:
+            _LOGGER.error(f"Failed to open connection on port {self.port}: {e}")
+            self.reader, self.writer = None, None
+            raise
+
+    async def close_connection(self):
+        if self.writer:
+            try:
+                self.writer.close()
+                await self.writer.wait_closed()
+                _LOGGER.info("Connection closed successfully.")
+            except Exception as e:
+                _LOGGER.error(f"Error while closing connection: {e}")
+        else:
+            _LOGGER.warning("Connection was already closed or not initialized.")
+
+    async def send_data(self, data):
+        if self.writer:
+            try:
+                self.writer.write(data.encode())
+                await self.writer.drain()
+                _LOGGER.debug(f"Sent data: {data}")
+            except Exception as e:
+                _LOGGER.error(f"Error while sending data: {e}")
+        else:
+            _LOGGER.warning("Cannot send data: Writer is not initialized.")
+
+    async def read_data(self):
+        if self.reader:
+            try:
+                data = await self.reader.readuntil(b"\n")
+                _LOGGER.debug(f"Read data: {data.decode().strip()}")
+                return data.decode().strip()
+            except Exception as e:
+                _LOGGER.error(f"Error while reading data: {e}")
+                return None
+        else:
+            _LOGGER.warning("Cannot read data: Reader is not initialized.")
+            return None

pygryfsmart-0.1.0/pygryfsmart.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.2
+Name: pygryfsmart
+Version: 0.1.0
+Summary: Library for the GryfSmart system
+Home-page: https://github.com/karlowiczpl/pygryfsmart
+Author: @karlowiczpl
+Author-email: k.karlowski@outlook.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: pyserial
+Requires-Dist: pyserial-asyncio
+
+#Gryf smart system lib
+

pygryfsmart-0.1.0/pygryfsmart.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+pygryfsmart/__init__.py
+pygryfsmart/const.py
+pygryfsmart/device.py
+pygryfsmart/feedback.py
+pygryfsmart/rs232.py
+pygryfsmart.egg-info/PKG-INFO
+pygryfsmart.egg-info/SOURCES.txt
+pygryfsmart.egg-info/dependency_links.txt
+pygryfsmart.egg-info/requires.txt
+pygryfsmart.egg-info/top_level.txt
+tests/__init__.py
+tests/test_feedback.py
+tests/test_rs232.py

pygryfsmart-0.1.0/pygryfsmart.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pygryfsmart-0.1.0/pygryfsmart.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pyserial
+pyserial-asyncio

pygryfsmart-0.1.0/pygryfsmart.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+pygryfsmart
+tests

pygryfsmart-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"

pygryfsmart-0.1.0/setup.cfg

@@ -0,0 +1,24 @@
+[metadata]
+name = pygryfsmart
+version = 0.1.0
+author = @karlowiczpl
+author_email = k.karlowski@outlook.com
+description = Library for the GryfSmart system
+long_description = file: README.md
+url = https://github.com/karlowiczpl/pygryfsmart
+license = MIT
+classifiers = 
+	Programming Language :: Python :: 3
+	Operating System :: OS Independent
+
+[options]
+packages = find:
+python_requires = >=3.8
+install_requires = 
+	pyserial
+	pyserial-asyncio
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

pygryfsmart-0.1.0/tests/test_feedback.py

@@ -0,0 +1,111 @@
+import pytest
+from unittest.mock import AsyncMock
+from pygryfsmart.feedback import Feedback
+from pygryfsmart.const import (
+    COMMAND_FUNCTION_IN,
+    COMMAND_FUNCTION_OUT,
+    COMMAND_FUNCTION_PWM,
+    COMMAND_FUNCTION_COVER,
+    COMMAND_FUNCTION_FIND,
+    COMMAND_FUNCTION_PONG,
+    COMMAND_FUNCTION_PRESS_SHORT,
+    COMMAND_FUNCTION_PRESS_LONG,
+    COMMAND_FUNCTION_TEMP,
+)
+
+
+@pytest.fixture
+def feedback():
+    return Feedback()
+
+
+@pytest.mark.asyncio
+async def test_parse_metod_1(feedback):
+    line = "IN=1,1,0,1,0,1,0,1;"
+    parsed_states = ["1", "1", "0", "1", "0", "1", "0", "1" , "1"]
+    await feedback._Feedback__parse_metod_1(parsed_states, line, COMMAND_FUNCTION_IN)
+
+    assert feedback.data[COMMAND_FUNCTION_IN][1] == {1: 1, 2: 0, 3: 1, 4: 0, 5: 1, 6: 0, 7: 1, 8: 1}
+
+
+@pytest.mark.asyncio
+async def test_parse_metod_2(feedback):
+    line = "PS=2,3;"
+    parsed_states = ["2", "3"]
+    await feedback._Feedback__parse_metod_2(parsed_states, line, COMMAND_FUNCTION_PRESS_SHORT, 2)
+    
+    assert feedback.data[COMMAND_FUNCTION_PRESS_SHORT][2][3] == 2
+
+
+@pytest.mark.asyncio
+async def test_parse_metod_3(feedback):
+    line = "PWM=3,2,255;"
+    parsed_states = ["3", "2", "255"]
+    await feedback._Feedback__parse_metod_3(parsed_states, line, COMMAND_FUNCTION_PWM)
+
+    assert feedback.data[COMMAND_FUNCTION_PWM][3][2] == "255" 
+
+
+@pytest.mark.asyncio
+async def test_parse_cover(feedback):
+    line = "COVER=4,1,0,1,0;"
+    parsed_states = ["4", "1", "0", "1", "0"]
+    await feedback._Feedback__parse_cover(parsed_states, line, COMMAND_FUNCTION_COVER)
+
+    assert feedback.data[COMMAND_FUNCTION_COVER][4] == {1: 1, 2: 0, 3: 1, 4: 0}
+
+
+@pytest.mark.asyncio
+async def test_parse_temp(feedback):
+    line = "TEMP=5,2,25,5;"
+    parsed_states = ["5", "2", "25", "5"]
+    await feedback._Feedback__parse_temp(parsed_states, line)
+
+    assert feedback.data[COMMAND_FUNCTION_TEMP][5] == {2: 25.5}
+
+
+@pytest.mark.asyncio
+async def test_parse_find(feedback):
+    parsed_states = ["6", "123", "45"]
+    await feedback._Feedback__parse_find(parsed_states)
+
+    assert feedback.data[COMMAND_FUNCTION_FIND][6] == 123.45
+
+@pytest.mark.asyncio
+async def test_input_data_valid(feedback):
+    callback = AsyncMock()
+    feedback.callback = callback
+
+    line = "IN=1,1,0,1,0,1,0,1;"
+    await feedback.input_data(line)
+
+    assert feedback.data == {
+        COMMAND_FUNCTION_IN: {},
+        COMMAND_FUNCTION_OUT: {},
+        COMMAND_FUNCTION_PWM: {},
+        COMMAND_FUNCTION_COVER: {},
+        COMMAND_FUNCTION_FIND: {},
+        COMMAND_FUNCTION_PONG: {},
+        COMMAND_FUNCTION_TEMP: {},
+        COMMAND_FUNCTION_PRESS_SHORT: {},
+        COMMAND_FUNCTION_PRESS_LONG: {},
+    }
+
+@pytest.mark.asyncio
+async def test_input_data_invalid_command(feedback):
+    line = "INVALID=1,1,0,1;"
+    await feedback.input_data(line)
+
+    # Brak zmian w danych, ponieważ komenda jest nieznana
+    assert feedback.data == {
+        COMMAND_FUNCTION_IN: {},
+        COMMAND_FUNCTION_OUT: {},
+        COMMAND_FUNCTION_PWM: {},
+        COMMAND_FUNCTION_COVER: {},
+        COMMAND_FUNCTION_FIND: {},
+        COMMAND_FUNCTION_PONG: {},
+        COMMAND_FUNCTION_TEMP: {},
+        COMMAND_FUNCTION_PRESS_SHORT: {},
+        COMMAND_FUNCTION_PRESS_LONG: {},
+    }
+

pygryfsmart-0.1.0/tests/test_rs232.py

@@ -0,0 +1,47 @@
+import pytest
+from unittest.mock import AsyncMock, patch
+from pygryfsmart.rs232 import RS232Handler
+
+@pytest.fixture
+def rs232_handler():
+    return RS232Handler(port="/dev/ttyUSB0", baudrate=115200)
+pytest.mark.asyncio
+@patch("serial_asyncio.open_serial_connection")
+async def test_open_connection(mock_open_serial):
+    mock_reader = AsyncMock()
+    mock_writer = AsyncMock()
+    mock_open_serial.return_value = (mock_reader, mock_writer)
+
+    rs232_handler = RS232Handler(port="/dev/ttyUSB0", baudrate=115200)
+
+    await rs232_handler.open_connection()
+
+    mock_open_serial.assert_called_once_with(url="/dev/ttyUSB0", baudrate=115200)
+    mock_writer = AsyncMock()
+    rs232_handler.writer = mock_writer
+
+    await rs232_handler.close_connection()
+
+    mock_writer.close.assert_called_once()
+    await mock_writer.wait_closed()
+
+@pytest.mark.asyncio
+async def test_send_data(rs232_handler):
+    mock_writer = AsyncMock()
+    rs232_handler.writer = mock_writer
+
+    await rs232_handler.send_data("Test data")
+
+    mock_writer.write.assert_called_once_with(b"Test data")
+    await mock_writer.drain()
+
+@pytest.mark.asyncio
+async def test_read_data(rs232_handler):
+    mock_reader = AsyncMock()
+    mock_reader.readuntil = AsyncMock(return_value=b"Test data\n")
+    rs232_handler.reader = mock_reader
+
+    data = await rs232_handler.read_data()
+
+    assert data == "Test data"
+    mock_reader.readuntil.assert_called_once_with(b"\n")