save

uds_async/server.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from typing import Awaitable, Callable, Dict, Optional
+
+from isotp_async.transport import IsoTpChannel
+from .exceptions import UdsNegativeResponse
+
+UdsHandler = Callable[[bytes], Awaitable[Optional[bytes]]]
+
+
+@dataclass
+class UdsServer:
+
+    isotp: IsoTpChannel
+    p2_timeout: float = 1.0
+    handlers: Dict[int, UdsHandler] = field(default_factory=dict)
+
+    async def serve_forever(self) -> None:
+        while True:
+            try:
+                req = await self.isotp.recv_pdu(timeout=self.p2_timeout)
+            except asyncio.CancelledError:
+                break
+
+            if not req:
+                continue
+
+            sid = req[0]
+            handler = self.handlers.get(sid)
+            if handler is None:
+                # ServiceNotSupported
+                await self._send_negative_response(sid, 0x11)
+                continue
+
+            try:
+                resp = await handler(req)
+                if resp is None:
+                    continue
+
+                await self.isotp.send_pdu(resp)
+
+            except UdsNegativeResponse as e:
+                await self._send_negative_response(e.req_sid, e.nrc)
+
+            except Exception:
+                # General programming failure (0x72)
+                await self._send_negative_response(sid, 0x72)
+
+    async def _send_negative_response(self, sid: int, nrc: int) -> None:
+        payload = bytes([0x7F, sid & 0xFF, nrc & 0xFF])
+        await self.isotp.send_pdu(payload)
+
+    def add_handler(self, sid: int, handler: UdsHandler) -> None:
+        self.handlers[sid & 0xFF] = handler
+
+    def service(self, sid: int):
+        def decorator(func: UdsHandler) -> UdsHandler:
+            self.add_handler(sid, func)
+            return func
+        return decorator