autouds 0.1.0__py3-none-any.whl

autouds/__init__.py

@@ -0,0 +1,13 @@
+"""
+@文件: __init__.py
+@作者: 雷小鸥
+@日期: 2026/6/9 18:58
+@许可: MIT License
+@描述:
+@版本: Version 0.1
+"""
+from ._handler import handler, set_send_impl
+from ._models import Response, Request, UdsError
+from .app import App
+
+__all__ = ['handler', 'set_send_impl', 'Response', 'Request', 'UdsError', 'App']

autouds/__main__.py

@@ -0,0 +1,44 @@
+"""
+@文件: __main__.py
+@作者: 雷小鸥
+@日期: 2026/6/10 08:51
+@许可: MIT License
+@描述: UDS 诊断入口
+@版本: Version 0.1
+"""
+import logging
+from . import App
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(funcName)s - %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+
+
+def main():
+    app = App(
+        ip='<tester-ip>',
+        ecus={
+            'mcu': (0x1001, '<ecu-ip>', 0),
+            'soc': (0x1002, '<ecu-ip>', 0),
+        },
+    )
+
+    # 诊断会话控制
+    p2, p2_star = app.default()
+    print(f'default: P2={p2}, P2*={p2_star}')
+
+    # 切换到 soc
+    app.on('soc')
+
+    # 安全访问
+    seed = app.l1()
+    print(f'L1 seed: {seed.hex()}')
+
+    app.l1_ex(seed)
+    print('L1 unlock done')
+
+
+if __name__ == '__main__':
+    main()

autouds/_handler.py

@@ -0,0 +1,106 @@
+"""
+@文件: _handler.py
+@作者: 雷小鸥
+@日期: 2026/6/11 12:01
+@许可: MIT License
+@描述: handler 装饰器 + 发送桥接。
+@版本: Version 0.1
+"""
+from __future__ import annotations
+
+import functools
+from typing import Callable, Generator, ParamSpec, TypeVar
+from ._models import Request, Response, UdsError
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def handler(*args, **kwargs):
+    """装饰器工厂：预建 Request，驱动用户生成器完成 UDS 交互。"""
+    fn = args[0] if len(args) == 1 else None
+
+    def decorator(f: Callable[..., Generator[bytes | None, Response, R]]) -> Callable[..., R]:
+        @functools.wraps(f)
+        def wrapper(self, *inner_args, **inner_kwargs):
+            # 1. 从装饰器参数取初始值（可能为 None）
+            s_name = kwargs.get('service_name', None)
+            s_id = kwargs.get('s_id', None)
+            fn_name = kwargs.get('sub_fn_name', None)
+            sub_fn = kwargs.get('sub_fn', None)
+            supp = kwargs.get('suppress_positive_response', None)
+
+            # 2. 调用时关键字覆盖：不传则保留装饰器参数
+            s_name = inner_kwargs.pop('service_name', s_name)
+            s_id = inner_kwargs.pop('s_id', s_id)
+            fn_name = inner_kwargs.pop('sub_fn_name', fn_name)
+            sub_fn = inner_kwargs.pop('sub_fn', sub_fn)
+            supp = inner_kwargs.pop('suppress_positive_response', supp)
+
+            # 3. 最终默认值
+            if supp is None:
+                supp = False
+
+            # 4. 工厂形式：驱动生成器获取 params
+            gen = f(self, *inner_args, **inner_kwargs)
+            params = next(gen)  # 驱动生成器到第一个 yield
+            if params is not None and not isinstance(params, bytes):
+                raise TypeError("生成器第一个 yield 必须为 bytes 或 None")
+
+            request = Request.model_validate({
+                'service_name'              : s_name,
+                'service_id'                : s_id,
+                'sub_fn_name'               : fn_name,
+                'sub_fn'                    : sub_fn,
+                'suppress_positive_response': supp,
+                'params'                    : params
+            })
+
+            # 6. 发送请求、收集响应
+            resp: Response | None = None
+            for raw in send(request.raw):
+                resp = Response.model_validate({
+                    'raw': raw, 'request': request, 'father': resp
+                })
+                if not (resp.is_negative and resp.nrc == 0x78):
+                    break
+
+            if resp is None:
+                resp = Response.model_validate({'request': request})
+
+            if resp.is_negative:
+                raise UdsError(resp)
+
+            try:
+                gen.send(resp)
+            except StopIteration as e:
+                return e.value
+            finally:
+                gen.close()
+
+            raise RuntimeError(
+                "generator must return immediately after receiving Response"
+            )
+
+        return wrapper
+
+    return decorator(fn) if fn else decorator
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# 发送桥接
+# ═══════════════════════════════════════════════════════════════════════
+
+_send_impl = None
+
+
+def set_send_impl(func):
+    """注入真正的 send 实现（生成器函数，接收 bytes 载荷，yield 原始响应字节）。"""
+    global _send_impl
+    _send_impl = func
+
+
+def send(payload: bytes):
+    if _send_impl is None:
+        raise RuntimeError("请先调用 set_send_impl() 设置发送函数")
+    yield from _send_impl(payload)

