python-snap7 3.2.1__py3-none-any.whl → 3.3.0__py3-none-any.whl

{python_snap7-3.2.1.dist-info → python_snap7-3.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-snap7
-Version: 3.2.1
+Version: 3.3.0
 Summary: Pure Python S7 communication library for Siemens PLCs
 Author-email: Gijs Molenaar <gijsmolenaar@gmail.com>
 License-Expression: MIT
@@ -24,7 +24,7 @@ License-File: LICENSE
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-asyncio; extra == "test"
-Requires-Dist: pytest-bdd<9,>=8.1; extra == "test"
+Requires-Dist: pytest-bdd<10,>=8.1; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: pytest-html; extra == "test"
 Requires-Dist: hypothesis; extra == "test"
@@ -75,6 +75,26 @@ using the classic S7 protocol. It supports S7-300 and S7-400 controllers, as
 well as S7-1200 and S7-1500 controllers with PUT/GET access enabled. It
 supports Python 3.10+ on Windows, Linux, and macOS without native dependencies.
 
+S7-1200 and S7-1500
+===================
+
+On S7-1200 and S7-1500 controllers, python-snap7 only works when PUT/GET access
+is enabled in TIA Portal, and it cannot access optimized data blocks. PUT/GET
+is unauthenticated and disabled by default, so leaving it disabled is the more
+secure configuration.
+
+If PUT/GET is disabled, or you need optimized data blocks or symbolic access,
+use `s7commplus <https://github.com/gijzelaerr/s7commplus>`_ instead::
+
+   pip install s7commplus
+
+s7commplus is a separate, younger project that implements S7CommPlus, the
+protocol these controllers speak natively. Check the
+`firmware versions validated so far <https://s7commplus.readthedocs.io/en/latest/connections.html>`_
+before relying on it, and see the
+`PLC support matrix <https://python-snap7.readthedocs.io/en/latest/plc-support.html>`_
+for what python-snap7 supports on each controller family.
+
 Installation
 ============
 
@@ -105,3 +125,5 @@ Read the full documentation at
 
 The safe volunteer hardware-test procedure is in
 `Real-PLC acceptance testing <doc/real-plc-testing.rst>`_.
+The CPUs and firmware versions it has passed on are listed under
+`Tested and Verified Hardware <doc/plc-support.rst>`_.

{python_snap7-3.2.1.dist-info → python_snap7-3.3.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-python_snap7-3.2.1.dist-info/licenses/LICENSE,sha256=PIihE_yP-8gc-ff9ikvQQPOa0biOCZ6Bc-6h3G3xRUQ,1097
+python_snap7-3.3.0.dist-info/licenses/LICENSE,sha256=PIihE_yP-8gc-ff9ikvQQPOa0biOCZ6Bc-6h3G3xRUQ,1097
 s7/__init__.py,sha256=q6E4rA1BDx36PPkJS55xv7XCxwlaQeEK6HNotFjLeYo,1096
 snap7/__init__.py,sha256=2NAAE1oaSSd7DqPl0dx7jNXtsM2PRBWRm9X-bkmgC6U,1275
-snap7/async_client.py,sha256=yPyqzD4WH3544hKV4aDHt48r8LSWKsbFcVBZxtQOcYQ,52571
+snap7/async_client.py,sha256=SxIf2W-mimITD6P0cL3J66vpEr1SeCHne645lwkmbPU,66346
 snap7/cli.py,sha256=L1B7NMAemDcl93JUSqJV3Ls_CN2ghlG75nTMD08JkMs,13787
-snap7/client.py,sha256=MWnqsxjjdSSAloluSqAXtmfpokyJEKezJj77e_SqR6I,107985
+snap7/client.py,sha256=WYRZiQ6qwyHMl-SUd_ckhcPmIOzaZ9RiIOKe2v26MXg,108330
 snap7/client_base.py,sha256=tNZs_MA8FGit8pg9axNoljH1kFToDI1HIzXC8WQLYHs,11324
 snap7/connection.py,sha256=Qjis-ICK6E74_YfoJuy2_lgDqfSYs4ULux1FShJVvtw,18834
 snap7/datatypes.py,sha256=Gqu1XDuKkQI76n4TYrFrhm0RlPz4XNA5GKA-GJJXJDU,12042
@@ -17,18 +17,18 @@ snap7/partner.py,sha256=HxaTYfojsf5Z170R4cAYFzoMSwqCOF42qPCkOaxbUkU,37916
 snap7/ppi.py,sha256=p0fVelfUQOT3QH5uuWOjpDxA5IyT3gx5FzCMaYYEuWQ,16070
 snap7/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 snap7/rate_limiter.py,sha256=dnXCOJLWmszo8oskbFM0om0gPC4LHHCOr-Nt22tImeU,4151
-snap7/s7protocol.py,sha256=BLuI6h3Cfbr4R55-v20fYMlKCY6ASbtxdJOC5T0JyaI,69396
-snap7/szl.py,sha256=a9NhH7Lyp8SXJ2_kvyyV-14srIxm3tXnAnclBy5alDk,7998
+snap7/s7protocol.py,sha256=gPfU4BL3S4iicKgDrqksSTjPuRnVmHmrrMDzcLSBiDY,70946
+snap7/szl.py,sha256=952lFvuTTE4nBlG2Lvn_3SaS_hazkM0ZfboIPgTwFM8,7999
 snap7/tags.py,sha256=TmbNRHNWZVe3Yl_1L5WXE3Qb0lxIEW-veoCRGt0giZQ,26987
 snap7/type.py,sha256=EiXqU0ayYYxlM-5fUcPL7psgL1EGNNqAa7JXH4QlAnU,9752
-snap7/server/__init__.py,sha256=0XqMGlqblhVNmILT_Ddm-yxTw1r19bfFrr-VuPLEDnI,112468
+snap7/server/__init__.py,sha256=BsLUWAn0X3kVJ6NNZvJ1iLXfw12ksjlO2cRfCWMDQAU,113218
 snap7/server/__main__.py,sha256=OdOgyMmFThjSe2jSgvlbkquGYnZcBW6wubs2ldhNSOE,1206
 snap7/util/__init__.py,sha256=d6n2oy7tNYke1ia0TUyWz_ni3l0XN1qvilM5sW0T-Es,1874
 snap7/util/db.py,sha256=geesYS2oyOuTADOJa2me1p1rqJVzPuLTCfye6JIeav0,27120
-snap7/util/getters.py,sha256=pMsiCz0soMV7Q-VDPBdFG5eHzcFESZtKPw6mxj4S5ko,25370
+snap7/util/getters.py,sha256=UjojRLazJECrngor_8BI38R8VMEMdXusC95zqNEErJg,25767
 snap7/util/setters.py,sha256=BpFqVxxUbhqarV6Gzt4ZuxycHljtDYsONCr6e9G33Ms,27226
-python_snap7-3.2.1.dist-info/METADATA,sha256=-oAcJHaF7AZL-10-rfF1c73I5E-JElaLi-azSxq76zg,3662
-python_snap7-3.2.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_snap7-3.2.1.dist-info/entry_points.txt,sha256=IPZyYr1lKyavXXpAc4xO505afTGwTY8GmNFuy5lsSiM,75
-python_snap7-3.2.1.dist-info/top_level.txt,sha256=PTgDoDG45QNL2XIE9RM7S_ZCdWQjtMMuXNyrI2UdnbU,9
-python_snap7-3.2.1.dist-info/RECORD,,
+python_snap7-3.3.0.dist-info/METADATA,sha256=_fe4bkkd7bKdlTxAUa6CbNOKpeuIYTytvvifNBSVY3g,4669
+python_snap7-3.3.0.dist-info/WHEEL,sha256=a-udL2m4V_6Yn8b-uKzWb12RjRxwwMo6ohYFM24tpaY,91
+python_snap7-3.3.0.dist-info/entry_points.txt,sha256=IPZyYr1lKyavXXpAc4xO505afTGwTY8GmNFuy5lsSiM,75
+python_snap7-3.3.0.dist-info/top_level.txt,sha256=PTgDoDG45QNL2XIE9RM7S_ZCdWQjtMMuXNyrI2UdnbU,9
+python_snap7-3.3.0.dist-info/RECORD,,

{python_snap7-3.2.1.dist-info → python_snap7-3.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (84.0.0)
+Generator: setuptools (84.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

snap7/async_client.py

@@ -10,9 +10,9 @@ import asyncio
 import logging
 import struct
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from contextvars import ContextVar
-from typing import List, Any, Optional, Tuple, Type
+from typing import List, Any, Optional, Tuple, Type, Union
 from types import TracebackType
 from datetime import datetime
 
@@ -21,6 +21,8 @@ from .s7protocol import S7Protocol, S7UserDataGroup, S7UserDataSubfunction, get_
 from .datatypes import S7DataTypes, S7WordLen
 from .error import S7Error, S7ConnectionError, S7ProtocolError, S7TimeoutError
 from .client_base import ClientMixin, _instrumented
+from .tags import Tag
+from .client import Client, _decode_tag, _encode_tag
 from .szl import parse_cp_info_szl, parse_cpu_info_szl, parse_order_code_szl, parse_protection_szl
 from .client import _parse_force_szl
 from .rate_limiter import RateLimitAlgorithm, RateLimitBehavior, RequestRateLimiter
@@ -59,6 +61,8 @@ class AsyncISOTCPConnection:
     COTP_PARAM_PDU_SIZE = 0xC0
     COTP_PARAM_CALLING_TSAP = 0xC1
     COTP_PARAM_CALLED_TSAP = 0xC2
+    COTP_PARAM_SUBNET_ID = 0xC6
+    COTP_PARAM_ROUTING_TSAP = 0xC7
 
     def __init__(
         self,
@@ -83,6 +87,17 @@ class AsyncISOTCPConnection:
         self._reader: Optional[asyncio.StreamReader] = None
         self._writer: Optional[asyncio.StreamWriter] = None
 
+        # Routing parameters (set via set_routing)
+        self._routing: bool = False
+        self._subnet_id: int = 0
+        self._routing_tsap: int = 0
+
+    def set_routing(self, subnet_id: int, dest_rack: int, dest_slot: int) -> None:
+        """Configure S7 routing parameters for multi-subnet access (experimental)."""
+        self._routing = True
+        self._subnet_id = subnet_id & 0xFFFF
+        self._routing_tsap = 0x0100 | (dest_rack << 5) | dest_slot
+
     async def connect(self, timeout: float = 5.0) -> None:
         """Establish ISO on TCP connection."""
         self.timeout = timeout
@@ -204,6 +219,9 @@ class AsyncISOTCPConnection:
         called_tsap = struct.pack(">BBH", self.COTP_PARAM_CALLED_TSAP, 2, self.remote_tsap)
         pdu_size_param = struct.pack(">BBB", self.COTP_PARAM_PDU_SIZE, 1, self.tpdu_size)
         parameters = calling_tsap + called_tsap + pdu_size_param
+        if self._routing:
+            parameters += struct.pack(">BBH", self.COTP_PARAM_SUBNET_ID, 2, self._subnet_id)
+            parameters += struct.pack(">BBH", self.COTP_PARAM_ROUTING_TSAP, 2, self._routing_tsap)
         total_length = 6 + len(parameters)
         cr_pdu = struct.pack(">B", total_length) + base_pdu[1:] + parameters
 
@@ -457,6 +475,78 @@ class AsyncClient(ClientMixin):
 
         return self
 
+    @property
+    def is_alive(self) -> bool:
+        """Whether the client is connected.
+
+        Unlike the synchronous client there is no background heartbeat, so this
+        reflects the connection state seen by the last operation.
+        """
+        return self.connected and self.connection is not None and self.connection.connected
+
+    async def connect_routed(
+        self,
+        host: str,
+        router_rack: int,
+        router_slot: int,
+        subnet: int,
+        dest_rack: int,
+        dest_slot: int,
+        port: int = 102,
+        timeout: float = 5.0,
+    ) -> "AsyncClient":
+        """Connect to an S7 PLC via a routing gateway on another subnet.
+
+        .. warning:: This method is experimental and may change in future versions.
+
+        Args:
+            host: IP address of the routing gateway PLC
+            router_rack: Rack number of the gateway PLC
+            router_slot: Slot number of the gateway PLC
+            subnet: Subnet ID of the target network (0x0000-0xFFFF)
+            dest_rack: Rack number of the destination PLC
+            dest_slot: Slot number of the destination PLC
+            port: TCP port (default 102)
+            timeout: Connection timeout in seconds
+
+        Returns:
+            Self for method chaining
+        """
+        self.host = host
+        self.port = port
+        self.rack = router_rack
+        self.slot = router_slot
+        self._params[Parameter.RemotePort] = port
+
+        # Remote TSAP targets the gateway rack/slot
+        self.remote_tsap = (self.connection_type << 8) | (router_rack << 5) | router_slot
+
+        try:
+            start_time = time.time()
+
+            self.connection = AsyncISOTCPConnection(
+                host=host, port=port, local_tsap=self.local_tsap, remote_tsap=self.remote_tsap
+            )
+            self.connection.set_routing(subnet, dest_rack, dest_slot)
+            await self.connection.connect(timeout=timeout)
+
+            await self._setup_communication()
+
+            self.connected = True
+            self._exec_time = int((time.time() - start_time) * 1000)
+            logger.info(
+                f"Connected (routed) to {host}:{port} via rack {router_rack} slot {router_slot}, "
+                f"subnet {subnet:#06x} -> rack {dest_rack} slot {dest_slot}"
+            )
+        except Exception as e:
+            await self.disconnect()
+            if isinstance(e, S7Error):
+                raise
+            else:
+                raise S7ConnectionError(f"Routed connection failed: {e}")
+
+        return self
+
     async def disconnect(self) -> int:
         """Disconnect from S7 PLC.
 
@@ -508,6 +598,224 @@ class AsyncClient(ClientMixin):
         await self.write_area(Area.DB, db_number, start, data)
         return 0
 
+    # ---------------------------------------------------------------
+    # Typed DB access and tag helpers (parity with the sync Client)
+    # ---------------------------------------------------------------
+
+    async def db_read_array(self, db_number: int, start: int, count: int, fmt: str = ">f") -> list[Any]:
+        """Read *count* consecutive values of struct format *fmt* from a DB."""
+        item_size = struct.calcsize(fmt)
+        data = await self.db_read(db_number, start, item_size * count)
+        return [struct.unpack_from(fmt, data, i * item_size)[0] for i in range(count)]
+
+    async def db_write_array(self, db_number: int, start: int, values: list[Any], fmt: str = ">f") -> int:
+        """Write *values* packed with struct format *fmt* to a DB. Returns 0 on success."""
+        item_size = struct.calcsize(fmt)
+        data = bytearray(item_size * len(values))
+        for i, v in enumerate(values):
+            struct.pack_into(fmt, data, i * item_size, v)
+        return await self.db_write(db_number, start, data)
+
+    async def db_read_bool(self, db_number: int, byte_offset: int, bit_offset: int) -> bool:
+        """Read a single bit from a DB."""
+        from .util import get_bool
+
+        data = await self.db_read(db_number, byte_offset, 1)
+        return get_bool(data, 0, bit_offset)
+
+    async def db_write_bool(self, db_number: int, byte_offset: int, bit_offset: int, value: bool) -> None:
+        """Write a single bit to a DB, preserving the other bits in the byte."""
+        from .util import set_bool
+
+        data = await self.db_read(db_number, byte_offset, 1)
+        set_bool(data, 0, bit_offset, value)
+        await self.db_write(db_number, byte_offset, data)
+
+    async def db_read_byte(self, db_number: int, offset: int) -> int:
+        """Read a BYTE (8-bit unsigned) from a DB."""
+        data = await self.db_read(db_number, offset, 1)
+        return data[0]
+
+    async def db_write_byte(self, db_number: int, offset: int, value: int) -> None:
+        """Write a BYTE (8-bit unsigned) to a DB."""
+        from .util import set_byte
+
+        data = bytearray(1)
+        set_byte(data, 0, value)
+        await self.db_write(db_number, offset, data)
+
+    async def db_read_int(self, db_number: int, offset: int) -> int:
+        """Read an INT (16-bit signed) from a DB."""
+        from .util import get_int
+
+        return get_int(await self.db_read(db_number, offset, 2), 0)
+
+    async def db_write_int(self, db_number: int, offset: int, value: int) -> None:
+        """Write an INT (16-bit signed) to a DB."""
+        from .util import set_int
+
+        data = bytearray(2)
+        set_int(data, 0, value)
+        await self.db_write(db_number, offset, data)
+
+    async def db_read_uint(self, db_number: int, offset: int) -> int:
+        """Read a UINT (16-bit unsigned) from a DB."""
+        from .util import get_uint
+
+        return get_uint(await self.db_read(db_number, offset, 2), 0)
+
+    async def db_write_uint(self, db_number: int, offset: int, value: int) -> None:
+        """Write a UINT (16-bit unsigned) to a DB."""
+        from .util import set_uint
+
+        data = bytearray(2)
+        set_uint(data, 0, value)
+        await self.db_write(db_number, offset, data)
+
+    async def db_read_word(self, db_number: int, offset: int) -> int:
+        """Read a WORD (16-bit unsigned) from a DB."""
+        data = await self.db_read(db_number, offset, 2)
+        return (data[0] << 8) | data[1]
+
+    async def db_write_word(self, db_number: int, offset: int, value: int) -> None:
+        """Write a WORD (16-bit unsigned) to a DB."""
+        from .util import set_word
+
+        data = bytearray(2)
+        set_word(data, 0, value)
+        await self.db_write(db_number, offset, data)
+
+    async def db_read_dint(self, db_number: int, offset: int) -> int:
+        """Read a DINT (32-bit signed) from a DB."""
+        from .util import get_dint
+
+        return get_dint(await self.db_read(db_number, offset, 4), 0)
+
+    async def db_write_dint(self, db_number: int, offset: int, value: int) -> None:
+        """Write a DINT (32-bit signed) to a DB."""
+        from .util import set_dint
+
+        data = bytearray(4)
+        set_dint(data, 0, value)
+        await self.db_write(db_number, offset, data)
+
+    async def db_read_udint(self, db_number: int, offset: int) -> int:
+        """Read a UDINT (32-bit unsigned) from a DB."""
+        from .util import get_udint
+
+        return get_udint(await self.db_read(db_number, offset, 4), 0)
+
+    async def db_write_udint(self, db_number: int, offset: int, value: int) -> None:
+        """Write a UDINT (32-bit unsigned) to a DB."""
+        from .util import set_udint
+
+        data = bytearray(4)
+        set_udint(data, 0, value)
+        await self.db_write(db_number, offset, data)
+
+    async def db_read_dword(self, db_number: int, offset: int) -> int:
+        """Read a DWORD (32-bit unsigned) from a DB."""
+        from .util import get_dword
+
+        return get_dword(await self.db_read(db_number, offset, 4), 0)
+
+    async def db_write_dword(self, db_number: int, offset: int, value: int) -> None:
+        """Write a DWORD (32-bit unsigned) to a DB."""
+        from .util import set_dword
+
+        data = bytearray(4)
+        set_dword(data, 0, value)
+        await self.db_write(db_number, offset, data)
+
+    async def db_read_real(self, db_number: int, offset: int) -> float:
+        """Read a REAL (32-bit float) from a DB."""
+        from .util import get_real
+
+        return get_real(await self.db_read(db_number, offset, 4), 0)
+
+    async def db_write_real(self, db_number: int, offset: int, value: float) -> None:
+        """Write a REAL (32-bit float) to a DB."""
+        from .util import set_real
+
+        data = bytearray(4)
+        set_real(data, 0, value)
+        await self.db_write(db_number, offset, data)
+
+    async def db_read_lreal(self, db_number: int, offset: int) -> float:
+        """Read a LREAL (64-bit float) from a DB."""
+        from .util import get_lreal
+
+        return get_lreal(await self.db_read(db_number, offset, 8), 0)
+
+    async def db_write_lreal(self, db_number: int, offset: int, value: float) -> None:
+        """Write a LREAL (64-bit float) to a DB."""
+        from .util import set_lreal
+
+        data = bytearray(8)
+        set_lreal(data, 0, value)
+        await self.db_write(db_number, offset, data)
+
+    async def db_read_string(self, db_number: int, offset: int) -> str:
+        """Read an S7 STRING from a DB (header first to learn the max length)."""
+        from .util import get_string
+
+        header = await self.db_read(db_number, offset, 2)
+        data = await self.db_read(db_number, offset, 2 + header[0])
+        return get_string(data, 0)
+
+    async def db_write_string(self, db_number: int, offset: int, value: str, max_length: int = 254) -> None:
+        """Write an S7 STRING with the given maximum length to a DB."""
+        from .util import set_string
+
+        data = bytearray(2 + max_length)
+        set_string(data, 0, value, max_length)
+        await self.db_write(db_number, offset, data)
+
+    async def db_read_wstring(self, db_number: int, offset: int) -> str:
+        """Read an S7 WSTRING from a DB (header first to learn the max length)."""
+        from .util import get_wstring
+
+        header = await self.db_read(db_number, offset, 4)
+        max_len = (header[0] << 8) | header[1]
+        data = await self.db_read(db_number, offset, 4 + max_len * 2)
+        return get_wstring(data, 0)
+
+    async def db_write_wstring(self, db_number: int, offset: int, value: str, max_length: int = 254) -> None:
+        """Write an S7 WSTRING with the given maximum length (in characters) to a DB."""
+        from .util import set_wstring
+
+        data = bytearray(4 + max_length * 2)
+        set_wstring(data, 0, value, max_length)
+        await self.db_write(db_number, offset, data)
+
+    async def read_tag(self, tag: "Union[Tag, str]", encoding: str = "latin-1") -> Any:
+        """Read a typed value by :class:`~snap7.tags.Tag` or PLC4X-style address string."""
+        resolved = Tag.from_string(tag) if isinstance(tag, str) else tag
+        if resolved.is_symbolic:
+            raise NotImplementedError("Symbolic (LID-based) tag access is not supported by the classic S7 client.")
+        data = await self.read_area(Area(resolved.area), resolved.db_number, resolved.byte_offset, resolved.size)
+        return _decode_tag(resolved, bytearray(data), encoding=encoding)
+
+    async def write_tag(self, tag: "Union[Tag, str]", value: Any, encoding: str = "latin-1") -> int:
+        """Write a typed value by :class:`~snap7.tags.Tag` or address string. Returns 0 on success."""
+        resolved = Tag.from_string(tag) if isinstance(tag, str) else tag
+        if resolved.is_symbolic:
+            raise NotImplementedError("Symbolic (LID-based) tag access is not supported by the classic S7 client.")
+        buf = bytearray(resolved.size)
+        if resolved.datatype.upper() == "BOOL":
+            # Preserve the other bits of the byte
+            current = await self.read_area(Area(resolved.area), resolved.db_number, resolved.byte_offset, 1)
+            buf[0] = current[0]
+        _encode_tag(resolved, buf, value, encoding=encoding)
+        return await self.write_area(Area(resolved.area), resolved.db_number, resolved.byte_offset, buf)
+
+    async def read_tags(self, tags: "Sequence[Union[Tag, str]]", encoding: str = "latin-1") -> list[Any]:
+        """Read multiple tags in a single optimized request, in input order."""
+        resolved = [Tag.from_string(t) if isinstance(t, str) else t for t in tags]
+        items = [{"area": Area(t.area), "db_number": t.db_number, "start": t.byte_offset, "size": t.size} for t in resolved]
+        _code, data_list = await self.read_multi_vars(items)
+        return [_decode_tag(t, bytearray(d), encoding=encoding) for t, d in zip(resolved, data_list)]
+
     async def db_get(self, db_number: int, size: int = 0) -> bytearray:
         """Get entire DB.
 
@@ -1010,7 +1318,9 @@ class AsyncClient(ClientMixin):
 
         request = self.protocol.build_set_clock_request(dt)
         response = await self._send_receive(request)
-        self.protocol.check_userdata_response(response, S7UserDataGroup.TIME, S7UserDataSubfunction.SET_CLOCK)
+        self.protocol.check_userdata_response(
+            response, S7UserDataGroup.TIME, S7UserDataSubfunction.SET_CLOCK, accept_null_ack=True
+        )
         logger.info(f"Set PLC datetime to {dt}")
         return 0
 
@@ -1090,6 +1400,14 @@ class AsyncClient(ClientMixin):
 
         return szl
 
+    async def read_diagnostic_buffer(self) -> list[dict[str, Any]]:
+        """Read the PLC diagnostic buffer (experimental), newest first.
+
+        Each entry is a dict with keys ``event_id``, ``timestamp`` and ``info``.
+        """
+        szl = await self.read_szl(0x00A0, 0)
+        return Client._parse_diagnostic_buffer(bytes(szl.Data[: szl.Header.LengthDR]))
+
     async def read_szl_list(self) -> bytes:
         """Read list of available SZL IDs."""
         if not self.get_connected():
@@ -1198,7 +1516,9 @@ class AsyncClient(ClientMixin):
         encoded = self.protocol.encode_password(password)
         request = self.protocol.build_set_session_password_request(encoded)
         response = await self._send_receive(request)
-        self.protocol.check_userdata_response(response, S7UserDataGroup.SECURITY, S7UserDataSubfunction.SET_SESSION_PASSWORD)
+        self.protocol.check_userdata_response(
+            response, S7UserDataGroup.SECURITY, S7UserDataSubfunction.SET_SESSION_PASSWORD, accept_null_ack=True
+        )
         logger.info("Session password set successfully")
         return 0
 
@@ -1219,7 +1539,9 @@ class AsyncClient(ClientMixin):
 
         request = self.protocol.build_clear_session_password_request()
         response = await self._send_receive(request)
-        self.protocol.check_userdata_response(response, S7UserDataGroup.SECURITY, S7UserDataSubfunction.CLEAR_SESSION_PASSWORD)
+        self.protocol.check_userdata_response(
+            response, S7UserDataGroup.SECURITY, S7UserDataSubfunction.CLEAR_SESSION_PASSWORD, accept_null_ack=True
+        )
         logger.info("Session password cleared successfully")
         return 0
 

snap7/client.py

@@ -1892,7 +1892,9 @@ class Client(ClientMixin):
         # Build and send set clock request
         request = self.protocol.build_set_clock_request(dt)
         response = self._send_receive(request)
-        self.protocol.check_userdata_response(response, S7UserDataGroup.TIME, S7UserDataSubfunction.SET_CLOCK)
+        self.protocol.check_userdata_response(
+            response, S7UserDataGroup.TIME, S7UserDataSubfunction.SET_CLOCK, accept_null_ack=True
+        )
 
         logger.info(f"Set PLC datetime to {dt}")
         return 0
@@ -1915,7 +1917,7 @@ class Client(ClientMixin):
         """
         Compress PLC memory.
 
-        Sends real S7 PLC_CONTROL protocol with PI service "_MSZL".
+        Sends real S7 PLC_CONTROL protocol with PI service "_GARB".
 
         Args:
             timeout: Timeout in milliseconds (used for receive timeout)
@@ -1938,7 +1940,7 @@ class Client(ClientMixin):
         """
         Copy RAM to ROM.
 
-        Sends real S7 PLC_CONTROL protocol with PI service "_MSZL" and file ID "P".
+        Sends real S7 PLC_CONTROL protocol with PI service "_MODU" and file system "EP".
 
         Args:
             timeout: Timeout in milliseconds (used for receive timeout)
@@ -2093,7 +2095,9 @@ class Client(ClientMixin):
             return self.protocol.build_set_session_password_request(encoded)
 
         response = self._send_receive_with_reconnect(build_request)
-        self.protocol.check_userdata_response(response, S7UserDataGroup.SECURITY, S7UserDataSubfunction.SET_SESSION_PASSWORD)
+        self.protocol.check_userdata_response(
+            response, S7UserDataGroup.SECURITY, S7UserDataSubfunction.SET_SESSION_PASSWORD, accept_null_ack=True
+        )
         logger.info("Session password set successfully")
         return 0
 
@@ -2116,7 +2120,9 @@ class Client(ClientMixin):
             return self.protocol.build_clear_session_password_request()
 
         response = self._send_receive_with_reconnect(build_request)
-        self.protocol.check_userdata_response(response, S7UserDataGroup.SECURITY, S7UserDataSubfunction.CLEAR_SESSION_PASSWORD)
+        self.protocol.check_userdata_response(
+            response, S7UserDataGroup.SECURITY, S7UserDataSubfunction.CLEAR_SESSION_PASSWORD, accept_null_ack=True
+        )
         logger.info("Session password cleared successfully")
         return 0
 
@@ -2233,6 +2239,11 @@ class Client(ClientMixin):
         szl = self.read_szl(0x00A0, 0)
         raw = bytes(szl.Data[: szl.Header.LengthDR])
 
+        return self._parse_diagnostic_buffer(raw)
+
+    @classmethod
+    def _parse_diagnostic_buffer(cls, raw: bytes) -> list[dict[str, Any]]:
+        """Decode raw SZL 0x00A0 data into diagnostic entries."""
         entries: list[dict[str, Any]] = []
         # Each diagnostic entry is 20 bytes
         entry_size = 20
@@ -2243,7 +2254,7 @@ class Client(ClientMixin):
             # BCD-encoded timestamp at offset 2..9
             ts_bytes = raw[offset + 2 : offset + 10]
             try:
-                ts = self._parse_bcd_timestamp(ts_bytes)
+                ts = cls._parse_bcd_timestamp(ts_bytes)
             except Exception:
                 ts = None
 

snap7/s7protocol.py

@@ -114,6 +114,10 @@ _STOP_PARAMS = bytes.fromhex("29000000000009") + b"P_PROGRAM"
 _HOT_START_PARAMS = bytes.fromhex("28000000000000fd000009") + b"P_PROGRAM"
 # Cold start: same as hot start but with block "C " before PI service
 _COLD_START_PARAMS = bytes.fromhex("28000000000000fd0002432009") + b"P_PROGRAM"
+# Compress: function(0x28) + 7 reserved + block count(0) + PI length(5) + "_GARB" (as native Snap7 TReqFunCompress)
+_COMPRESS_PARAMS = bytes.fromhex("28000000000000fd000005") + b"_GARB"
+# Copy RAM to ROM: like compress but with file system "EP" before PI service "_MODU" (native TReqFunCopyRamToRom)
+_COPY_RAM_TO_ROM_PARAMS = bytes.fromhex("28000000000000fd0002455005") + b"_MODU"
 
 
 class S7Protocol:
@@ -402,7 +406,7 @@ class S7Protocol:
         Build PLC control request using the S7 PI service PDU format.
 
         Args:
-            operation: Control operation ('stop', 'hot_start', 'cold_start')
+            operation: Control operation ('stop', 'hot_start', 'cold_start', 'compress', 'copy_ram_to_rom')
 
         Returns:
             Complete S7 PDU for PLC control
@@ -411,6 +415,8 @@ class S7Protocol:
             "stop": _STOP_PARAMS,
             "hot_start": _HOT_START_PARAMS,
             "cold_start": _COLD_START_PARAMS,
+            "compress": _COMPRESS_PARAMS,
+            "copy_ram_to_rom": _COPY_RAM_TO_ROM_PARAMS,
         }
 
         if operation not in params:
@@ -449,87 +455,23 @@ class S7Protocol:
         """
         Build PLC control request for memory compression.
 
-        Uses PI service "_MSZL" (compress memory).
+        Uses PI service "_GARB" (compress memory), as native Snap7 does.
 
         Returns:
             Complete S7 PDU for compress request
         """
-        # PI service command for compress
-        pi_service = b"_MSZL"
-
-        # Parameter section: function code + PI service
-        # Format: func(1) + unknown(7) + pi_len(1) + pi_service
-        param_data = (
-            struct.pack(
-                ">BBBBBBBBB",
-                S7Function.PLC_CONTROL,  # 0x28
-                0x00,  # Reserved
-                0x00,  # Reserved
-                0x00,  # Reserved
-                0x00,  # Reserved
-                0x00,  # Reserved
-                0x00,  # Reserved
-                0x00,  # Reserved
-                len(pi_service),  # PI service length
-            )
-            + pi_service
-        )
-
-        header = struct.pack(
-            ">BBHHHH",
-            0x32,  # Protocol ID
-            S7PDUType.REQUEST,  # PDU type
-            0x0000,  # Reserved
-            self._next_sequence(),  # Sequence
-            len(param_data),  # Parameter length
-            0x0000,  # Data length
-        )
-
-        return header + param_data
+        return self.build_plc_control_request("compress")
 
     def build_copy_ram_to_rom_request(self) -> bytes:
         """
         Build PLC control request for copying RAM to ROM.
 
-        Uses PI service "_MSZL" with file system parameters.
+        Uses PI service "_MODU" with the "EP" file system, as native Snap7 does.
 
         Returns:
             Complete S7 PDU for copy RAM to ROM request
         """
-        # PI service command for copy RAM to ROM
-        # Uses EP parameter for target file system
-        pi_service = b"_MSZL"
-        file_id = b"P"  # P = passive file system (ROM)
-
-        # Parameter section with file system identifier
-        param_data = (
-            struct.pack(
-                ">BBBBBBBBB",
-                S7Function.PLC_CONTROL,  # 0x28
-                0x00,  # Reserved
-                0x00,  # Reserved
-                0x00,  # Reserved
-                0x00,  # Reserved
-                0x00,  # Reserved
-                0x00,  # Reserved
-                len(file_id),  # File ID length
-                len(pi_service),  # PI service length
-            )
-            + file_id
-            + pi_service
-        )
-
-        header = struct.pack(
-            ">BBHHHH",
-            0x32,  # Protocol ID
-            S7PDUType.REQUEST,  # PDU type
-            0x0000,  # Reserved
-            self._next_sequence(),  # Sequence
-            len(param_data),  # Parameter length
-            0x0000,  # Data length
-        )
-
-        return header + param_data
+        return self.build_plc_control_request("copy_ram_to_rom")
 
     # ========================================================================
     # Block Transfer PDU Builders (Upload/Download)
@@ -913,10 +855,9 @@ class S7Protocol:
         data_info = response.get("data", {})
         raw_data = data_info.get("data", b"")
 
-        if not raw_data:
-            return result
-        if len(raw_data) % 4 != 0:
-            raise S7ProtocolError("Block-count response length is not a multiple of four")
+        # Native Snap7 requires exactly seven four-byte entries (28 bytes)
+        if len(raw_data) != 28:
+            raise S7ProtocolError("Block-count response must contain exactly seven entries (28 bytes)")
 
         # Parse block entries (4 bytes each: 0x30 | type | count_hi | count_lo)
         # Block type codes
@@ -930,18 +871,19 @@ class S7Protocol:
             0x46: "SFBCount",  # System Function Block
         }
 
-        offset = 0
-        while offset + 4 <= len(raw_data):
+        seen: set[int] = set()
+        for offset in range(0, 28, 4):
             indicator = raw_data[offset]
             block_type = raw_data[offset + 1]
             count = struct.unpack(">H", raw_data[offset + 2 : offset + 4])[0]
 
             if indicator != 0x30 or block_type not in type_to_name:
                 raise S7ProtocolError("Invalid block-count response entry")
+            if block_type in seen:
+                raise S7ProtocolError("Duplicate block type in block-count response")
+            seen.add(block_type)
             result[type_to_name[block_type]] = count
 
-            offset += 4
-
         return result
 
     def parse_list_blocks_of_type_response(self, response: Dict[str, Any]) -> List[int]:
@@ -998,10 +940,10 @@ class S7Protocol:
             0x00,  # DataRef (0x00 for initial request)
         )
 
-        # Data section: [0x30, type, 'A', ASCII_num(5)] per Snap7 C format
+        # Data section: [0x30, type, ASCII_num(5), 'A'] per Snap7 C TReqDataBlockInfo
         # Block number is 5-digit zero-padded ASCII (e.g., 1 -> "00001")
         block_num_ascii = f"{block_num:05d}".encode("ascii")
-        data_payload = struct.pack(">BB", 0x30, block_type) + b"A" + block_num_ascii
+        data_payload = struct.pack(">BB", 0x30, block_type) + block_num_ascii + b"A"
         data_section = struct.pack(">BBH", 0xFF, 0x09, len(data_payload)) + data_payload
 
         # S7 header for USER_DATA
@@ -1117,8 +1059,8 @@ class S7Protocol:
         # Data section: SZL ID and Index
         data_section = struct.pack(
             ">BBHHH",
-            0x0A,  # Return value (request)
-            0x00,  # Transport size
+            0xFF,  # Return value (0xFF, as engineering tools and native Snap7 send for requests carrying data)
+            0x09,  # Transport size (octet string)
             0x0004,  # Length (4 bytes for ID + Index)
             szl_id,  # SZL ID
             szl_index,  # SZL Index
@@ -1149,18 +1091,23 @@ class S7Protocol:
         Returns:
             Complete S7 PDU for follow-up request
         """
-        # Parameter section: same as initial but with DataRef = sequence_number
+        # Parameter section as sent by engineering tools for continuation requests: 12 bytes, method 0x12,
+        # DataRef = sequence_number, followed by last-data-unit and error code fields set to zero
         type_group = 0x40 | (group & 0x0F)  # Type 4 (request) | group
         param_data = struct.pack(
-            ">BBBBBBBB",
+            ">BBBBBBBBBBBB",
             0x00,  # Reserved
             0x01,  # Parameter count
             0x12,  # Type/length header
-            0x04,  # Length of following data
-            0x11,  # Method (0x11 = request)
+            0x08,  # Length of following data
+            0x12,  # Method (0x12)
             type_group,  # Type | Group
             subfunction,  # Subfunction
             sequence_number,  # DataRef from previous response
+            0x00,  # Last data unit
+            0x00,  # Reserved
+            0x00,  # Error code high
+            0x00,  # Error code low
         )
 
         # Minimal data section for follow-up
@@ -1268,6 +1215,9 @@ class S7Protocol:
 
         Returns:
             Complete S7 PDU for set clock request
+
+        Raises:
+            ValueError: If the year is outside 1990-2089, which the two-digit S7 year cannot represent.
         """
 
         # Convert datetime to BCD format
@@ -1275,6 +1225,9 @@ class S7Protocol:
         def to_bcd(value: int) -> int:
             return ((value // 10) << 4) | (value % 10)
 
+        # The two-digit S7 year maps 90-99 to 1990-1999 and 00-89 to 2000-2089
+        if not 1990 <= dt.year <= 2089:
+            raise ValueError(f"S7 clock supports years 1990-2089, got {dt.year}")
         year = dt.year % 100
         millisecond = dt.microsecond // 1000
         bcd_time = struct.pack(
@@ -1288,7 +1241,7 @@ class S7Protocol:
             to_bcd(dt.minute),  # Minute (BCD)
             to_bcd(dt.second),  # Second (BCD)
             to_bcd(millisecond // 10),
-            ((millisecond % 10) << 4) | ((dt.weekday() + 1) & 0x0F),
+            ((millisecond % 10) << 4) | (dt.isoweekday() % 7 + 1),  # S7 weekday: 1=Sunday .. 7=Saturday
         )
 
         # Parameter section for USER_DATA clock request
@@ -1335,26 +1288,39 @@ class S7Protocol:
         data_info = response.get("data", {})
         raw_data = data_info.get("data", b"")
 
-        if len(raw_data) != 8:
-            raise S7ProtocolError("Clock response must contain exactly eight bytes")
+        # The S7 clock data is ten bytes: reserved, century (0x19/0x20), then year, month, day,
+        # hour, minute, second and milliseconds/weekday. The older eight-byte form (no century byte,
+        # no milliseconds) is still accepted.
+        if len(raw_data) == 10:
+            time_bytes = raw_data[2:]
+        elif len(raw_data) == 8:
+            time_bytes = raw_data[1:]
+        else:
+            raise S7ProtocolError("Clock response must contain ten bytes (or eight in the legacy form)")
 
-        # Parse BCD time
         def from_bcd(value: int) -> int:
+            if value >> 4 > 9 or value & 0x0F > 9:
+                raise S7ProtocolError("Clock response contains an invalid BCD timestamp")
             return ((value >> 4) * 10) + (value & 0x0F)
 
-        # Skip first byte (reserved)
-        year = from_bcd(raw_data[1])
-        month = from_bcd(raw_data[2])
-        day = from_bcd(raw_data[3])
-        hour = from_bcd(raw_data[4])
-        minute = from_bcd(raw_data[5])
-        second = from_bcd(raw_data[6])
-
-        # Determine century (assume 2000s for years 0-99)
+        year = from_bcd(time_bytes[0])
+        month = from_bcd(time_bytes[1])
+        day = from_bcd(time_bytes[2])
+        hour = from_bcd(time_bytes[3])
+        minute = from_bcd(time_bytes[4])
+        second = from_bcd(time_bytes[5])
+        microsecond = 0
+        if len(raw_data) == 10:
+            # Byte 8: milliseconds hundreds/tens (BCD); high nibble of byte 9: milliseconds ones
+            microsecond = (from_bcd(time_bytes[6]) * 10 + (time_bytes[7] >> 4)) * 1000
+            if microsecond > 999000:
+                raise S7ProtocolError("Clock response contains an invalid BCD timestamp")
+
+        # The two-digit S7 year maps 90-99 to 1990-1999 and 00-89 to 2000-2089
         full_year = 2000 + year if year < 90 else 1900 + year
 
         try:
-            return dt_class(full_year, month, day, hour, minute, second)
+            return dt_class(full_year, month, day, hour, minute, second, microsecond)
         except ValueError as exc:
             raise S7ProtocolError("Clock response contains an invalid BCD timestamp") from exc
 
@@ -1469,6 +1435,8 @@ class S7Protocol:
         response: Dict[str, Any],
         expected_group: int | None = None,
         expected_subfunction: int | None = None,
+        *,
+        accept_null_ack: bool = False,
     ) -> None:
         """Check a USERDATA response for errors.
 
@@ -1477,6 +1445,11 @@ class S7Protocol:
 
         Args:
             response: Parsed S7 response from :meth:`parse_response`.
+            expected_group: Expected function group, if it should be verified.
+            expected_subfunction: Expected subfunction, if it should be verified.
+            accept_null_ack: For services that return no data (set clock, session passwords). Real PLCs
+                acknowledge these with return code 0x0A, transport size 0 and length 0 next to a zero
+                parameter error code, which is then a success.
 
         Raises:
             ~snap7.error.S7ProtocolError: If the response indicates an error.
@@ -1487,6 +1460,8 @@ class S7Protocol:
             if param_error != 0:
                 error_msg = get_protocol_error_message(param_error)
                 raise S7ProtocolError(f"USERDATA request failed: {error_msg} (0x{param_error:04x})")
+            if params.get("last_data_unit", 0) not in (0x00, 0x01):
+                raise S7ProtocolError(f"Invalid USERDATA last data unit value 0x{params['last_data_unit']:02x}")
             if expected_group is not None and params.get("group") != expected_group:
                 raise S7ProtocolError("Unexpected USERDATA response function group")
             if expected_subfunction is not None and params.get("subfunction") != expected_subfunction:
@@ -1497,7 +1472,13 @@ class S7Protocol:
         data_info = response.get("data", {})
         if isinstance(data_info, dict):
             return_code = data_info.get("return_code", 0xFF)
-            if return_code != 0xFF:
+            null_ack = (
+                accept_null_ack
+                and return_code == 0x0A
+                and data_info.get("transport_size", 0) == 0
+                and data_info.get("data_length", 0) == 0
+            )
+            if return_code != 0xFF and not null_ack:
                 desc = get_return_code_description(return_code)
                 raise S7ProtocolError(f"USERDATA request failed: {desc} (0x{return_code:02x})")
         else:
@@ -1580,8 +1561,9 @@ class S7Protocol:
         if pdu_type not in (S7PDUType.ACK, S7PDUType.ACK_DATA, S7PDUType.USERDATA):
             raise S7ProtocolError(f"Expected response PDU, got {pdu_type}")
 
+        # Like native Snap7, treat the whole 16-bit header error word as the failure indicator
         combined_error = (error_class << 8) | error_code
-        if error_class != 0:
+        if combined_error != 0:
             error_msg = get_protocol_error_message(combined_error)
             raise S7ProtocolError(
                 f"S7 protocol error (class={error_class:#04x}, code={error_code:#04x}): {error_msg}",
@@ -1633,7 +1615,9 @@ class S7Protocol:
             raise S7ProtocolError("S7 response contains trailing bytes")
 
         if pdu_type == S7PDUType.USERDATA:
-            self.check_userdata_response(response)
+            # The null acknowledgement is only a success for no-data services; callers that expect data
+            # run check_userdata_response again without accept_null_ack.
+            self.check_userdata_response(response, accept_null_ack=True)
 
         return response
 
@@ -1707,7 +1691,7 @@ class S7Protocol:
             [6]    Subfunction
             [7]    Sequence number (used as DataRef in follow-up)
             [8]    Data unit reference
-            [9]    Last data unit (0x00 = last, non-zero = more)
+            [9]    Last data unit (0x00 = last, 0x01 = more)
             [10-11] Error code
         """
         type_group = param_data[5]

snap7/server/__init__.py

@@ -1129,14 +1129,10 @@ class Server:
             pi_service = params.get("pi_service", b"")
 
             # Check for PI service operations
-            if pi_service == b"_MSZL":
-                file_id = params.get("file_id", b"")
-                if file_id == b"P":
-                    # Copy RAM to ROM
-                    logger.info(f"Copy RAM to ROM requested from {client_address}")
-                else:
-                    # Compress memory
-                    logger.info(f"Compress memory requested from {client_address}")
+            if pi_service == b"_MODU":
+                logger.info(f"Copy RAM to ROM requested from {client_address}")
+            elif pi_service == b"_GARB":
+                logger.info(f"Compress memory requested from {client_address}")
             elif len(params) >= 2:
                 # Has restart type parameter - start operation
                 restart_type = params.get("restart_type", 1)
@@ -1411,9 +1407,10 @@ class Server:
             if b"P_PROGRAM" in param_data:
                 restart_type = 2 if b"C " in param_data else 1
                 return {"function_code": function_code, "restart_type": restart_type, "pi_service": b"P_PROGRAM"}
-            elif b"_MSZL" in param_data:
-                file_id = b"P" if b"P_MSZL" in param_data else b""
-                return {"function_code": function_code, "pi_service": b"_MSZL", "file_id": file_id}
+            elif b"_MODU" in param_data:
+                return {"function_code": function_code, "pi_service": b"_MODU", "file_id": b"EP"}
+            elif b"_GARB" in param_data:
+                return {"function_code": function_code, "pi_service": b"_GARB"}
             elif b"_DELE" in param_data:
                 return {"function_code": function_code, "pi_service": b"_DELE"}
             if len(param_data) >= 2 and param_data[1] in (1, 2):
@@ -1867,15 +1864,17 @@ class Server:
         """
         Handle get clock request - returns current server time.
 
-        Returns time in BCD format (8 bytes):
+        Returns time in BCD format (10 bytes, as native Snap7 ``TResDataGetTime``):
         - Byte 0: Reserved (0x00)
-        - Byte 1: Year (BCD, 0-99)
-        - Byte 2: Month (BCD, 1-12)
-        - Byte 3: Day (BCD, 1-31)
-        - Byte 4: Hour (BCD, 0-23)
-        - Byte 5: Minute (BCD, 0-59)
-        - Byte 6: Second (BCD, 0-59)
-        - Byte 7: Day of week (1=Monday)
+        - Byte 1: Century (0x19 for years 1990-1999, 0x20 for 2000-2089)
+        - Byte 2: Year (BCD, 0-99)
+        - Byte 3: Month (BCD, 1-12)
+        - Byte 4: Day (BCD, 1-31)
+        - Byte 5: Hour (BCD, 0-23)
+        - Byte 6: Minute (BCD, 0-59)
+        - Byte 7: Second (BCD, 0-59)
+        - Byte 8: Milliseconds hundreds/tens (BCD)
+        - Byte 9: Milliseconds ones (high nibble) and day of week (low nibble, 1=Sunday .. 7=Saturday)
         """
         from datetime import datetime
 
@@ -1885,16 +1884,19 @@ class Server:
             return ((value // 10) << 4) | (value % 10)
 
         year = now.year % 100
+        millisecond = now.microsecond // 1000
         bcd_time = struct.pack(
-            ">BBBBBBBB",
+            ">BBBBBBBBBB",
             0x00,  # Reserved
+            0x19 if now.year < 2000 else 0x20,  # Century
             to_bcd(year),  # Year (BCD)
             to_bcd(now.month),  # Month (BCD)
             to_bcd(now.day),  # Day (BCD)
             to_bcd(now.hour),  # Hour (BCD)
             to_bcd(now.minute),  # Minute (BCD)
             to_bcd(now.second),  # Second (BCD)
-            (now.weekday() + 1) & 0x0F,  # Day of week (1=Monday)
+            to_bcd(millisecond // 10),  # Milliseconds hundreds/tens (BCD)
+            ((millisecond % 10) << 4) | (now.isoweekday() % 7 + 1),  # Milliseconds ones, day of week (1=Sunday)
         )
 
         logger.debug(f"Get clock from {client_address}: returning {now}")
@@ -1940,8 +1942,8 @@ class Server:
 
         logger.info(f"Set clock from {client_address}: {timestamp}")
 
-        # Return success (empty response data)
-        return self._build_userdata_success_response(request, userdata_params, b"")
+        # Return success (null acknowledgement, as real PLCs send for set clock)
+        return self._build_userdata_success_response(request, userdata_params, b"", null_ack=True)
 
     def _handle_security(
         self, request: Dict[str, Any], userdata_params: Dict[str, Any], client_address: Tuple[str, int]
@@ -1953,7 +1955,7 @@ class Server:
         """
         logger.debug(f"Security request from {client_address} (returning success)")
         # Return success - emulator doesn't require password
-        return self._build_userdata_success_response(request, userdata_params, b"")
+        return self._build_userdata_success_response(request, userdata_params, b"", null_ack=True)
 
     def _handle_list_all_blocks(
         self, request: Dict[str, Any], userdata_params: Dict[str, Any], client_address: Tuple[str, int]
@@ -2098,13 +2100,13 @@ class Server:
         # Block type code constants
         block_db = 0x41  # Data Block
 
-        # Parse request: handle new format [0x30, type, 'A', ASCII_num(5)]
+        # Parse request: handle the Snap7 format [0x30, type, ASCII_num(5), 'A']
         # and old format [type, num(2), 0x41]
         if len(raw_data) >= 8 and raw_data[0] == 0x30:
-            # New format: 0x30 + type + 'A' + 5-digit ASCII number
+            # Snap7 format: 0x30 + type + 5-digit ASCII number + 'A'
             requested_type = raw_data[1]
             try:
-                block_number = int(raw_data[3:8].decode("ascii"))
+                block_number = int(raw_data[2:7].decode("ascii"))
             except (ValueError, UnicodeDecodeError):
                 block_number = 1
         elif len(raw_data) >= 3:
@@ -2198,7 +2200,9 @@ class Server:
 
         return header + param_data + data_section
 
-    def _build_userdata_success_response(self, request: Dict[str, Any], userdata_params: Dict[str, Any], data: bytes) -> bytes:
+    def _build_userdata_success_response(
+        self, request: Dict[str, Any], userdata_params: Dict[str, Any], data: bytes, null_ack: bool = False
+    ) -> bytes:
         """
         Build USER_DATA success response PDU.
 
@@ -2206,6 +2210,8 @@ class Server:
             request: Original request
             userdata_params: Parsed USER_DATA parameters
             data: Response data
+            null_ack: Acknowledge with the no-data form a real PLC uses for services that return nothing
+                (return code 0x0A, transport size 0, length 0) instead of 0xFF/0x09
 
         Returns:
             Success response PDU
@@ -2232,7 +2238,10 @@ class Server:
         )
 
         # Data section: return code (0xFF = success) + data
-        data_section = struct.pack(">BBH", 0xFF, 0x09, len(data)) + data
+        if null_ack:
+            data_section = struct.pack(">BBH", 0x0A, 0x00, 0)
+        else:
+            data_section = struct.pack(">BBH", 0xFF, 0x09, len(data)) + data
 
         # Build S7 header for USERDATA (10 bytes, no error_class/error_code in header)
         header = struct.pack(

snap7/szl.py

@@ -104,7 +104,7 @@ def _parse_order_code_structured(data: bytes, record_len: int, ndr: int, order_c
 
         if record_id == 0x0001 and record_len >= 22:
             found_structured = True
-            order_code.OrderCode = rec[2:22].rstrip(b"\x00")
+            order_code.OrderCode = rec[2:22].rstrip(b"\x00 ")
             if record_len >= 26 and not has_0x0007 and (rec[23] != 0 or rec[24] != 0):
                 order_code.V1, order_code.V2, order_code.V3 = rec[23], rec[24], rec[25]
 

snap7/util/getters.py

@@ -218,6 +218,10 @@ def get_string(bytearray_: Buffer, byte_index: int, encoding: str = "latin-1") -
             "String contains {str_length} chars, but max. {max_string_size} chars are expected or is "
             "larger than 254. Bytearray doesn't seem to be a valid string."
         )
+    if byte_index + 2 + str_length > len(bytearray_):
+        raise ValueError(
+            f"String contains {str_length} chars, but only {len(bytearray_) - byte_index - 2} bytes are in the buffer"
+        )
     raw = bytes(bytearray_[byte_index + 2 : byte_index + 2 + str_length])
     return raw.decode(encoding)
 
@@ -781,17 +785,22 @@ def get_wstring(bytearray_: Buffer, byte_index: int) -> str:
 
     max_wstring_size = bytearray_[byte_index : byte_index + 2]
     packed = struct.pack("2B", *max_wstring_size)
-    max_wstring_symbols = struct.unpack(">H", packed)[0] * 2
+    max_wstring_chars = struct.unpack(">H", packed)[0]
 
     wstr_length_raw = bytearray_[byte_index + 2 : byte_index + 4]
-    wstr_symbols_amount = struct.unpack(">H", struct.pack("2B", *wstr_length_raw))[0] * 2
+    wstr_chars = struct.unpack(">H", struct.pack("2B", *wstr_length_raw))[0]
 
-    if wstr_symbols_amount > max_wstring_symbols or max_wstring_symbols > 16382:
+    if wstr_chars > max_wstring_chars or max_wstring_chars > 16382:
         logger.error("The wstring is too big for the size encountered in specification")
         logger.error("WRONG SIZED STRING ENCOUNTERED")
         raise TypeError(
-            f"WString contains {wstr_symbols_amount} chars, but max {max_wstring_symbols} chars are "
+            f"WString contains {wstr_chars} chars, but max {max_wstring_chars} chars are "
             f"expected or is larger than 16382. Bytearray doesn't seem to be a valid string."
         )
 
-    return bytes(bytearray_[wstring_start : wstring_start + wstr_symbols_amount]).decode("utf-16-be")
+    wstr_bytes = wstr_chars * 2
+    if wstring_start + wstr_bytes > len(bytearray_):
+        raise ValueError(
+            f"WString contains {wstr_chars} chars, but only {len(bytearray_) - wstring_start} bytes are in the buffer"
+        )
+    return bytes(bytearray_[wstring_start : wstring_start + wstr_bytes]).decode("utf-16-be")