python-s7comm 0.1.0__py3-none-any.whl

python_s7comm/__init__.py

@@ -0,0 +1,10 @@
+from .async_client import AsyncClient
+from .s7comm import S7Comm
+from .sync_client import Client
+
+
+__all__ = [
+    "S7Comm",
+    "Client",
+    "AsyncClient",
+]

python_s7comm/async_client.py

@@ -0,0 +1,79 @@
+from .s7comm import AsyncS7Comm, enums
+from .s7comm.packets.variable_address import VariableAddress
+from .s7comm.szl import (
+    CPUStateDataTree,
+    ModuleIdentificationDataTree,
+    ModuleIdentificationIndex,
+    SZLResponseData,
+)
+
+
+class AsyncClient:
+    def __init__(
+        self,
+        tpdu_size: int = 1024,  # cotp packet length
+        pdu_length: int = 480,  # s7comm packet length
+        source_tsap: int = 0x0100,
+        dest_tsap: int = 0x0101,
+    ) -> None:
+        self.s7comm = AsyncS7Comm(
+            tpdu_size=tpdu_size,
+            pdu_length=pdu_length,
+            source_tsap=source_tsap,
+            dest_tsap=dest_tsap,
+        )
+        self.is_connected = False
+
+    async def connect(self, address: str, rack: int, slot: int, port: int = 102) -> None:
+        await self.s7comm.connect(address=address, rack=rack, slot=slot, port=port)
+        self.is_connected = True
+
+    async def disconnect(self) -> None:
+        await self.close()
+        self.is_connected = False
+
+    def get_pdu_length(self) -> int:
+        return self.s7comm.pdu_length
+
+    async def close(self) -> None:
+        await self.s7comm.close()
+
+    async def get_cpu_state(self) -> enums.CPUStatus:
+        response = await self.s7comm.read_szl(szl_id=0x0424, szl_index=0x0000)
+        response_data = SZLResponseData.parse(response.data.data)
+        cpu_state = CPUStateDataTree.parse(response_data.szl_data_tree_list[0])
+        return cpu_state.requested_mode
+
+    async def read_area(self, address: str) -> bytes:
+        return await self.s7comm.read_area(VariableAddress.from_string(address))
+
+    async def write_area(self, address: str, data: bytes) -> None:
+        await self.s7comm.write_area(address=VariableAddress.from_string(address), data=data)
+
+    async def get_order_code(self) -> str | None:
+        response = await self.s7comm.read_szl(szl_id=0x0011, szl_index=0x0000)
+        szl_data = SZLResponseData.parse(response.data.data)
+        for date_tree in szl_data.szl_data_tree_list:
+            module_identification = ModuleIdentificationDataTree.parse(date_tree)
+            if module_identification.index == ModuleIdentificationIndex.MODULE_IDENTIFICATION:
+                return module_identification.order_number
+        return None
+
+    async def read_szl(self, szl_id: int, szl_index: int = 0x0000) -> SZLResponseData:
+        response_data = await self.s7comm.read_szl(szl_id=szl_id, szl_index=szl_index)
+        return SZLResponseData.parse(response_data.data.data)
+
+    async def read_szl_list(self) -> SZLResponseData:
+        response_data = await self.s7comm.read_szl(szl_id=0x0000, szl_index=0x0000)
+        return SZLResponseData.parse(response_data.data.data)
+
+    async def read_multi_vars(self, items: list[str]) -> list[bytes]:
+        vars_ = [VariableAddress.from_string(item) for item in items]
+        response = await self.s7comm.read_multi_vars(items=vars_)
+        return response.values()
+
+    async def write_multi_vars(self, items: list[tuple[str, bytes]]) -> None:
+        vars_ = [(VariableAddress.from_string(address), data) for address, data in items]
+        response = await self.s7comm.write_multi_vars(items=vars_)
+        response.check_result()
+        return None

python_s7comm/s7comm/__init__.py

@@ -0,0 +1,6 @@
+from .async_client import AsyncS7Comm
+from .client import S7Comm
+from .exceptions import PacketLostError, StalePacketError
+
+
+__all__ = ["S7Comm", "AsyncS7Comm", "PacketLostError", "StalePacketError"]

