添加无线模块

2026-08-19 09:59:36 +08:00
parent 344f662970
commit 52c4dd08f9
33 changed files with 4740 additions and 246 deletions
@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import unittest
+from collections import deque
+from types import SimpleNamespace
+
+from cognitive_agent.application.mqtt_ota_seat_executor import (
+    MqttOtaSeatExecutor,
+)
+from cognitive_agent.infrastructure.can.gateway import CanFrame
+
+
+def _axis_frame(axis: int, value_x100: int, *, valid: bool = True) -> CanFrame:
+    flags = (1 << 3) if valid else 0
+    return CanFrame(
+        0x302,
+        bytes(
+            (
+                axis,
+                0,
+                flags,
+                0,
+                0,
+                value_x100 & 0xFF,
+                (value_x100 >> 8) & 0xFF,
+                0,
+            )
+        ),
+        channel=0,
+    )
+
+
+class _FakeOtaBus:
+    def __init__(self, initial_frames: list[CanFrame]) -> None:
+        self.frames = deque(initial_frames)
+        self.sent: list[CanFrame] = []
+        self.closed = False
+
+    def send(
+        self,
+        arbitration_id: int,
+        data: bytes,
+        *,
+        is_fd: bool = False,
+        bitrate_switch: bool = False,
+    ) -> CanFrame:
+        frame = CanFrame(
+            arbitration_id,
+            bytes(data),
+            channel=0,
+            is_fd=is_fd,
+            bitrate_switch=bitrate_switch,
+        )
+        self.sent.append(frame)
+        opcode = data[2]
+        job_state = (
+            1 | (4 << 4) | (9 << 8)
+            if opcode == 0x66
+            else (1 | (3 << 4) | (7 << 8))
+            if opcode in {0x64, 0x65}
+            else (1 << 1) | (1 << 2)
+        )
+        self.frames.append(
+            CanFrame(
+                0x6A2,
+                bytes((0x7C, data[1], opcode, 0))
+                + job_state.to_bytes(4, "little"),
+                channel=0,
+            )
+        )
+        if opcode == 0x64:
+            target_x100 = int.from_bytes(data[4:8], "little") * 10
+            self.frames.append(_axis_frame(data[3], target_x100))
+        return frame
+
+    def receive(self, _timeout_ms: int, *, include_fd: bool = False) -> CanFrame | None:
+        del include_fd
+        return self.frames.popleft() if self.frames else None
+
+    def close(self) -> None:
+        self.closed = True
+
+
+class _StatusExecutor:
+    def read_physical_state(self) -> dict[str, object]:
+        return {"position": {}, "complete": False}
+
+    def _capture_physical_state(
+        self,
+        _bus: _FakeOtaBus,
+        _results: list[dict[str, object]],
+    ) -> dict[str, object]:
+        return {"position": {}, "complete": True, "missing": []}
+
+
+def _function_config(capability: str, parameters: dict[str, object]) -> dict[str, object]:
+    return {
+        "metadata": {"request_id": "req-mqtt-ota-seat"},
+        "spec": {
+            "operations": [
+                {
+                    "id": "operation-1",
+                    "capability": capability,
+                    "target": {"zone": "front_right", "instance": "passenger"},
+                    "parameters": parameters,
+                }
+            ]
+        },
+    }
+
+
+class MqttOtaSeatExecutorTests(unittest.TestCase):
+    def test_absolute_move_uses_runtime_move_and_fresh_position_confirmation(self) -> None:
+        bus = _FakeOtaBus([_axis_frame(0, 4_000)])
+        executor = MqttOtaSeatExecutor(  # type: ignore[arg-type]
+            _StatusExecutor(),
+            lambda: bus,
+        )
+        plan = {
+            "spec": {
+                "commands": [
+                    {
+                        "operation_ref": "operation-1",
+                        "message": "T2G_Seat_Move_Command_300",
+                        "signals": {"Opcode": 1, "Motor_Selector": 0},
+                        "completion": {
+                            "value": 5_000,
+                            "tolerance": 100,
+                            "timeout_ms": 1_000,
+                        },
+                    }
+                ]
+            }
+        }
+
+        report = executor.execute(
+            plan,
+            _function_config(
+                "seat.set_longitudinal_position",
+                {"position_pct": 50},
+            ),
+        )
+
+        self.assertEqual(report["spec"]["status"], "succeeded")
+        self.assertEqual(bus.sent[0].arbitration_id, 0x6A0)
+        self.assertEqual(bus.sent[0].data[2], 0x64)
+        self.assertEqual(bus.sent[0].data[3], 0)
+        self.assertEqual(int.from_bytes(bus.sent[0].data[4:8], "little"), 500)
+        self.assertEqual(
+            report["spec"]["results"][0]["telemetry"]["effective_position_pct"],
+            50,
+        )
+        self.assertTrue(bus.closed)
+
+    def test_legacy_zero_target_maps_to_move_not_homing(self) -> None:
+        bus = _FakeOtaBus([_axis_frame(3, 2_000)])
+        executor = MqttOtaSeatExecutor(  # type: ignore[arg-type]
+            _StatusExecutor(),
+            lambda: bus,
+        )
+        plan = {
+            "spec": {
+                "commands": [
+                    {
+                        "operation_ref": "operation-1",
+                        "message": "T2G_Seat_Move_Command_300",
+                        "signals": {"Opcode": 0x0B, "Motor_Selector": 3},
+                        "completion": {
+                            "value": 0,
+                            "tolerance": 100,
+                            "timeout_ms": 1_000,
+                        },
+                    }
+                ]
+            }
+        }
+
+        report = executor.execute(
+            plan,
+            _function_config("seat.set_legrest_height", {"position_pct": 0}),
+        )
+
+        self.assertEqual(report["spec"]["status"], "succeeded")
+        self.assertEqual(bus.sent[0].data[2], 0x64)
+        self.assertEqual(int.from_bytes(bus.sent[0].data[4:8], "little"), 0)
+        self.assertNotIn(0x61, [frame.data[2] for frame in bus.sent])
+        self.assertNotIn(0x62, [frame.data[2] for frame in bus.sent])
+
+    def test_wireless_thermal_command_fails_before_publish(self) -> None:
+        bus = _FakeOtaBus([])
+        executor = MqttOtaSeatExecutor(  # type: ignore[arg-type]
+            _StatusExecutor(),
+            lambda: bus,
+        )
+        plan = {
+            "spec": {
+                "commands": [
+                    {
+                        "operation_ref": "operation-1",
+                        "message": "T2G_Seat_Thermal_Control_29E",
+                        "signals": {},
+                    }
+                ]
+            }
+        }
+
+        report = executor.execute(
+            plan,
+            _function_config("seat.set_heating", {"state": "on", "level": 1}),
+        )
+
+        self.assertEqual(report["spec"]["status"], "failed")
+        self.assertIn("does not provide wireless thermal control", report["spec"]["results"][0]["message"])
+        self.assertEqual(bus.sent, [])
+
+
+if __name__ == "__main__":
+    unittest.main()