ilesp 0.1.0__py3-none-any.whl

ilesp/__init__.py

@@ -0,0 +1,17 @@
+"""ILESP — Intelligent Logistics Equipment Scheduling Platform.
+
+核心库（纯 stdlib，零框架依赖）：
+    from ilesp.core.tasks import TaskStore, TaskStatus
+    from ilesp.wcs.scheduler import Topology, WcsScheduler
+    from ilesp.rcs.traffic import TrafficController
+    from ilesp.runtime import IlespRuntime
+
+可选 FastAPI 服务：
+    pip install ilesp[api] → from ilesp.api import create_app
+"""
+from ilesp.core.tasks import TaskStore, TaskStatus
+from ilesp.wcs.scheduler import Topology, WcsScheduler, Station
+
+__version__ = "0.1.0"
+
+__all__ = ["TaskStore", "TaskStatus", "Topology", "WcsScheduler", "Station", "__version__"]

ilesp/adapters/__init__.py

@@ -0,0 +1 @@
+"""ILESP."""

ilesp/adapters/base.py

@@ -0,0 +1,46 @@
+"""ILESP 适配器缝：模拟与真实设备的统一接口（平滑过渡的唯一机制）。
+
+EquipmentAdapter —— 设备级（输送线站台/提升机/门）：WCS 逐站推进的执行面
+FleetAdapter     —— 车队级（AMR）：RCS 搬运腿的执行面
+
+simulated/* 与 real/*（modbus 等）实现同一接口；生产配置引用 real/*，
+测试/演示引用 simulated/*——代码零分叉。
+"""
+from __future__ import annotations
+
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class EquipmentAdapter(Protocol):
+    """设备级执行面。实现方负责站台状态机（有货/方向/故障/心跳）。"""
+
+    def load_topology(self) -> list[dict[str, Any]]:
+        """声明站台清单 [{station_no, kind, zone}]（WCS 据此建拓扑）。"""
+        ...
+
+    def move_cargo(self, from_station: str, to_station: str, cargo: dict[str, Any]) -> bool:
+        """请求设备把货物从 from 推进到 to（相邻站）。阻塞直到完成或失败；False=设备拒绝/故障。"""
+        ...
+
+    def station_state(self, station_no: str) -> dict[str, Any]:
+        """站台当前状态 {occupied, fault, auto, ...}（WCS 发车前问下游收不收得下）。"""
+        ...
+
+
+@runtime_checkable
+class FleetAdapter(Protocol):
+    """车队级执行面。实现方负责 AMR 行驶/电量/交通（仿真内核或真实 RCS/VDA5050）。"""
+
+    def available_amrs(self) -> list[str]:
+        """当前可接单的 AMR id 列表。"""
+        ...
+
+    def dispatch(self, amr_id: str, mission_id: str, from_station: str, to_station: str,
+                 cargo: dict[str, Any]) -> bool:
+        """下发搬运腿。返回是否受理（受理后由实现方异步推进，pick_up/drop_off 回调经 runtime）。"""
+        ...
+
+    def mission_state(self, mission_id: str) -> dict[str, Any]:
+        """腿执行状态 {state: driving|arrived|failed, progress: 0..1}。"""
+        ...

ilesp/adapters/importer.py