python_s7comm/s7comm/async_client.py

@@ -0,0 +1,192 @@
+import asyncio
+import logging
+import struct
+from typing import cast
+
+from .base import BaseS7Comm
+from .enums import HeaderError, ItemReturnCode, MessageType, SubfunctionCode, UserdataFunction, UserdataLastPDU
+from .error_messages import ERROR_MESSAGES
+from .exceptions import PacketLostError, StalePacketError
+from .packets import (
+    RequestPLCStop,
+    S7AckDataHeader,
+    S7Packet,
+    SetupCommunicationRequest,
+    UserDataContinuationRequest,
+    UserDataRequest,
+    UserDataResponse,
+    VariableAddress,
+    VariableReadRequest,
+    VariableWriteRequest,
+)
+from .packets.exceptions import ReadVariableException
+from .packets.parser import S7PacketParser
+from .packets.rw_variable import ReadVariableResponse, WriteVariableResponse
+from .transport import AsyncCOTP, AsyncTransport
+
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncS7Comm(BaseS7Comm):
+    def __init__(
+        self,
+        tpdu_size: int = 1024,
+        pdu_length: int = 480,
+        source_tsap: int = 0x0100,
+        dest_tsap: int = 0x0101,
+        transport: AsyncTransport | None = None,
+    ):
+        super().__init__(pdu_length=pdu_length)
+        self.transport: AsyncTransport
+        if transport is None:
+            self.transport = AsyncCOTP(tpdu_size=tpdu_size, source_tsap=source_tsap, dest_tsap=dest_tsap)
+        else:
+            self.transport = transport
+        self.lock = asyncio.Lock()
+
+    async def connect(
+        self,
+        address: str,
+        rack: int,
+        slot: int,
+        port: int = 102,
+        max_amq_caller_ack: int = 0x0001,
+        max_amq_callee_ack: int = 0x0001,
+        pdu_length: int = 0x01E0,
+    ) -> None:
+        await self.transport.connect(address=address, rack=rack, slot=slot, port=port)
+
+        request = self._create_communication_request(
+            max_amq_caller_ack=max_amq_caller_ack,
+            max_amq_callee_ack=max_amq_callee_ack,
+            pdu_length=pdu_length,
+        )
+        response = await self.send(request=request)
+        if not isinstance(response, SetupCommunicationRequest):
+            raise ValueError("Invalid packet")
+        self.pdu_length = response.parameter.pdu_length
+
+    async def send(self, request: S7Packet) -> S7Packet:
+        async with self.lock:
+            await self._send_raw(request)
+            response = await self._receive()
+
+            # Validate PDU reference, retry receive if stale packet
+            while True:
+                if response.header is None:
+                    raise ValueError("Response header is None")
+                try:
+                    self._validate_pdu_reference(response=response)
+                    break
+                except StalePacketError:
+                    logger.warning("Dropping stale packet")
+                    response = await self._receive()  # retry receive
+                    continue
+                except PacketLostError:
+                    raise  # unrecoverable
+
+            if response.header.message_type == MessageType.Userdata and isinstance(response, UserDataResponse):
+                accumulated_data = response.data.data
+                while response.parameter.last_data_unit == UserdataLastPDU.NO:
+                    continuation_request = UserDataContinuationRequest.from_response(response)
+                    await self._send_raw(continuation_request)
+                    next_response = await self._receive()
+                    if not isinstance(next_response, UserDataResponse):
+                        raise ValueError("Expected UserDataResponse for continuation")
+                    accumulated_data += next_response.data.data
+                    response = next_response
+                response.data.data = accumulated_data
+            # Check Error
+            if isinstance(response.header, S7AckDataHeader) and response.header.error_code != HeaderError.NO_ERROR:
+                error_message = ERROR_MESSAGES.get(0x81 << 8 | 0x04, "Unknown Error")
+                raise ValueError(
+                    f"Error class {response.header.error_class}, "
+                    f"error code: f{response.header.error_code}, "
+                    f"error message: {error_message}"
+                )
+            return response
+
+    async def _send_raw(self, request: S7Packet) -> None:
+        packet = self._create_packet(request=request, pdu_reference=self.pdu_reference)
+        await self.transport.send(payload=packet)
+
+    async def _receive(self) -> S7Packet:
+        """Receive and parse S7 packet from transport."""
+        return S7PacketParser.parse(await self.transport.receive())
+
+    async def close(self) -> None:
+        await self.transport.close()
+
+    async def read_area(self, address: VariableAddress) -> bytes:
+        result = bytes()
+        main_request = VariableReadRequest.create(items=[address])
+
+        async for request in main_request.async_request_generator(pdu_length=self.pdu_length):
+            response = await self.send(request=request)
+            if isinstance(response, ReadVariableResponse):
+                for response_item in response.data:
+                    if response_item.return_code != ItemReturnCode.SUCCESS:
+                        raise ReadVariableException(
+                            f"DataItem return code: {response_item.return_code}", response=response
+                        )
+                    result += response_item.data
+        return result
+
+    async def write_area(self, address: VariableAddress, data: bytes) -> WriteVariableResponse:
+        """
+        Writes data to PLC memory area with automatic splitting into multiple requests
+        if data exceeds PDU size.
+
+        Args:
+            address: Memory area address (e.g., "M0 INT 1")
+            data: Data to write
+
+        Returns:
+            WriteVariableResponse with operation result
+        """
+        main_request = VariableWriteRequest.create(items=[(address, data)])
+        for request in main_request.request_generator(pdu_length=self.pdu_length):
+            response = await self.send(request=request)
+            if not isinstance(response, WriteVariableResponse):
+                raise ValueError("Invalid response class")
+            response.check_result()
+            # TODO: combine all separate requests into one common initial request and return
+        return cast(WriteVariableResponse, response)
+
+    async def read_multi_vars(self, items: list[VariableAddress]) -> ReadVariableResponse:
+        if len(items) > self.MAX_VARS:
+            raise ValueError("Too many items")
+
+        request = VariableReadRequest.create(items=items)
+        response = await self.send(request=request)
+        if not isinstance(response, ReadVariableResponse):
+            raise ValueError("Invalid response class")
+        return response
+
+    async def write_multi_vars(self, items: list[tuple[VariableAddress, bytes]]) -> WriteVariableResponse:
+        if len(items) > self.MAX_VARS:
+            raise ValueError("Too many items")
+
+        request = VariableWriteRequest.create(items=items)
+        response = await self.send(request=request)
+        if not isinstance(response, WriteVariableResponse):
+            raise ValueError("Invalid response class")
+        return response
+
+    async def read_szl(self, szl_id: int, szl_index: int) -> UserDataResponse:
+        data = struct.pack("!HH", szl_id, szl_index)
+        request = UserDataRequest.create(
+            function_group=UserdataFunction.CPU_FUNCTION,
+            subfunction=SubfunctionCode.READ_SZL,
+            length=len(data),
+            data=data,
+        )
+        response = await self.send(request=request)
+        if not isinstance(response, UserDataResponse):
+            raise ValueError("Invalid response class")
+        return response
+
+    async def plc_stop(self) -> S7Packet:
+        response = await self.send(request=RequestPLCStop())
+        return response

