pypck 0.8.4__tar.gz → 0.8.6__tar.gz

{pypck-0.8.4/pypck.egg-info → pypck-0.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pypck
-Version: 0.8.4
+Version: 0.8.6
 Summary: LCN-PCK library
 Home-page: https://github.com/alengwenus/pypck
 Author-email: Andre Lengwenus <alengwenus@gmail.com>
@@ -18,6 +18,7 @@ Classifier: Topic :: Home Automation
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: license-file
 
 # pypck - Asynchronous LCN-PCK library written in Python
 

pypck-0.8.6/VERSION

@@ -0,0 +1 @@
+0.8.6

{pypck-0.8.4 → pypck-0.8.6}/pypck/connection.py

@@ -181,10 +181,8 @@ class PchkConnectionManager:
                         )
                         continue
                 await self.process_message(message)
-        except asyncio.CancelledError:
-            pass
-
-        _LOGGER.debug("Read data loop closed")
+        finally:
+            _LOGGER.debug("Read data loop closed")
 
     async def write_data_loop(self) -> None:
         """Processes queue and writes data."""
@@ -204,14 +202,11 @@ class PchkConnectionManager:
                 self.writer.write(data)
                 await self.writer.drain()
                 self.last_bus_activity = time.time()
-        except asyncio.CancelledError:
-            pass
-
-        # empty the queue
-        while not self.buffer.empty():
-            await self.buffer.get()
-
-        _LOGGER.debug("Write data loop closed")
+        finally:
+            # empty the queue
+            while not self.buffer.empty():
+                await self.buffer.get()
+            _LOGGER.debug("Write data loop closed")
 
     # Open/close connection, authentication & setup.
 

{pypck-0.8.4 → pypck-0.8.6}/pypck/inputs.py

@@ -398,8 +398,10 @@ class ModSn(ModInput):
                 ValueError
             ):  # unconventional manufacturer code (e.g., due to LinHK VM)
                 manu = 0xFF
