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

snap7/async_client.py

@@ -10,15 +10,19 @@ import asyncio
 import logging
 import struct
 import time
-from typing import List, Any, Optional, Tuple, Type
+from collections.abc import Callable, Sequence
+from contextvars import ContextVar
+from typing import List, Any, Optional, Tuple, Type, Union
 from types import TracebackType
 from datetime import datetime
 
 from .connection import TPDUSize
-from .s7protocol import S7Protocol, get_return_code_description
+from .s7protocol import S7Protocol, S7UserDataGroup, S7UserDataSubfunction, get_return_code_description
 from .datatypes import S7DataTypes, S7WordLen
 from .error import S7Error, S7ConnectionError, S7ProtocolError, S7TimeoutError
-from .client_base import ClientMixin
+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
@@ -57,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,
@@ -81,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
@@ -202,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
 
@@ -319,6 +339,7 @@ class AsyncClient(ClientMixin):
         rate_limit_algorithm: RateLimitAlgorithm = "fixed",
         rate_limit_behavior: RateLimitBehavior = "block",
         rate_limit_burst: int | None = None,
+        on_operation: Optional[Callable[[str, float, bool], None]] = None,
     ) -> None:
         self.connection: Optional[AsyncISOTCPConnection] = None
         self.protocol = S7Protocol()
@@ -336,6 +357,8 @@ class AsyncClient(ClientMixin):
 
         self._exec_time = 0
         self._last_error = 0