python_s7comm/s7comm/base.py

@@ -0,0 +1,54 @@
+from .exceptions import PacketLostError, StalePacketError
+from .packets import (
+    S7Header,
+    S7Packet,
+    SetupCommunicationParameter,
+    SetupCommunicationRequest,
+)
+
+
+class BaseS7Comm:
+    MAX_VARS = 20  # Max vars that can be transferred with MultiRead/MultiWrite
+
+    def __init__(self, pdu_length: int = 480) -> None:
+        self._pdu_reference = -1
+        self.pdu_length = pdu_length
+
+    @property
+    def pdu_reference(self) -> int:
+        self._pdu_reference = (self._pdu_reference + 1) & 0xFFFF
+        return self._pdu_reference
+
+    @staticmethod
+    def _create_communication_request(
+        max_amq_caller_ack: int = 0x0001,
+        max_amq_callee_ack: int = 0x0001,
+        pdu_length: int = 0x01E0,
+    ) -> SetupCommunicationRequest:
+        parameter = SetupCommunicationParameter(
+            max_amq_caller_ack=max_amq_caller_ack,
+            max_amq_callee_ack=max_amq_callee_ack,
+            pdu_length=pdu_length,
+        )
+        return SetupCommunicationRequest(parameter=parameter)
+
+    @staticmethod
+    def _create_packet(request: S7Packet, pdu_reference: int) -> bytes:
+        parameter = request.serialize_parameter()
+        data = request.serialize_data()
+        header = S7Header(
+            pdu_reference=pdu_reference,
+            message_type=request.MESSAGE_TYPE,
+            parameter_length=len(parameter),
+            data_length=len(data),
+        )
+        request.header = header
+        return bytes(header.serialize() + parameter + data)
+
+    def _validate_pdu_reference(self, response: S7Packet) -> None:
+        """Raises if PDU reference is invalid."""
+        assert response.header is not None
+        if response.header.pdu_reference > self._pdu_reference:
+            raise PacketLostError(f"Expected {self._pdu_reference}, got {response.header.pdu_reference}")
+        elif response.header.pdu_reference < self._pdu_reference:
+            raise StalePacketError(f"Stale packet: {response.header.pdu_reference}")