-                _LOGGER.debug(
-                    "Unconventional manufacturer code: %s. Defaulting to 0x%02X",
+                _LOGGER.warning(
+                    "Unconventional manufacturer code for module (S%d, M%d): %s. Defaulting to 0x%02X",
+                    addr.seg_id,
+                    addr.addr_id,
                     matcher.group("manu"),
                     manu,
                 )
@@ -596,7 +598,10 @@ class ModStatusOutputNative(ModInput):
 
 
 class ModStatusRelays(ModInput):
-    """Status of 8 relays received from an LCN module."""
+    """Status of 8 relays received from an LCN module.
+
+    Includes helper functions for motor states based on LCN wiring.
+    """
 
     def __init__(self, physical_source_addr: LcnAddr, states: list[bool]):
         """Construct ModInput object."""
@@ -614,6 +619,43 @@ class ModStatusRelays(ModInput):
         """
         return self.states[relay_id]
 
+    def get_motor_onoff_relay(self, motor_id: int) -> int:
+        """Get the motor on/off relay id."""
+        if 0 > motor_id > 3:
+            raise ValueError("Motor id must be in range 0..3")
+        return motor_id * 2
+
+    def get_motor_updown_relay(self, motor_id: int) -> int:
+        """Get the motor up/down relay id."""
+        if 0 > motor_id > 3:
+            raise ValueError("Motor id must be in range 0..3")
+        return motor_id * 2 + 1
+
+    def motor_is_on(self, motor_id: int) -> bool:
+        """Check if a motor is on."""
+        return self.states[self.get_motor_onoff_relay(motor_id)]
+
+    def is_opening(self, motor_id: int) -> bool:
+        """Check if a motor is opening."""
+        if self.motor_is_on(motor_id):
+            return not self.states[self.get_motor_updown_relay(motor_id)]
+        return False
+
+    def is_closing(self, motor_id: int) -> bool:
+        """Check if a motor is closing."""
+        if self.motor_is_on(motor_id):
+            return self.states[self.get_motor_updown_relay(motor_id)]
+        return False
+
+    def is_assumed_closed(self, motor_id: int) -> bool:
+        """Check if a motor is closed.
+
+        The closed state is assumed if the motor direction is down and the motor is switched off."
+        """
+        if not self.motor_is_on(motor_id):
+            return self.states[self.get_motor_updown_relay(motor_id)]
+        return False
+
     @staticmethod
     def try_parse(data: str) -> list[Input] | None:
         """Try to parse the given input text.
@@ -1024,13 +1066,120 @@ class ModStatusSceneOutputs(ModInput):
         if matcher:
             addr = LcnAddr(int(matcher.group("seg_id")), int(matcher.group("mod_id")))
             scene_id = int(matcher.group("scene_id"))
-            values = [int(matcher.group(f"output{i+1:d}")) for i in range(4)]
-            ramps = [int(matcher.group(f"ramp{i+1:d}")) for i in range(4)]
+            values = [int(matcher.group(f"output{i + 1:d}")) for i in range(4)]
+            ramps = [int(matcher.group(f"ramp{i + 1:d}")) for i in range(4)]
             return [ModStatusSceneOutputs(addr, scene_id, values, ramps)]
 
         return None
 
 
+class ModStatusMotorPositionBS4(ModInput):
+    """Status of motor positions (if BS4 connected) received from an LCN module.
+
+    Position and limit is in percent. 0%: cover closed, 100%: cover open.
+    """
+
+    def __init__(
+        self,
+        physical_source_addr: LcnAddr,
+        motor: int,
+        position: float,
+        limit: float | None = None,
+        time_down: int | None = None,
+        time_up: int | None = None,
+    ):
+        """Construct ModInput object."""
+        super().__init__(physical_source_addr)
+        self.motor = motor
+        self.position = position
+        self.limit = limit
+        self.time_down = time_down
+        self.time_up = time_up
+
+    @staticmethod
+    def try_parse(data: str) -> list[Input] | None:
+        """Try to parse the given input text.
+
+        Will return a list of parsed Inputs. The list might be empty (but not
+        null).
+
+        :param    data    str:    The input data received from LCN-PCHK
+
+        :return:            The parsed Inputs (never null)
+        :rtype:             List with instances of :class:`~pypck.input.Input`
+        """
+        matcher = PckParser.PATTERN_STATUS_MOTOR_POSITION_BS4.match(data)
+        if matcher:
+            motor_status_inputs: list[Input] = []
+            addr = LcnAddr(int(matcher.group("seg_id")), int(matcher.group("mod_id")))
+            for idx in (1, 2):
+                motor = matcher.group(f"motor{idx}_id")
+                position = matcher.group(f"position{idx}")
+                limit = matcher.group(f"limit{idx}")
+                time_down = matcher.group(f"time_down{idx}")
+                time_up = matcher.group(f"time_up{idx}")
+
+                motor_status_inputs.append(
+                    ModStatusMotorPositionBS4(
+                        addr,
+                        int(motor) - 1,
+                        (200 - int(position)) / 2,
+                        None if limit == "?" else (200 - int(limit)) / 2,
+                        None if time_down == "?" else int(time_down),
+                        None if time_up == "?" else int(time_up),
+                    )
+                )
+            return motor_status_inputs
+
+        return None
+
+
+class ModStatusMotorPositionModule(ModInput):
+    """Status of motor positions received from an LCN module.
+
+    Position is in percent. 0%: cover closed, 100%: cover open.
+    """
+
+    def __init__(
+        self,
+        physical_source_addr: LcnAddr,
+        motor: int,
+        position: float,
+    ):
+        """Construct ModInput object."""
+        super().__init__(physical_source_addr)
+        self.motor = motor
+        self.position = position
+
+    @staticmethod
+    def try_parse(data: str) -> list[Input] | None:
+        """Try to parse the given input text.
+
+        Will return a list of parsed Inputs. The list might be empty (but not
+        null).
+
+        :param    data    str:    The input data received from LCN-PCHK
+
+        :return:            The parsed Inputs (never null)
+        :rtype:             List with instances of :class:`~pypck.input.Input`
+        """
+        matcher = PckParser.PATTERN_STATUS_MOTOR_POSITION_MODULE.match(data)
+        if matcher:
+            addr = LcnAddr(int(matcher.group("seg_id")), int(matcher.group("mod_id")))
+            motor = matcher.group("motor_id")
+            position = matcher.group("position")
+
+            return [
+                ModStatusMotorPositionModule(
+                    addr,
+                    int(motor) - 1,
+                    float(position),
+                )
+            ]
+
+        return None
+
+
 class ModSendCommandHost(ModInput):
     """Send command to host message from module."""
 
@@ -1200,6 +1349,8 @@ class InputParser:
         ModStatusKeyLocks,
         ModStatusAccessControl,
         ModStatusSceneOutputs,
+        ModStatusMotorPositionBS4,
+        ModStatusMotorPositionModule,
         ModSendCommandHost,
         ModSendKeysHost,
         Unknown,

{pypck-0.8.4 → pypck-0.8.6}/pypck/lcn_defs.py

@@ -228,7 +228,7 @@ def ramp_value_to_time(ramp_value: int) -> int:
     :rtype: int
     """
     if not 0 <= ramp_value <= 250:
-        raise ValueError("Ramp value has to be in range 0..250.")
+        raise ValueError("Ramp value has to be in range 0..250")
 
     if ramp_value < 10:
         times = [0, 250, 500, 660, 1000, 1400, 2000, 3000, 4000, 5000]
@@ -250,7 +250,7 @@ def time_to_native_value(time_msec: int) -> int:
     :rtype: int
     """
     if not 0 <= time_msec <= 240960:
-        raise ValueError("Time has to be in range 0..240960ms.")
+        raise ValueError("Time has to be in range 0..240960ms")
     time_scaled = time_msec / (1000 * 0.03 * 32.0) + 1.0
 
     pre_decimal = int(time_scaled).bit_length() - 1
@@ -264,7 +264,6 @@ def native_value_to_time(value: int) -> int:
     """Convert native LCN value to time.
 
     Scales the given byte value (0..255) to a time value in milliseconds.
-    Inverse to time_to_native_value().
 
     :param    int    value:    Duration of timer in native LCN units
 
@@ -272,7 +271,7 @@ def native_value_to_time(value: int) -> int:
     :rtype: int
     """
     if not 0 <= value <= 255:
-        raise ValueError("Value has to be in range 0..255.")
+        raise ValueError("Value has to be in range 0..255")
     pre_decimal = value // 32
     decimal = value / 32 - pre_decimal
 
@@ -282,6 +281,39 @@ def native_value_to_time(value: int) -> int:
     return int(time_msec)
 
 
+def motor_position_time_to_native_value(time_msec: int) -> int:
+    """Convert time to native LCN time value.
+
+    Scales the given time value in milliseconds to a two-byte value.
+
+    :param    int    time_msec:    Duration of timer in milliseconds (1001..65535000)
+
+    :returns: The duration in native LCN units
+    :rtype: int
+    """
+    if not 1001 <= time_msec <= 65535000:
+        raise ValueError("Time has to be in range 1001..65535000ms")
+    value = 0xFFFF * 1000 / time_msec
+    return int(value)
+
+
+def native_value_to_motor_position_time(value: int) -> int:
+    """Convert native LCN value to time.
+
+    Scales the given two-byte value (1..65535) to a time value in milliseconds.
+
+    :param    int    value:    Duration of timer in native LCN units
+
+    :returns: The duration in milliseconds
+    :rtype: int
+    """
+    if not 1 <= value <= 0xFFFF:
+        raise ValueError("Value has to be in range 1..65535")
+
+    time_msec = 0xFFFF * 1000 / value
+    return int(time_msec)
+
+
 class Var(Enum):
     """LCN variable types."""
 
@@ -1242,9 +1274,18 @@ class MotorReverseTime(Enum):
     For modules with FW<190C the release time has to be specified.
     """
 
-    RT70 = auto()  # 70ms
-    RT600 = auto()  # 600ms
-    RT1200 = auto()  # 1200ms
+    RT70 = "RT70"  # 70ms
+    RT600 = "RT600"  # 600ms
+    RT1200 = "RT1200"  # 1200ms
+
+
+class MotorPositioningMode(Enum):
+    """Motor positioning mode used in LCN commands."""
+
+    NONE = "NONE"
+    BS4 = "BS4"
+    MODULE = "MODULE"
+    # EMULATED = "EMULATED"
 
 
 class RelVarRef(Enum):

{pypck-0.8.4 → pypck-0.8.6}/pypck/module.py

@@ -232,22 +232,46 @@ class AbstractConnection:
             self.wants_ack, PckGenerator.control_relays_timer(time_msec, states)
         )
 
-    async def control_motors_relays(
-        self, states: list[lcn_defs.MotorStateModifier]
+    async def control_motor_relays(
+        self,
+        motor_id: int,
+        state: lcn_defs.MotorStateModifier,
+        mode: lcn_defs.MotorPositioningMode = lcn_defs.MotorPositioningMode.NONE,
     ) -> bool:
         """Send a command to control motors via relays.
 
-        :param    states:   The 4 modifiers for the cover states as a list
-        :type     states:   list(:class: `~pypck.lcn-defs.MotorStateModifier`)
+        :param    int                    motor_id:    The motor id 0..3
+        :param    MotorStateModifier     state:       The modifier for the
+        :param    MotorPositioningMode   mode:        The motor positioning mode (ooptional)
+
+        :returns:    True if command was sent successfully, False otherwise
+        :rtype:      bool
+        """
+        return await self.send_command(
+            self.wants_ack, PckGenerator.control_motor_relays(motor_id, state, mode)
+        )
+
+    async def control_motor_relays_position(
+        self,
+        motor_id: int,
+        position: float,
+        mode: lcn_defs.MotorPositioningMode,
+    ) -> bool:
+        """Control motor position via relays and BS4.
+
+        :param    int                  motor_id:   The motor port of the LCN module
+        :param    float                position:   The position to set in percentage (0..100)
+        :param    MotorPositioningMode mode:       The motor positioning mode
 
         :returns:    True if command was sent successfully, False otherwise
         :rtype:      bool
         """
         return await self.send_command(
-            self.wants_ack, PckGenerator.control_motors_relays(states)
+            self.wants_ack,
+            PckGenerator.control_motor_relays_position(motor_id, position, mode),
         )
 
-    async def control_motors_outputs(
+    async def control_motor_outputs(
         self,
         state: lcn_defs.MotorStateModifier,
         reverse_time: lcn_defs.MotorReverseTime | None = None,
@@ -264,7 +288,7 @@ class AbstractConnection:
         """
         return await self.send_command(
             self.wants_ack,
-            PckGenerator.control_motors_outputs(state, reverse_time),
+            PckGenerator.control_motor_outputs(state, reverse_time),
         )
 
     async def activate_scene(
@@ -736,7 +760,7 @@ class GroupConnection(AbstractConnection):
             result &= await super().var_rel(var, value, software_serial=0)
         return result
 
-    async def activate_status_request_handler(self, item: Any) -> None:
+    async def activate_status_request_handler(self, item: Any, option: Any) -> None:
         """Activate a specific TimeoutRetryHandler for status requests."""
         await self.conn.segment_scan_completed_event.wait()
 
@@ -849,9 +873,13 @@ class ModuleConnection(AbstractConnection):
         """
         await self.acknowledges.put(code)
 
-    async def activate_status_request_handler(self, item: Any) -> None:
+    async def activate_status_request_handler(
+        self, item: Any, option: Any = None
+    ) -> None:
         """Activate a specific TimeoutRetryHandler for status requests."""
-        self.task_registry.create_task(self.status_requests_handler.activate(item))
+        self.task_registry.create_task(
+            self.status_requests_handler.activate(item, option)
+        )
 
     async def activate_status_request_handlers(self) -> None:
         """Activate all TimeoutRetryHandlers for status requests."""

{pypck-0.8.4 → pypck-0.8.6}/pypck/pck_commands.py

@@ -192,6 +192,21 @@ class PckParser:
         r"(?P<code1>\d{3})(?P<code2>\d{3})(?P<code3>\d{3})"
     )
 
+    # Pattern to parse motor position BS4 status messages.
+    PATTERN_STATUS_MOTOR_POSITION_BS4 = re.compile(
+        r"=M(?P<seg_id>\d{3})(?P<mod_id>\d{3})\."
+        r"RM(?P<motor1_id>[1-4])(?P<position1>[0-9]{3})(?P<limit1>[0-9]{3}|\?)"
+        r"(?P<time_down1>[0-9]{5}|\?)(?P<time_up1>[0-9]{5}|\?)"
+        r"RM(?P<motor2_id>[1-4])(?P<position2>[0-9]{3})(?P<limit2>[0-9]{3}|\?)"
+        r"(?P<time_down2>[0-9]{5}|\?)(?P<time_up2>[0-9]{5}|\?)"
+    )
+
+    # Pattern to parse motor position module status messages.
+    PATTERN_STATUS_MOTOR_POSITION_MODULE = re.compile(
+        r":M(?P<seg_id>\d{3})(?P<mod_id>\d{3})"
+        r"P(?P<motor_id>[1-4])(?P<position>[0-9]{3})"
+    )
+
     @staticmethod
     def get_boolean_value(input_byte: int) -> list[bool]:
         """Get boolean representation for the given byte.
@@ -536,44 +551,117 @@ class PckGenerator:
         return ret
 
     @staticmethod
-    def control_motors_relays(states: list[lcn_defs.MotorStateModifier]) -> str:
+    def control_motor_relays(
+        motor_id: int,
+        state: lcn_defs.MotorStateModifier,
+        mode: lcn_defs.MotorPositioningMode = lcn_defs.MotorPositioningMode.NONE,
+    ) -> str:
         """Generate a command to control motors via relays.
 
-        :param    MotorStateModifier    states:    The 4 modifiers for the
-                                                   motor states as a list
+        :param    int                 motor_id:    The motor id 0..3
+        :param    MotorStateModifier  state:       The modifier for the
+                                                   motor state
         :return:  The PCK command (without address header) as text
         :rtype:   str
         """
-        if len(states) != 4:
-            raise ValueError("Invalid states length.")
-        ret = "R8"
-        for state in states:
-            if state == lcn_defs.MotorStateModifier.UP:
-                ret += lcn_defs.RelayStateModifier.ON.value
-                ret += lcn_defs.RelayStateModifier.OFF.value
-            elif state == lcn_defs.MotorStateModifier.DOWN:
-                ret += lcn_defs.RelayStateModifier.ON.value
-                ret += lcn_defs.RelayStateModifier.ON.value
-            elif state == lcn_defs.MotorStateModifier.STOP:
-                ret += lcn_defs.RelayStateModifier.OFF.value
-                ret += lcn_defs.RelayStateModifier.NOCHANGE.value
-            elif state == lcn_defs.MotorStateModifier.TOGGLEONOFF:
-                ret += lcn_defs.RelayStateModifier.TOGGLE.value
-                ret += lcn_defs.RelayStateModifier.NOCHANGE.value
-            elif state == lcn_defs.MotorStateModifier.TOGGLEDIR:
-                ret += lcn_defs.RelayStateModifier.NOCHANGE.value
-                ret += lcn_defs.RelayStateModifier.TOGGLE.value
-            elif state == lcn_defs.MotorStateModifier.CYCLE:
-                ret += lcn_defs.RelayStateModifier.TOGGLE.value
-                ret += lcn_defs.RelayStateModifier.TOGGLE.value
-            elif state == lcn_defs.MotorStateModifier.NOCHANGE:
-                ret += lcn_defs.RelayStateModifier.NOCHANGE.value
-                ret += lcn_defs.RelayStateModifier.NOCHANGE.value
+        if 0 > motor_id > 3:
+            raise ValueError("Invalid motor id")
 
-        return ret
+        if mode not in lcn_defs.MotorPositioningMode:
+            raise ValueError("Wrong motor position mode")
+
+        if mode == lcn_defs.MotorPositioningMode.BS4:
+            if state not in [
+                lcn_defs.MotorStateModifier.UP,
+                lcn_defs.MotorStateModifier.DOWN,
+            ]:
+                raise ValueError("Invalid motor state for BS4 mode")
+
+            new_motor_id = [1, 2, 5, 6][motor_id]
+            # AU=window open / cover down
+            # ZU=window close / cover up
+            action = "AU" if state == lcn_defs.MotorStateModifier.DOWN else "ZU"
+            return f"R8M{new_motor_id}{action}"
+
+        # lcn_defs.MotorPositioningMode.NONE
+        # lcn_defs.MotorPositioningMode.MODULE
+        if state == lcn_defs.MotorStateModifier.UP:
+            port_onoff = lcn_defs.RelayStateModifier.ON
+            port_updown = lcn_defs.RelayStateModifier.OFF
+        elif state == lcn_defs.MotorStateModifier.DOWN:
+            port_onoff = lcn_defs.RelayStateModifier.ON
+            port_updown = lcn_defs.RelayStateModifier.ON
+        elif state == lcn_defs.MotorStateModifier.STOP:
+            port_onoff = lcn_defs.RelayStateModifier.OFF
+            port_updown = lcn_defs.RelayStateModifier.NOCHANGE
+        elif state == lcn_defs.MotorStateModifier.TOGGLEONOFF:
+            port_onoff = lcn_defs.RelayStateModifier.TOGGLE
+            port_updown = lcn_defs.RelayStateModifier.NOCHANGE
+        elif state == lcn_defs.MotorStateModifier.TOGGLEDIR:
+            port_onoff = lcn_defs.RelayStateModifier.NOCHANGE
+            port_updown = lcn_defs.RelayStateModifier.TOGGLE
+        elif state == lcn_defs.MotorStateModifier.CYCLE:
+            port_onoff = lcn_defs.RelayStateModifier.TOGGLE
+            port_updown = lcn_defs.RelayStateModifier.TOGGLE
+        elif state == lcn_defs.MotorStateModifier.NOCHANGE:
+            port_onoff = lcn_defs.RelayStateModifier.NOCHANGE
+            port_updown = lcn_defs.RelayStateModifier.NOCHANGE
+        else:
+            raise ValueError("Invalid motor state")
+
+        states = [lcn_defs.RelayStateModifier.NOCHANGE] * 8
+        states[motor_id * 2] = port_onoff
+        states[motor_id * 2 + 1] = port_updown
+        return "R8" + "".join([state.value for state in states])
 
     @staticmethod
-    def control_motors_outputs(
+    def control_motor_relays_position(
+        motor_id: int, position: float, mode: lcn_defs.MotorPositioningMode
+    ) -> str:
+        """Control motor position via relays and BS4 or module.
+
+        :param    int                   motor_id:   The motor port of the LCN module
+        :param    float                 position:   The position to set in percentage (0..100)
+                                                    (0: closed cover, 100: open cover)
+        :param    MotorPositioningMode  mode:       The motor positioning mode
+
+        :return:  The PCK command (without address header) as text
+        :rtype:   str
+        """
+        if mode not in (
+            lcn_defs.MotorPositioningMode.BS4,
+            lcn_defs.MotorPositioningMode.MODULE,
+        ):
+            raise ValueError("Wrong motor positioning mode")
+
+        if 0 > motor_id > 3:
+            raise ValueError("Invalid motor")
+
+        if mode == lcn_defs.MotorPositioningMode.BS4:
+            new_motor_id = [1, 2, 5, 6][motor_id]
+            action = f"GP{int(200 - 2 * position):03d}"
+            return f"R8M{new_motor_id}{action}"
+        elif mode == lcn_defs.MotorPositioningMode.MODULE:
+            new_motor_id = 1 << motor_id
+            return f"JH{position:03d}{new_motor_id:03d}"
+
+        return ""
+
+    @staticmethod
+    def request_motor_position_status(motor_pair: int) -> str:
+        """Generate a motor position status request for BS4.
+
+        :param    int    motor_pair:    Motor pair 0: 1, 2; 1: 3, 4
+
+        :return:    The PCK command (without address header) as text
+        :rtype:    str
+        """
+        if motor_pair not in [0, 1]:
+            raise ValueError("Invalid motor_pair.")
+        return f"R8M{7 if motor_pair else 3}P{motor_pair + 1}"
+
+    @staticmethod
+    def control_motor_outputs(
         state: lcn_defs.MotorStateModifier,
         reverse_time: lcn_defs.MotorReverseTime | None = None,
     ) -> str:
@@ -728,16 +816,11 @@ class PckGenerator:
             if var_id == 0:
                 # Old command for variable 1 / T-var (compatible with all
                 # modules)
-                pck = "Z" f"{'A' if value >= 0 else 'S'}" f"{abs(value)}"
+                pck = f"Z{'A' if value >= 0 else 'S'}{abs(value)}"
             else:
                 # New command for variable 1-12 (compatible with all modules,
                 # since LCN-PCHK 2.8)
-                pck = (
-                    "Z"
-                    f"{'+' if value >= 0 else '-'}"
-                    f"{var_id + 1:03d}"
-                    f"{abs(value)}"
-                )
+                pck = f"Z{'+' if value >= 0 else '-'}{var_id + 1:03d}{abs(value)}"
             return pck
 
         set_point_id = lcn_defs.Var.to_set_point_id(var)
@@ -1051,7 +1134,7 @@ class PckGenerator:
             raise ValueError("Wrong target_value.")
         if (target_value != -1) and (software_serial >= 0x120301) and state:
             reg_byte = reg_id * 0x40 + 0x07
-            return f"X2{0x1E:03d}{reg_byte:03d}{int(2*target_value):03d}"
+            return f"X2{0x1E:03d}{reg_byte:03d}{int(2 * target_value):03d}"
         return f"RE{'A' if reg_id == 0 else 'B'}X{'S' if state else 'A'}"
 
     @staticmethod

{pypck-0.8.4 → pypck-0.8.6}/pypck/request_handlers.py

@@ -466,6 +466,17 @@ class StatusRequestsHandler:
             self.request_status_relays_timeout
         )
 
+        # Motor positions request status (1, 2 and 3, 4)
+        self.request_status_motor_positions = []
+        for motor_pair in range(2):
+            trh = TimeoutRetryHandler(
+                self.task_registry, -1, self.settings["MAX_STATUS_POLLED_VALUEAGE"]
+            )
+            trh.set_timeout_callback(
+                self.request_status_motor_positions_timeout, motor_pair
+            )
+            self.request_status_motor_positions.append(trh)
+
         # Binary-sensors request status (all 8)
         self.request_status_bin_sensors = TimeoutRetryHandler(
             self.task_registry, -1, self.settings["MAX_STATUS_EVENTBASED_VALUEAGE"]
@@ -542,6 +553,15 @@ class StatusRequestsHandler:
                 False, PckGenerator.request_relays_status()
             )
 
+    async def request_status_motor_positions_timeout(
+        self, failed: bool = False, motor_pair: int = 0
+    ) -> None:
+        """Is called on motor position status request timeout."""
+        if not failed:
+            await self.addr_conn.send_command(
+                False, PckGenerator.request_motor_position_status(motor_pair)
+            )
+
     async def request_status_bin_sensors_timeout(self, failed: bool = False) -> None:
         """Is called on binary sensor status request timeout."""
         if not failed:
@@ -589,7 +609,7 @@ class StatusRequestsHandler:
                 False, PckGenerator.request_key_lock_status()
             )
 
-    async def activate(self, item: Any) -> None:
+    async def activate(self, item: Any, option: Any = None) -> None:
         """Activate status requests for given item."""
         await self.addr_conn.conn.segment_scan_completed_event.wait()
         # handle variables independently
@@ -608,6 +628,8 @@ class StatusRequestsHandler:
             self.request_status_relays.activate()
         elif item in lcn_defs.MotorPort:
             self.request_status_relays.activate()
+            if option == lcn_defs.MotorPositioningMode.BS4:
+                self.request_status_motor_positions[item.value // 2].activate()
         elif item in lcn_defs.BinSensorPort:
             self.request_status_bin_sensors.activate()
         elif item in lcn_defs.LedPort:
@@ -627,6 +649,7 @@ class StatusRequestsHandler:
             await self.request_status_relays.cancel()
         elif item in lcn_defs.MotorPort:
             await self.request_status_relays.cancel()
+            await self.request_status_motor_positions[item.value // 2].cancel()
         elif item in lcn_defs.BinSensorPort:
             await self.request_status_bin_sensors.cancel()
         elif item in lcn_defs.LedPort:

{pypck-0.8.4 → pypck-0.8.6}/pypck/timeout_retry.py

@@ -65,10 +65,7 @@ class TimeoutRetryHandler:
     async def done(self) -> None:
         """Signal the completion of the TimeoutRetryHandler."""
         if self.timeout_loop_task is not None:
-            try:
-                await self.timeout_loop_task
-            except asyncio.CancelledError:
-                pass
+            await self.timeout_loop_task
 
     async def cancel(self) -> None:
         """Must be called when a response (requested or not) is received."""

{pypck-0.8.4 → pypck-0.8.6/pypck.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pypck
-Version: 0.8.4
+Version: 0.8.6
 Summary: LCN-PCK library
 Home-page: https://github.com/alengwenus/pypck
 Author-email: Andre Lengwenus <alengwenus@gmail.com>
@@ -18,6 +18,7 @@ Classifier: Topic :: Home Automation
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: license-file
 
 # pypck - Asynchronous LCN-PCK library written in Python
 

{pypck-0.8.4 → pypck-0.8.6}/tests/test_commands.py

@@ -7,6 +7,7 @@ from pypck.lcn_defs import (
     BeepSound,
     KeyLockStateModifier,
     LedStatus,
+    MotorPositioningMode,
     MotorReverseTime,
     MotorStateModifier,
     OutputPort,
@@ -71,9 +72,9 @@ COMMANDS = {
     # General status commands
     "SK": (PckGenerator.segment_coupler_scan,),
     "SN": (PckGenerator.request_serial,),
-    **{f"NMN{block+1}": (PckGenerator.request_name, block) for block in range(2)},
-    **{f"NMK{block+1}": (PckGenerator.request_comment, block) for block in range(3)},
-    **{f"NMO{block+1}": (PckGenerator.request_oem_text, block) for block in range(4)},
+    **{f"NMN{block + 1}": (PckGenerator.request_name, block) for block in range(2)},
+    **{f"NMK{block + 1}": (PckGenerator.request_comment, block) for block in range(3)},
+    **{f"NMO{block + 1}": (PckGenerator.request_oem_text, block) for block in range(4)},
     "GP": (PckGenerator.request_group_membership_static,),
     "GD": (PckGenerator.request_group_membership_dynamic,),
     # Output, relay, binsensors, ... status commands
@@ -87,7 +88,7 @@ COMMANDS = {
     "STX": (PckGenerator.request_key_lock_status,),
     # Variable status (new commands)
     **{
-        f"MWT{Var.to_var_id(var)+1:03d}": (
+        f"MWT{Var.to_var_id(var) + 1:03d}": (
             PckGenerator.request_var_status,
             var,
             NEW_VAR_SW_AGE,
@@ -95,7 +96,7 @@ COMMANDS = {
         for var in Var.variables  # type: ignore
     },
     **{
-        f"MWS{Var.to_set_point_id(var)+1:03d}": (
+        f"MWS{Var.to_set_point_id(var) + 1:03d}": (
             PckGenerator.request_var_status,
             var,
             NEW_VAR_SW_AGE,
@@ -103,7 +104,7 @@ COMMANDS = {
         for var in Var.set_points  # type: ignore
     },
     **{
-        f"MWC{Var.to_s0_id(var)+1:03d}": (
+        f"MWC{Var.to_s0_id(var) + 1:03d}": (
             PckGenerator.request_var_status,
             var,
             NEW_VAR_SW_AGE,
@@ -111,7 +112,7 @@ COMMANDS = {
         for var in Var.s0s  # type: ignore
     },
     **{
-        f"SE{Var.to_thrs_register_id(var)+1:03d}": (
+        f"SE{Var.to_thrs_register_id(var) + 1:03d}": (
             PckGenerator.request_var_status,
             var,
             NEW_VAR_SW_AGE,
@@ -131,11 +132,11 @@ COMMANDS = {
     },
     # Output manipulation
     **{
-        f"A{output+1:d}DI050123": (PckGenerator.dim_output, output, 50.0, 123)
+        f"A{output + 1:d}DI050123": (PckGenerator.dim_output, output, 50.0, 123)
         for output in range(4)
     },
     **{
-        f"O{output+1:d}DI101123": (PckGenerator.dim_output, output, 50.5, 123)
+        f"O{output + 1:d}DI101123": (PckGenerator.dim_output, output, 50.5, 123)
         for output in range(4)
     },
     "OY100100100100123": (PckGenerator.dim_all_outputs, 50.0, 123, 0x180501),
@@ -145,23 +146,23 @@ COMMANDS = {
     "AE123": (PckGenerator.dim_all_outputs, 100.0, 123, 0x180500),
     "AH050": (PckGenerator.dim_all_outputs, 50.0, 123, 0x180500),
     **{
-        f"A{output+1:d}AD050": (PckGenerator.rel_output, output, 50.0)
+        f"A{output + 1:d}AD050": (PckGenerator.rel_output, output, 50.0)
         for output in range(4)
     },
     **{
-        f"A{output+1:d}SB050": (PckGenerator.rel_output, output, -50.0)
+        f"A{output + 1:d}SB050": (PckGenerator.rel_output, output, -50.0)
         for output in range(4)
     },
     **{
-        f"O{output+1:d}AD101": (PckGenerator.rel_output, output, 50.5)
+        f"O{output + 1:d}AD101": (PckGenerator.rel_output, output, 50.5)
         for output in range(4)
     },
     **{
-        f"O{output+1:d}SB101": (PckGenerator.rel_output, output, -50.5)
+        f"O{output + 1:d}SB101": (PckGenerator.rel_output, output, -50.5)
         for output in range(4)
     },
     **{
-        f"A{output+1:d}TA123": (PckGenerator.toggle_output, output, 123)
+        f"A{output + 1:d}TA123": (PckGenerator.toggle_output, output, 123)
         for output in range(4)
     },
     "AU123": (PckGenerator.toggle_all_outputs, 123),
@@ -193,60 +194,90 @@ COMMANDS = {
             RelayStateModifier.OFF,
         ],
     ),
-    "R810110---": (
-        PckGenerator.control_motors_relays,
-        [
-            MotorStateModifier.UP,
-            MotorStateModifier.DOWN,
-            MotorStateModifier.STOP,
-            MotorStateModifier.NOCHANGE,
-        ],
+    # Motor state manipulation
+    "R8--10----": (
+        PckGenerator.control_motor_relays,
+        1,
+        MotorStateModifier.UP,
     ),
-    "R8U--UUU--": (
-        PckGenerator.control_motors_relays,
-        [
-            MotorStateModifier.TOGGLEONOFF,
-            MotorStateModifier.TOGGLEDIR,
-            MotorStateModifier.CYCLE,
-            MotorStateModifier.NOCHANGE,
-        ],
+    "R8-----U--": (
+        PckGenerator.control_motor_relays,
+        2,
+        MotorStateModifier.TOGGLEDIR,
+    ),
+    "R8UU------": (
+        PckGenerator.control_motor_relays,
+        0,
+        MotorStateModifier.CYCLE,
+    ),
+    "R8M1GP200": (
+        PckGenerator.control_motor_relays_position,
+        0,
+        0.0,
+        MotorPositioningMode.BS4,
+    ),
+    "R8M6GP100": (
+        PckGenerator.control_motor_relays_position,
+        3,
+        50.0,
+        MotorPositioningMode.BS4,
+    ),
+    "R8M3P1": (
+        PckGenerator.request_motor_position_status,
+        0,
+    ),
+    "R8M7P2": (
+        PckGenerator.request_motor_position_status,
+        1,
+    ),
+    "JH050001": (
+        PckGenerator.control_motor_relays_position,
+        0,
+        50,
+        MotorPositioningMode.MODULE,
+    ),
+    "JH100004": (
+        PckGenerator.control_motor_relays_position,
+        2,
+        100,
+        MotorPositioningMode.MODULE,
     ),
     "X2001228000": (
-        PckGenerator.control_motors_outputs,
+        PckGenerator.control_motor_outputs,
         MotorStateModifier.UP,
         MotorReverseTime.RT70,
     ),
     "A1DI100008": (
-        PckGenerator.control_motors_outputs,
+        PckGenerator.control_motor_outputs,
         MotorStateModifier.UP,
         MotorReverseTime.RT600,
     ),
     "A1DI100011": (
-        PckGenerator.control_motors_outputs,
+        PckGenerator.control_motor_outputs,
         MotorStateModifier.UP,
         MotorReverseTime.RT1200,
     ),
     "X2001000228": (
-        PckGenerator.control_motors_outputs,
+        PckGenerator.control_motor_outputs,
         MotorStateModifier.DOWN,
         MotorReverseTime.RT70,
     ),
     "A2DI100008": (
-        PckGenerator.control_motors_outputs,
+        PckGenerator.control_motor_outputs,
         MotorStateModifier.DOWN,
         MotorReverseTime.RT600,
     ),
     "A2DI100011": (
-        PckGenerator.control_motors_outputs,
+        PckGenerator.control_motor_outputs,
         MotorStateModifier.DOWN,
         MotorReverseTime.RT1200,
     ),
     "AY000000": (
-        PckGenerator.control_motors_outputs,
+        PckGenerator.control_motor_outputs,
         MotorStateModifier.STOP,
     ),
     "JE": (
-        PckGenerator.control_motors_outputs,
+        PckGenerator.control_motor_outputs,
         MotorStateModifier.CYCLE,
     ),
     # Variable manipulation
@@ -277,7 +308,7 @@ COMMANDS = {
         if var != Var.TVAR
     },
     **{
-        f"RE{('A','B')[nvar]}S{('A','P')[nref]}-500": (
+        f"RE{('A', 'B')[nvar]}S{('A', 'P')[nref]}-500": (
             PckGenerator.var_rel,
             var,
             ref,
@@ -289,7 +320,7 @@ COMMANDS = {
         for sw_age in (0x170206, 0x170205)
     },
     **{
-        f"RE{('A','B')[nvar]}S{('A','P')[nref]}+500": (
+        f"RE{('A', 'B')[nvar]}S{('A', 'P')[nref]}+500": (
             PckGenerator.var_rel,
             var,
             ref,
@@ -301,7 +332,7 @@ COMMANDS = {
         for sw_age in (0x170206, 0x170205)
     },
     **{
-        f"SS{('R','E')[nref]}0500SR{r+1}{i+1}": (
+        f"SS{('R', 'E')[nref]}0500SR{r + 1}{i + 1}": (
             PckGenerator.var_rel,
             Var.thresholds[r][i],  # type: ignore
             ref,
@@ -313,7 +344,7 @@ COMMANDS = {
         for nref, ref in enumerate(RelVarRef)
     },
     **{
-        f"SS{('R','E')[nref]}0500AR{r+1}{i+1}": (
+        f"SS{('R', 'E')[nref]}0500AR{r + 1}{i + 1}": (
             PckGenerator.var_rel,
             Var.thresholds[r][i],  # type: ignore
             ref,
@@ -325,7 +356,7 @@ COMMANDS = {
         for nref, ref in enumerate(RelVarRef)
     },
     **{
-        f"SS{('R','E')[nref]}0500S{1<<(4-i):05b}": (
+        f"SS{('R', 'E')[nref]}0500S{1 << (4 - i):05b}": (
             PckGenerator.var_rel,
             Var.thresholds[0][i],  # type: ignore
             ref,
@@ -336,7 +367,7 @@ COMMANDS = {
         for nref, ref in enumerate(RelVarRef)
     },
     **{
-        f"SS{('R','E')[nref]}0500A{1<<(4-i):05b}": (
+        f"SS{('R', 'E')[nref]}0500A{1 << (4 - i):05b}": (
             PckGenerator.var_rel,
             Var.thresholds[0][i],  # type: ignore
             ref,
@@ -348,7 +379,7 @@ COMMANDS = {
     },
     # Led manipulation
     **{
-        f"LA{led+1:03d}{state.value}": (PckGenerator.control_led, led, state)
+        f"LA{led + 1:03d}{state.value}": (PckGenerator.control_led, led, state)
         for led in range(12)
         for state in LedStatus
     },
@@ -378,7 +409,7 @@ COMMANDS = {
         if dcmd != SendKeyCommand.DONTSEND
     },
     **{
-        f"TV{('A','B','C','D')[table]}040{unit.value}11001110": (
+        f"TV{('A', 'B', 'C', 'D')[table]}040{unit.value}11001110": (
             PckGenerator.send_keys_hit_deferred,
             table,
             40,
@@ -390,7 +421,7 @@ COMMANDS = {
     },
     # Lock keys
     **{
-        f"TX{('A','B','C','D')[table]}10U--01U": (
+        f"TX{('A', 'B', 'C', 'D')[table]}10U--01U": (
             PckGenerator.lock_keys,
             table,
             [
@@ -417,15 +448,15 @@ COMMANDS = {
     },
     # Lock regulator
     **{
-        f"RE{('A','B')[reg]:s}XS": (PckGenerator.lock_regulator, reg, True, -1)
+        f"RE{('A', 'B')[reg]:s}XS": (PckGenerator.lock_regulator, reg, True, -1)
         for reg in range(2)
     },
     **{
-        f"RE{('A','B')[reg]:s}XA": (PckGenerator.lock_regulator, reg, False, -1)
+        f"RE{('A', 'B')[reg]:s}XA": (PckGenerator.lock_regulator, reg, False, -1)
         for reg in range(2)
     },
     **{
-        f"X2030{0x40*reg + 0x07:03d}{2*value:03d}": (
+        f"X2030{0x40 * reg + 0x07:03d}{2 * value:03d}": (
             PckGenerator.lock_regulator,
             reg,
             True,
@@ -436,11 +467,11 @@ COMMANDS = {
         for value in (0, 50, 100)
     },
     **{
-        f"RE{('A','B')[reg]:s}XS": (PckGenerator.lock_regulator, reg, True, 0x120301)
+        f"RE{('A', 'B')[reg]:s}XS": (PckGenerator.lock_regulator, reg, True, 0x120301)
         for reg in range(2)
     },
     **{
-        f"RE{('A','B')[reg]:s}XA": (PckGenerator.lock_regulator, reg, False, 0x120301)
+        f"RE{('A', 'B')[reg]:s}XA": (PckGenerator.lock_regulator, reg, False, 0x120301)
         for reg in range(2)
     },
     # scenes
@@ -490,7 +521,7 @@ COMMANDS = {
     ),
     # dynamic text
     **{
-        f"GTDT{row+1:d}{part+1:d}asdfasdfasdf".encode(): (
+        f"GTDT{row + 1:d}{part + 1:d}asdfasdfasdf".encode(): (
             PckGenerator.dyn_text_part,
             row,
             part,

{pypck-0.8.4 → pypck-0.8.6}/tests/test_messages.py

@@ -15,6 +15,8 @@ from pypck.inputs import (
     ModStatusGroups,
     ModStatusKeyLocks,
     ModStatusLedsAndLogicOps,
+    ModStatusMotorPositionBS4,
+    ModStatusMotorPositionModule,
     ModStatusOutput,
     ModStatusOutputNative,
     ModStatusRelays,
@@ -239,6 +241,33 @@ MESSAGES = {
             [150, 100, 0, 200],
         )
     ],
+    # Status motor position via BS4
+    "=M000010.RM1100?1234567890RM2200200??": [
+        (
+            ModStatusMotorPositionBS4,
+            0,
+            50,
+            None,
+            12345,
+            67890,
+        ),
+        (
+            ModStatusMotorPositionBS4,
+            1,
+            0,
+            0,
+            None,
+            None,
+        ),
+    ],
+    # Status motor position via module
+    ":M000010P1050": [
+        (
+            ModStatusMotorPositionModule,
+            0,
+            50,
+        )
+    ],
     # SKH
     "+M004000010.SKH000001": [(ModSendCommandHost, (0, 1))],
     "+M004000010.SKH000001002003004005": [

pypck-0.8.4/VERSION

@@ -1 +0,0 @@
-0.8.4