@@ -0,0 +1,131 @@
+"""点表导入器（M3，PlcSimulator Import 设计借鉴）：项目点表 CSV → ILESP 设备配置。
+
+CSV 列（首行 header，UTF-8）：
+    station_no,kind,zone,link_prev,link_next,status_offset,task_offset
+  - link_prev/link_next：显式链式相邻（避免方向值歧义——PlcSimulator 的教训：
+    "33 行 stationNo/itemname 不一致"与"arrow 方向值"都曾造成静默归组失败）
+  - status_offset/task_offset：该站台在 Modbus 保持寄存器中的状态字/任务字偏移
+  - kind：conveyor | lifter | door | scanner | dock（缺省 conveyor）
+
+产出设备配置 JSON（ModbusEquipmentAdapter 直接消费）：
+    {"stations": [{station_no, kind, zone, status_offset, task_offset}],
+     "links": [[a, b], ...]}
+
+校验（导入即拦住数据问题，PlcSimulator 的"重复站号主动告警"同思路）：
+  - 重复 station_no → 错误
+  - 偏移冲突/越界 → 错误
+  - link_prev/link_next 断链（单向声明）→ 告警并自动补全反向
+  - 孤儿站台（无任何链接）→ 告警（合法：dock/amr_dock 端点站）
+  - offset 与 station_no 数量不一致 → 告警
+"""
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+from typing import Any
+
+KINDS = ("conveyor", "lifter", "door", "scanner", "dock", "amr_dock")
+
+
+def import_points_csv(path: str | Path) -> dict[str, Any]:
+    """导入点表 CSV → 设备配置 dict（含 warnings）。"""
+    rows: list[dict[str, str]] = []
+    with open(path, encoding="utf-8-sig", newline="") as f:
+        reader = csv.DictReader(f)
+        for col in ("station_no",):
+            if col not in (reader.fieldnames or []):
+                raise ValueError(f"点表缺必需列 {col}（header: {reader.fieldnames}）")
+        rows = list(reader)
+
+    errors: list[str] = []
+    warnings: list[str] = []
+    stations: list[dict[str, Any]] = []
+    links: set[tuple[str, str]] = set()
+    seen: set[str] = set()
+    seen_offsets: dict[int, str] = {}
+
+    for i, r in enumerate(rows):
+        no = (r.get("station_no") or "").strip()
+        tag = f"row{i + 2}"                                    # CSV 行号（含 header）
+        if not no:
+            errors.append(f"{tag}: station_no 为空")
+            continue
+        if no in seen:
+            errors.append(f"{tag}: 重复 station_no {no}")
+            continue
+        seen.add(no)
+        kind = (r.get("kind") or "conveyor").strip()
+        if kind not in KINDS:
+            warnings.append(f"{tag}: 未知 kind '{kind}' → conveyor")
+            kind = "conveyor"
+        zone = (r.get("zone") or "Z1").strip()
+
+        def _int(col: str) -> int | None:
+            v = (r.get(col) or "").strip()
+            if v == "":
+                return None
+            try:
+                return int(v)
+            except ValueError:
+                errors.append(f"{tag}: {col} 非整数 '{v}'")
+                return None
+
+        so, to = _int("status_offset"), _int("task_offset")
+        for name, off in (("status_offset", so), ("task_offset", to)):
+            if off is not None:
+                if off in seen_offsets and seen_offsets[off] != no:
+                    errors.append(f"{tag}: {name}={off} 与 {seen_offsets[off]} 冲突")
+                else:
+                    seen_offsets[off] = no
+        stations.append({"station_no": no, "kind": kind, "zone": zone,
+                         "status_offset": so, "task_offset": to})
+
+    # 链式相邻：显式 prev/next + 断链自动补全（告警）
+    by_no = {s["station_no"]: s for s in stations}
+    rows_by_no = {r.get("station_no", "").strip(): r for r in rows}
+    for s in stations:
+        no = s["station_no"]
+        for col, peer_col in (("link_next", "link_prev"), ("link_prev", "link_next")):
+            peer = (rows_by_no.get(no, {}).get(col) or "").strip()
+            if not peer:
+                continue
+            if peer not in by_no:
+                errors.append(f"{no}: {col}={peer} 不存在")
+                continue
+            links.add((no, peer) if col == "link_next" else (peer, no))
+            back = (rows_by_no.get(peer, {}).get(peer_col) or "").strip()
+            if back != no:
+                warnings.append(f"{no}: 与 {peer} 单向链接（{peer} 未声明 {peer_col}）→ 自动补全")
+                links.add((peer, no) if col == "link_next" else (no, peer))
+
+    # 孤儿站台
+    linked = {a for a, b in links} | {b for a, b in links}
+    for s in stations:
+        if s["station_no"] not in linked:
+            warnings.append(f"{s['station_no']}: 孤儿站台（无链接；dock/amr_dock 端点为合法）")
+
+    return {"stations": stations, "links": [list(l) for l in sorted(links)],
+            "errors": errors, "warnings": warnings}
+
+
+def check_report(config: dict[str, Any]) -> str:
+    """`check` 命令的人类可读报告：每站台"字节 ↔ 寄存器"映射 + 链接表（PlcSimulator check 同思路）。"""
+    lines = ["站台映射（HR 偏移）："]
+    for s in config["stations"]:
+        lines.append(f"  {s['station_no']:<10} {s['kind']:<9} "
+                     f"状态字 HR{40001 + (s['status_offset'] or 0)}  任务字 HR{40001 + (s['task_offset'] or 0)}")
+    lines.append("链接：")
+    for a, b in config["links"]:
+        lines.append(f"  {a} ⇄ {b}")
+    for w in config.get("warnings", []):
+        lines.append(f"⚠ {w}")
+    for e in config.get("errors", []):
+        lines.append(f"✗ {e}")
+    return "\n".join(lines)
+
+
+def import_to_file(csv_path: str | Path, out_path: str | Path) -> dict[str, Any]:
+    config = import_points_csv(csv_path)
+    Path(out_path).write_text(json.dumps(config, ensure_ascii=False, indent=1), encoding="utf-8")
+    return config