python_s7comm/s7comm/client.py

@@ -0,0 +1,185 @@
+import logging
+import struct
+from typing import cast
+
+from .base import BaseS7Comm
+from .enums import HeaderError, ItemReturnCode, MessageType, SubfunctionCode, UserdataFunction, UserdataLastPDU
+from .error_messages import ERROR_MESSAGES
+from .exceptions import PacketLostError, StalePacketError
+from .packets import (
+    RequestPLCStop,
+    S7AckDataHeader,
+    S7Packet,
+    SetupCommunicationRequest,
+    UserDataContinuationRequest,
+    UserDataRequest,
+    UserDataResponse,
+    VariableAddress,
+    VariableReadRequest,
+    VariableWriteRequest,
+)
+from .packets.exceptions import ReadVariableException
+from .packets.parser import S7PacketParser
+from .packets.rw_variable import ReadVariableResponse, WriteVariableResponse
+from .transport import COTP, Transport
+
+
+logger = logging.getLogger(__name__)
+
+
+class S7Comm(BaseS7Comm):
+    def __init__(
+        self,
+        tpdu_size: int = 1024,
+        pdu_length: int = 480,
+        source_tsap: int = 0x0100,
+        dest_tsap: int = 0x0101,
+        transport: Transport | None = None,
+    ) -> None:
+        super().__init__(pdu_length=pdu_length)
+        self.transport: Transport
+        if transport is None:
+            self.transport = COTP(tpdu_size=tpdu_size, source_tsap=source_tsap, dest_tsap=dest_tsap)
+        else:
+            self.transport = transport
+
+    def read_multi_vars(self, items: list[VariableAddress]) -> ReadVariableResponse:
+        if len(items) > self.MAX_VARS:
+            raise ValueError("Too many items")
+
+        request = VariableReadRequest.create(items=items)
+        response = self.send(request=request)
+        if not isinstance(response, ReadVariableResponse):
+            raise ValueError("Invalid response class")
+        return response
+
+    def write_multi_vars(self, items: list[tuple[VariableAddress, bytes]]) -> WriteVariableResponse:
+        if len(items) > self.MAX_VARS:
+            raise ValueError("Too many items")
+
+        request = VariableWriteRequest.create(items=items)
+        response = self.send(request=request)
+        if not isinstance(response, WriteVariableResponse):
+            raise ValueError("Invalid response class")
+        return response
+
+    def read_area(self, address: VariableAddress) -> bytes:
+        result = bytes()
+        main_request = VariableReadRequest.create(items=[address])
+
+        for request in main_request.request_generator(pdu_length=self.pdu_length):
+            response = self.send(request=request)
+            if isinstance(response, ReadVariableResponse):
+                for response_item in response.data:
+                    if response_item.return_code != ItemReturnCode.SUCCESS:
+                        raise ReadVariableException(
+                            f"DataItem return code: {response_item.return_code}", response=response
+                        )
+                    result += response_item.data
+        return result
+
+    def write_area(self, address: VariableAddress, data: bytes) -> WriteVariableResponse:
+        """
+        Writes data to PLC memory area with automatic splitting into multiple requests
+        if data exceeds PDU size.
+
+        Args:
+            address: Memory area address (e.g., "M0 INT 1")
+            data: Data to write
+
+        Returns:
+            WriteVariableResponse with operation result
+        """
+        main_request = VariableWriteRequest.create(items=[(address, data)])
+        for request in main_request.request_generator(pdu_length=self.pdu_length):
+            response = self.send(request=request)
+            if not isinstance(response, WriteVariableResponse):
+                raise ValueError("Invalid response class")
+            response.check_result()
+            # TODO: combine all separate requests into one common initial request and return
+        return cast(WriteVariableResponse, response)
+
+    def connect(
+        self,
+        address: str,
+        rack: int,
+        slot: int,
+        port: int = 102,
+        max_amq_caller_ack: int = 0x0001,
+        max_amq_callee_ack: int = 0x0001,
+        pdu_length: int = 0x01E0,
+    ) -> None:
+        self.transport.connect(address=address, rack=rack, slot=slot, port=port)
+        request = self._create_communication_request(
+            max_amq_caller_ack=max_amq_caller_ack,
+            max_amq_callee_ack=max_amq_callee_ack,
+            pdu_length=pdu_length,
+        )
+        response = self.send(request=request)
+        if not isinstance(response, SetupCommunicationRequest):
+            raise ValueError("Invalid packet")
+        self.pdu_length = response.parameter.pdu_length
+
+    def _send_raw(self, request: S7Packet) -> None:
+        packet = self._create_packet(request=request, pdu_reference=self.pdu_reference)
+        self.transport.send(payload=packet)
+
+    def send(self, request: S7Packet) -> S7Packet:
+        self._send_raw(request)
+        response = self._receive()
+
+        # Validate PDU reference, retry receive if stale packet
+        while True:
+            if response.header is None:
+                raise ValueError("Response header is None")
+            try:
+                self._validate_pdu_reference(response=response)
+                break
+            except StalePacketError:
+                logger.warning("Dropping stale packet")
+                response = self._receive()  # retry receive
+                continue
+            except PacketLostError:
+                raise  # unrecoverable
+
+        if response.header.message_type == MessageType.Userdata and isinstance(response, UserDataResponse):
+            accumulated_data = response.data.data
+            while response.parameter.last_data_unit == UserdataLastPDU.NO:
+                continuation_request = UserDataContinuationRequest.from_response(response)
+                self._send_raw(continuation_request)
+                next_response = self._receive()
+                if not isinstance(next_response, UserDataResponse):
+                    raise ValueError("Expected UserDataResponse for continuation")
+                accumulated_data += next_response.data.data
+                response = next_response
+            response.data.data = accumulated_data
+        # Check Error
+        if isinstance(response.header, S7AckDataHeader) and response.header.error_code != HeaderError.NO_ERROR:
+            error_message = ERROR_MESSAGES.get(0x81 << 8 | 0x04, "Unknown Error")
+            raise ValueError(
+                f"Error class {response.header.error_class}, "
+                f"error code: f{response.header.error_code}, "
+                f"error message: {error_message}"
+            )
+        return response
+
+    def _receive(self) -> S7Packet:
+        """Receive and parse S7 packet from transport."""
+        return S7PacketParser.parse(self.transport.receive())
+
+    def close(self) -> None:
+        self.transport.close()
+
+    def read_szl(self, szl_id: int, szl_index: int) -> S7Packet:
+        data = struct.pack("!HH", szl_id, szl_index)
+        request = UserDataRequest.create(
+            function_group=UserdataFunction.CPU_FUNCTION,
+            subfunction=SubfunctionCode.READ_SZL,
+            data=data,
+        )
+        response = self.send(request=request)
+        return response
+
+    def plc_stop(self) -> S7Packet:
+        response = self.send(request=RequestPLCStop())
+        return response