autouds/_models.py

@@ -0,0 +1,226 @@
+"""
+@文件: _models.py
+@作者: 雷小鸥
+@日期: 2026/6/11 12:02
+@许可: MIT License
+@描述:
+    UDS Request / Response 模型
+
+    Request — 构造时可用 model_validate 传入语义名，内部查表转换：
+    - Request.model_validate({'service_name': 'session', 'sub_fn_name': 'default'})
+    - Request.model_validate({'service_id': 0x10, 'sub_fn': 0x01})
+
+    Response — 两阶段：先创建空壳，收到 raw 后 _parse 填充
+
+@版本: Version 0.1
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field, model_validator, PrivateAttr
+from ._tables import SERVICE_MAP, SUB_FN_MAP, NRC_MAP
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# Request
+# ═══════════════════════════════════════════════════════════════════════
+
+class Request(BaseModel):
+    service_id: int = Field(..., ge=0x00, le=0xFF)
+    sub_fn: int | None = Field(None, ge=0x00, le=0x7F)
+    suppress_positive_response: bool = False
+
+    params: bytes | None = Field(None)
+
+    _fn_byte: bytes | None = PrivateAttr(None)
+
+    # noinspection PyPropertyDefinition
+    @property
+    def raw(self) -> bytes:
+        return self.service_id.to_bytes(1, 'big') + (self._fn_byte or b'') + (self.params or b'')
+
+    # noinspection PyPropertyDefinition
+    @property
+    def hex(self) -> str:
+        return ' '.join(f'{b:02X}' for b in self.raw)
+
+    # noinspection PyNestedDecorators
+    @model_validator(mode='before')
+    @classmethod
+    def _preprocess(cls, data):
+        """统一处理 service_name / sub_fn_name，并按依赖顺序验证。"""
+        if not isinstance(data, dict):
+            return data
+
+        # 1. 解析 service_name -> service_id
+        s_name = data.pop('service_name', None)
+        if s_name is not None:
+            resolved_sid = SERVICE_MAP.get(s_name)
+            if resolved_sid is None:
+                raise ValueError(f'未知服务名: {s_name!r}')
+            existing_sid = data.get('service_id')
+            if existing_sid is not None and existing_sid != resolved_sid:
+                raise ValueError(
+                    f'service_name({s_name!r}) 与 service_id(0x{existing_sid:02X}) 冲突'
+                )
+            data['service_id'] = resolved_sid
+
+        # 2. 尝试获取 service_id（可能上一步已设置，或用户直接提供）
+        s_id = data.get('service_id')
+
+        # 3. 解析 sub_fn_name -> sub_fn（此时必须已知 service_id）
+        sub_fn_name = data.pop('sub_fn_name', None)
+        if sub_fn_name is not None:
+            if s_id is None:
+                raise ValueError(
+                    '提供了 sub_fn_name 但未指定服务，请同时提供 service_id 或 service_name'
+                )
+            table = SUB_FN_MAP.get(s_id)
+            if table is None or not table.get('enable'):
+                raise ValueError(
+                    f'服务 0x{s_id:02X} 不支持子功能，却提供了 sub_fn_name: {sub_fn_name!r}'
+                )
+            resolved_fn = table.get(sub_fn_name)
+            if resolved_fn is None:
+                raise ValueError(
+                    f'未知子功能名: {sub_fn_name!r} (服务 0x{s_id:02X})'
+                )
+            existing_fn = data.get('sub_fn')
+            if existing_fn is not None and existing_fn != resolved_fn:
+                raise ValueError(
+                    f'sub_fn_name({sub_fn_name!r}) 与 sub_fn(0x{existing_fn:02X}) 冲突'
+                )
+            data['sub_fn'] = resolved_fn
+
+        # 4. 验证直接传入的 sub_fn 值（如果存在）
+        fn = data.get('sub_fn')
+        if fn is not None:
+            if not isinstance(fn, int) or not (0x00 <= fn <= 0x7F):
+                raise ValueError('sub_fn 必须是 0x00~0x7F 的整数')
+            if s_id is None:
+                raise ValueError('提供了 sub_fn 但未指定服务，请同时提供 service_id 或 service_name')
+            table = SUB_FN_MAP.get(s_id)
+            if table is None or not table.get('enable'):
+                raise ValueError(f'服务 0x{s_id:02X} 不支持子功能，却提供了 sub_fn=0x{fn:02X}')
+
+            allowed_values = {v for k, v in table.items() if k != 'enable'}
+            if fn not in allowed_values:
+                raise ValueError(f'sub_fn=0x{fn:02X} 对于服务 0x{s_id:02X} 无效')
+
+        return data
+
+    @model_validator(mode='after')
+    def _build_fn_byte(self):
+        """根据 sub_fn 和 suppress_positive_response 构造功能字节。"""
+        if self.sub_fn is None:
+            self._fn_byte = b''
+        else:
+            fn_byte = self.sub_fn
+            if self.suppress_positive_response:
+                fn_byte |= 0x80
+            self._fn_byte = fn_byte.to_bytes(1, 'big')
+        return self
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# Response
+# ═══════════════════════════════════════════════════════════════════════
+
+class Response(BaseModel):
+    father: Response | None = None
+    request: Request
+    raw: bytes = b''
+
+    # ── 解析后的字段 ──
+    ok: bool = False
+    is_negative: bool = False
+
+    service_id: int = 0
+    sub_fn: int | None = None
+    params: bytes = b''
+
+    request_id: int = 0
+    nrc: int = 0
+    nrc_desc: str = ''
+
+    # noinspection PyPropertyDefinition
+    @property
+    def hex(self) -> str:
+        return ' '.join(f'{b:02X}' for b in self.raw)
+
+    @model_validator(mode='after')
+    def _parse(self):
+        if not self.raw:
+            return self
+
+        raw = self.raw
+        s_id = raw[0]
+
+        match s_id:
+            case 0x7F:
+                self.__handle_negative(raw)
+            case _:
+                self.__handle_positive(raw)
+        return self
+
+    def __handle_negative(self, raw: bytes):
+        if len(raw) < 3:
+            raise ValueError("负响应长度不足，至少需要 3 字节")
+        request_id = raw[1]
+        if request_id != self.request.service_id:
+            raise ValueError(
+                f"负响应的请求 SID 不匹配：期望 0x{self.request.service_id:02X}，"
+                f"收到 0x{request_id:02X}"
+            )
+        self.request_id = request_id
+        self.is_negative = True
+        self.service_id = raw[0]
+        self.nrc = raw[2]
+        self.nrc_desc = NRC_MAP.get(self.nrc, "Unknown NRC")
+
+    def __handle_positive(self, raw: bytes):
+        expected_sid = self.request.service_id | 0x40
+        s_id = raw[0]
+        if s_id != expected_sid:
+            raise ValueError(f"无效响应：期望 SID 0x{expected_sid:02X}，收到 0x{s_id:02X}")
+
+        self.ok = True
+        self.is_negative = False
+        self.service_id = s_id
+
+        # 判断服务是否需要子功能字节
+        table = SUB_FN_MAP.get(self.request.service_id)
+        need_sub_fn = (table is not None and table.get('enable', False))
+
+        if not need_sub_fn:
+            self.sub_fn = None
+            self.params = raw[1:] if len(raw) > 1 else b''
+            return
+
+        if len(raw) < 2:
+            raise ValueError(f"服务 0x{self.request.service_id:02X} 需要子功能，但响应缺少子功能字节")
+
+        if self.request.sub_fn is None:
+            raise ValueError("服务需要子功能但请求未提供子功能")
+
+        response_sub_fn = raw[1]
+        if response_sub_fn != self.request.sub_fn:
+            raise ValueError(
+                f"响应子功能不匹配：期望 0x{self.request.sub_fn:02X}，"
+                f"收到 0x{response_sub_fn:02X}"
+            )
+
+        self.sub_fn = response_sub_fn
+        self.params = raw[2:] if len(raw) > 2 else b''
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# UdsError
+# ═══════════════════════════════════════════════════════════════════════
+
+class UdsError(Exception):
+    """UDS 负响应异常，通过 resp 属性获取完整 Response。"""
+
+    def __init__(self, resp: Response):
+        self.resp = resp
+        super().__init__(f'{resp.nrc_desc} 0x{resp.nrc:02X}')

autouds/_tables.py

@@ -0,0 +1,441 @@
+"""
+@文件: _tables.py
+@作者: 雷小鸥
+@日期: 2026/6/11 12:03
+@许可: MIT License
+@描述: UDS 服务标识符映射表，按 ISO 14229-1 分类。
+@版本: Version 0.1
+"""
+SERVICE_MAP = {
+    # ═══════════════════════════════════════
+    # 诊断和通信管理类
+    # ═══════════════════════════════════════
+    '会话'                              : 0x10,
+    'Diagnostic Session Control'        : 0x10,
+    'session'                           : 0x10,
+
+    'ECU 复位'                          : 0x11,
+    'ECU Reset'                         : 0x11,
+    'reset'                             : 0x11,
+
+    '安全访问'                          : 0x27,
+    'Security Access'                   : 0x27,
+    'security_access'                   : 0x27,
+    'unlock'                            : 0x27,
+
+    '通讯控制'                          : 0x28,
+    'Communication Control'             : 0x28,
+    'communication_control'             : 0x28,
+    'comm'                              : 0x28,
+
+    '待机'                              : 0x3E,
+    'Tester Present'                    : 0x3E,
+    'tester_present'                    : 0x3E,
+    'present'                           : 0x3E,
+
+    '访问时间参数'                      : 0x83,
+    'Access Timing Parameter'           : 0x83,
+    'timing'                            : 0x83,
+
+    '安全数据传输'                      : 0x84,
+    'Secured Data Transmission'         : 0x84,
+    'transmission'                      : 0x84,
+
+    '控制DTC的设置'                     : 0x85,
+    'Control DTC Setting'               : 0x85,
+    'dtc_setting'                       : 0x85,
+
+    '事件响应'                          : 0x86,
+    'Response On Event'                 : 0x86,
+    'event'                             : 0x86,
+
+    '链路控制'                          : 0x87,
+    'Link Control'                      : 0x87,
+    'link'                              : 0x87,
+
+    # ═══════════════════════════════════════
+    # 数据传输类
+    # ═══════════════════════════════════════
+    '标识符读数据'                      : 0x22,
+    'Read Data By Identifier'           : 0x22,
+    'read_did'                          : 0x22,
+
+    '地址读内存'                        : 0x23,
+    'Read Memory By Address'            : 0x23,
+    'read_memory'                       : 0x23,
+    'read_mem'                          : 0x23,
+
+    '标识符读比例数据'                  : 0x24,
+    'Read Scaling Data By Identifier'   : 0x24,
+    'scaling'                           : 0x24,
+
+    '周期标识符读数据'                  : 0x2A,
+    'Read Data By Periodic Identifier'  : 0x2A,
+    'periodic'                          : 0x2A,
+
+    '动态定义标识符'                    : 0x2C,
+    'Dynamically Define Data Identifier': 0x2C,
+    'define'                            : 0x2C,
+
+    '标识符写数据'                      : 0x2E,
+    'Write Data By Identifier'          : 0x2E,
+    'write_did'                         : 0x2E,
+
+    '地址写内存'                        : 0x3D,
+    'Write Memory By Address'           : 0x3D,
+    'write_mem'                         : 0x3D,
+
+    # ═══════════════════════════════════════
+    # 存储数据传输类
+    # ═══════════════════════════════════════
+    '清除诊断信息'                      : 0x14,
+    'Clear Diagnostic Information'      : 0x14,
+    'clear_dtc'                         : 0x14,
+
+    '读取故障信息码'                    : 0x19,
+    'Read DTC Information'              : 0x19,
+    'read_dtc'                          : 0x19,
+
+    # ═══════════════════════════════════════
+    # 输入输出控制类
+    # ═══════════════════════════════════════
+    '通过标识符控制输入输出'            : 0x2F,
+    'Input Output Control By Identifier': 0x2F,
+    'io'                                : 0x2F,
+
+    # ═══════════════════════════════════════
+    # 例程功能类
+    # ═══════════════════════════════════════
+    '例行程序控制'                      : 0x31,
+    'Routine Control'                   : 0x31,
+    'routine'                           : 0x31,
+
+    # ═══════════════════════════════════════
+    # 上传下载类
+    # ═══════════════════════════════════════
+    '请求下载'                          : 0x34,
+    'Request Download'                  : 0x34,
+    'download'                          : 0x34,
+
+    '请求上传'                          : 0x35,
+    'Request Upload'                    : 0x35,
+    'upload'                            : 0x35,
+
+    '数据传输'                          : 0x36,
+    'Transfer Data'                     : 0x36,
+    'transfer'                          : 0x36,
+
+    '请求退出传输'                      : 0x37,
+    'Request Transfer Exit'             : 0x37,
+    'exit_tf'                           : 0x37,
+
+    '请求文件传输'                      : 0x38,
+    'Request File Transfer'             : 0x38,
+    'file'                              : 0x38,
+}
+
+# ── 子功能映射 ──
+# 键为 service_id (int)，值为 { enable: bool, 中文/英文/短key: sub_fn 值 }
+# enable=True 表示该服务支持子功能，子功能字段有效
+
+SUB_FN_MAP = {
+    # ── 诊断会话控制 (0x10) ──
+    0x10: {
+        'enable'             : True,
+
+        '默认'               : 0x01,
+        'default session'    : 0x01,
+        'default'            : 0x01,
+
+        '编程'               : 0x02,
+        'programming session': 0x02,
+        'program'            : 0x02,
+
+        '拓展'               : 0x03,
+        'extended session'   : 0x03,
+        'extend'             : 0x03,
+
+        '安全'               : 0x04,
+        'security session'   : 0x04,
+        'safety'             : 0x04,
+    },
+
+    # ── ECU 复位 (0x11) ──
+    0x11: {
+        'enable'                  : True,
+
+        '硬'                      : 0x01,
+        'hard reset'              : 0x01,
+        'hard'                    : 0x01,
+
+        '钥匙'                    : 0x02,
+        'key off on'              : 0x02,
+        'key'                     : 0x02,
+
+        '软'                      : 0x03,
+        'soft reset'              : 0x03,
+        'soft'                    : 0x03,
+
+        '启用快速断电'            : 0x04,
+        'enable rapid power down' : 0x04,
+        'on'                      : 0x04,
+
+        '禁用快速断电'            : 0x05,
+        'disable rapid power down': 0x05,
+        'off'                     : 0x05,
+    },
+
+    # ── 安全访问 (0x27) ──
+    0x27: {
+        'enable'         : True,
+
+        'L1'             : 0x01,
+        'L1 Ex'          : 0x02,
+
+        'level 1'        : 0x01,
+        'level 1 extend' : 0x02,
+
+        'L5'             : 0x05,
+        'L5 Ex'          : 0x06,
+
+        'level 5'        : 0x05,
+        'level 5 extend' : 0x06,
+
+        'L19'            : 0x19,
+        'L19 Ex'         : 0x1A,
+
+        'level 19'       : 0x19,
+        'level 19 extend': 0x1A,
+    },
+
+    # ── 通讯控制 (0x28) ──
+    0x28: {
+        'enable'                       : True,
+
+        '启用接收和发送'               : 0x00,
+        'enable rx and tx'             : 0x00,
+        'en_rx_tx'                     : 0x00,
+
+        '启用接收禁用发送'             : 0x01,
+        'enable rx disable tx'         : 0x01,
+        'rx'                           : 0x01,
+
+        '禁用接收启用发送'             : 0x02,
+        'disable rx enable tx'         : 0x02,
+        'tx'                           : 0x02,
+
+        '禁用接收和发送'               : 0x03,
+        'disable rx and tx'            : 0x03,
+        'dis_rx_tx'                    : 0x03,
+
+        '启用接收禁用发送增强'         : 0x04,
+        'enable rx disable tx enhanced': 0x04,
+        'rx_enhanced'                  : 0x04,
+
+        '启用接收和发送增强'           : 0x05,
+        'enable rx and tx enhanced'    : 0x05,
+        'rx_tx_enhanced'               : 0x05,
+    },
+
+    # ── 待机握手 (0x3E) ──
+    0x3E: {
+        'enable'  : True,
+
+        '响应'    : 0x00,
+        'response': 0x00,
+        'resp'    : 0x00,
+    },
+
+    # ── 控制 DTC 设置 (0x85) ──
+    0x85: {
+        'enable'            : True,
+
+        '允许 DTC 更新'     : 0x01,
+        'enable dtc update' : 0x01,
+        'on'                : 0x01,
+
+        '禁止 DTC 更新'     : 0x02,
+        'disable dtc update': 0x02,
+        'off'               : 0x02,
+    },
+
+    0x22: {'enable': False},
+    0x23: {'enable': False},
+
+    # ── 读取 DTC 信息 (0x19) ──
+    0x14: {'enable': False},
+    0x19: {
+        'enable'                                                  : True,
+        '通过状态掩码报告 DTC 数量'                               : 0x01,
+        'report number of dtc by status mask'                     : 0x01,
+        'count_by_mask'                                           : 0x01,
+
+        '通过状态掩码报告 DTC'                                    : 0x02,
+        'report dtc by status mask'                               : 0x02,
+        'dtc_by_mask'                                             : 0x02,
+
+        '获取 DTC 快照记录 ID'                                    : 0x03,
+        'report dtc snapshot identification'                      : 0x03,
+        'snapshot_id'                                             : 0x03,
+
+        '请求指定 DTC 快照信息'                                   : 0x04,
+        'report dtc snapshot record by dtc number'                : 0x04,
+        'snapshot_by_dtc'                                         : 0x04,
+
+        '通过记录 ID 报告 DTC 存储数据'                           : 0x05,
+        'report dtc stored data by record number'                 : 0x05,
+        'stored_data'                                             : 0x05,
+
+        '通过 DTC 报告扩展数据'                                   : 0x06,
+        'report dtc record by dtc number'                         : 0x06,
+        'ext_data'                                                : 0x06,
+
+        '通过严重性掩码报告 DTC 数量'                             : 0x07,
+        'report number of dtc by severity mask record'            : 0x07,
+        'count_by_severity'                                       : 0x07,
+
+        '通过严重性掩码报告 DTC'                                  : 0x08,
+        'report dtc by severity mask record'                      : 0x08,
+        'dtc_by_severity'                                         : 0x08,
+
+        '报告 DTC 严重性信息'                                     : 0x09,
+        'report severity information of dtc'                      : 0x09,
+        'severity_info'                                           : 0x09,
+
+        '读取支持的所有 DTC 列表'                                 : 0x0A,
+        'report supported dtc'                                    : 0x0A,
+        'supported_dtc'                                           : 0x0A,
+
+        '报告第一次测试失败的 DTC'                                : 0x0B,
+        'report first test failed dtc'                            : 0x0B,
+        'first_test_failed'                                       : 0x0B,
+
+        '报告第一次确认的 DTC'                                    : 0x0C,
+        'report first confirmed dtc'                              : 0x0C,
+        'first_confirmed'                                         : 0x0C,
+
+        '报告最近一次测试失败的 DTC'                              : 0x0D,
+        'report most recent test failed dtc'                      : 0x0D,
+        'recent_test_failed'                                      : 0x0D,
+
+        '报告最近一次确认的 DTC'                                  : 0x0E,
+        'report most recent confirmed dtc'                        : 0x0E,
+        'recent_confirmed'                                        : 0x0E,
+
+        '报告 DTC 故障检测计数器'                                 : 0x14,
+        'report dtc fault detection counter'                      : 0x14,
+        'fault_counter'                                           : 0x14,
+
+        '用户定义内存 DTC 扩展数据'                               : 0x19,
+        'report user def memory dtc ext data record by dtc number': 0x19,
+        'user_def_memory'                                         : 0x19,
+    },
+
+    0x2F: {'enable': False},
+    0x34: {'enable': False},
+    0x35: {'enable': False},
+    0x36: {'enable': False},
+    0x37: {'enable': False},
+
+    # ── 例行程序控制 (0x31) ──
+    0x31: {
+        'enable'                 : True,
+        '启动程序'               : 0x01,
+        'start routine'          : 0x01,
+        'start'                  : 0x01,
+
+        '停止程序'               : 0x02,
+        'stop routine'           : 0x02,
+        'stop'                   : 0x02,
+
+        '请求运行结果'           : 0x03,
+        'request routine results': 0x03,
+        'result'                 : 0x03,
+    },
+
+}
+
+NRC_MAP = {
+    # ── 0x01 ~ 0x0F 暂时保留 ──
+
+    # ── 0x10 ~ 0x14 通用错误 ──
+    0x10: '未知错误，服务暂时被拒绝',
+    0x11: '不支持该服务请求',
+    0x12: '不支持子功能',
+    0x13: '消息长度或格式错误',
+    0x14: '请求长度超出',
+
+    # ── 0x15 ~ 0x20 暂时保留 ──
+
+    # ── 0x21 ~ 0x26 条件/顺序错误 ──
+    0x21: '服务端正忙',
+    0x22: '条件不满足',
+
+    # 0x23 暂时保留
+
+    0x24: '请求顺序错误',
+    0x25: '指令已被接收，但是未被执行',
+    0x26: '失败的操作导致当前操作无法执行',
+
+    # ── 0x27 ~ 0x30 暂时保留 ──
+
+    # ── 0x31 ~ 0x36 参数/安全错误 ──
+    0x31: '参数错误',
+
+    # 0x32 暂时保留
+
+    0x33: '安全校验未通过',
+
+    # 0x34 暂时保留
+
+    0x35: '密钥不匹配',
+    0x36: '已达到解锁最大错误次数',
+    0x37: '请求延时未过期，请稍后再试',
+
+    # ── 0x38 ~ 0x4F 为扩展数据链路安全性文档暂时保留 ──
+    # ── 0x50 ~ 0x6F 暂时保留 ──
+
+    # ── 0x70 ~ 0x73 上传下载错误 ──
+    0x70: '不允许上传下载',
+    0x71: '数据传输中断',
+    0x72: '擦除或烧写内存错误',
+    0x73: '块序列计数错误',
+
+    # ── 0x74 ~ 0x77 暂时保留 ──
+
+    0x78: '收到请求，延迟响应',
+
+    # ── 0x79 ~ 0x7D 暂时保留 ──
+
+    0x7E: '当前会话下子功能不支持',
+    0x7F: '当前会话下子服务不支持',
+
+    # 0x80 暂时保留
+
+    # ── 0x81 ~ 0x93 条件不满足类 ──
+    0x81: '每分钟转速（RPM）太高',
+    0x82: '每分钟转速太低',
+    0x83: '当前引擎正在运行',
+    0x84: '当前引擎未运行',
+    0x85: '截止当前时间引擎运行时间太短',
+    0x86: '温度过高',
+    0x87: '温度过低',
+    0x88: '车速过高',
+    0x89: '车速过低',
+    0x8A: '油门/踏板过高（超过了当前要求的最大阈值）',
+    0x8B: '油门/踏板过低',
+    0x8C: '变速器档位不在空挡',
+    0x8D: '变速器档位不在排档',
+
+    # 0x8E 暂时保留
+
+    0x8F: '制动开关没有关闭',
+    0x90: '换挡杆不在驻车档',
+    0x91: '变矩器离合器锁定',
+    0x92: '电压过高',
+    0x93: '电压过低',
+
+    # ── 0x94 ~ 0xEF 为"条件不满足"类错误码扩展暂时保留 ──
+    # ── 0xF0 ~ 0xFE 为汽车制造商保留 ──
+    # ── 0xFF 暂时保留 ──
+}

autouds/app.py

@@ -0,0 +1,270 @@
+"""
+@文件: app.py
+@作者: 雷小鸥
+@日期: 2026/6/10
+@许可: MIT License
+@描述: UDS App 基类，封装所有 UDS 服务方法
+@版本: Version 0.1
+"""
+from typing import Generator
+from autodoip import Endpoint, Config as DoIpConfig
+from ._handler import handler, set_send_impl
+from ._models import Response
+
+
+class App:
+    def __init__(
+            self,
+            ecus: dict[str, tuple[int, str, int]],
+            ip: str,
+            port: int = 13400,
+            tester: int = 0x0E80,
+            doip_config: DoIpConfig | None = None,
+    ):
+        self._ecus = ecus
+        self._first_name = next(iter(ecus))
+
+        endpoint_ecus = {
+            addr: (ecu_ip, port)
+            for addr, ecu_ip, port in ecus.values()
+        }
+
+        self._endpoint = Endpoint(ip=ip, ecus=endpoint_ecus, port=port, tester=tester, config=doip_config or DoIpConfig())
+        self._endpoint.start()
+        self._endpoint.select(ecus[self._first_name][0])
+        set_send_impl(self._endpoint.conversation)
+
+    def on(self, name: str):
+        """切换到指定 ECU。"""
+        addr, _, _ = self._ecus[name]
+        self._endpoint.select(addr)
+
+    # ═══════════════════════════════════════════════════════════════════
+    # 诊断会话控制 (0x10)
+    # ═══════════════════════════════════════════════════════════════════
+
+    @handler(service_name='session', sub_fn_name='default')
+    def default(self) -> Generator[None, Response, tuple[int, int]]:
+        resp: Response = yield
+        if not resp.params:
+            return 0, 0
+        params: bytes = resp.params
+        p2 = int.from_bytes(params[0:2], byteorder='big')
+        p2_star = int.from_bytes(params[2:4], byteorder='big') * 10
+        return p2, p2_star
+
+    @handler(service_name='session', sub_fn_name='program')
+    def program(self) -> Generator[None, Response, tuple[int, int]]:
+        resp: Response = yield
+        if not resp.params:
+            return 0, 0
+        params: bytes = resp.params
+        p2 = int.from_bytes(params[0:2], byteorder='big')
+        p2_star = int.from_bytes(params[2:4], byteorder='big') * 10
+        return p2, p2_star
+
+    @handler(service_name='session', sub_fn_name='extend')
+    def extend(self) -> Generator[None, Response, tuple[int, int]]:
+        resp: Response = yield
+        if not resp.params:
+            return 0, 0
+        params: bytes = resp.params
+        p2 = int.from_bytes(params[0:2], byteorder='big')
+        p2_star = int.from_bytes(params[2:4], byteorder='big') * 10
+        return p2, p2_star
+
+    @handler(service_name='session', sub_fn_name='safety')
+    def safety(self) -> Generator[None, Response, tuple[int, int]]:
+        resp: Response = yield
+        if not resp.params:
+            return 0, 0
+        params: bytes = resp.params
+        p2 = int.from_bytes(params[0:2], byteorder='big')
+        p2_star = int.from_bytes(params[2:4], byteorder='big') * 10
+        return p2, p2_star
+
+    # ═══════════════════════════════════════════════════════════════════
+    # ECU 复位 (0x11)
+    # ═══════════════════════════════════════════════════════════════════
+
+    @handler(service_name='reset', sub_fn_name='hard')
+    def hard(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    @handler(service_name='reset', sub_fn_name='key')
+    def key(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    @handler(service_name='reset', sub_fn_name='soft')
+    def soft(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    # ═══════════════════════════════════════════════════════════════════
+    # 待机握手 (0x3E)
+    # ═══════════════════════════════════════════════════════════════════
+
+    @handler(service_name='present', sub_fn_name='resp', suppress_positive_response=True)
+    def present(self) -> Generator[None, Response, None]:
+        yield
+
+    # ═══════════════════════════════════════════════════════════════════
+    # 安全访问 (0x27)
+    # ═══════════════════════════════════════════════════════════════════
+
+    @handler(service_name='unlock', sub_fn_name='L1')
+    def l1(self) -> Generator[None, Response, bytes]:
+        resp: Response = yield
+        if not resp.params:
+            return b''
+        return resp.params
+
+    @handler(service_name='unlock', sub_fn_name='L1 Ex')
+    def l1_ex(self, payload: bytes) -> Generator[bytes, Response, None]:
+        yield payload
+
+    @handler(service_name='unlock', sub_fn_name='L5')
+    def l5(self) -> Generator[None, Response, bytes]:
+        resp: Response = yield
+        if not resp.params:
+            return b''
+        return resp.params
+
+    @handler(service_name='unlock', sub_fn_name='L5 Ex')
+    def l5_ex(self, payload: bytes) -> Generator[bytes, Response, None]:
+        yield payload
+
+    @handler(service_name='unlock', sub_fn_name='L19')
+    def l19(self) -> Generator[None, Response, bytes]:
+        resp: Response = yield
+        if not resp.params:
+            return b''
+        return resp.params
+
+    @handler(service_name='unlock', sub_fn_name='L19 Ex')
+    def l19_ex(self, payload: bytes) -> Generator[bytes, Response, None]:
+        yield payload
+
+    # ═══════════════════════════════════════════════════════════════════
+    # 通讯控制 (0x28)
+    # ═══════════════════════════════════════════════════════════════════
+
+    @handler(service_name='comm', sub_fn_name='en_rx_tx')
+    def comm_enable_rx_tx(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    @handler(service_name='comm', sub_fn_name='dis_rx_tx')
+    def comm_disable_rx_tx(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    # ═══════════════════════════════════════════════════════════════════
+    # 控制 DTC 设置 (0x85)
+    # ═══════════════════════════════════════════════════════════════════
+
+    @handler(service_name='dtc_setting', sub_fn_name='on')
+    def dtc_on(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    @handler(service_name='dtc_setting', sub_fn_name='off')
+    def dtc_off(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    # ═══════════════════════════════════════════════════════════════════
+    # 清除诊断信息 (0x14)
+    # ═══════════════════════════════════════════════════════════════════
+
+    @handler(service_name='clear_dtc')
+    def clear_dtc(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    # ═══════════════════════════════════════════════════════════════════
+    # 读取故障信息码 (0x19)
+    # ═══════════════════════════════════════════════════════════════════
+
+    @handler(service_name='read_dtc', sub_fn_name='count_by_mask')
+    def read_dtc_count(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    @handler(service_name='read_dtc', sub_fn_name='dtc_by_mask')
+    def read_dtc_by_mask(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    # ═══════════════════════════════════════════════════════════════════
+    # 标识符读数据 (0x22)
+    # ═══════════════════════════════════════════════════════════════════
+
+    @handler(service_name='read_did')
+    def read_did(self, did: int) -> Generator[bytes, Response, bytes]:
+        resp: Response = yield did.to_bytes(2, byteorder='big')
+        if not resp.params:
+            return b''
+        return resp.params
+
+    # ═══════════════════════════════════════════════════════════════════
+    # 标识符写数据 (0x2E)
+    # ═══════════════════════════════════════════════════════════════════
+
+    @handler(service_name='write_did')
+    def write_did(self, did: int, payload: bytes) -> Generator[bytes, Response, None]:
+        yield did.to_bytes(2, byteorder='big') + payload
+
+    # ═══════════════════════════════════════════════════════════════════
+    # 通过标识符控制输入输出 (0x2F)
+    # ═══════════════════════════════════════════════════════════════════
+
+    @handler(service_name='io')
+    def io_control(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    # ═══════════════════════════════════════════════════════════════════
+    # 例行程序控制 (0x31)
+    # ═══════════════════════════════════════════════════════════════════
+
+    @handler(service_name='routine', sub_fn_name='start')
+    def routine_start(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    @handler(service_name='routine', sub_fn_name='stop')
+    def routine_stop(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    @handler(service_name='routine', sub_fn_name='result')
+    def routine_result(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    # ═══════════════════════════════════════════════════════════════════
+    # 上传下载类 (0x34 / 0x35 / 0x36 / 0x37)
+    # ═══════════════════════════════════════════════════════════════════
+
+    @handler(service_name='download')
+    def request_download(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    @handler(service_name='upload')
+    def request_upload(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    @handler(service_name='transfer')
+    def transfer_data(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp
+
+    @handler(service_name='exit_tf')
+    def exit_transfer(self) -> Generator[None, Response, Response]:
+        resp: Response = yield
+        return resp

autouds-0.1.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: autouds
+Version: 0.1.0
+Summary: UDS (Unified Diagnostic Services) diagnostic tool over DoIP — ISO 14229-1
+Project-URL: Homepage, https://github.com/leno166/autouds
+Project-URL: Source, https://github.com/leno166/autouds
+Author: leno augenstern
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.14
+Requires-Dist: autodoip>=0.1.4
+Requires-Dist: pydantic>=2.0

autouds-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+autouds/__init__.py,sha256=39bu5LUuNPCW9_kctnFBqCbO8TyY61ol-zlas7wDak4,333
+autouds/__main__.py,sha256=2py7m-rBoexlARxOBdhHK731bqdi_Ykg9zMhMYxvqos,846
+autouds/_handler.py,sha256=plvZdRAGjkoUJPawxRxE0UyC1m90V2NDURStje8t36A,4040
+autouds/_models.py,sha256=mFb9QQelrVc1Amk40wk4qAAv6THtC1o0JNiEeiRxu-E,9081
+autouds/_tables.py,sha256=OKtAjcUr-D_EiqKonFhhGU_VVq-HWCbweDgErL-6dSw,16935
+autouds/app.py,sha256=gnIjY2UHTjPZvLGvGhglLDV6lH2lE_gVXHp2ZTYHLhk,13647
+autouds-0.1.0.dist-info/METADATA,sha256=mezS47lPU0b7_xb9_hQlutnSja5aubM8HCn0qgY_07o,559
+autouds-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+autouds-0.1.0.dist-info/entry_points.txt,sha256=KI_yA34-jbMSPARJVU8b9i7TK9God1BMjaKU0FdOKgQ,50
+autouds-0.1.0.dist-info/RECORD,,

autouds-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

autouds-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+autouds = autouds.__main__:main