ilesp/adapters/modbus.py

@@ -0,0 +1,116 @@
+"""Modbus 设备适配器（M3 硬化版）：配置驱动 + 位译码 + 握手完成语义 + 断线重连。
+
+- 配置来自点表导入器（importer.py）：每站台 {status_offset, task_offset}；
+- 状态字位定义（对齐现场惯例，PlcSimulator 逆向语义）：X8=有货(occupied) X9=自动(auto) X10=故障(fault)；
+- 握手完成语义：WCS 写任务字(task_no) → PLC 执行 → **任务字清零 = 本腿到达确认（landed）**——
+  runtime 的到达确认（landed）由此驱动，与真实 PLC 握手感一致；
+- 断线重连：读写异常 → 置脏 → 下次调用重建连接（单次重试）。
+"""
+from __future__ import annotations
+
+import time
+from typing import Any
+
+BIT_OCCUPIED = 0x0100   # X8
+BIT_AUTO = 0x0200       # X9
+BIT_FAULT = 0x0400      # X10
+
+
+class ModbusEquipmentAdapter:
+    def __init__(self, host: str, port: int = 502, device_config: dict[str, Any] | None = None,
+                 client_factory: Any = None, timeout_s: float = 2.0,
+                 task_clear_grace_ticks: int = 0) -> None:
+        cfg = device_config or {"stations": [], "links": []}
+        self.host, self.port = host, port
+        self.stations: dict[str, dict[str, Any]] = {
+            s["station_no"]: s for s in cfg["stations"]}
+        self.links = {tuple(l) for l in cfg.get("links", [])}
+        self.timeout_s = timeout_s
+        self._factory = client_factory or self._default_factory
+        self._cli: Any = None
+        self._dirty = False
+        self._pending_task: dict[str, int] = {}     # to_station → task_no（握手未完成）
+
+    @staticmethod
+    def _default_factory(host: str, port: int) -> Any:
+        from pymodbus.client import ModbusTcpClient
+        return ModbusTcpClient(host, port=port)
+
+    # ── 连接管理（断线置脏 + 单次重连） ──
+    def _client(self) -> Any:
+        if self._cli is None or self._dirty:
+            self._cli = self._factory(self.host, self.port)
+            if not self._cli.connect():
+                raise ConnectionError(f"Modbus 连接失败 {self.host}:{self.port}")
+            self._dirty = False
+        return self._cli
+
+    def _read_hr(self, offset: int) -> int:
+        try:
+            rr = self._client().read_holding_registers(offset, 1)
+        except Exception:
+            self._dirty = True
+            rr = self._client().read_holding_registers(offset, 1)   # 单次重连重试
+        if rr.isError():
+            raise RuntimeError(f"读 HR{40001 + offset} 错误：{rr}")
+        return rr.registers[0]
+
+    def _write_hr(self, offset: int, value: int) -> None:
+        try:
+            rr = self._client().write_register(offset, value)
+        except Exception:
+            self._dirty = True
+            rr = self._client().write_register(offset, value)
+        if rr.isError():
+            raise RuntimeError(f"写 HR{40001 + offset} 错误：{rr}")
+
+    # ── EquipmentAdapter ──
+    def load_topology(self) -> list[dict[str, Any]]:
+        return [{"station_no": no, "kind": s["kind"], "zone": s["zone"]}
+                for no, s in self.stations.items()]
+
+    def station_state(self, station_no: str) -> dict[str, Any]:
+        s = self.stations[station_no]
+        if s.get("status_offset") is None:
+            return {"occupied": False, "landed": False, "fault": False, "auto": True}
+        word = self._read_hr(s["status_offset"])
+        occupied = bool(word & BIT_OCCUPIED)
+        task_off = s.get("task_offset")
+        handshake_done = True
+        if task_off is not None and station_no in self._pending_task:
+            task_word = self._read_hr(task_off)
+            handshake_done = task_word == 0          # PLC 清任务字 = 本腿执行完成
+            if handshake_done:
+                del self._pending_task[station_no]
+        return {"occupied": occupied,
+                "landed": occupied and handshake_done and station_no not in self._pending_task,
+                "fault": bool(word & BIT_FAULT),
+                "auto": bool(word & BIT_AUTO)}
+
+    def move_cargo(self, from_station: str, to_station: str, cargo: dict[str, Any]) -> bool:
+        """写目的站任务字（任务号）= 受理；到达由 runtime 的 landed 确认轮询判定。"""
+        s = self.stations.get(to_station)
+        if s is None or s.get("task_offset") is None:
+            return False
+        st = self.station_state(to_station)
+        if st["fault"] or not st["auto"] or st["occupied"]:
+            return False                              # 下游忙/故障/手动 → 不发车
+        task_no = int(cargo.get("task_no", int(time.time()) % 30000))
+        self._write_hr(s["task_offset"], task_no)
+        self._pending_task[to_station] = task_no
+        return True
+
+    def load_cargo(self, station_no: str, cargo: dict[str, Any]) -> bool:
+        """真实设备：货物上载是物理现实（X8 位由 PLC 置位）——适配器侧无需动作。"""
+        return True
+
+    def cargo_at(self, station_no: str) -> dict[str, Any] | None:
+        """真实设备不保存随货 JSON——返回占位（payload 由任务账本供）。"""
+        return {"station_no": station_no} if self.station_state(station_no).get("occupied") else None
+
+    def inject_fault(self, station_no: str, on: bool) -> None:
+        """调试辅助：写故障位（X10）。"""
+        s = self.stations[station_no]
+        word = self._read_hr(s["status_offset"])
+        word = (word | BIT_FAULT) if on else (word & ~BIT_FAULT)
+        self._write_hr(s["status_offset"], word)