+        self._on_operation = on_operation
+        self._operation_depth: ContextVar[int] = ContextVar("snap7_async_client_operation_depth", default=0)
 
         self._lock = asyncio.Lock()
         self._rate_limiter = RequestRateLimiter(
@@ -452,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.
 
@@ -503,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.
 
@@ -539,6 +852,7 @@ class AsyncClient(ClientMixin):
     # Core read / write
     # ---------------------------------------------------------------
 
+    @_instrumented("read_area")
     async def read_area(self, area: Area, db_number: int, start: int, size: int) -> bytearray:
         """Read data from memory area.
 
@@ -585,6 +899,7 @@ class AsyncClient(ClientMixin):
         self._exec_time = int((time.time() - start_time) * 1000)
         return result
 
+    @_instrumented("write_area")
     async def write_area(self, area: Area, db_number: int, start: int, data: bytearray) -> int:
         """Write data to memory area.
 
@@ -630,6 +945,7 @@ class AsyncClient(ClientMixin):
         self._exec_time = int((time.time() - start_time) * 1000)
         return 0
 
+    @_instrumented("read_multi_vars")
     async def read_multi_vars(self, items: List[dict[str, Any]]) -> Tuple[int, list[bytearray]]:
         """Read multiple variables (sequentially, one read_area per item).
 
@@ -654,6 +970,7 @@ class AsyncClient(ClientMixin):
             results.append(data)
         return (0, results)
 
+    @_instrumented("write_multi_vars")
     async def write_multi_vars(self, items: List[dict[str, Any]]) -> int:
         """Write multiple variables (sequentially, one write_area per item).
 
@@ -687,6 +1004,7 @@ class AsyncClient(ClientMixin):
 
         request = self.protocol.build_list_blocks_request()
         response = await self._send_receive(request)
+        self.protocol.check_userdata_response(response, S7UserDataGroup.BLOCK_INFO, S7UserDataSubfunction.LIST_ALL)
 
         data_info = response.get("data", {})
         return_code = data_info.get("return_code", 0xFF) if isinstance(data_info, dict) else 0xFF
@@ -719,6 +1037,7 @@ class AsyncClient(ClientMixin):
 
         request = self.protocol.build_list_blocks_of_type_request(type_code)
         response = await self._send_receive(request)
+        self.protocol.check_userdata_response(response, S7UserDataGroup.BLOCK_INFO, S7UserDataSubfunction.LIST_BLOCKS_OF_TYPE)
 
         data_info = response.get("data", {})
         return_code = data_info.get("return_code", 0xFF) if isinstance(data_info, dict) else 0xFF
@@ -744,6 +1063,7 @@ class AsyncClient(ClientMixin):
                 response_data = await conn.receive_data()
 
             response = self.protocol.parse_response(response_data)
+            self.protocol.check_userdata_response(response, S7UserDataGroup.BLOCK_INFO, S7UserDataSubfunction.LIST_BLOCKS_OF_TYPE)
 
             data_info = response.get("data", {})
             return_code = data_info.get("return_code", 0xFF) if isinstance(data_info, dict) else 0xFF
@@ -779,6 +1099,7 @@ class AsyncClient(ClientMixin):
 
         request = self.protocol.build_get_block_info_request(type_code, db_number)
         response = await self._send_receive(request)
+        self.protocol.check_userdata_response(response, S7UserDataGroup.BLOCK_INFO, S7UserDataSubfunction.BLOCK_INFO)
 
         data_info = response.get("data", {})
         return_code = data_info.get("return_code", 0xFF) if isinstance(data_info, dict) else 0xFF
@@ -808,6 +1129,7 @@ class AsyncClient(ClientMixin):
     # Upload / Download / Delete
     # ---------------------------------------------------------------
 
+    @_instrumented("upload")
     async def upload(self, block_num: int) -> bytearray:
         """Upload block from PLC (3-step: START_UPLOAD, UPLOAD, END_UPLOAD)."""
         if not self.get_connected():
@@ -819,19 +1141,27 @@ class AsyncClient(ClientMixin):
         response = await self._send_receive(request)
 
         upload_info = self.protocol.parse_start_upload_response(response)
-        upload_id = upload_info.get("upload_id", 1)
-
-        request = self.protocol.build_upload_request(upload_id)
-        response = await self._send_receive(request)
+        upload_id = upload_info["upload_id"]
 
-        block_data = self.protocol.parse_upload_response(response)
+        block_data = bytearray()
+        for fragment_index in range(1000):
+            request = self.protocol.build_upload_request(upload_id)
+            response = await self._send_receive(request)
+            fragment, is_last = self.protocol.parse_upload_fragment(response, first_fragment=fragment_index == 0)
+            block_data.extend(fragment)
+            if is_last:
+                break
+        else:
+            raise S7ProtocolError("Upload response exceeded fragment limit")
 
         request = self.protocol.build_end_upload_request(upload_id)
         response = await self._send_receive(request)
+        self.protocol.check_end_upload_response(response)
 
         logger.info(f"Uploaded {len(block_data)} bytes from block {block_num}")
-        return bytearray(block_data)
+        return block_data
 
+    @_instrumented("download")
     async def download(self, data: bytearray, block_num: int = -1) -> int:
         """Download block to PLC."""
         if not self.get_connected():
@@ -846,44 +1176,33 @@ class AsyncClient(ClientMixin):
             else:
                 block_num = 1
 
-        # Step 1: Request download
         request = self.protocol.build_download_request(block_type, block_num, bytes(data))
-        await self._send_receive(request)
-
-        # Step 2: Download block (send data)
-        param_data = struct.pack(">BBB", 0x1B, 0x01, 0x00)
-        data_section = struct.pack(">HH", len(data), 0x00FB) + bytes(data)
-        header = struct.pack(
-            ">BBHHHH",
-            0x32,
-            0x01,
-            0x0000,
-            self.protocol._next_sequence(),
-            len(param_data),
-            len(data_section),
-        )
-
         async with self._lock:
-            await self._send_data(conn, header + param_data + data_section)
+            await self._send_data(conn, request)
             response_data = await conn.receive_data()
-        self.protocol.parse_response(response_data)
-
-        # Step 3: Download ended
-        param_data = struct.pack(">B", 0x1C)
-        header = struct.pack(
-            ">BBHHHH",
-            0x32,
-            0x01,
-            0x0000,
-            self.protocol._next_sequence(),
-            len(param_data),
-            0x0000,
-        )
+            response = self.protocol.parse_response(response_data)
+            if response["sequence"] != int.from_bytes(request[4:6], "big") or response.get("raw_parameters") != bytes((0x1A,)):
+                raise S7ProtocolError("Invalid request-download acknowledgement")
+
+            offset = 0
+            max_slice = self.pdu_length - 18
+            if max_slice <= 0:
+                raise S7ProtocolError("Negotiated PDU is too small for download")
+            for _ in range(1000):
+                request_data = await conn.receive_data()
+                sequence = self.protocol.parse_download_service_request(request_data, 0x1B, block_num)
+                fragment = bytes(data[offset : offset + max_slice])
+                offset += len(fragment)
+                is_last = offset == len(data)
+                await self._send_data(conn, self.protocol.build_download_fragment_response(sequence, is_last, fragment))
+                if is_last:
+                    break
+            else:
+                raise S7ProtocolError("Download exceeded fragment limit")
 
-        async with self._lock:
-            await self._send_data(conn, header + param_data)
-            response_data = await conn.receive_data()
-        self.protocol.parse_response(response_data)
+            request_data = await conn.receive_data()
+            sequence = self.protocol.parse_download_service_request(request_data, 0x1C, block_num)
+            await self._send_data(conn, self.protocol.build_download_ended_response(sequence))
 
         logger.info(f"Downloaded {len(data)} bytes to block {block_num}")
         return 0
@@ -931,32 +1250,27 @@ class AsyncClient(ClientMixin):
         response = await self._send_receive(request)
 
         upload_info = self.protocol.parse_start_upload_response(response)
-        upload_id = upload_info.get("upload_id", 1)
+        upload_id = upload_info["upload_id"]
 
-        request = self.protocol.build_upload_request(upload_id)
-        response = await self._send_receive(request)
-        block_data = self.protocol.parse_upload_response(response)
+        block_data = bytearray()
+        for fragment_index in range(1000):
+            request = self.protocol.build_upload_request(upload_id)
+            response = await self._send_receive(request)
+            fragment, is_last = self.protocol.parse_upload_fragment(
+                response, first_fragment=fragment_index == 0, include_block_header=True
+            )
+            block_data.extend(fragment)
+            if is_last:
+                break
+        else:
+            raise S7ProtocolError("Upload response exceeded fragment limit")
 
         request = self.protocol.build_end_upload_request(upload_id)
         response = await self._send_receive(request)
+        self.protocol.check_end_upload_response(response)
 
-        block_header = struct.pack(
-            ">BBHBBBBHH",
-            0x70,
-            block_type.value,
-            block_num,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            len(block_data) + 14,
-            len(block_data),
-        )
-        block_footer = b"\x00" * 4
-        full_block = bytearray(block_header + block_data + block_footer)
-
-        logger.info(f"Full upload of block {block_type.name} {block_num}: {len(full_block)} bytes")
-        return full_block, len(full_block)
+        logger.info(f"Full upload of block {block_type.name} {block_num}: {len(block_data)} bytes")
+        return block_data, len(block_data)
 
     # ---------------------------------------------------------------
     # PLC control
@@ -994,6 +1308,7 @@ class AsyncClient(ClientMixin):
 
         request = self.protocol.build_get_clock_request()
         response = await self._send_receive(request)
+        self.protocol.check_userdata_response(response, S7UserDataGroup.TIME, S7UserDataSubfunction.GET_CLOCK)
         return self.protocol.parse_get_clock_response(response)
 
     async def set_plc_datetime(self, dt: datetime) -> int:
@@ -1002,7 +1317,10 @@ class AsyncClient(ClientMixin):
             raise S7ConnectionError("Not connected to PLC")
 
         request = self.protocol.build_set_clock_request(dt)
-        await self._send_receive(request)
+        response = await self._send_receive(request)
+        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
 
@@ -1032,6 +1350,7 @@ class AsyncClient(ClientMixin):
 
         request = self.protocol.build_read_szl_request(ssl_id, index)
         response = await self._send_receive(request)
+        self.protocol.check_userdata_response(response, S7UserDataGroup.SZL, S7UserDataSubfunction.READ_SZL)
 
         data_info = response.get("data", {})
         return_code = data_info.get("return_code", 0xFF) if isinstance(data_info, dict) else 0xFF
@@ -1058,6 +1377,7 @@ class AsyncClient(ClientMixin):
                 response_data = await conn.receive_data()
 
             response = self.protocol.parse_response(response_data)
+            self.protocol.check_userdata_response(response, S7UserDataGroup.SZL, S7UserDataSubfunction.READ_SZL)
 
             data_info = response.get("data", {})
             return_code = data_info.get("return_code", 0xFF) if isinstance(data_info, dict) else 0xFF
@@ -1080,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():
@@ -1188,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)
+        self.protocol.check_userdata_response(
+            response, S7UserDataGroup.SECURITY, S7UserDataSubfunction.SET_SESSION_PASSWORD, accept_null_ack=True
+        )
         logger.info("Session password set successfully")
         return 0
 
@@ -1209,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)
+        self.protocol.check_userdata_response(
+            response, S7UserDataGroup.SECURITY, S7UserDataSubfunction.CLEAR_SESSION_PASSWORD, accept_null_ack=True
+        )
         logger.info("Session password cleared successfully")
         return 0