ilesp/adapters/simulated/__init__.py

@@ -0,0 +1 @@
+"""ILESP."""

ilesp/adapters/simulated/sim.py

@@ -0,0 +1,120 @@
+"""内置仿真适配器：模拟输送站台 + 模拟 AMR 车队（确定性：固定 tick + 可传 seed）。"""
+from __future__ import annotations
+
+import random
+from typing import Any
+
+
+class SimulatedEquipment:
+    """模拟输送线：站台占用/故障状态 + 相邻推进（50ms 级 tick 由 runtime 驱动）。"""
+
+    def __init__(self, stations: list[dict[str, Any]], seed: int | None = 42,
+                 move_ticks: int = 4, fault_rate: float = 0.0) -> None:
+        self.kind_of = {s["station_no"]: s.get("kind", "conveyor") for s in stations}
+        self.occupied: dict[str, dict[str, Any] | None] = {s["station_no"]: None for s in stations}
+        self.fault: dict[str, bool] = {s["station_no"]: False for s in stations}
+        self.auto: dict[str, bool] = {s["station_no"]: True for s in stations}
+        self._moving: dict[str, dict[str, Any]] = {}       # to_station → cargo（在途）
+        self._move_left = {s["station_no"]: 0 for s in stations}
+        self._move_ticks = max(1, move_ticks)
+        self._rng = random.Random(seed)
+        self.fault_rate = fault_rate
+
+    # ── EquipmentAdapter ──
+    def load_topology(self) -> list[dict[str, Any]]:
+        return [{"station_no": no, "kind": k, "zone": "Z1"} for no, k in self.kind_of.items()]
+
+    def move_cargo(self, from_station: str, to_station: str, cargo: dict[str, Any]) -> bool:
+        """把货从 from 推进到 to：源清空、目的进入在途；目的忙/故障/非自动 → False（WCS 等待）。"""
+        if self.fault.get(to_station) or not self.auto.get(to_station, True):
+            return False
+        if self.occupied.get(to_station) is not None or to_station in self._moving:
+            return False                                    # 下游收不收得下（WaitingDownstream 语义）
+        if self.occupied.get(from_station) is None:
+            return False
+        self.occupied[from_station] = None
+        self._moving[to_station] = dict(cargo)
+        self._move_left[to_station] = self._move_ticks
+        return True
+
+    def cargo_at(self, station_no: str) -> dict[str, Any] | None:
+        """站上当前货物（含随货信息 task_id 等）。"""
+        return self.occupied.get(station_no)
+
+    def load_cargo(self, station_no: str, cargo: dict[str, Any]) -> bool:
+        """上货点装载（WMS 入库语义）：站空闲则上货。"""
+        if self.occupied.get(station_no) is not None or station_no in self._moving:
+            return False
+        self.occupied[station_no] = dict(cargo)
+        return True
+
+    def station_state(self, station_no: str) -> dict[str, Any]:
+        """occupied = 忙（在途也算，供"下一站忙不发车"）；landed = 货已落位（供到达确认）。"""
+        return {"occupied": self.occupied.get(station_no) is not None or station_no in self._moving,
+                "landed": self.occupied.get(station_no) is not None,
+                "fault": self.fault.get(station_no, False),
+                "auto": self.auto.get(station_no, True)}
+
+    # ── 仿真推进（runtime tick 调用） ──
+    def tick(self) -> None:
+        """在途货物计时推进；到站落位。偶发故障（可配 fault_rate，seed 确定）。"""
+        done = [no for no, left in self._move_left.items() if left > 0]
+        for no in done:
+            self._move_left[no] -= 1
+            if self._move_left[no] <= 0:
+                self.occupied[no] = self._moving.pop(no)
+                if self.fault_rate > 0 and self._rng.random() < self.fault_rate:
+                    self.fault[no] = True
+
+    def inject_fault(self, station_no: str, on: bool = True) -> None:
+        self.fault[station_no] = on
+
+
+class SimulatedFleet:
+    """模拟 AMR 车队：直线行驶 + 电量 + 充电回归（运动学点模型，借鉴 fleetdeck 的保真度取舍）。"""
+
+    def __init__(self, amr_ids: list[str], seed: int | None = 42,
+                 speed_mps: float = 1.2, distance_m: float = 24.0, tick_s: float = 0.2) -> None:
+        self.battery = {a: 60.0 + random.Random(seed).random() * 30 for a in amr_ids}
+        self.missions: dict[str, dict[str, Any]] = {}      # mission_id → 腿执行状态
+        self.amr_mission: dict[str, str | None] = {a: None for a in amr_ids}
+        self.progress: dict[str, float] = {}               # mission_id → 0..1
+        self._rng = random.Random(seed)
+        self.speed = speed_mps
+        self.dist = distance_m
+        self.tick_s = tick_s
+        self._ids = list(amr_ids)
+
+    # ── FleetAdapter ──
+    def available_amrs(self) -> list[str]:
+        return [a for a in self._ids if self.amr_mission.get(a) is None and self.battery[a] > 20]
+
+    def dispatch(self, amr_id: str, mission_id: str, from_station: str, to_station: str,
+                 cargo: dict[str, Any]) -> bool:
+        if self.amr_mission.get(amr_id) is not None:
+            return False
+        self.amr_mission[amr_id] = mission_id
+        self.missions[mission_id] = {"amr": amr_id, "from": from_station, "to": to_station,
+                                     "state": "driving", "cargo": dict(cargo)}
+        self.progress[mission_id] = 0.0
+        return True
+
+    def mission_state(self, mission_id: str) -> dict[str, Any]:
+        m = self.missions.get(mission_id)
+        if m is None:
+            return {"state": "unknown", "progress": 0.0}
+        return {"state": m["state"], "progress": round(self.progress.get(mission_id, 0.0), 3)}
+
+    # ── 仿真推进 ──
+    def tick(self) -> None:
+        """每 tick 行驶一段；电量消耗；到站置 arrived。"""
+        for mid, m in list(self.missions.items()):
+            if m["state"] != "driving":
+                continue
+            p = self.progress[mid] + (self.speed * self.tick_s) / self.dist
+            self.battery[m["amr"]] = max(0.0, self.battery[m["amr"]] - 0.05 * self.speed * self.tick_s)
+            if p >= 1.0:
+                self.progress[mid] = 1.0
+                m["state"] = "arrived"
+            else:
+                self.progress[mid] = p

ilesp/adapters/vda5050.py

@@ -0,0 +1,146 @@
+"""VDA5050 FleetAdapter：MQTT 传输 + 语义三判据 + 预留 TTL——FleetAdapter 协议的多厂商 AMR 实现。
+
+传输可插拔：`mqtt_transport` 参数接受 (publish, subscribe) 二元组；
+测试/演示可注入 InProcessMqtt（内存总线）；生产用 paho-mqtt 连 mosquitto/EMQX。
+"""
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, Callable
+
+from .base import FleetAdapter
+from ..rcs.vda5050 import VdaOrder, VdaState, build_order, topic_order, topic_state
+
+
+class InProcessMqtt:
+    """进程内 MQTT 总线（测试/演示：同一进程内 publish → subscribe 回调）。"""
+
+    def __init__(self) -> None:
+        self.subs: dict[str, list[Callable[[str, bytes], None]]] = {}
+        self.messages: list[tuple[str, bytes]] = []
+
+    def publish(self, topic: str, payload: bytes, qos: int = 0) -> None:
+        self.messages.append((topic, payload))
+        for pat, cbs in self.subs.items():
+            if self._match(pat, topic):
+                for cb in cbs:
+                    cb(topic, payload)
+
+    def subscribe(self, topic: str, callback: Callable[[str, bytes], None]) -> None:
+        self.subs.setdefault(topic, []).append(callback)
+
+    @staticmethod
+    def _match(pattern: str, topic: str) -> bool:
+        """MQTT 通配符 + / # 匹配。"""
+        pp, tp = pattern.split("/"), topic.split("/")
+        for i, seg in enumerate(pp):
+            if seg == "#":
+                return True
+            if i >= len(tp):
+                return False
+            if seg != "+" and seg != tp[i]:
+                return False
+        return len(pp) == len(tp)
+
+
+class Vda5050FleetAdapter(FleetAdapter):
+    """FleetAdapter 的 VDA5050 over MQTT 实现（多厂商 AMR 统一接入）。
+
+    transport = (publish_fn, subscribe_fn)——可插拔：测试注入 InProcessMqtt，
+    生产注入 paho-mqtt 客户端的 publish/subscribe 封装。
+    """
+
+    OFFLINE_S = 15.0      # 无 state 心跳 → 离线
+    EVICT_S = 300.0       # 持续离线 → 驱逐
+
+    def __init__(self, manufacturer: str = "ilesp", transport: Any = None,
+                 battery_min: float = 20.0) -> None:
+        self.mfr = manufacturer
+        self.battery_min = battery_min
+        self.robots: dict[str, dict[str, Any]] = {}   # serial → {state: VdaState, last_seen, order_id}
+        self.reserved: dict[str, tuple[str, float]] = {}  # serial → (task_id, at)
+        self._transport = transport
+        if transport is not None and hasattr(transport, "publish"):
+            self._publish = transport.publish
+            self._subscribe = transport.subscribe
+            transport.subscribe(topic_state(self.mfr, "+"), self._on_state)
+        else:
+            self._publish = transport[0] if isinstance(transport, tuple) else None
+            self._subscribe = transport[1] if isinstance(transport, tuple) and len(transport) > 1 else None
+            if self._subscribe:
+                self._subscribe(topic_state(self.mfr, "+"), self._on_state)
+
+    # ── MQTT 回调 ──
+    def _on_state(self, topic: str, payload: bytes) -> None:
+        try:
+            d = json.loads(payload)
+        except Exception:
+            return
+        serial = d.get("serialNumber", "")
+        if not serial:
+            return
+        st = VdaState.from_json(d)
+        self.robots[serial] = {"state": st, "last_seen": time.time()}
+        # fleetdeck：机器人报到对应 orderId 时释放预留
+        oid = st.order_id
+        if oid:
+            for r, (tid, _) in list(self.reserved.items()):
+                if r == serial and tid == oid:
+                    del self.reserved[r]
+
+    def publish_order(self, serial: str, order: VdaOrder) -> None:
+        """向指定机器人发布 order（QoS1 语义——预留在 adapter 层）。"""
+        topic = topic_order(self.mfr, serial)
+        payload = json.dumps(order.to_json()).encode()
+        if self._publish is not None:
+            self._publish(topic, payload, qos=1)
+        # 本地也登记（模拟车直接消费；真车经 MQTT 收到后回 state 报到）
+        self.robots.setdefault(serial, {"state": VdaState(manufacturer=self.mfr, serial_number=serial),
+                                        "last_seen": time.time()})
+        self.robots[serial]["order_id"] = order.order_id
+
+    # ── FleetAdapter 协议 ──
+    def available_amrs(self) -> list[str]:
+        now = time.time()
+        out = []
+        for serial, info in self.robots.items():
+            if now - info["last_seen"] > self.OFFLINE_S:
+                continue
+            if serial in self.reserved:
+                continue
+            st: VdaState = info["state"]
+            if st.is_available() and st.battery_charge > self.battery_min:
+                out.append(serial)
+        return out
+
+    def dispatch(self, amr_id: str, mission_id: str, from_station: str,
+                 to_station: str, cargo: dict[str, Any]) -> bool:
+        if amr_id in self.reserved:
+            return False
+        order = build_order(mission_id, [from_station, to_station])
+        self.publish_order(amr_id, order)
+        self.reserved[amr_id] = (mission_id, time.time())
+        return True
+
+    def mission_state(self, mission_id: str) -> dict[str, Any]:
+        for serial, info in self.robots.items():
+            st: VdaState = info["state"]
+            if st.order_id == mission_id:
+                if st.has_finished():
+                    return {"state": "arrived", "progress": 1.0}
+                if st.is_executing():
+                    prog = 1.0 - min(1.0, st.remaining_nodes() / 2.0) if st.remaining_nodes() else 0.5
+                    return {"state": "driving", "progress": round(prog, 2)}
+        return {"state": "unknown", "progress": 0.0}
+
+    def battery(self, serial: str) -> float:
+        info = self.robots.get(serial)
+        return info["state"].battery_charge if info else 0.0
+
+    # ── 预留 TTL（fleetdeck 模式） ──
+    def _reclaim_expired(self) -> None:
+        now = time.time()
+        expired = [(s, tid) for s, (tid, at) in self.reserved.items() if now - at > 60.0]
+        for s, tid in expired:
+            del self.reserved[s]