feat: CAN 模拟器 TCP 化 + 多设备并发调试 + 后台生命周期管理

wenxiangchao

4 天以前 559890c482f5973f06aafdfec9550fee5ba3c7f2

feat: CAN 模拟器 TCP 化 + 多设备并发调试 + 后台生命周期管理

核心改造:
- CAN 模拟器 TCP 线协议化，独立 CanSimulatorServer 进程 (127.0.0.1:9000)
- 统一 CanDeviceDriver + ICanTransport (NodeChannelTransport / BrokerRpcTransport)
- 新增 DeviceBroker 独立进程，Broker 共享设备走 IPC 管道
- 分层资源管理 LayeredResourceManager + DbLeaseStore (arb.db 仲裁库)
- 总线应答器 EchoResponderToSender (BUS_ECHO ON)

调试面板改造:
- DeviceDebug 多标签页架构 (DeviceDebugTab + CanChannelView)
- CanChannelView 接收帧推送改用 Dispatcher.BeginInvoke 修复死锁
- DebugSessionManager 增加维护租约心跳续期 (120s 周期 < TTL 300s)

自动化与测试:
- IntegrationTest 新增逐设备一次收发测试 (CAN-001~004)
- CanDeviceDriver 惰性连接 EnsureConnectedAsync
- ValidateOwner 用完整 TTL 续期，避免砍短租约
- 回归测试 51/51 通过 (含 BrokerE2E + LayeredResourceManager)

文档:
- 程序架构解析报告 V3.1
- 仪器调用架构与数据流转报告
- 多进程仪器资源方案 / Broker IPC 对比等设计文档

 Aging.Infrastructure/Aging.Infrastructure.csproj

@@ -13,12 +13,14 @@
  <ItemGroup>
    <PackageReference Include="log4net" Version="3.0.4" />
    <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="8.0.0" />
    <PackageReference Include="System.Data.SQLite" Version="1.0.118" />
  </ItemGroup>

  <ItemGroup>
    <Reference Include="HslCommunication">
      <HintPath>..\Libs\HslCommunication.dll</HintPath>
    </Reference>
    <Reference Include="System.Configuration" />
  </ItemGroup>

  <ItemGroup>
@@ -29,6 +31,7 @@
    <ProjectReference Include="..\S7Driver\S7Driver.csproj" />
    <ProjectReference Include="..\ModBusTcpController\ModBusTcpController.csproj" />
    <ProjectReference Include="..\CanSimulator\CanSimulator.csproj" />
    <ProjectReference Include="..\Aging.ResourceContracts\Aging.ResourceContracts.csproj" />
  </ItemGroup>

</Project>

 Aging.Infrastructure/Broker/BrokerClientChannel.cs

New file
@@ -0,0 +1,283 @@
using System;
using System.Buffers.Binary;
using System.Collections.Concurrent;
using System.IO;
using System.IO.Pipes;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Aging.ResourceContracts;
using log4net;

namespace Aging.Infrastructure.Broker
{
    /// <summary>
    /// DeviceBroker å‘½åç®¡é“客户端通道（V3.0 Â§13 åŒæœºåŸºçº¿ï¼‰ã€‚
    /// ä¿®å¤çŽ°æœ‰ PipeClient çš„三大问题：响应关联可达、超时生效、取消可传播。
    /// å¸§æ ¼å¼ï¼š4 å­—节大端长度前缀 + UTF8 JSON å°å¥—；请求-响应经 RequestId/CorrelationId é…å¯¹ã€‚
    /// çº¿ç¨‹æ¨¡åž‹ï¼šå•åŽå°è¯»å¾ªçŽ¯ + pending å­—典；写入用信号量串行化。线程安全，可被多租约共享。
    /// </summary>
    public sealed class BrokerClientChannel : IDisposable
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(BrokerClientChannel));

        private readonly string _pipeName;
        private readonly string _clientInstanceId;
        private readonly SemaphoreSlim _writeLock = new SemaphoreSlim(1, 1);
        private readonly ConcurrentDictionary<string, TaskCompletionSource<IpcEnvelope>> _pending = new();

        private NamedPipeClientStream? _pipe;
        private Task? _readLoop;
        private volatile bool _disposed;
        private volatile bool _connected;
        private int _inFlight;

        /// <summary>握手成功后的 Broker çºªå…ƒï¼ˆé‡å¯åŽé€’增，用于本地陈旧判定）</summary>
        public long ServerEpoch { get; private set; }

        /// <summary>Broker ç”Ÿæ•ˆé…ç½®å“ˆå¸Œï¼ˆINV-04 å¯¹è´¦å‚照）</summary>
        public string BrokerConfigHash { get; private set; } = "";

        public string BrokerId { get; private set; } = "";

        public bool IsConnected => _connected && !_disposed;

        /// <summary>连接/握手默认超时（毫秒）</summary>
        public int ConnectTimeoutMs { get; set; } = 3000;

        /// <summary>单次 RPC é»˜è®¤ç­‰å¾…上限（毫秒）</summary>
        public int DefaultRequestTimeoutMs { get; set; } = 10_000;

        public BrokerClientChannel(string pipeName, string clientInstanceId)
        {
            _pipeName = pipeName ?? throw new ArgumentNullException(nameof(pipeName));
            _clientInstanceId = clientInstanceId ?? throw new ArgumentNullException(nameof(clientInstanceId));
        }

        /// <summary>
        /// ç¡®ä¿è¿žæŽ¥å¹¶å®Œæˆ Hello æ¡æ‰‹ï¼ˆå¹‚等；断线后可重呼）。
        /// åè®®ä¸»ç‰ˆæœ¬ä¸åŒ¹é…æ—¶æŠ›å‡º InvalidOperationException å¹¶æ‹’绝后续请求。
        /// </summary>
        public async Task EnsureConnectedAsync(CancellationToken ct)
        {
            if (_disposed) throw new ObjectDisposedException(nameof(BrokerClientChannel));
            if (_connected) return;

            var pipe = new NamedPipeClientStream("localhost", _pipeName,
                PipeDirection.InOut, PipeOptions.Asynchronous);
            try
            {
                using (var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(ct))
                {
                    timeoutCts.CancelAfter(ConnectTimeoutMs);
                    await pipe.ConnectAsync(timeoutCts.Token).ConfigureAwait(false);
                }
            }
            catch (Exception ex)
            {
                pipe.Dispose();
                throw new InvalidOperationException($"BROKER_UNREACHABLE: æ— æ³•è¿žæŽ¥ DeviceBroker ç®¡é“ [{_pipeName}]: {ex.Message}", ex);
            }

            _pipe = pipe;
            _connected = true;
            _readLoop = Task.Run(() => ReadLoopAsync(pipe, ct));

            // Hello æ¡æ‰‹
            var hello = NewEnvelope(IpcMessageTypes.Hello);
            var resp = await SendAsync(hello, ct).ConfigureAwait(false);
            var result = BrokerIpc.DeserializeBody<HelloResult>(resp.BodyJson);
            if (result == null)
                throw new InvalidOperationException("BROKER_HANDSHAKE_FAILED: Hello å“åº”无效");
            if (result.ProtocolVersion != BrokerIpc.ProtocolVersion)
            {
                _connected = false;
                throw new InvalidOperationException(
                    $"BROKER_PROTOCOL_MISMATCH: å®¢æˆ·ç«¯ v{BrokerIpc.ProtocolVersion}, Broker v{result.ProtocolVersion}");
            }
            ServerEpoch = result.ServerEpoch;
            BrokerConfigHash = result.ConfigHash;
            BrokerId = result.BrokerId;
            Log.Info($"[BrokerChannel] å·²è¿žæŽ¥ {_pipeName}: BrokerId={BrokerId}, epoch={ServerEpoch}, configHash={ShortHash(BrokerConfigHash)}");
        }

        /// <summary>
        /// å‘送一帧请求并等待其关联响应。超时/断线均返回可区分的错误封套（不抛裸异常）。
        /// </summary>
        public async Task<IpcEnvelope> SendAsync(IpcEnvelope request, CancellationToken ct)
        {
            if (_disposed) throw new ObjectDisposedException(nameof(BrokerClientChannel));
            var pipe = _pipe;
            if (!_connected || pipe == null)
                return ErrorEnvelope(request, "BROKER_UNREACHABLE", "未连接 DeviceBroker");

            var tcs = new TaskCompletionSource<IpcEnvelope>(TaskCreationOptions.RunContinuationsAsynchronously);
            _pending[request.RequestId] = tcs;
            Interlocked.Increment(ref _inFlight);
            try
            {
                byte[] frame;
                try
                {
                    frame = BrokerIpc.EncodeFrame(BrokerIpc.EncodeEnvelope(request));
                }
                catch (Exception ex)
                {
                    return ErrorEnvelope(request, "PROTOCOL_ERROR", ex.Message);
                }

                // å†™å…¥ä¸²è¡ŒåŒ–ï¼›pipe åŠåŒå·¥äº¤é”™ä¸‹ async å†™å¯èƒ½æŒ‚死，故写入不加应用级超时（依赖读侧 deadline + æ–­çº¿æ„ŸçŸ¥ï¼‰
                await _writeLock.WaitAsync(ct).ConfigureAwait(false);
                try
                {
                    await pipe.WriteAsync(frame, 0, frame.Length, ct).ConfigureAwait(false);
                    await pipe.FlushAsync(ct).ConfigureAwait(false);
                }
                catch (IOException ex)
                {
                    Fault($"管道写失败: {ex.Message}");
                    return ErrorEnvelope(request, "BROKER_IO_ERROR", ex.Message);
                }
                finally
                {
                    _writeLock.Release();
                }

                using (var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(ct))
                {
                    int waitMs = request.DeadlineUtcMs > 0
                        ? (int)Math.Max(1, request.DeadlineUtcMs - BrokerIpc.NowUtcMs())
                        : DefaultRequestTimeoutMs;
                    var delay = Task.Delay(waitMs, timeoutCts.Token);
                    var winner = await Task.WhenAny(tcs.Task, delay).ConfigureAwait(false);
                    if (winner == tcs.Task)
                    {
                        timeoutCts.Cancel();  // é‡Šæ”¾ delay å®šæ—¶å™¨
                        return await tcs.Task.ConfigureAwait(false);
                    }
                    // INV-06：请求已写出且可能在途 â†’ ç»“果未知(Unknown)，禁止当未执行
                    return UnknownEnvelope(request, "BROKER_TIMEOUT",
                        "等待响应超时，结果未知，按未完成处理");
                }
            }
            finally
            {
                _pending.TryRemove(request.RequestId, out _);
                Interlocked.Decrement(ref _inFlight);
            }
        }

        /// <summary>便捷方法：提交一次 OneShot è®¾å¤‡åŠ¨ä½œï¼Œè¿”回结果体。</summary>
        public async Task<BrokerIpc.ResultBody> SubmitAsync(BrokerIpc.SubmitBody body, string configHash, CancellationToken ct)
        {
            await EnsureConnectedAsync(ct).ConfigureAwait(false);
            var env = NewEnvelope(IpcMessageTypes.SubmitTask);
            env.ConfigHash = configHash ?? "";
            env.BodyJson = BrokerIpc.SerializeBody(body);
            var resp = await SendAsync(env, ct).ConfigureAwait(false);
            var result = BrokerIpc.DeserializeBody<BrokerIpc.ResultBody>(resp.BodyJson)
                ?? new BrokerIpc.ResultBody { State = "Unknown", ErrorCode = "BAD_RESPONSE" };
            return result;
        }

        // ==================== å†…部 ====================

        private async Task ReadLoopAsync(NamedPipeClientStream pipe, CancellationToken ct)
        {
            var lenBuf = new byte[4];
            try
            {
                while (!ct.IsCancellationRequested && !_disposed)
                {
                    await ReadExactAsync(pipe, lenBuf, 4, ct).ConfigureAwait(false);
                    int len = BinaryPrimitives.ReadInt32BigEndian(lenBuf);
                    if (len <= 0 || len > BrokerIpc.MaxFrameBytes)
                        throw new IOException($"非法帧长度 {len}");
                    var payload = new byte[len];
                    await ReadExactAsync(pipe, payload, len, ct).ConfigureAwait(false);

                    IpcEnvelope env;
                    try
                    {
                        env = BrokerIpc.DecodeEnvelope(Encoding.UTF8.GetString(payload));
                    }
                    catch (Exception)
                    {
                        continue; // æ— æ³•è§£æžçš„单帧丢弃，不影响后续关联
                    }

                    if (!string.IsNullOrEmpty(env.CorrelationId)
                        && _pending.TryGetValue(env.CorrelationId, out var tcs))
                    {
                        tcs.TrySetResult(env);
                    }
                }
            }
            catch (OperationCanceledException) { /* æ­£å¸¸é€€å‡º */ }
            catch (Exception ex)
            {
                if (!_disposed) Fault($"读循环终止: {ex.Message}");
            }
        }

        private static async Task ReadExactAsync(Stream s, byte[] buf, int count, CancellationToken ct)
        {
            int off = 0;
            while (off < count)
            {
                int n = await s.ReadAsync(buf, off, count - off, ct).ConfigureAwait(false);
                if (n <= 0) throw new EndOfStreamException("管道已关闭");
                off += n;
            }
        }

        /// <summary>连接失效：置降级态，等待下次 EnsureConnectedAsync é‡è¿žï¼›åœ¨é€”请求由其自身超时收口。</summary>
        private void Fault(string reason)
        {
            if (!_connected) return;
            _connected = false;
            Log.Warn($"[BrokerChannel] è¿žæŽ¥å¤±æ•ˆ({reason})，将在下次请求时重连");
            try { _pipe?.Dispose(); } catch { }
            _pipe = null;
        }

        private IpcEnvelope NewEnvelope(string type) => new IpcEnvelope
        {
            ProtocolVersion = BrokerIpc.ProtocolVersion,
            MessageType = type,
            RequestId = Guid.NewGuid().ToString("N"),
            CorrelationId = "",
            ClientInstanceId = _clientInstanceId,
            AuthorityId = BrokerId
        };

        private static IpcEnvelope ErrorEnvelope(IpcEnvelope? request, string code, string message)
            => BuildEnvelope(request, "Failed", code, message);

        private static IpcEnvelope UnknownEnvelope(IpcEnvelope? request, string code, string message)
            => BuildEnvelope(request, "Unknown", code, message);

        private static IpcEnvelope BuildEnvelope(IpcEnvelope? request, string state, string code, string message)
            => new IpcEnvelope
            {
                ProtocolVersion = BrokerIpc.ProtocolVersion,
                MessageType = "Result",
                CorrelationId = request?.RequestId ?? "",
                BodyJson = "{\"State\":\"" + state + "\",\"ErrorCode\":\"" + code + "\",\"Readback\":\"" +
                           message.Replace("\"", "'") + "\"}"
            };

        private static string ShortHash(string h)
            => string.IsNullOrEmpty(h) ? "" : (h.Length > 8 ? h.Substring(0, 8) : h);

        public void Dispose()
        {
            if (_disposed) return;
            _disposed = true;
            _connected = false;
            try { _pipe?.Dispose(); } catch { }
            _pipe = null;
            _writeLock.Dispose();
        }
    }
}

 Aging.Infrastructure/Broker/BrokerPipeName.cs

New file
@@ -0,0 +1,19 @@
using System;
using Aging.ResourceContracts;

namespace Aging.Infrastructure.Broker
{
    /// <summary>
    /// DeviceBroker å‘½åç®¡é“服务名约定：aging.{brokerId}.v{协议主版本}
    /// ï¼ˆV3.0 Â§13：服务名含 Station/Broker/协议主版本）。
    /// </summary>
    public static class BrokerPipeName
    {
        public static string For(string brokerId)
        {
            if (string.IsNullOrWhiteSpace(brokerId))
                throw new ArgumentException("brokerId ä¸èƒ½ä¸ºç©º", nameof(brokerId));
            return $"aging.{brokerId.Trim().ToLowerInvariant()}.v{BrokerIpc.ProtocolVersion}";
        }
    }
}

 Aging.Infrastructure/Broker/DeviceConfigHash.cs

New file
@@ -0,0 +1,78 @@
using System;
using System.Data;
using System.IO;
using System.Security.Cryptography;
using System.Text;

namespace Aging.Infrastructure.Broker
{
    /// <summary>
    /// ä»Ž DeviceConfig çš„ data.db è®¡ç®—不可变配置快照哈希（INV-04 å¯¹è´¦åŸºå‡†ï¼‰ã€‚
    /// æ‹¼æŽ¥è§„则与 Plugin.DeviceConfig.Model.DeviceConfigModel.ComputeConfigHash ä¿æŒä¸€è‡´ï¼š
    /// DEVICE / CHANNEL / SLOT ä¸‰æ®µæŒ‰å„自排序拼接后 SHA256（小写十六进制）。
    /// OwnerProcessId å±žè¿è¡ŒæœŸä¿¡æ¯ï¼Œä¸å‚与哈希。
    /// </summary>
    public static class DeviceConfigHash
    {
        public static string Compute(string dataDbPath)
        {
            if (!File.Exists(dataDbPath))
                throw new FileNotFoundException("配置库不存在", dataDbPath);

            var sb = new StringBuilder();
            using (var conn = new System.Data.SQLite.SQLiteConnection(
                       $"Data Source={dataDbPath};Version=3;Read Only=True;"))
            {
                conn.Open();
                AppendRows(conn, "DeviceDefinition", "SELECT * FROM DeviceDefinition ORDER BY DeviceId;", sb, row =>
                {
                    string em = Col(row, "ExecutionMode") ?? "Local";
                    string auth = Col(row, "AuthorityId") ?? "";
                    string bk = Col(row, "BrokerId") ?? "";
                    string sk = Col(row, "PhysicalSessionKey") ?? "";
                    return $"DEVICE:{row["DeviceId"]}|{row["Kind"]}|{row["DriverType"]}|{row["Transport"]}|{row["Endpoint"]}|{em}|{auth}|{bk}|{sk};";
                });
                AppendRows(conn, "DeviceChannel", "SELECT * FROM DeviceChannel ORDER BY DeviceId, ChannelId;", sb, row =>
                    $"CHANNEL:{row["DeviceId"]}|{row["ChannelId"]}|{row["Capability"]}|{row["MaxVoltage"]}|{row["MaxCurrent"]};");
                AppendRows(conn, "SlotDeviceMapping", "SELECT * FROM SlotDeviceMapping ORDER BY SlotId, Capability, Version;", sb, row =>
                    $"SLOT:{row["SlotId"]}|{row["Capability"]}|{row["Version"]}|{row["DeviceId"]}|{row["ChannelId"]};");
            }

            using (var sha = SHA256.Create())
            {
                var hash = sha.ComputeHash(Encoding.UTF8.GetBytes(sb.ToString()));
                return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
            }
        }

        private static void AppendRows(System.Data.SQLite.SQLiteConnection conn, string table, string sql, StringBuilder sb, Func<DataRow, string> fmt)
        {
            // è¡¨ç¼ºå¤±æ—¶è·³è¿‡ç©ºæ®µï¼šå“ˆå¸Œå¯¹â€œä¸å­˜åœ¨çš„数据”与“零行”结果一致，两侧同函数保证可对账
            using (var probe = conn.CreateCommand())
            {
                probe.CommandText = "SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name=@t;";
                probe.Parameters.AddWithValue("@t", table);
                var has = Convert.ToInt64(probe.ExecuteScalar()) > 0;
                if (!has) return;
            }
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandText = sql;
                using (var rd = cmd.ExecuteReader())
                {
                    var dt = new DataTable();
                    dt.Load(rd);
                    foreach (DataRow row in dt.Rows)
                        sb.Append(fmt(row));
                }
            }
        }

        private static string? Col(DataRow row, string name)
        {
            if (row.Table.Columns.Contains(name) && row[name] != DBNull.Value)
                return row[name].ToString();
            return null;
        }
    }
}

 Aging.Infrastructure/Contracts/IAutoDeviceFacade.cs

New file
@@ -0,0 +1,88 @@
using System;
using System.Threading;
using System.Threading.Tasks;

namespace Aging.Infrastructure.Contracts
{
    /// <summary>
    /// è‡ªåŠ¨åŒ–设备门面：为全自动测试程序提供"一次调用/一次作用域"的语义，
    /// å†…部封装资源预约、驱动分派、审计。
    /// 
    /// ä½¿ç”¨åœºæ™¯å¯¹æ¯”：
    ///   æ‰‹åŠ¨è°ƒè¯•ï¼ˆDeviceDebug）：需要 UI é€æ­¥æŽ§åˆ¶ä¼šè¯çŠ¶æ€ï¼ˆReadOnly â†’ Maintenance）。
    ///   å…¨è‡ªåŠ¨æµ‹è¯•ï¼ˆTestStep）：只关心"发命令拿结果"，不希望暴露状态机。
    /// æœ¬æŽ¥å£é¢å‘后者。
    /// </summary>
    public interface IAutoDeviceFacade
    {
        /// <summary>
        /// ä¸€æ¬¡æ€§æ‰§è¡Œï¼šå†…部自动完成 ç”³è¯·ç§Ÿçº¦ â†’ æ‰“开会话 â†’ æ‰§è¡Œ â†’ å…³é—­ä¼šè¯ â†’ é‡Šæ”¾ç§Ÿçº¦ã€‚
        /// é€‚合单条命令调用。多条命令建议使用 AcquireAsync å¤ç”¨ç§Ÿçº¦ã€‚
        /// </summary>
        Task<DeviceCommandResult> ExecuteAsync(
            string deviceId, string command, CancellationToken ct = default);

        /// <summary>
        /// ä¸€æ¬¡æ€§æŸ¥è¯¢ï¼šå†…部自动完成完整生命周期。
        /// </summary>
        Task<DeviceCommandResult> QueryAsync(
            string deviceId, string query, CancellationToken ct = default);

        /// <summary>
        /// ç”³è¯·ä½œç”¨åŸŸç§Ÿçº¦ï¼šå ç”¨è®¾å¤‡ï¼Œè¿”回 lease å¥æŸ„。
        /// using ç»“束时（Dispose）自动关会话 + é‡Šæ”¾ç§Ÿçº¦ã€‚
        /// åŒä¸€ lease å†…的多次调用共享同一份资源占用，保证原子性。
        /// </summary>
        /// <param name="deviceId">设备标识</param>
        /// <param name="stepName">测试步骤名称（用于日志/审计标识）</param>
        /// <param name="ct">取消令牌；申请超时视为失败</param>
        Task<IAutoDeviceLease> AcquireAsync(
            string deviceId, string stepName, CancellationToken ct = default);

        /// <summary>
        /// é»˜è®¤ç§Ÿçº¦è¶…时（秒）。可申请更短的 per-call è¶…时。
        /// </summary>
        int DefaultLeaseTimeoutSeconds { get; set; }
    }

    /// <summary>
    /// è‡ªåŠ¨åŒ–设备作用域租约。
    /// ä¸€æ¬¡ç”³è¯·ï¼Œå¤šæ¬¡è°ƒç”¨ï¼›Dispose æ—¶è‡ªåŠ¨é‡Šæ”¾ã€‚
    /// </summary>
    public interface IAutoDeviceLease : IDisposable
    {
        /// <summary>本次租约关联的设备 ID</summary>
        string DeviceId { get; }

        /// <summary>本次租约的内部会话标识（用于审计关联）</summary>
        string SessionId { get; }

        /// <summary>测试步骤名称</summary>
        string StepName { get; }

        /// <summary>申请时刻</summary>
        DateTime AcquiredAt { get; }

        /// <summary>租约是否已被释放</summary>
        bool IsReleased { get; }

        /// <summary>
        /// åœ¨ç§Ÿçº¦ä½œç”¨åŸŸå†…发送命令。
        /// </summary>
        Task<DeviceCommandResult> ExecuteAsync(string command, CancellationToken ct = default);

        /// <summary>
        /// åœ¨ç§Ÿçº¦ä½œç”¨åŸŸå†…查询。
        /// </summary>
        Task<DeviceCommandResult> QueryAsync(string query, CancellationToken ct = default);

        /// <summary>V3.0：租约失效（续期连续失败/被回收）时触发；订阅者应停止下发。</summary>
        event EventHandler LeaseLost;

        /// <summary>V3.0：显式异步释放。</summary>
        Task ReleaseAsync(CancellationToken ct = default);

        /// <summary>V3.0：维护让渡请求（Draining é¢„留，MVP æ’ false）。</summary>
        bool HandoverRequested { get; }
    }
}

 Aging.Infrastructure/Core/DbLeaseStore.cs

New file
@@ -0,0 +1,585 @@
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using Aging.ResourceContracts;
using log4net;

namespace Aging.Infrastructure.Core
{
    public sealed class DbLeaseStore : ILeaseCoordinator
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(DbLeaseStore));

        private readonly string _dbPath;
        private readonly string _authorityId;

        public string AuthorityId => _authorityId;
        public long CurrentEpoch { get; private set; }

        public DbLeaseStore(string dbPath, string authorityId)
        {
            _dbPath = dbPath;
            _authorityId = authorityId;
            EnsureDirectory();
            InitializeSchema();
            CurrentEpoch = ReadOrInitEpoch();
        }

        private void EnsureDirectory()
        {
            var dir = Path.GetDirectoryName(_dbPath);
            if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
                Directory.CreateDirectory(dir);
        }

        private void BeginImmediateTx(System.Data.SQLite.SQLiteConnection conn)
        {
            // BEGIN IMMEDIATE èŽ·å– RESERVED é”ï¼Œé˜»æ­¢å…¶ä»–进程写入，防止 TOCTOU ç«žæ€
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandText = "BEGIN IMMEDIATE";
                cmd.ExecuteNonQuery();
            }
        }

        private void CommitTx(System.Data.SQLite.SQLiteConnection conn)
        {
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandText = "COMMIT";
                cmd.ExecuteNonQuery();
            }
        }

        private void RollbackTx(System.Data.SQLite.SQLiteConnection conn)
        {
            try
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandText = "ROLLBACK";
                    cmd.ExecuteNonQuery();
                }
            }
            catch { }
        }

        private System.Data.SQLite.SQLiteConnection Open()
        {
            var conn = new System.Data.SQLite.SQLiteConnection(
                $"Data Source={_dbPath};Version=3;");
            conn.Open();
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandText = "PRAGMA journal_mode=WAL;";
                cmd.ExecuteNonQuery();
                cmd.CommandText = "PRAGMA busy_timeout=3000;";
                cmd.ExecuteNonQuery();
                cmd.CommandText = "PRAGMA synchronous=FULL;";
                cmd.ExecuteNonQuery();
            }
            return conn;
        }

        private void InitializeSchema()
        {
            using (var conn = Open())
            {
                BeginImmediateTx(conn);
                try
                {
                    Execute(conn, @"
                        CREATE TABLE IF NOT EXISTS authority_meta(
                          AuthorityId TEXT PRIMARY KEY, Epoch INTEGER NOT NULL,
                          BootId TEXT NOT NULL, SchemaVersion INTEGER NOT NULL)");
                    Execute(conn, @"
                        CREATE TABLE IF NOT EXISTS resource_state(
                          ResourceKey TEXT PRIMARY KEY,
                          Generation INTEGER NOT NULL DEFAULT 0,
                          Phase INTEGER NOT NULL DEFAULT 0,
                          LeaseId TEXT, OwnerId TEXT, OwnerType INTEGER,
                          ProcessInstanceId TEXT, MachineName TEXT, HostProcessId INTEGER,
                          Epoch INTEGER NOT NULL DEFAULT 0, Reason TEXT,
                          AcquiredUtcMs INTEGER, ExpiresUtcMs INTEGER, UpdatedUtcMs INTEGER)");
                    Execute(conn, @"
                        CREATE TABLE IF NOT EXISTS lease_history(
                          EventId INTEGER PRIMARY KEY AUTOINCREMENT,
                          ResourceKey TEXT NOT NULL, Generation INTEGER NOT NULL,
                          Epoch INTEGER NOT NULL, LeaseId TEXT, OwnerId TEXT,
                          EventType TEXT NOT NULL, Reason TEXT, UtcMs INTEGER NOT NULL)");
                    Execute(conn, @"
                        CREATE TABLE IF NOT EXISTS recovery_checkpoint(
                          ResourceKey TEXT PRIMARY KEY, Epoch INTEGER NOT NULL,
                          Status INTEGER NOT NULL,
                          PhysicalReadbackJson TEXT NOT NULL, ApprovedBy TEXT,
                          EvidenceUtcMs INTEGER NOT NULL)");
                    CommitTx(conn);
                }
                catch
                {
                    RollbackTx(conn);
                    throw;
                }
            }
        }

        private long ReadOrInitEpoch()
        {
            using (var conn = Open())
            {
                long nowMs = NowMs();
                var row = QueryRow(conn,
                    "SELECT Epoch, BootId FROM authority_meta WHERE AuthorityId=?",
                    _authorityId);
                if (row == null)
                {
                    Execute(conn, "INSERT INTO authority_meta VALUES(?,?,?,1)",
                        _authorityId, 1L, Guid.NewGuid().ToString("N"));
                    return 1;
                }
                long oldEpoch = Convert.ToInt64(row["Epoch"]);
                long newEpoch = oldEpoch + 1;
                Execute(conn,
                    "UPDATE authority_meta SET Epoch=?, BootId=? WHERE AuthorityId=?",
                    newEpoch, Guid.NewGuid().ToString("N"), _authorityId);
                Execute(conn,
                    @"INSERT INTO lease_history(ResourceKey,Generation,Epoch,LeaseId,OwnerId,EventType,Reason,UtcMs)
                      VALUES('*',0,?,'','system','EpochBump','open-authority',?)",
                    newEpoch, nowMs);
                return newEpoch;
            }
        }

        // ================= ILeaseCoordinator =================

        public AcquireOutcome Acquire(AcquireRequest request)
        {
            if (request.ResourceKeys.Length == 0)
                throw new ArgumentException("ResourceKeys ä¸èƒ½ä¸ºç©º");
            var keys = request.ResourceKeys
                .Select(NormKey)
                .OrderBy(k => k, StringComparer.Ordinal)
                .Distinct()
                .ToArray();

            var deadline = NowMs() + Math.Max(0, request.WaitTimeoutMs);
            while (true)
            {
                var outcome = TryAcquireOnce(keys, request);
                if (outcome.Code != AcquireResultCode.Timeout) return outcome;
                if (NowMs() >= deadline) { outcome.Code = AcquireResultCode.Timeout; return outcome; }
                System.Threading.Thread.Sleep(50);
            }
        }

        private AcquireOutcome TryAcquireOnce(string[] keys, AcquireRequest req)
        {
            long now = NowMs();
            using (var conn = Open())
            {
                BeginImmediateTx(conn);
                try
                {
                    var grants = new List<LeaseGrant>(keys.Length);
                    foreach (var key in keys)
                    {
                        var st = QueryRow(conn,
                            "SELECT * FROM resource_state WHERE ResourceKey=?", key);

                        // RecoveryRequired â†’ é˜»æ­¢èŽ·å–
                        if (st != null &&
                            Convert.ToInt32(st["Phase"]) == (int)LeasePhase.RecoveryRequired)
                        {
                            RollbackTx(conn);
                            return new AcquireOutcome
                            {
                                Code = AcquireResultCode.RecoveryBlocked,
                                RecoveryCheckpointKey = key
                            };
                        }

                        // Active ä¸”未过期 â†’ å†²çª
                        bool activeHeld = st != null
                            && Convert.ToInt32(st["Phase"]) == (int)LeasePhase.Active
                            && Convert.ToInt64(st["ExpiresUtcMs"]) > now;
                        if (activeHeld)
                        {
                            RollbackTx(conn);
                            return new AcquireOutcome
                            {
                                Code = AcquireResultCode.ConflictHeld,
                                Holder = new ConflictInfo
                                {
                                    OwnerId = st["OwnerId"]?.ToString() ?? "",
                                    OwnerType = (OwnerTypeV3)Convert.ToInt32(st["OwnerType"]),
                                    MachineName = st["MachineName"]?.ToString() ?? "",
                                    HostProcessId = Convert.ToInt32(st["HostProcessId"]),
                                    Reason = st["Reason"]?.ToString() ?? "",
                                    ExpiresUtcMs = Convert.ToInt64(st["ExpiresUtcMs"])
                                }
                            };
                        }

                        // Active ä½†å·²è¿‡æœŸï¼ˆå°šæœªè¢« Sweep）→ é˜»æ­¢èŽ·å–，要求先完成 Recovery
                        bool expiredNotSwept = st != null
                            && Convert.ToInt32(st["Phase"]) == (int)LeasePhase.Active
                            && Convert.ToInt64(st["ExpiresUtcMs"]) <= now;
                        if (expiredNotSwept)
                        {
                            RollbackTx(conn);
                            return new AcquireOutcome
                            {
                                Code = AcquireResultCode.RecoveryBlocked,
                                RecoveryCheckpointKey = key
                            };
                        }

                        long gen = (st != null ? Convert.ToInt64(st["Generation"]) : 0) + 1;
                        string leaseId = "lease_" + Guid.NewGuid().ToString("N").Substring(0, 12);
                        long exp = now + req.TtlSeconds * 1000L;

                        if (st == null)
                        {
                            Execute(conn,
                                @"INSERT INTO resource_state(ResourceKey,Generation,Phase,LeaseId,OwnerId,
                                  OwnerType,ProcessInstanceId,MachineName,HostProcessId,Epoch,Reason,
                                  AcquiredUtcMs,ExpiresUtcMs,UpdatedUtcMs)
                                  VALUES(?,?,1,?,?,?,?,?,?,?,?,?,?,?)",
                                key, gen, leaseId, req.OwnerId, (int)req.OwnerType,
                                req.ProcessInstanceId, req.MachineName, req.HostProcessId,
                                CurrentEpoch, req.Reason, now, exp, now);
                        }
                        else
                        {
                            Execute(conn,
                                @"UPDATE resource_state SET Generation=?, Phase=1, LeaseId=?, OwnerId=?,
                                  OwnerType=?, ProcessInstanceId=?, MachineName=?, HostProcessId=?,
                                  Epoch=?, Reason=?, AcquiredUtcMs=?, ExpiresUtcMs=?, UpdatedUtcMs=?
                                  WHERE ResourceKey=?",
                                gen, leaseId, req.OwnerId, (int)req.OwnerType, req.ProcessInstanceId,
                                req.MachineName, req.HostProcessId, CurrentEpoch, req.Reason,
                                now, exp, now, key);
                        }

                        Execute(conn,
                            @"INSERT INTO lease_history(ResourceKey,Generation,Epoch,LeaseId,OwnerId,EventType,Reason,UtcMs)
                              VALUES(?,?,?,?,?,'Acquire',?,?)",
                            key, gen, CurrentEpoch, leaseId, req.OwnerId, req.Reason, now);

                        grants.Add(new LeaseGrant(_authorityId, key, leaseId, req.OwnerId,
                            req.OwnerType, CurrentEpoch, gen, exp));
                    }
                    CommitTx(conn);
                    return new AcquireOutcome { Code = AcquireResultCode.Acquired, Grants = grants.ToArray() };
                }
                catch
                {
                    RollbackTx(conn);
                    throw;
                }
            }
        }

        public bool Renew(LeaseGrant grant, int extendSeconds)
        {
            long now = NowMs();
            using (var conn = Open())
            {
                BeginImmediateTx(conn);
                try
                {
                    int n = Execute(conn,
                        @"UPDATE resource_state SET ExpiresUtcMs=?, UpdatedUtcMs=?
                          WHERE ResourceKey=? AND LeaseId=? AND Generation=? AND Epoch=?
                            AND Phase=1 AND ExpiresUtcMs>?",
                        now + extendSeconds * 1000L, now,
                        NormKey(grant.ResourceKey), grant.LeaseId, grant.Generation, grant.Epoch, now);
                    if (n == 1)
                        CommitTx(conn);
                    else
                    {
                        RollbackTx(conn);
                        Log.Warn($"[Lease] ç»­æœŸå¤±è´¥(栅栏不符): {grant.ResourceKey} gen={grant.Generation}");
                    }
                    return n == 1;
                }
                catch
                {
                    RollbackTx(conn);
                    throw;
                }
            }
        }

        public bool Release(LeaseGrant grant, string note)
        {
            long now = NowMs();
            using (var conn = Open())
            {
                BeginImmediateTx(conn);
                try
                {
                    int n = Execute(conn,
                        @"UPDATE resource_state SET Phase=0, LeaseId=NULL, OwnerId=NULL,
                          ExpiresUtcMs=0, UpdatedUtcMs=?
                          WHERE ResourceKey=? AND LeaseId=? AND Generation=?",
                        now, NormKey(grant.ResourceKey), grant.LeaseId, grant.Generation);
                    Execute(conn,
                        @"INSERT INTO lease_history(ResourceKey,Generation,Epoch,LeaseId,OwnerId,EventType,Reason,UtcMs)
                          SELECT ?,?,?,?,?, 'Release', ?, ? WHERE ?=1",
                        NormKey(grant.ResourceKey), grant.Generation, grant.Epoch, grant.LeaseId,
                        grant.OwnerId, note, now, n);
                    if (n == 1) CommitTx(conn); else RollbackTx(conn);
                    return n == 1;
                }
                catch
                {
                    RollbackTx(conn);
                    throw;
                }
            }
        }

        public ConflictInfo ProbeConflict(string resourceKey)
        {
            long now = NowMs();
            using (var conn = Open())
            {
                var st = QueryRow(conn,
                    "SELECT * FROM resource_state WHERE ResourceKey=? AND Phase=1 AND ExpiresUtcMs>?",
                    NormKey(resourceKey), now);
                if (st == null) return null;
                return new ConflictInfo
                {
                    OwnerId = st["OwnerId"]?.ToString() ?? "",
                    OwnerType = (OwnerTypeV3)Convert.ToInt32(st["OwnerType"]),
                    MachineName = st["MachineName"]?.ToString() ?? "",
                    HostProcessId = Convert.ToInt32(st["HostProcessId"]),
                    Reason = st["Reason"]?.ToString() ?? "",
                    ExpiresUtcMs = Convert.ToInt64(st["ExpiresUtcMs"])
                };
            }
        }

        public LeasePhase PhaseOf(string resourceKey)
        {
            using (var conn = Open())
            {
                var st = QueryRow(conn,
                    "SELECT * FROM resource_state WHERE ResourceKey=?", NormKey(resourceKey));
                if (st == null) return LeasePhase.Free;
                int phase = Convert.ToInt32(st["Phase"]);
                if (phase == (int)LeasePhase.RecoveryRequired) return LeasePhase.RecoveryRequired;
                if (phase == (int)LeasePhase.Active && Convert.ToInt64(st["ExpiresUtcMs"]) <= NowMs())
                    return LeasePhase.RecoveryRequired;
                return (LeasePhase)phase;
            }
        }

        public int SweepExpired()
        {
            long now = NowMs();
            using (var conn = Open())
            {
                BeginImmediateTx(conn);
                try
                {
                    var rows = QueryRows(conn,
                        "SELECT * FROM resource_state WHERE Phase=1 AND ExpiresUtcMs<=?", now);
                    int count = 0;
                    foreach (var st in rows)
                    {
                        string key = st["ResourceKey"]?.ToString() ?? "";
                        long gen = Convert.ToInt64(st["Generation"]);
                        long epoch = Convert.ToInt64(st["Epoch"]);
                        string leaseId = st["LeaseId"]?.ToString() ?? "";
                        string ownerId = st["OwnerId"]?.ToString() ?? "";
                        Execute(conn,
                            "UPDATE resource_state SET Phase=2, UpdatedUtcMs=? WHERE ResourceKey=?",
                            now, key);
                        Execute(conn,
                            @"INSERT INTO lease_history(ResourceKey,Generation,Epoch,LeaseId,OwnerId,EventType,Reason,UtcMs)
                              VALUES(?,?,?,?,?,'ExpiredToRecovery','ttl-missed',?)",
                            key, gen, epoch, leaseId, ownerId, now);
                        Execute(conn,
                            @"INSERT OR REPLACE INTO recovery_checkpoint(ResourceKey,Epoch,Status,PhysicalReadbackJson,ApprovedBy,EvidenceUtcMs)
                              VALUES(?,?,0,'{}',NULL,?)", key, epoch, now);
                        count++;
                    }
                    CommitTx(conn);
                    return count;
                }
                catch
                {
                    RollbackTx(conn);
                    throw;
                }
            }
        }

        public bool ApproveRecovery(string resourceKey, string readbackJson, string approvedBy)
        {
            long now = NowMs();
            using (var conn = Open())
            {
                BeginImmediateTx(conn);
                try
                {
                    Execute(conn,
                        @"INSERT OR REPLACE INTO recovery_checkpoint(ResourceKey,Epoch,Status,PhysicalReadbackJson,ApprovedBy,EvidenceUtcMs)
                          VALUES(?,?,1,?,?,?)",
                        NormKey(resourceKey), CurrentEpoch, readbackJson, approvedBy, now);
                    int n = Execute(conn,
                        @"UPDATE resource_state SET Phase=0, LeaseId=NULL, OwnerId=NULL, UpdatedUtcMs=?
                          WHERE ResourceKey=? AND Phase=2",
                        now, NormKey(resourceKey));
                    Execute(conn,
                        @"INSERT INTO lease_history(ResourceKey,Generation,Epoch,LeaseId,OwnerId,EventType,Reason,UtcMs)
                          SELECT ResourceKey,Generation,Epoch,'','system','RecoveryApproved',?,? FROM resource_state WHERE ResourceKey=?",
                        approvedBy, now, NormKey(resourceKey));
                    CommitTx(conn);
                    return n == 1;
                }
                catch
                {
                    RollbackTx(conn);
                    throw;
                }
            }
        }

        /// <summary>当前处于待回收相位的资源键（含过期未扫的 Active）。</summary>
        public string[] GetRecoveryRequiredKeys()
        {
            using (var conn = Open())
            {
                var rows = QueryRows(conn,
                    "SELECT ResourceKey FROM resource_state WHERE Phase=2 OR (Phase=1 AND ExpiresUtcMs<=?)",
                    NowMs());
                return rows.Select(st => st["ResourceKey"]?.ToString() ?? "")
                           .Where(k => k.Length > 0).ToArray();
            }
        }

        /// <summary>
        /// å¯åŠ¨å¯¹è´¦ï¼ˆå®¿ä¸»èº«ä»½æ›´æ›¿ï¼‰ï¼šè¿›ç¨‹é‡å¯åŽæ—§ owner è¿›ç¨‹å·²ä¸å­˜åœ¨ï¼Œå…¶ç‰©ç† I/O éšè¿›ç¨‹è‡ªç„¶éš”离，
        /// æŒ‰ INV-03 æµç¨‹å®Œæˆå›žæ”¶ï¼šå…ˆ SweepExpired è¿‡æœŸè½¬å¾…回收，再登记读回证据并置 Free。
        /// è¿™æ˜¯ MVP å•æœºå½¢æ€çš„自动化形式（启动方即宿主自身）；生产多宿主应改为人工审批 UI（P2）。
        /// </summary>
        /// <returns>本次回收的资源数</returns>
        public int ReconcileAfterBoot(string hostIdentity)
        {
            int swept = SweepExpired();
            int approved = 0;
            foreach (var key in GetRecoveryRequiredKeys())
            {
                var evidence = "{\"probe\":\"boot-reconcile\",\"host\":\"" + hostIdentity + "\"}";
                if (ApproveRecovery(key, evidence, "boot-recovery:" + hostIdentity))
                    approved++;
            }
            if (swept > 0 || approved > 0)
                Log.Info($"[DbLeaseStore] å¯åŠ¨å¯¹è´¦å®Œæˆ: swept={swept}, approved={approved} (host={hostIdentity})");
            return approved;
        }

        public void BumpEpochForTest(string reason)
        {
            using (var conn = Open())
            {
                BeginImmediateTx(conn);
                try
                {
                    // æå‡ authority_meta ä¸­çš„ epoch
                    Execute(conn,
                        "UPDATE authority_meta SET Epoch=Epoch+1, BootId=? WHERE AuthorityId=?",
                        Guid.NewGuid().ToString("N"), _authorityId);
                    // åœ¨äº‹åŠ¡å†…读取新 epoch，用于同步更新 resource_state
                    var row = QueryRow(conn,
                        "SELECT Epoch FROM authority_meta WHERE AuthorityId=?", _authorityId);
                    long newEpoch = row != null ? Convert.ToInt64(row["Epoch"]) : CurrentEpoch;
                    // åŒæ­¥æå‡ resource_state ä¸­æ‰€æœ‰æ´»è·ƒè¡Œçš„ Epoch，使旧 Grant çš„ Epoch å­—段失效
                    Execute(conn,
                        "UPDATE resource_state SET Epoch=? WHERE Phase=1",
                        newEpoch);
                    Execute(conn,
                        @"INSERT INTO lease_history(ResourceKey,Generation,Epoch,LeaseId,OwnerId,EventType,Reason,UtcMs)
                          VALUES('*',0,?,'','system','EpochBump',?,?)",
                        newEpoch, reason, NowMs());
                    CommitTx(conn);
                    // èµ‹å€¼æ”¾åœ¨ Commit ä¹‹åŽï¼Œä¿è¯ DB ä¸Žå†…å­˜ epoch ä¸€è‡´
                    CurrentEpoch = newEpoch;
                    Log.Info($"[Lease] epoch æå‡è‡³ {CurrentEpoch}: {reason}");
                }
                catch
                {
                    RollbackTx(conn);
                    throw;
                }
            }
        }

        // ================= è¾…助 =================

        public static string NormKey(string key) =>
            key.Trim().ToLowerInvariant().Replace(' ', '-');

        private static long NowMs() =>
            DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

        private static int Execute(System.Data.SQLite.SQLiteConnection conn, string sql,
            params object[] args)
        {
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandText = sql;
                foreach (var arg in args)
                    cmd.Parameters.Add(new System.Data.SQLite.SQLiteParameter { Value = arg });
                return cmd.ExecuteNonQuery();
            }
        }

        private static Dictionary<string, object> QueryRow(
            System.Data.SQLite.SQLiteConnection conn, string sql, params object[] args)
        {
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandText = sql;
                foreach (var arg in args)
                    cmd.Parameters.Add(new System.Data.SQLite.SQLiteParameter { Value = arg });
                using (var reader = cmd.ExecuteReader())
                {
                    if (!reader.Read()) return null;
                    var row = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
                    for (int i = 0; i < reader.FieldCount; i++)
                        row[reader.GetName(i)] = reader.IsDBNull(i) ? null : reader.GetValue(i);
                    return row;
                }
            }
        }

        private static List<Dictionary<string, object>> QueryRows(
            System.Data.SQLite.SQLiteConnection conn, string sql, params object[] args)
        {
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandText = sql;
                foreach (var arg in args)
                    cmd.Parameters.Add(new System.Data.SQLite.SQLiteParameter { Value = arg });
                using (var reader = cmd.ExecuteReader())
                {
                    var rows = new List<Dictionary<string, object>>();
                    while (reader.Read())
                    {
                        var row = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
                        for (int i = 0; i < reader.FieldCount; i++)
                            row[reader.GetName(i)] = reader.IsDBNull(i) ? null : reader.GetValue(i);
                        rows.Add(row);
                    }
                    return rows;
                }
            }
        }
    }
}

 Aging.Infrastructure/Core/LayeredResourceManager.cs

New file
@@ -0,0 +1,231 @@
using System.Collections.Concurrent;
using Aging.Infrastructure.Contracts;
using Aging.ResourceContracts;
using log4net;

namespace Aging.Infrastructure.Core
{
    /// <summary>
    /// åŸºäºŽ DbLeaseStore çš„ IResourceManager åˆ†å±‚实现。
    /// å¯¹å¤–签名与 ResourceManager å®Œå…¨ä¸€è‡´ï¼ˆé›¶æ”¹åŠ¨ï¼‰ï¼Œå†…部转发到 ILeaseCoordinator ä»²è£åº“。
    /// </summary>
    public sealed class LayeredResourceManager : IResourceManager
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(LayeredResourceManager));

        private readonly ILeaseCoordinator _lease;

        /// <summary>
        /// æŒ‰ TokenId ç¼“存已获取的 LeaseGrant æ•°ç»„，供 ValidateOwner / Release / AcquireOperation ä½¿ç”¨ã€‚
        /// </summary>
        private readonly ConcurrentDictionary<string, LeaseGrant[]> _grantsByToken = new();

        /// <summary>
        /// é»˜è®¤ç§Ÿçº¦ TTL（秒）
        /// </summary>
        private const int DefaultTtlSeconds = 300; // 5 åˆ†é’Ÿï¼Œè¶³å¤Ÿé•¿ç”¨äºŽ MVP

        public LayeredResourceManager(ILeaseCoordinator lease)
        {
            _lease = lease ?? throw new ArgumentNullException(nameof(lease));
        }

        /// <summary>
        /// èŽ·å–底层的 ILeaseCoordinator（供 AutoDeviceLease å¿ƒè·³ç»­æœŸä½¿ç”¨ï¼‰
        /// </summary>
        public ILeaseCoordinator Coordinator => _lease;

        // ======================== ReserveAsync ========================

        public async Task<ResourceReservation> ReserveAsync(
            ResourceOwnerToken owner, ResourceKey resource, CancellationToken ct)
        {
            if (owner == null) throw new ArgumentNullException(nameof(owner));
            if (resource == null) throw new ArgumentNullException(nameof(resource));

            var req = new AcquireRequest
            {
                OwnerId = owner.OwnerId,
                OwnerType = (OwnerTypeV3)(int)owner.OwnerType,
                ResourceKeys = new[] { resource.ToString() },
                TtlSeconds = DefaultTtlSeconds,
                WaitTimeoutMs = 0,
                Reason = owner.OwnerId
            };

            AcquireOutcome outcome;
            try
            {
                outcome = await Task.Run(() => _lease.Acquire(req), ct).ConfigureAwait(false);
            }
            catch (OperationCanceledException)
            {
                throw;
            }
            catch (Exception ex)
            {
                Log.Error($"[LayeredRM] Acquire å¼‚常: {ex.Message}", ex);
                throw new ResourceConflictException($"资源 {resource} èŽ·å–异常: {ex.Message}", ex);
            }

            switch (outcome.Code)
            {
                case AcquireResultCode.Acquired:
                case AcquireResultCode.Reused:
                    _grantsByToken[owner.TokenId] = outcome.Grants;
                    Log.Info($"[LayeredRM] èµ„源 {resource} é¢„约成功，所有者: {owner.OwnerId}，lease: {outcome.Grants[0].LeaseId}");
                    return new ResourceReservation(resource, owner)
                    {
                        State = ReservationState.Active,
                        Description = $"LeaseId={outcome.Grants[0].LeaseId}"
                    };

                case AcquireResultCode.ConflictHeld:
                case AcquireResultCode.Timeout:
                    var msg = BuildConflictMessage(resource, outcome.Holder);
                    Log.Warn($"[LayeredRM] èµ„源冲突: {msg}");
                    throw new ResourceConflictException(msg);

                case AcquireResultCode.RecoveryBlocked:
                    throw new ResourceConflictException(
                        $"资源 {resource} å¤„于恢复中（RecoveryRequired），暂不可用");

                default:
                    throw new ResourceConflictException($"资源 {resource} èŽ·å–失败: {outcome.Code}");
            }
        }

        // ======================== ReleaseReservationAsync ========================

        public async Task ReleaseReservationAsync(
            ResourceOwnerToken owner, ResourceKey resource, CancellationToken ct)
        {
            if (owner == null) throw new ArgumentNullException(nameof(owner));
            if (resource == null) throw new ArgumentNullException(nameof(resource));

            var grant = FindGrant(owner.TokenId, resource);
            if (grant == null)
            {
                Log.Warn($"[LayeredRM] å°è¯•é‡Šæ”¾æ—  grant çš„资源: {resource}, owner: {owner.OwnerId}");
                return;
            }

            await Task.Run(() => _lease.Release(grant, owner.OwnerId), ct).ConfigureAwait(false);

            // æ¸…除缓存
            _grantsByToken.TryRemove(owner.TokenId, out _);
            Log.Info($"[LayeredRM] èµ„源 {resource} å·²é‡Šæ”¾ï¼Œæ‰€æœ‰è€…: {owner.OwnerId}");
        }

        // ======================== ValidateOwner ========================

        public bool ValidateOwner(ResourceOwnerToken owner, ResourceKey resource)
        {
            if (owner == null) throw new ArgumentNullException(nameof(owner));
            if (resource == null) throw new ArgumentNullException(nameof(resource));

            var grant = FindGrant(owner.TokenId, resource);
            if (grant == null) return false;

            // æ …栏校验：Renew ä»…在“租约仍 Active ä¸” generation/epoch åŒ¹é…ä¸”未过期”时返回 true。
            // ç”¨å®Œæ•´ TTL ç»­æœŸè€Œéž 1s：既校验归属，又作为每次操作的保活，
            // é¿å…æŠŠç§Ÿçº¦åˆ°æœŸæ—¶é—´ç åˆ° 1s å¯¼è‡´åŽç»­å¿ƒè·³ Renew å› â€œå·²è¿‡æœŸâ€è€Œå¤±è´¥â†’误报租约失效。
            return _lease.Renew(grant, DefaultTtlSeconds);
        }

        // ======================== IsReserved ========================

        public bool IsReserved(ResourceKey resource, out ResourceReservation? reservation)
        {
            if (resource == null) throw new ArgumentNullException(nameof(resource));

            var conflict = _lease.ProbeConflict(resource.ToString());
            if (conflict != null)
            {
                // æž„造一个 "占位" reservation è¿”回给调用方
                var syntheticOwner = new ResourceOwnerToken(
                    (OwnerType)(int)conflict.OwnerType, conflict.OwnerId);
                reservation = new ResourceReservation(resource, syntheticOwner,
                    $"占用中: {conflict.OwnerId} ({conflict.Reason})")
                {
                    State = ReservationState.Active
                };
                return true;
            }

            reservation = null;
            return false;
        }

        // ======================== AcquireOperationAsync ========================

        public async Task<IOperationLease> AcquireOperationAsync(
            ResourceOwnerToken owner, ResourceKey resource, CancellationToken ct)
        {
            if (owner == null) throw new ArgumentNullException(nameof(owner));
            if (resource == null) throw new ArgumentNullException(nameof(resource));

            // æ …栏校验：确保 owner ä»æŒæœ‰è¯¥èµ„源
            if (!ValidateOwner(owner, resource))
            {
                throw new InvalidOperationException(
                    $"资源 {resource} çš„所有者栅栏校验失败，owner: {owner.OwnerId}");
            }

            await Task.CompletedTask;

            return new OperationLease(
                resource,
                owner,
                onRelease: () => Log.Debug($"[LayeredRM] æ“ä½œç§Ÿçº¦é‡Šæ”¾: {resource}"),
                leaseDurationSeconds: 30);
        }

        // ======================== å†…部辅助 ========================

        /// <summary>
        /// æ ¹æ® TokenId èŽ·å–缓存的 LeaseGrant æ•°ç»„（供 AutoDeviceLease å¿ƒè·³ç»­æœŸä½¿ç”¨ï¼‰
        /// </summary>
        public bool TryGetGrants(string tokenId, out LeaseGrant[] grants)
        {
            return _grantsByToken.TryGetValue(tokenId, out grants);
        }

        /// <summary>
        /// æ ¹æ® TokenId å’Œèµ„源键查找对应的 LeaseGrant
        /// </summary>
        private LeaseGrant? FindGrant(string tokenId, ResourceKey resource)
        {
            if (!_grantsByToken.TryGetValue(tokenId, out var grants))
                return null;

            var resourceStr = resource.ToString();
            foreach (var g in grants)
            {
                // DbLeaseStore å¯¹ key åšäº† NormKey（trim+lower+空格替换为-），
                // è¿™é‡Œç”¨ç›¸åŒçš„规范化来比较
                if (string.Equals(DbLeaseStore.NormKey(g.ResourceKey),
                                  DbLeaseStore.NormKey(resourceStr),
                                  StringComparison.OrdinalIgnoreCase))
                    return g;
            }
            return null;
        }

        /// <summary>
        /// æž„造冲突异常消息
        /// </summary>
        private static string BuildConflictMessage(ResourceKey resource, ConflictInfo? holder)
        {
            if (holder == null)
                return $"资源 {resource} æ­£è¢«å ç”¨";

            long nowMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            long remaining = Math.Max(0, (holder.ExpiresUtcMs - nowMs) / 1000);

            return $"资源 {resource} æ­£è¢«å ç”¨ï¼š{holder.OwnerId}" +
                   $"（{holder.OwnerType}，机器 {holder.MachineName} PID {holder.HostProcessId}，" +
                   $"剩余租约 {remaining}s）";
        }
    }
}

 Aging.Infrastructure/Drivers/BrokerRpcTransport.cs

New file
@@ -0,0 +1,152 @@
using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
using Aging.Infrastructure.Broker;
using Aging.ResourceContracts;
using log4net;

namespace Aging.Infrastructure.Drivers
{
    /// <summary>
    /// Broker ä¼ è¾“后端：命令经命名管道 RPC å§”托 DeviceBroker å®¿ä¸»æ‰§è¡Œï¼ˆç‰©ç†ä¼šè¯ç”±å®¿ä¸»å”¯ä¸€æŒæœ‰ï¼‰ã€‚
    /// ä¸‰é‡å…³å¡ï¼ˆç™½åå•/configHash/租约栅栏）与 SessionGate å…¨åœ¨å®¿ä¸»ä¾§ï¼Œæœ¬ç±»åªåšæäº¤ä¸Žæ€æ˜ å°„。
    /// æŽ¥æ”¶å¸§ç”±å®¿ä¸»éšå“åº”以 "|PUSHED:n|EV:RECV…" åŽç¼€æŽå¸¦è¿”回，解析后经 FramePushed ä¸ŠæŠ›ï¼ˆÂ§5.4 æŽå¸¦æ¨¡åž‹ï¼‰ã€‚
    /// </summary>
    internal sealed class BrokerRpcTransport : ICanTransport
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(BrokerRpcTransport));

        private readonly BrokerClientChannel _channel;
        private readonly string _deviceId;
        private readonly string _configHash;
        private bool _disposed;

        public bool IsConnected => _channel.IsConnected;
        public event Action<string> FramePushed;
        public event Action TransportBroken;

        public BrokerRpcTransport(string deviceId, string pipeName, string configHash)
        {
            _deviceId = deviceId ?? throw new ArgumentNullException(nameof(deviceId));
            _configHash = configHash ?? "";
            string instanceId = $"{Environment.MachineName}/{Process.GetCurrentProcess().Id}";
            _channel = new BrokerClientChannel(pipeName, instanceId);
        }

        // busName/nodeIndex å¯¹ Broker æ— æ„ä¹‰ï¼ˆç‰©ç†ä¼šè¯åœ¨å®¿ä¸»æŒ‰è®¾å¤‡ç«¯ç‚¹å»ºç«‹ï¼‰ï¼ŒCONNECT å³æ³¨å†Œ
        public Task ConnectAsync(string busName, int nodeIndex, CancellationToken ct)
            => SubmitExpectOkAsync("CONNECT", "", ct);

        public Task DisconnectAsync()
            => SubmitExpectOkAsync("DISCONNECT", "", CancellationToken.None);

        public async Task<string> TransceiveAsync(string line, CancellationToken ct)
        {
            if (_disposed) throw new ObjectDisposedException(nameof(BrokerRpcTransport));

            // line å½¢å¦‚ "SEND:…" æˆ– "QUERY:…"，映射回宿主白名单 opCode + payload：
            //   SEND  â†’ å®¿ä¸»çš„ device.Driver.SendCommandAsync éœ€å®Œæ•´ "SEND:frameId:data"，payload ä¿ç•™å‰ç¼€
            //   QUERY â†’ å®¿ä¸»çš„ device.Driver.QueryAsync éœ€åŽ» QUERY: å‰ç¼€çš„裸查询
            string opCode;
            string payload;
            if (line.StartsWith("SEND:", StringComparison.Ordinal))
            {
                opCode = "SEND";
                payload = line;
            }
            else if (line.StartsWith("QUERY:", StringComparison.Ordinal))
            {
                opCode = "QUERY";
                payload = line.Substring("QUERY:".Length);
            }
            else
            {
                opCode = "QUERY";
                payload = line;
            }

            var result = await SubmitAsync(opCode, payload, ct).ConfigureAwait(false);
            DrainPiggyback(result.Readback, out string clean);
            return clean;
        }

        private async Task SubmitExpectOkAsync(string opCode, string payload, CancellationToken ct)
        {
            var r = await SubmitAsync(opCode, payload, ct).ConfigureAwait(false);
            // CONNECT/DISCONNECT æ— æœ‰æ•ˆè¯»å›žå¸§ï¼Œå¿½ç•¥æŽå¸¦
            _ = r.Readback;
        }

        private async Task<BrokerIpc.ResultBody> SubmitAsync(string opCode, string payload, CancellationToken ct)
        {
            try
            {
                await _channel.EnsureConnectedAsync(ct).ConfigureAwait(false);
                var body = new BrokerIpc.SubmitBody
                {
                    DeviceId = _deviceId,
                    OperationCode = opCode,
                    Payload = payload ?? "",
                    ResourceKey = _deviceId,
                    ClientInstanceId = $"{Environment.MachineName}/{Process.GetCurrentProcess().Id}"
                };
                var r = await _channel.SubmitAsync(body, _configHash, ct).ConfigureAwait(false);
                ThrowForState(opCode, r);
                return r;
            }
            catch (Exception ex) when (!(ex is ObjectDisposedException))
            {
                Log.Error($"[BrokerRpcCAN] {_deviceId} {opCode} å¤±è´¥: {ex.Message}", ex);
                throw;
            }
        }

        /// <summary>从 readback å°¾éƒ¨å‰¥ç¦» |PUSHED:n|EV:RECV… æ®µå¹¶è§¦å‘ FramePushed。</summary>
        private void DrainPiggyback(string readback, out string clean)
        {
            clean = readback ?? "";
            if (string.IsNullOrEmpty(clean)) return;

            int idx = clean.IndexOf("|PUSHED:", StringComparison.Ordinal);
            if (idx < 0) return;

            string pushSection = clean.Substring(idx + "|PUSHED:".Length);
            clean = clean.Substring(0, idx);

            // pushSection å½¢å¦‚ "n|EV:RECV:…|EV:RECV:…"
            var segs = pushSection.Split('|');
            for (int i = 1; i < segs.Length; i++)
            {
                if (segs[i].StartsWith("EV:", StringComparison.Ordinal))
                    FramePushed?.Invoke(segs[i]);
            }
        }

        private void ThrowForState(string opCode, BrokerIpc.ResultBody r)
        {
            switch (r.State)
            {
                case "Succeeded":
                    return;
                case "RejectedStaleLease":
                    throw new InvalidOperationException($"LEASE_STALE: {_deviceId} ç§Ÿçº¦æ …栏校验失败: {r.ErrorCode} {r.Readback}");
                case "RejectedConfigMismatch":
                    throw new InvalidOperationException($"CONFIG_MISMATCH: Broker ç”Ÿæ•ˆé…ç½®ä¸Žæœ¬åœ°å¿«ç…§ä¸ä¸€è‡´(INV-04): {r.Readback}");
                case "RejectedQueueFull":
                    throw new InvalidOperationException($"QUEUE_FULL: {r.Readback}");
                case "Unknown":
                    throw new TimeoutException($"UNKNOWN: {_deviceId} åŠ¨ä½œ {opCode} ç»“果未知，禁止重试假定未执行(INV-06): {r.Readback}");
                default:
                    throw new InvalidOperationException($"Broker æ‰§è¡Œå¤±è´¥[{r.ErrorCode}]: {r.Readback}");
            }
        }

        public void Dispose()
        {
            if (_disposed) return;
            _disposed = true;
            _channel.Dispose();
        }
    }
}

 Aging.Infrastructure/Drivers/CanDeviceDriver.cs

New file
@@ -0,0 +1,334 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Aging.Infrastructure.Contracts;
using CanSimulator;
using log4net;

namespace Aging.Infrastructure.Drivers
{
    /// <summary>
    /// å…¨ç³»ç»Ÿå”¯ä¸€çš„ CAN è®¾å¤‡é©±åŠ¨ã€‚实现 IDeviceDriver，命令语义（SEND/QUERY）与原适配器一致。
    /// Local ä¸Ž Broker çš„差异下沉到构造时选择的 <see cref="ICanTransport"/> åŽç«¯ï¼š
    ///   Local  â†’ <see cref="NodeChannelTransport"/>（TCP ç›´è¿ž CanSimulatorServer）
    ///   Broker â†’ <see cref="BrokerRpcTransport"/>（命名管道委托 DeviceBroker å®¿ä¸»ï¼‰
    /// æŽ¥æ”¶å¸§ç”±åŽç«¯ FramePushed äº‹ä»¶é©±åŠ¨ï¼Œè¿›å…¥æœ¬åœ°ç¼“冲并触发 <see cref="DriverFrameReceived"/>，
    /// ä½¿è°ƒè¯•é¢æ¿ä¸Žè‡ªåŠ¨åŒ–程序对两种执行模式完全无感知。
    /// </summary>
    public sealed class CanDeviceDriver : IDeviceDriver
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(CanDeviceDriver));

        // ä¿¡æ¯åž‹æŸ¥è¯¢ï¼šå“åº”去掉传输层的 OK: å‰ç¼€ï¼Œè¿˜åŽŸä¸ºé—ç•™ "VERB:payload" å½¢æ€ï¼ˆé¢æ¿æŒ‰æ­¤è§£æžï¼‰
        private static readonly Regex InfoVerb =
            new(@"^OK:([A-Z][A-Z_]*):", RegexOptions.Compiled);

        private readonly ICanTransport _transport;
        private readonly string _busName;
        private readonly int _nodeIndex;
        private readonly Queue<CanFrame> _recvBuffer = new();
        private readonly object _bufferLock = new();

        /// <summary>宿主侧待捎带推送行（EV:RECV åŽŸæ–‡ï¼‰ï¼Œä¾› BrokerServer éšå“åº”追加给客户端。</summary>
        private readonly Queue<string> _pendingPushLines = new();
        private const int MaxPendingPushLines = 1000;
        private readonly Stopwatch _latency = new();

        private bool _disposed;
        private string _lastError = string.Empty;
        private DateTime? _lastErrorTime;
        private long _txCount;
        private int _reconnectCount;

        public string DeviceId { get; }
        public bool IsConnected => !_disposed && _transport.IsConnected;

        public event EventHandler<DeviceConnectionEventArgs>? ConnectionChanged;

        /// <summary>接收帧即时事件（Local/Broker ç»Ÿä¸€ç”±åŽç«¯æŽ¨é€é©±åŠ¨ï¼‰</summary>
        public event EventHandler<CanFrame>? DriverFrameReceived;

        /// <summary>Local è®¾å¤‡ï¼šä»Žç«¯ç‚¹è§£æž bus:node，TCP ç›´è¿žæ¨¡æ‹Ÿå™¨ï¼ˆhost/port å–配置或覆盖值）。</summary>
        public CanDeviceDriver(string deviceId, string endpoint,
            string hostOverride = null, int? portOverride = null)
        {
            DeviceId = deviceId ?? throw new ArgumentNullException(nameof(deviceId));
            (_busName, _nodeIndex) = ParseEndpoint(endpoint);
            _transport = new NodeChannelTransport(hostOverride, portOverride, deviceId);
            WireTransport();
        }

        /// <summary>Broker è®¾å¤‡ï¼šæ³¨å…¥ä»£ç†ä¼ è¾“后端（由 DriverFactory ä¾ ExecutionMode æž„造）。</summary>
        internal CanDeviceDriver(string deviceId, string endpoint, ICanTransport transport)
        {
            DeviceId = deviceId ?? throw new ArgumentNullException(nameof(deviceId));
            (_busName, _nodeIndex) = ParseEndpoint(endpoint);
            _transport = transport ?? throw new ArgumentNullException(nameof(transport));
            WireTransport();
        }

        /// <summary>Broker è®¾å¤‡ä»£ç†å·¥åŽ‚：客户端/Bootstrapper æ®æ­¤æž„造委托宿主的统一驱动。</summary>
        public static CanDeviceDriver CreateBrokerProxy(string deviceId, string endpoint, string pipeName, string configHash)
            => new CanDeviceDriver(deviceId, endpoint, new BrokerRpcTransport(deviceId, pipeName, configHash));

        private void WireTransport()
        {
            _transport.FramePushed += OnFramePushed;
            _transport.TransportBroken += () => OnConnection(false, "通道断开");
        }

        private static (string, int) ParseEndpoint(string endpoint)
        {
            if (string.IsNullOrWhiteSpace(endpoint))
                throw new ArgumentException("CAN ç«¯ç‚¹ä¸èƒ½ä¸ºç©º", nameof(endpoint));
            var parts = endpoint.Split(':');
            if (parts.Length < 2 || !int.TryParse(parts[1], out int node) || node < 0)
                throw new ArgumentException($"CAN ç«¯ç‚¹æ ¼å¼åº”为 æ€»çº¿åç§°:节点编号，实际: {endpoint}");
            return (parts[0], node);
        }

        public async Task ConnectAsync(CancellationToken ct)
        {
            ThrowIfDisposed();
            _latency.Restart();
            try
            {
                await _transport.ConnectAsync(_busName, _nodeIndex, ct).ConfigureAwait(false);
                _lastError = string.Empty;
                OnConnection(true, "连接成功");
            }
            catch (Exception ex)
            {
                _lastError = ex.Message;
                _lastErrorTime = DateTime.Now;
                Log.Error($"[CAN] è®¾å¤‡ {DeviceId} è¿žæŽ¥å¤±è´¥: {ex.Message}", ex);
                throw;
            }
            finally
            {
                if (_latency.IsRunning) _latency.Stop();
            }
        }

        public async Task DisconnectAsync()
        {
            ThrowIfDisposed();
            try { await _transport.DisconnectAsync().ConfigureAwait(false); }
            finally { OnConnection(false, "主动断开"); }
        }

        public async Task<string> SendCommandAsync(string command, CancellationToken ct)
        {
            ThrowIfDisposed();
            await EnsureConnectedAsync(ct).ConfigureAwait(false);
            _latency.Restart();
            try
            {
                // å‘½ä»¤ä¸²åŽŸæ ·é€ä¼ ï¼ˆSEND:frameId:data）；响应去 OK: ä¼ è¾“前缀交由 QUERY è¯­ä¹‰ï¼Œ
                // å‘送响应保留遗留 "OK:TX:…" å½¢æ€ï¼ˆä¸Šå±‚与测试按 OK:TX æ–­è¨€ï¼‰
                string resp = await _transport.TransceiveAsync(command, ct).ConfigureAwait(false);
                Interlocked.Increment(ref _txCount);
                return resp;
            }
            catch (Exception ex)
            {
                RecordError(ex);
                throw;
            }
            finally
            {
                if (_latency.IsRunning) _latency.Stop();
            }
        }

        public async Task<string> QueryAsync(string query, CancellationToken ct)
        {
            ThrowIfDisposed();
            await EnsureConnectedAsync(ct).ConfigureAwait(false);
            _latency.Restart();
            try
            {
                string op = (query ?? "").Split(':')[0].ToUpperInvariant();

                // æŽ¥æ”¶ç±»æŸ¥è¯¢ç”±æœ¬åœ°ç¼“冲应答（推送已实时入队），无需往返模拟器
                if (op == "RECV") return HandleRecv();
                if (op == "RECV_ALL") return HandleRecvAll();

                string resp = await _transport.TransceiveAsync("QUERY:" + query, ct).ConfigureAwait(false);
                return NormalizeResponse(resp);
            }
            catch (Exception ex)
            {
                RecordError(ex);
                throw;
            }
            finally
            {
                if (_latency.IsRunning) _latency.Stop();
            }
        }

        public DeviceDriverStatus GetStatus() => new DeviceDriverStatus
        {
            IsConnected = IsConnected,
            IsHealthy = IsConnected && string.IsNullOrEmpty(_lastError),
            LastError = _lastError,
            LastErrorTime = _lastErrorTime,
            LatencyMs = _latency.IsRunning ? _latency.Elapsed.TotalMilliseconds : 0,
            ReconnectCount = _reconnectCount
        };

        // ==================== æŽ¨é€ä¸Žç¼“冲 ====================

        /// <summary>后端 EV:RECV è¡Œ â†’ è§£æžä¸ºå¸§ â†’ å…¥æœ¬åœ°ç¼“冲 + è§¦å‘即时事件。</summary>
        private void OnFramePushed(string line)
        {
            if (_disposed) return;
            try
            {
                var frame = ParsePush(line);
                if (frame == null) return;

                lock (_bufferLock)
                {
                    while (_recvBuffer.Count >= 1000) _recvBuffer.Dequeue();
                    _recvBuffer.Enqueue(frame);

                    // ç´¯ç§¯åŽŸå§‹æŽ¨é€è¡Œä¾›å®¿ä¸»æŽå¸¦ç»™è¿œç«¯å®¢æˆ·ç«¯ï¼ˆæ»¡åˆ™ä¸¢æœ€è€ï¼‰
                    while (_pendingPushLines.Count >= MaxPendingPushLines) _pendingPushLines.Dequeue();
                    _pendingPushLines.Enqueue(line);
                }
                DriverFrameReceived?.Invoke(this, frame);
            }
            catch (Exception ex)
            {
                Log.Warn($"[CAN] {DeviceId} æŽ¨é€å¸§è§£æžå¤±è´¥: {ex.Message} [{line}]");
            }
        }

        private static CanFrame ParsePush(string line)
        {
            // EV:RECV:{frameIdHex}:{dataHex}:{ts}:{srcNodeIndex}
            if (!line.StartsWith("EV:RECV:", StringComparison.Ordinal)) return null;
            var body = line.Substring("EV:RECV:".Length);
            var parts = body.Split(':');
            if (parts.Length < 2) return null;

            uint id = CanFrame.ParseFrameId(parts[0]);
            byte[] data = parts.Length >= 2 ? CanFrame.ParseData(parts[1]) : Array.Empty<byte>();
            return new CanFrame
            {
                FrameId = id,
                Format = id > 0x7FF ? CanFrameFormat.Extended : CanFrameFormat.Standard,
                Type = CanFrameType.Data,
                Data = data,
                SourceNodeId = parts.Length >= 4 ? parts[3] : "",
                Timestamp = DateTime.Now
            };
        }

        private string HandleRecv()
        {
            lock (_bufferLock)
            {
                if (_recvBuffer.Count == 0) return "RECV:EMPTY";
                var f = _recvBuffer.Dequeue();
                return $"RECV:{f.FrameIdHex}:{f.DataHex}:{f.Timestamp:HH:mm:ss.fff}";
            }
        }

        private string HandleRecvAll()
        {
            List<CanFrame> batch = new();
            lock (_bufferLock)
            {
                while (_recvBuffer.Count > 0) batch.Add(_recvBuffer.Dequeue());
            }
            if (batch.Count == 0) return "RECV_ALL:0";
            var items = batch.Select(f => $"{f.FrameIdHex}:{f.DataHex}");
            return $"RECV_ALL:{batch.Count}:{string.Join("|", items)}";
        }

        /// <summary>
        /// ä¿¡æ¯åž‹æŸ¥è¯¢ï¼ˆVERB:…）去掉传输层 OK: å‰ç¼€è¿˜åŽŸé—留格式；
        /// åŠ¨ä½œç¡®è®¤ï¼ˆä¸­æ–‡æç¤ºç­‰ï¼‰ä¿ç•™ OK:。
        /// </summary>
        private static string NormalizeResponse(string resp)
        {
            if (string.IsNullOrEmpty(resp)) return resp;
            var m = InfoVerb.Match(resp);
            if (m.Success)
                return resp.Substring(3); // åŽ» "OK:"
            return resp;
        }

        // ==================== æ‚项 ====================

        /// <summary>
        /// å®¿ä¸»ä¸“用：取出并清空自上次以来累积的推送行，供 BrokerServer æ‹¼æŽ¥åˆ°å“åº” readback å°¾éƒ¨ã€‚
        /// </summary>
        public List<string> DrainPendingPushLines()
        {
            lock (_bufferLock)
            {
                var list = _pendingPushLines.ToList();
                _pendingPushLines.Clear();
                return list;
            }
        }

        private void EnsureConnected()
        {
            if (!IsConnected) throw new InvalidOperationException($"[CAN] è®¾å¤‡ {DeviceId} æœªè¿žæŽ¥");
        }

        /// <summary>按需连接：首次 I/O æ—¶è‹¥æœªè¿žæŽ¥åˆ™è‡ªåŠ¨å»ºç«‹é€šé“（契合“按需连接”设计）。</summary>
        private async Task EnsureConnectedAsync(CancellationToken ct)
        {
            if (IsConnected) return;
            await ConnectAsync(ct).ConfigureAwait(false);
        }

        private void RecordError(Exception ex)
        {
            _lastError = ex.Message;
            _lastErrorTime = DateTime.Now;
            Log.Error($"[CAN] è®¾å¤‡ {DeviceId} æ“ä½œå¤±è´¥: {ex.Message}", ex);
        }

        private void OnConnection(bool connected, string reason)
        {
            if (!connected) _reconnectCount++;
            ConnectionChanged?.Invoke(this, new DeviceConnectionEventArgs
            {
                DeviceId = DeviceId,
                IsConnected = connected,
                Reason = reason
            });
        }

        public void Dispose()
        {
            if (_disposed) return;
            _disposed = true;
            try
            {
                _transport.FramePushed -= OnFramePushed;
                _transport.Dispose();
            }
            catch (Exception ex)
            {
                Log.Error($"[CAN] è®¾å¤‡ {DeviceId} é‡Šæ”¾å¼‚常: {ex.Message}", ex);
            }
        }

        private void ThrowIfDisposed()
        {
            if (_disposed) throw new ObjectDisposedException(nameof(CanDeviceDriver));
        }
    }
}

 Aging.Infrastructure/Drivers/CanDriverAdapter.cs

File was deleted

 Aging.Infrastructure/Drivers/DriverFactory.cs

@@ -97,10 +97,9 @@

                case "CAN":
                    // CAN é©±åŠ¨: endpoint æ ¼å¼ä¸º "busName:nodeIndex" å¦‚ "CAN_BUS_1:0"
                    string busName = ip; // ip å­—段用作总线名称
                    int nodeIndex = port; // port å­—段用作节点编号
                    Log.Info($"[DriverFactory] åˆ›å»º CAN è™šæ‹Ÿé©±åŠ¨: Bus={busName}, Node={nodeIndex}");
                    return new CanDriverAdapter(deviceId, busName, nodeIndex);
                    // ç»Ÿä¸€çš„ CanDeviceDriver（Local é»˜è®¤èµ° TCP NodeChannel è¿žæ¨¡æ‹Ÿå™¨ï¼‰
                    Log.Info($"[DriverFactory] åˆ›å»º CAN é©±åŠ¨: Endpoint={endpoint}");
                    return new CanDeviceDriver(deviceId, endpoint);

                default:
                    throw new NotSupportedException($"不支持的传输协议类型: {transport}。支持的类型: Tcp, SCPI, ModBus, S7, Serial, CAN");

 Aging.Infrastructure/Drivers/ICanTransport.cs

New file
@@ -0,0 +1,34 @@
using System;
using System.Threading;
using System.Threading.Tasks;

namespace Aging.Infrastructure.Drivers
{
    /// <summary>
    /// CAN é©±åŠ¨ä¼ è¾“后端抽象：屏蔽 Local(TCP ç›´è¿žæ¨¡æ‹Ÿå™¨) ä¸Ž Broker(命名管道委托宿主) å·®å¼‚。
    /// ä¸Šå±‚ <see cref="CanDeviceDriver"/> åªä¸Žæœ¬æŽ¥å£äº¤äº’，命令串语义原样透传。
    /// </summary>
    internal interface ICanTransport : IDisposable
    {
        /// <summary>后端是否处于可用连接态</summary>
        bool IsConnected { get; }

        /// <summary>建立通道（TCP è¿žæŽ¥ + HELLO æŒ‚è½½ / Broker CONNECT æ³¨å†Œç‰©ç†ä¼šè¯ï¼‰</summary>
        Task ConnectAsync(string busName, int nodeIndex, CancellationToken ct);

        /// <summary>断开当前节点挂载（TCP DISCONNECT / Broker DISCONNECT）</summary>
        Task DisconnectAsync();

        /// <summary>
        /// å‘送一行命令并等待响应行。line ä¸ºå®Œæ•´å‘½ä»¤ä¸²ï¼ˆSEND:… æˆ– QUERY:…）。
        /// è¿”回响应文本（含 OK:/ERR: å‰ç¼€ï¼Œç”±ä¸Šå±‚解析）；超时/断线抛异常。
        /// </summary>
        Task<string> TransceiveAsync(string line, CancellationToken ct);

        /// <summary>服务端推送的 EV:RECV è¡Œåˆ°è¾¾ï¼ˆNodeChannel ä¸º TCP ç›´æŽ¨ï¼›BrokerRpc ä¸ºéšå“åº”捎带）</summary>
        event Action<string> FramePushed;

        /// <summary>通道断裂事件（触发上层重连/状态更新）</summary>
        event Action TransportBroken;
    }
}

 Aging.Infrastructure/Drivers/NodeChannelTransport.cs

New file
@@ -0,0 +1,219 @@
using System;
using System.Configuration;
using System.IO;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using CanSimulator;
using log4net;

namespace Aging.Infrastructure.Drivers
{
    /// <summary>
    /// Local ä¼ è¾“后端：TCP ç›´è¿ž CanSimulatorServer，握手 HELLO æŒ‚è½½ (bus,nodeIndex)，
    /// å‘½ä»¤ä¸²ç» TransceiveAsync ä¸€é—®ä¸€ç­”，接收帧由服务端 EV:RECV ä¸»åŠ¨æŽ¨é€è§¦å‘ FramePushed。
    /// </summary>
    internal sealed class NodeChannelTransport : ICanTransport
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(NodeChannelTransport));

        private readonly string _host;
        private readonly int _port;
        private readonly string _clientTag;

        private TcpClient _socket;
        private Stream _stream;
        private CancellationTokenSource _cts;
        private Task _readLoop;

        // ä¸€é—®ä¸€ç­”：同一时刻仅一个在途请求
        private readonly SemaphoreSlim _requestLock = new(1, 1);
        private TaskCompletionSource<string> _pending;

        private volatile bool _connected;
        private bool _disposed;
        private string _busName;
        private int _nodeIndex = -1;

        public bool IsConnected => _connected;
        public event Action<string> FramePushed;
        public event Action TransportBroken;

        public NodeChannelTransport(string hostOverride, int? portOverride, string clientTag)
        {
            _host = hostOverride ?? ReadCfg("CanSimulator.Host", "127.0.0.1");
            _port = portOverride ?? ReadIntCfg("CanSimulator.Port", 9000);
            _clientTag = clientTag ?? $"{Environment.MachineName}/{System.Diagnostics.Process.GetCurrentProcess().Id}";
        }

        private static string ReadCfg(string key, string def)
        {
            try { var v = ConfigurationManager.AppSettings[key]; return string.IsNullOrWhiteSpace(v) ? def : v; }
            catch { return def; }
        }
        private static int ReadIntCfg(string key, int def)
            => int.TryParse(ReadCfg(key, null), out int v) ? v : def;

        public async Task ConnectAsync(string busName, int nodeIndex, CancellationToken ct)
        {
            if (_disposed) throw new ObjectDisposedException(nameof(NodeChannelTransport));
            _busName = busName;
            _nodeIndex = nodeIndex;

            try
            {
                _socket = new TcpClient();
                await _socket.ConnectAsync(_host, _port).ConfigureAwait(false);
                _socket.NoDelay = true;
                _stream = _socket.GetStream();
                _cts = new CancellationTokenSource();

                // HELLO æ¡æ‰‹ï¼šè¯»å¾ªçŽ¯å¯åŠ¨å‰åŒæ­¥ç›´è¯»ä¸€è¡Œå“åº”（此时无并发推送）
                string ack = await HandshakeAsync(
                    $"HELLO:{busName}:{nodeIndex}:{_clientTag}", ct).ConfigureAwait(false);

                if (ack == "ERR:NODE_BUSY")
                    throw new InvalidOperationException(
                        $"模拟器总线 {busName} ä¸ŠèŠ‚点编号 {nodeIndex} å·²è¢«å ç”¨ï¼Œè¯·ä¿®æ”¹è®¾å¤‡ç«¯ç‚¹çš„节点编号");
                if (!ack.StartsWith("OK:HELLO", StringComparison.Ordinal))
                    throw new InvalidOperationException($"模拟器握手失败: {ack}");

                _connected = true;
                _readLoop = Task.Run(() => ReadLoopAsync(_cts.Token));
                Log.Info($"[CAN-TCP] å·²æŒ‚è½½ {busName}:N{nodeIndex} @ {_host}:{_port}");
            }
            catch (SocketException ex)
            {
                SafeCleanupSocket();
                throw new InvalidOperationException(
                    $"无法连接 CAN æ¨¡æ‹Ÿå™¨æœåŠ¡ {_host}:{_port}（{ex.Message}）。请先启动 CanSimulatorServer.exe", ex);
            }
        }

        public async Task DisconnectAsync()
        {
            if (!_connected) return;
            try { await RequestLineAsync("DISCONNECT", CancellationToken.None).ConfigureAwait(false); }
            catch { /* æ–­å¼€å°½åŠ›è€Œä¸º */ }
            Teardown();
        }

        public async Task<string> TransceiveAsync(string line, CancellationToken ct)
        {
            if (_disposed) throw new ObjectDisposedException(nameof(NodeChannelTransport));
            if (!_connected) throw new InvalidOperationException("CAN é€šé“未连接");
            try
            {
                return await RequestLineAsync(line, ct).ConfigureAwait(false);
            }
            catch (IOException ex)
            {
                OnBroken();
                throw new InvalidOperationException("CAN æ¨¡æ‹Ÿå™¨è¿žæŽ¥å·²ä¸­æ–­: " + ex.Message, ex);
            }
        }

        /// <summary>握手专用：写 HELLO åŽç›´æŽ¥åŒæ­¥è¯»å–一行响应（读循环尚未启动，无并发）。</summary>
        private async Task<string> HandshakeAsync(string helloLine, CancellationToken ct)
        {
            byte[] frame = SimulatorFraming.Encode(helloLine);
            await _stream.WriteAsync(frame, 0, frame.Length, ct).ConfigureAwait(false);
            await _stream.FlushAsync(ct).ConfigureAwait(false);
            string resp = await SimulatorFraming.ReadFrameAsync(_stream, ct).ConfigureAwait(false);
            return resp ?? "<EOF>";
        }

        /// <summary>发送一行并等待其响应行；EV:RECV æŽ¨é€åœ¨æ­¤è¿‡ç¨‹ä¸­è¢«åˆ†æµå‡ºåŽ»ï¼Œä¸è®¡ä¸ºå“åº”。</summary>
        private async Task<string> RequestLineAsync(string line, CancellationToken ct)
        {
            await _requestLock.WaitAsync(ct).ConfigureAwait(false);
            try
            {
                var tcs = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
                _pending = tcs;

                byte[] frame = SimulatorFraming.Encode(line);
                await _stream.WriteAsync(frame, 0, frame.Length, ct).ConfigureAwait(false);
                await _stream.FlushAsync(ct).ConfigureAwait(false);

                // deadline：默认 5s，超时视为结果未知（上层禁止假定未执行）
                var timeoutTask = Task.Delay(TimeSpan.FromSeconds(5), ct);
                var done = await Task.WhenAny(tcs.Task, timeoutTask).ConfigureAwait(false);
                if (done != tcs.Task)
                {
                    _pending = null;
                    throw new TimeoutException($"CAN æ¨¡æ‹Ÿå™¨å‘½ä»¤è¶…æ—¶: {line}");
                }
                _pending = null;
                ct.ThrowIfCancellationRequested();
                return await tcs.Task.ConfigureAwait(false);
            }
            finally
            {
                _requestLock.Release();
            }
        }

        private async Task ReadLoopAsync(CancellationToken ct)
        {
            try
            {
                while (!ct.IsCancellationRequested)
                {
                    string resp = await SimulatorFraming.ReadFrameAsync(_stream, ct).ConfigureAwait(false);
                    if (resp == null) break; // EOF

                    if (resp.StartsWith("EV:", StringComparison.Ordinal))
                    {
                        FramePushed?.Invoke(resp);
                        continue;
                    }

                    // æ™®é€šå“åº”：交给在途请求
                    _pending?.TrySetResult(resp);
                }
            }
            catch (IOException) { }
            catch (InvalidDataException) { }
            catch (OperationCanceledException) { }
            catch (Exception ex) { Log.Warn($"[CAN-TCP] è¯»å¾ªçŽ¯å¼‚常: {ex.Message}"); }
            finally
            {
                if (!_disposed) OnBroken();
            }
        }

        private void OnBroken()
        {
            if (!_connected && _pending == null) return;
            _connected = false;
            _pending?.TrySetException(new IOException("CAN æ¨¡æ‹Ÿå™¨é€šé“已断开"));
            TransportBroken?.Invoke();
        }

        private void Teardown()
        {
            _connected = false;
            try { _cts?.Cancel(); } catch { }
            SafeCleanupSocket();
        }

        private void SafeCleanupSocket()
        {
            try { _stream?.Dispose(); } catch { }
            try { _socket?.Close(); } catch { }
            _stream = null;
            _socket = null;
        }

        public void Dispose()
        {
            if (_disposed) return;
            _disposed = true;
            Teardown();
            try { _readLoop?.Wait(200); } catch { }
            _requestLock.Dispose();
            _cts?.Dispose();
        }
    }
}

 Aging.Infrastructure/InfrastructureBootstrapper.cs

@@ -1,5 +1,7 @@
using System.IO;
using log4net;
using HMI.Core.Util;
using Aging.Infrastructure.Broker;
using Aging.Infrastructure.Contracts;
using Aging.Infrastructure.Core;
using Aging.Infrastructure.Services;
@@ -32,10 +34,16 @@
            {
                log.Info("开始初始化基础设施服务...");

                // 1. åˆ›å»º ResourceManager å•ä¾‹
                var resourceManager = new ResourceManager();
                // V3.0 MVP：仲裁库 arb.db（与 data.db åŒç›®å½•ï¼‰
                string arbPath = Path.Combine(Path.GetDirectoryName(deviceConfigDbPath)!, "arb.db");
                var leaseStore = new DbLeaseStore(arbPath, "local-main");
                // V3.0 INV-03：启动对账——上次进程异常退出未释放的租约在本机宿主更替后自动回收，
                // é¿å…è°ƒè¯•/生产维护被 RecoveryRequired æ°¸ä¹…阻塞（证据写入 recovery_checkpoint）
                leaseStore.ReconcileAfterBoot($"{Environment.MachineName}/{System.Diagnostics.Process.GetCurrentProcess().Id}");
                var resourceManager = new LayeredResourceManager(leaseStore);
                UtilContainer.RegisterUtil("LeaseCoordinator", leaseStore);
                UtilContainer.RegisterUtil("ResourceManager", resourceManager);
                log.Info("ResourceManager å·²æ³¨å†Œ");
                log.Info("LayeredResourceManager (基于 DbLeaseStore) å·²æ³¨å†Œ");

                // 2. åˆ›å»º DeviceManager å•ä¾‹
                var deviceManager = new DeviceManager();
@@ -57,8 +65,21 @@
                UtilContainer.RegisterUtil("PowerSupplyService", powerSupplyService);
                log.Info("PowerSupplyService å·²æ³¨å†Œ");

                // 6. ä»Žæ•°æ®åº“加载设备定义并注册驱动
                // 6. åˆ›å»º AutoDeviceFacade (自动化测试入口)
                var autoFacade = new AutoDeviceFacade(resourceManager, deviceService);
                UtilContainer.RegisterUtil("AutoDeviceFacade", autoFacade);
                log.Info("AutoDeviceFacade å·²æ³¨å†Œ");

                // 7. åˆ›å»º CanBusService (CAN ç±»åž‹åŒ–服务)
                var canBusService = new CanBusService(autoFacade);
                UtilContainer.RegisterUtil("CanBusService", canBusService);
                log.Info("CanBusService å·²æ³¨å†Œ");

                // 8. ä»Žæ•°æ®åº“加载设备定义并注册驱动
                LoadDevicesFromConfig(deviceManager, mappingResolver);

                // 8.5. V3.0 æ··åˆæž¶æž„：Broker åŸŸè®¾å¤‡æ³¨å†Œä»£ç†é©±åŠ¨ï¼ˆç‰©ç†ä¼šè¯ç”± DeviceBroker.exe å®¿ä¸»å”¯ä¸€æŒæœ‰ï¼‰
                RegisterBrokeredDrivers(deviceManager, deviceConfigDbPath);

                _initialized = true;
                log.Info("基础设施服务初始化完成");
@@ -71,6 +92,56 @@
        }

        /// <summary>
        /// V3.0：扫描配置库中 ExecutionMode=Broker çš„设备，注册统一 CanDeviceDriver（BrokerRpc ä»£ç†åŽç«¯ï¼‰ã€‚
        /// Local è®¾å¤‡ä¿æŒçŽ°æœ‰ç›´é©±è·¯å¾„不变；Broker å®¿ä¸»æœªå¯åŠ¨æ—¶ä»£ç†ä»…在发起 I/O æ—¶å¤±è´¥ï¼Œä¸é˜»å¡žåˆå§‹åŒ–。
        /// </summary>
        private static void RegisterBrokeredDrivers(IDeviceManager deviceManager, string deviceConfigDbPath)
        {
            try
            {
                if (!File.Exists(deviceConfigDbPath)) return;

                var brokeredDevices = new System.Collections.Generic.List<(string DeviceId, string BrokerId, string Endpoint)>();
                using (var conn = new System.Data.SQLite.SQLiteConnection(
                           $"Data Source={deviceConfigDbPath};Version=3;Read Only=True;"))
                {
                    conn.Open();
                    using var cmd = conn.CreateCommand();
                    cmd.CommandText = "SELECT DeviceId, BrokerId, Endpoint FROM DeviceDefinition WHERE ExecutionMode = 'Broker';";
                    using var rd = cmd.ExecuteReader();
                    while (rd.Read())
                    {
                        string id = rd.GetString(0);
                        string brokerId = rd.IsDBNull(1) ? "" : rd.GetString(1);
                        string endpoint = rd.IsDBNull(2) ? "" : rd.GetString(2);
                        if (!string.IsNullOrWhiteSpace(brokerId))
                            brokeredDevices.Add((id, brokerId, endpoint));
                    }
                }

                if (brokeredDevices.Count == 0) return;

                // INV-04：客户端侧生效配置快照，随每次 RPC æäº¤ä¾› Broker å¯¹è´¦
                string configHash;
                try { configHash = DeviceConfigHash.Compute(deviceConfigDbPath); }
                catch { configHash = ""; }

                foreach (var (deviceId, brokerId, endpoint) in brokeredDevices)
                {
                    if (deviceManager.GetDriver(deviceId) != null) continue;
                    var driver = CanDeviceDriver.CreateBrokerProxy(deviceId, endpoint, BrokerPipeName.For(brokerId), configHash);
                    deviceManager.RegisterDriver(deviceId, driver);
                    log.Info($"[Bootstrapper] è®¾å¤‡ {deviceId} å·²æ³¨å†Œ Broker ä»£ç†é©±åŠ¨ (管道={BrokerPipeName.For(brokerId)}, hash={configHash.Substring(0, Math.Min(8, configHash.Length))})");
                }
            }
            catch (Exception ex)
            {
                // ä»£ç†æ³¨å†Œå¤±è´¥é™çº§ï¼šä¸å½±å“ Local ç›´é©±è®¾å¤‡é“¾è·¯
                log.Warn($"[Bootstrapper] Broker ä»£ç†é©±åŠ¨æ³¨å†Œå¤±è´¥ï¼ˆBroker é“¾è·¯ä¸å¯ç”¨ï¼ŒLocal è®¾å¤‡ä¸å—影响）: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// ä»Ž DeviceConfig æ•°æ®åº“加载设备定义并注册驱动
        /// </summary>
        private static void LoadDevicesFromConfig(IDeviceManager deviceManager, SlotDeviceMappingResolver mappingResolver)

 Aging.Infrastructure/Services/AutoDeviceFacade.cs

New file
@@ -0,0 +1,287 @@
using System;
using System.Threading;
using System.Threading.Tasks;
using Aging.Infrastructure.Contracts;
using Aging.Infrastructure.Core;
using Aging.ResourceContracts;
using log4net;

namespace Aging.Infrastructure.Services
{
    /// <summary>
    /// è‡ªåŠ¨åŒ–设备门面实现。
    /// 
    /// ç”Ÿå‘½å‘¨æœŸï¼š
    ///   1) ReserveAsync ç”³è¯·èµ„源占用 â†’ å¾—到 ResourceOwnerToken
    ///   2) DeviceService åˆ†æ´¾å‘½ä»¤ â†’ å†…部再拿操作租约
    ///   3) ReleaseReservationAsync é‡Šæ”¾èµ„源
    /// 
    /// ä¸¤ç§è°ƒç”¨æ¨¡å¼ï¼š
    ///   - ExecuteAsync/QueryAsync：一次性执行（内部完成 1→2→3）
    ///   - AcquireAsync：作用域租约（1 æ‰‹åŠ¨è§¦å‘ï¼›3 åœ¨ lease.Dispose æ—¶è§¦å‘ï¼›2 å¯å¤šæ¬¡ï¼‰
    /// </summary>
    public sealed class AutoDeviceFacade : IAutoDeviceFacade
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(AutoDeviceFacade));

        private readonly IResourceManager _resourceManager;
        private readonly IDeviceService _deviceService;

        /// <summary>
        /// é»˜è®¤ç§Ÿçº¦ç”³è¯·è¶…时（秒）
        /// </summary>
        public int DefaultLeaseTimeoutSeconds { get; set; } = 30;

        /// <summary>
        /// æž„造函数
        /// </summary>
        public AutoDeviceFacade(IResourceManager resourceManager, IDeviceService deviceService)
        {
            _resourceManager = resourceManager ?? throw new ArgumentNullException(nameof(resourceManager));
            _deviceService = deviceService ?? throw new ArgumentNullException(nameof(deviceService));
        }

        // ==================== ä¸€æ¬¡æ€§æ‰§è¡Œæ¨¡å¼ ====================

        /// <inheritdoc/>
        public async Task<DeviceCommandResult> ExecuteAsync(
            string deviceId, string command, CancellationToken ct = default)
        {
            if (string.IsNullOrWhiteSpace(deviceId))
                throw new ArgumentException("设备 ID ä¸èƒ½ä¸ºç©º", nameof(deviceId));
            if (string.IsNullOrWhiteSpace(command))
                throw new ArgumentException("命令不能为空", nameof(command));

            // 1. ç”³è¯·èµ„源占用
            var owner = await ReserveCoreAsync(deviceId, "OneShot", ct).ConfigureAwait(false);
            try
            {
                // 2. é€šè¿‡ DeviceService åˆ†æ´¾å‘½ä»¤
                return await _deviceService.ExecuteCommandAsync(deviceId, command, owner, ct)
                    .ConfigureAwait(false);
            }
            finally
            {
                // 3. æ— è®ºæˆåŠŸå¤±è´¥éƒ½é‡Šæ”¾èµ„源
                await ReleaseCoreAsync(deviceId, owner).ConfigureAwait(false);
            }
        }

        /// <inheritdoc/>
        public async Task<DeviceCommandResult> QueryAsync(
            string deviceId, string query, CancellationToken ct = default)
        {
            if (string.IsNullOrWhiteSpace(deviceId))
                throw new ArgumentException("设备 ID ä¸èƒ½ä¸ºç©º", nameof(deviceId));

            var owner = await ReserveCoreAsync(deviceId, "OneShotQuery", ct).ConfigureAwait(false);
            try
            {
                return await _deviceService.ExecuteQueryAsync(deviceId, query, owner, ct)
                    .ConfigureAwait(false);
            }
            finally
            {
                await ReleaseCoreAsync(deviceId, owner).ConfigureAwait(false);
            }
        }

        // ==================== ä½œç”¨åŸŸç§Ÿçº¦æ¨¡å¼ ====================

        /// <inheritdoc/>
        public async Task<IAutoDeviceLease> AcquireAsync(
            string deviceId, string stepName, CancellationToken ct = default)
        {
            if (string.IsNullOrWhiteSpace(deviceId))
                throw new ArgumentException("设备 ID ä¸èƒ½ä¸ºç©º", nameof(deviceId));

            var owner = await ReserveCoreAsync(deviceId, stepName ?? "Step", ct).ConfigureAwait(false);
            var sessionId = Guid.NewGuid().ToString();

            Log.Info($"[AutoFacade] è®¾å¤‡ {deviceId} å·²èŽ·å¾—作用域租约: Session={sessionId.Substring(0, 8)}, Step={stepName}");

            var lease = new AutoDeviceLease(this, _deviceService, deviceId, sessionId, stepName ?? "Step", owner);

            // å¦‚果底层是 LayeredResourceManager，启动心跳续期
            if (_resourceManager is LayeredResourceManager lrm)
            {
                if (lrm.TryGetGrants(owner.TokenId, out var grants))
                {
                    lease.StartHeartbeat(lrm.Coordinator, grants);
                }
            }

            return lease;
        }

        // ==================== å†…部辅助 ====================

        /// <summary>
        /// å†…部：申请资源占用。
        /// ä½¿ç”¨ OwnerType.Production（自动化测试视为生产流程），
        /// ä¼šä¸Žå…¶ä»–测试/维护会话互斥。
        /// </summary>
        private async Task<ResourceOwnerToken> ReserveCoreAsync(
            string deviceId, string purpose, CancellationToken ct)
        {
            var owner = new ResourceOwnerToken(OwnerType.Production, $"auto_{Guid.NewGuid():N}");
            var resourceKey = new ResourceKey(deviceId, "Generic");

            // ä½¿ç”¨è¶…时包装
            using (var cts = CancellationTokenSource.CreateLinkedTokenSource(ct))
            {
                cts.CancelAfter(TimeSpan.FromSeconds(DefaultLeaseTimeoutSeconds));
                try
                {
                    await _resourceManager.ReserveAsync(owner, resourceKey, cts.Token).ConfigureAwait(false);
                    Log.Debug($"[AutoFacade] è®¾å¤‡ {deviceId} å·²é¢„约 (purpose={purpose}, owner={owner.OwnerId})");
                }
                catch (OperationCanceledException)
                {
                    throw new TimeoutException($"设备 {deviceId} ç§Ÿçº¦ç”³è¯·è¶…时（{DefaultLeaseTimeoutSeconds}s），可能被生产或维护占用");
                }
                catch (ResourceConflictException ex)
                {
                    throw new InvalidOperationException(
                        $"设备 {deviceId} å·²è¢«å…¶ä»–所有者占用: {ex.Message}", ex);
                }
            }

            return owner;
        }

        /// <summary>
        /// å†…部：释放资源占用。
        /// </summary>
        internal async Task ReleaseCoreAsync(string deviceId, ResourceOwnerToken owner)
        {
            try
            {
                var resourceKey = new ResourceKey(deviceId, "Generic");
                await _resourceManager.ReleaseReservationAsync(owner, resourceKey, CancellationToken.None)
                    .ConfigureAwait(false);
                Log.Debug($"[AutoFacade] è®¾å¤‡ {deviceId} å·²é‡Šæ”¾é¢„约 (owner={owner.OwnerId})");
            }
            catch (Exception ex)
            {
                // é‡Šæ”¾å¤±è´¥ä¸é˜»å¡žä¸»æµç¨‹ï¼Œä»…记录
                Log.Warn($"[AutoFacade] é‡Šæ”¾è®¾å¤‡ {deviceId} é¢„约异常: {ex.Message}");
            }
        }
    }

    /// <summary>
    /// è‡ªåŠ¨åŒ–设备作用域租约实现。
    /// Dispose æ—¶è‡ªåŠ¨é‡Šæ”¾åº•å±‚资源占用。
    /// å¹‚等：多次 Dispose åªé‡Šæ”¾ä¸€æ¬¡ã€‚
    /// </summary>
    internal sealed class AutoDeviceLease : IAutoDeviceLease
    {
        private readonly AutoDeviceFacade _facade;
        private readonly IDeviceService _deviceService;
        private readonly ResourceOwnerToken _owner;
        private bool _disposed;

        // V3.0 å¿ƒè·³ç»­æœŸå­—段
        private LeaseGrant[] _grants = new LeaseGrant[0];
        private Timer? _beacon;
        private volatile int _renewFailures;
        private ILeaseCoordinator? _coordinator;
        public event EventHandler? LeaseLost;
        public bool HandoverRequested => false;

        public string DeviceId { get; }
        public string SessionId { get; }
        public string StepName { get; }
        public DateTime AcquiredAt { get; }
        public bool IsReleased => _disposed;

        internal AutoDeviceLease(
            AutoDeviceFacade facade,
            IDeviceService deviceService,
            string deviceId,
            string sessionId,
            string stepName,
            ResourceOwnerToken owner)
        {
            _facade = facade;
            _deviceService = deviceService;
            DeviceId = deviceId;
            SessionId = sessionId;
            StepName = stepName;
            AcquiredAt = DateTime.Now;
            _owner = owner;
        }

        internal void StartHeartbeat(ILeaseCoordinator coordinator, LeaseGrant[] grants)
        {
            _coordinator = coordinator;
            _grants = grants;
            _beacon = new Timer(_ =>
            {
                if (_disposed) return;
                try
                {
                    bool allOk = true;
                    foreach (var g in _grants)
                    {
                        if (!_coordinator.Renew(g, 30)) { allOk = false; break; }
                    }
                    if (allOk)
                        Interlocked.Exchange(ref _renewFailures, 0);
                    else
                        Interlocked.Increment(ref _renewFailures);
                    if (Volatile.Read(ref _renewFailures) >= 2) LeaseLost?.Invoke(this, EventArgs.Empty);
                }
                catch
                {
                    if (Interlocked.Increment(ref _renewFailures) >= 2) LeaseLost?.Invoke(this, EventArgs.Empty);
                }
            }, null, 8000, 8000);
        }

        public Task<DeviceCommandResult> ExecuteAsync(string command, CancellationToken ct = default)
        {
            ThrowIfReleased();
            ThrowIfStale();
            return _deviceService.ExecuteCommandAsync(DeviceId, command, _owner, ct);
        }

        public Task<DeviceCommandResult> QueryAsync(string query, CancellationToken ct = default)
        {
            ThrowIfReleased();
            ThrowIfStale();
            return _deviceService.ExecuteQueryAsync(DeviceId, query, _owner, ct);
        }

        public Task ReleaseAsync(CancellationToken ct = default)
        {
            // Dispose() å†…部已处理 _beacon?.Dispose() å’Œ _disposed æ ‡è®°
            Dispose();
            return Task.CompletedTask;
        }

        public void Dispose()
        {
            if (_disposed) return;
            _beacon?.Dispose();
            _disposed = true;
            // åŒæ­¥é‡Šæ”¾ï¼ˆ.NET 4.7.2 æ—  IAsyncDisposable），阻塞等待
            _facade.ReleaseCoreAsync(DeviceId, _owner).GetAwaiter().GetResult();
            GC.SuppressFinalize(this);
        }

        private void ThrowIfReleased()
        {
            if (_disposed)
                throw new ObjectDisposedException(nameof(AutoDeviceLease),
                    $"设备 {DeviceId} çš„租约已释放 (Session={SessionId.Substring(0, 8)})");
        }

        private void ThrowIfStale()
        {
            if (Volatile.Read(ref _renewFailures) >= 2)
                throw new InvalidOperationException("LEASE_STALE: ç§Ÿçº¦å·²å¤±æ•ˆ");
        }
    }
}

 Aging.Infrastructure/Services/CanBusService.cs

New file
@@ -0,0 +1,209 @@
using System;
using System.Threading;
using System.Threading.Tasks;
using Aging.Infrastructure.Contracts;

namespace Aging.Infrastructure.Services
{
    /// <summary>
    /// CAN å¸§æ•°æ®ï¼ˆè·¨é¡¹ç›®é€šç”¨ç±»åž‹ï¼Œç”¨äºŽç±»åž‹åŒ– API è¿”回值）
    /// </summary>
    public sealed class CanFrameData
    {
        /// <summary>帧 ID（十进制值）</summary>
        public uint FrameId { get; set; }

        /// <summary>帧 ID（十六进制字符串，如 0x100）</summary>
        public string FrameIdHex => FrameId > 0x7FF ? $"0x{FrameId:X8}" : $"0x{FrameId:X3}";

        /// <summary>数据字节</summary>
        public byte[] Data { get; set; } = Array.Empty<byte>();

        /// <summary>数据的十六进制字符串表示</summary>
        public string DataHex => BitConverter.ToString(Data).Replace("-", " ");

        /// <summary>DLC（数据长度）</summary>
        public int Dlc => Data.Length;

        /// <summary>关联的时间戳</summary>
        public DateTime Timestamp { get; set; } = DateTime.Now;

        public override string ToString() => $"{FrameIdHex} [{Dlc}] {DataHex}";
    }

    /// <summary>
    /// CAN é€šè®¯ç±»åž‹åŒ–服务。
    /// éšè—åº•å±‚命令字符串，业务代码只面对帧 ID/数据数组。
    /// 
    /// æ”¯æŒä¸¤ç§è°ƒç”¨æ¨¡å¼ï¼š
    ///   1. ç‹¬ç«‹è°ƒç”¨ï¼šç›´æŽ¥ä¼  deviceId，内部走完整生命周期（一次申请）
    ///   2. å€Ÿç”¨ç§Ÿçº¦ï¼šå¤–部传入 lease，同一 lease å†…多次调用（Per-Step）
    /// </summary>
    public interface ICanBusService
    {
        // ============ æ¨¡å¼ 1：独立调用（自己申请租约） ============

        /// <summary>发送 CAN å¸§ï¼ˆç‹¬ç«‹è°ƒç”¨ï¼‰</summary>
        Task<bool> SendFrameAsync(string deviceId, uint frameId, byte[] data, CancellationToken ct = default);

        /// <summary>接收一帧（独立调用）；无数据时返回 null</summary>
        Task<CanFrameData?> ReceiveFrameAsync(string deviceId, CancellationToken ct = default);

        /// <summary>启用/禁用自动响应（独立调用）</summary>
        Task<bool> SetAutoResponseAsync(string deviceId, bool enabled, CancellationToken ct = default);

        /// <summary>获取节点状态（独立调用）</summary>
        Task<string> GetStatusAsync(string deviceId, CancellationToken ct = default);

        // ============ æ¨¡å¼ 2：借用租约（同一 lease å†…多次调用） ============

        /// <summary>发送 CAN å¸§ï¼ˆå€Ÿç”¨å¤–部租约）</summary>
        Task<bool> SendFrameAsync(IAutoDeviceLease lease, uint frameId, byte[] data, CancellationToken ct = default);

        /// <summary>接收一帧（借用外部租约）</summary>
        Task<CanFrameData?> ReceiveFrameAsync(IAutoDeviceLease lease, CancellationToken ct = default);

        /// <summary>启用/禁用自动响应（借用外部租约）</summary>
        Task<bool> SetAutoResponseAsync(IAutoDeviceLease lease, bool enabled, CancellationToken ct = default);

        /// <summary>获取节点状态（借用外部租约）</summary>
        Task<string> GetStatusAsync(IAutoDeviceLease lease, CancellationToken ct = default);

        /// <summary>查询设备状态（无副作用）</summary>
        Task<string> PeekBusLogAsync(string deviceId, int maxEntries = 20, CancellationToken ct = default);
    }

    /// <summary>
    /// CAN ç±»åž‹åŒ–服务实现。
    /// é€šè¿‡ IAutoDeviceFacade ä¸‹å‘实际命令；只做参数校验和字符串拼装。
    /// </summary>
    public sealed class CanBusService : ICanBusService
    {
        private readonly IAutoDeviceFacade _auto;

        public CanBusService(IAutoDeviceFacade autoFacade)
        {
            _auto = autoFacade ?? throw new ArgumentNullException(nameof(autoFacade));
        }

        // ============ æ¨¡å¼ 1：独立调用 ============

        public async Task<bool> SendFrameAsync(string deviceId, uint frameId, byte[] data, CancellationToken ct = default)
        {
            ValidateFrame(frameId, data);
            var result = await _auto.ExecuteAsync(deviceId, BuildSendCmd(frameId, data), ct).ConfigureAwait(false);
            return result.Success;
        }

        public async Task<CanFrameData?> ReceiveFrameAsync(string deviceId, CancellationToken ct = default)
        {
            var result = await _auto.QueryAsync(deviceId, "RECV", ct).ConfigureAwait(false);
            return ParseRecv(result);
        }

        public async Task<bool> SetAutoResponseAsync(string deviceId, bool enabled, CancellationToken ct = default)
        {
            var cmd = enabled ? "AUTO_RESPONSE:ON" : "AUTO_RESPONSE:OFF";
            var result = await _auto.QueryAsync(deviceId, cmd, ct).ConfigureAwait(false);
            return result.Success;
        }

        public Task<string> GetStatusAsync(string deviceId, CancellationToken ct = default)
            => _auto.QueryAsync(deviceId, "STATUS", ct).ContinueWith(
                t => t.Result.Readback ?? t.Result.RawResponse ?? "N/A", ct);

        // ============ æ¨¡å¼ 2：借用租约 ============

        public async Task<bool> SendFrameAsync(IAutoDeviceLease lease, uint frameId, byte[] data, CancellationToken ct = default)
        {
            if (lease == null) throw new ArgumentNullException(nameof(lease));
            ValidateFrame(frameId, data);
            var result = await lease.ExecuteAsync(BuildSendCmd(frameId, data), ct).ConfigureAwait(false);
            return result.Success;
        }

        public async Task<CanFrameData?> ReceiveFrameAsync(IAutoDeviceLease lease, CancellationToken ct = default)
        {
            if (lease == null) throw new ArgumentNullException(nameof(lease));
            var result = await lease.QueryAsync("RECV", ct).ConfigureAwait(false);
            return ParseRecv(result);
        }

        public async Task<bool> SetAutoResponseAsync(IAutoDeviceLease lease, bool enabled, CancellationToken ct = default)
        {
            if (lease == null) throw new ArgumentNullException(nameof(lease));
            var cmd = enabled ? "AUTO_RESPONSE:ON" : "AUTO_RESPONSE:OFF";
            var result = await lease.QueryAsync(cmd, ct).ConfigureAwait(false);
            return result.Success;
        }

        public async Task<string> GetStatusAsync(IAutoDeviceLease lease, CancellationToken ct = default)
        {
            if (lease == null) throw new ArgumentNullException(nameof(lease));
            var result = await lease.QueryAsync("STATUS", ct).ConfigureAwait(false);
            return result.Readback ?? result.RawResponse ?? "N/A";
        }

        public async Task<string> PeekBusLogAsync(string deviceId, int maxEntries = 20, CancellationToken ct = default)
        {
            var result = await _auto.QueryAsync(deviceId, "LOG", ct).ConfigureAwait(false);
            return result.Readback ?? result.RawResponse ?? "EMPTY";
        }

        // ============ å†…部辅助 ============

        private static string BuildSendCmd(uint frameId, byte[] data)
        {
            var hex = BitConverter.ToString(data).Replace("-", " ");
            return $"SEND:0x{frameId:X3}:{hex}";
        }

        private static void ValidateFrame(uint frameId, byte[] data)
        {
            if (frameId > 0x1FFFFFFF)
                throw new ArgumentException($"CAN å¸§ ID è¶…出范围（最大 0x1FFFFFFF）: 0x{frameId:X8}");
            if (data == null)
                throw new ArgumentNullException(nameof(data));
            if (data.Length > 8)
                throw new ArgumentException($"CAN æ•°æ®é•¿åº¦è¶…限（最大 8 å­—节）: {data.Length}");
        }

        private static CanFrameData? ParseRecv(DeviceCommandResult result)
        {
            var raw = result.Readback ?? result.RawResponse;
            if (string.IsNullOrWhiteSpace(raw)) return null;
            // æ ¼å¼ï¼šRECV:frameIdHex:dataHex:HH:mm:ss.fff
            var parts = raw.Split(':');
            if (parts.Length < 3) return null;
            if (parts[1].Equals("EMPTY", StringComparison.OrdinalIgnoreCase)) return null;

            try
            {
                var frameHex = parts[1].StartsWith("0x", StringComparison.OrdinalIgnoreCase)
                    ? parts[1].Substring(2)
                    : parts[1];
                var frameId = Convert.ToUInt32(frameHex, 16);
                var dataHex = parts[2];
                var data = ParseHexBytes(dataHex);
                DateTime.TryParse(parts.Length >= 4 ? parts[3] : null, out var ts);
                return new CanFrameData { FrameId = frameId, Data = data, Timestamp = ts == default ? DateTime.Now : ts };
            }
            catch
            {
                return null;
            }
        }

        private static byte[] ParseHexBytes(string hex)
        {
            if (string.IsNullOrWhiteSpace(hex)) return Array.Empty<byte>();
            var tokens = hex.Split(new[] { ' ', '-' }, StringSplitOptions.RemoveEmptyEntries);
            var bytes = new byte[tokens.Length];
            for (int i = 0; i < tokens.Length; i++)
            {
                bytes[i] = Convert.ToByte(tokens[i], 16);
            }
            return bytes;
        }
    }
}

 Aging.ResourceContracts/Aging.ResourceContracts.csproj

New file
@@ -0,0 +1,11 @@
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net472</TargetFramework>
    <Nullable>enable</Nullable>
    <LangVersion>10.0</LangVersion>
    <ImplicitUsings>disable</ImplicitUsings>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="System.Text.Json" Version="6.0.5" />
  </ItemGroup>
</Project>

 Aging.ResourceContracts/BrokerIpc.cs

New file
@@ -0,0 +1,91 @@
using System;
using System.Buffers.Binary;
using System.Text;
using System.Text.Json;

namespace Aging.ResourceContracts
{
    /// <summary>
    /// Broker IPC å¸§åè®®ï¼š4 å­—节大端长度前缀 + UTF8 JSON å°å¥—。
    /// åè®®ä¸»ç‰ˆæœ¬ä¸åŒ¹é…æ—¶ Broker ç›´æŽ¥æ‹’绝连接（V3.0 Â§13）。
    /// DTO çº¿æ ¼å¼ç‹¬ç«‹äºŽ LeaseGrant ç­‰åªè¯»æž„造器类型，规避 System.Text.Json ååºåˆ—化限制。
    /// </summary>
    public static class BrokerIpc
    {
        public const int ProtocolVersion = 1;

        /// <summary>单帧最大字节数（1MB），超限视为协议错误</summary>
        public const int MaxFrameBytes = 1024 * 1024;

        private static readonly JsonSerializerOptions JsonOpts = new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true,
            DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull
        };

        // ==================== å¸§ç¼–解码 ====================

        /// <summary>编码为一帧：[4 å­—节大端长度][UTF8 JSON]</summary>
        public static byte[] EncodeFrame(string json)
        {
            var payload = Encoding.UTF8.GetBytes(json);
            if (payload.Length > MaxFrameBytes)
                throw new InvalidOperationException($"帧超限: {payload.Length} > {MaxFrameBytes}");
            var frame = new byte[4 + payload.Length];
            BinaryPrimitives.WriteInt32BigEndian(frame.AsSpan(), payload.Length);
            payload.CopyTo(frame, 4);
            return frame;
        }

        /// <summary>从 payload JSON è§£ç å°å¥—。非法 JSON æŠ› FormatException。</summary>
        public static IpcEnvelope DecodeEnvelope(string payloadJson)
        {
            var env = JsonSerializer.Deserialize<IpcEnvelope>(payloadJson, JsonOpts);
            if (env == null || string.IsNullOrEmpty(env.MessageType))
                throw new FormatException("无效 IPC å°å¥—");
            return env;
        }

        public static string EncodeEnvelope(IpcEnvelope env)
            => JsonSerializer.Serialize(env, JsonOpts);

        // ==================== çº¿æ ¼å¼ DTO ====================

        /// <summary>SubmitTask Body：一次有界设备动作（OneShot åŒæ­¥æ¨¡åž‹ï¼‰</summary>
        public sealed class SubmitBody
        {
            public string DeviceId { get; set; } = "";
            /// <summary>白名单操作码：CONNECT/DISCONNECT/SEND/QUERY/STATUS</summary>
            public string OperationCode { get; set; } = "";
            /// <summary>操作载荷（命令或查询字符串）</summary>
            public string Payload { get; set; } = "";
            /// <summary>仲裁资源键（broker ä¾§ fence å†æ ¡éªŒç”¨ï¼Œå¦‚ CAN-003:Generic）</summary>
            public string ResourceKey { get; set; } = "";
            /// <summary>客户端进程实例身份 boot+pid，与 arb.db owner å¯¹é½</summary>
            public string ClientInstanceId { get; set; } = "";
        }

        /// <summary>SubmitTask å“åº” Body</summary>
        public sealed class ResultBody
        {
            public string State { get; set; } = "";      // Succeeded/Failed/RejectedStaleLease/RejectedConfigMismatch/...
            public string ErrorCode { get; set; } = "";
            public string Readback { get; set; } = "";
            public long ServerEpoch { get; set; }
        }

        public static string SerializeBody(object body)
            => JsonSerializer.Serialize(body, JsonOpts);

        public static T? DeserializeBody<T>(string json) where T : class
        {
            if (string.IsNullOrWhiteSpace(json)) return default;
            try { return JsonSerializer.Deserialize<T>(json, JsonOpts); }
            catch (JsonException) { return default; }
        }

        /// <summary>deadline è®¡ç®—：UTC æ¯«ç§’</summary>
        public static long NowUtcMs()
            => DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
    }
}

 Aging.ResourceContracts/DeviceOperationTypes.cs

New file
@@ -0,0 +1,36 @@
namespace Aging.ResourceContracts
{
    public enum OperationState
    {
        Succeeded, Failed,
        /// <summary>栅栏校验失败：Grant çš„ epoch/generation å·²å¤±æ•ˆï¼ˆå« Broker é‡å¯ï¼‰ã€‚</summary>
        RejectedStaleLease,
        /// <summary>INV-04 é›å½¢ï¼šå®¢æˆ·ç«¯ configHash ä¸Ž Broker ç”Ÿæ•ˆé…ç½®ä¸ä¸€è‡´ã€‚</summary>
        RejectedConfigMismatch,
        /// <summary>会话队列满。</summary>
        RejectedQueueFull,
        /// <summary>已发送但结果未知（INV-06：禁止当未执行）。</summary>
        Unknown
    }

    /// <summary>一次有界设备动作（MVP=OneShot）。Grants å¿…须覆盖 resources。</summary>
    public sealed class DeviceOperation
    {
        /// <summary>白名单操作码，如 "CAN_SEND"/"CAN_RECV"/"CAN_AUTO_RESPONSE"/"CAN_STATUS"。</summary>
        public string OperationCode { get; set; } = "";
        public string ParametersJson { get; set; } = "{}";
        public string IdempotencyKey { get; set; } = "";
        public string ConfigHash { get; set; } = "";
        public LeaseGrant[] Grants { get; set; } = new LeaseGrant[0];
        public long DeadlineUtcMs { get; set; }
    }

    public sealed class OperationResult
    {
        public string RequestId { get; set; } = "";
        public OperationState State { get; set; }
        public string ErrorCode { get; set; } = "";
        public string ReadbackJson { get; set; } = "{}";
        public long ServerEpoch { get; set; }
    }
}

 Aging.ResourceContracts/IpcEnvelope.cs

New file
@@ -0,0 +1,33 @@
namespace Aging.ResourceContracts
{
    /// <summary>IPC æ¶ˆæ¯ç±»åž‹å¸¸é‡ï¼ˆMVP ä»…四种）。</summary>
    public static class IpcMessageTypes
    {
        public const string Hello = "Hello";                 // æ¡æ‰‹ï¼šå›ž epoch/configHash
        public const string SubmitTask = "SubmitTask";       // body=DeviceOperation
        public const string CancelTask = "CancelTask";
        public const string ProbeReadback = "ProbeReadback"; // æ¢å¤å›žæ”¶å‰çš„读回探测
    }

    /// <summary>请求/响应共同封套。协议版本不匹配直接拒绝连接。</summary>
    public sealed class IpcEnvelope
    {
        public int ProtocolVersion { get; set; } = 1;
        public string MessageType { get; set; } = "";
        public string RequestId { get; set; } = "";
        public string CorrelationId { get; set; } = "";
        public string ClientInstanceId { get; set; } = "";
        public string AuthorityId { get; set; } = "";
        public string ConfigHash { get; set; } = "";
        public long DeadlineUtcMs { get; set; }
        public string BodyJson { get; set; } = "{}";
    }

    public sealed class HelloResult
    {
        public long ServerEpoch { get; set; }
        public string ConfigHash { get; set; } = "";
        public int ProtocolVersion { get; set; } = 1;
        public string BrokerId { get; set; } = "";
    }
}

 Aging.ResourceContracts/LeaseTypes.cs

New file
@@ -0,0 +1,89 @@
using System;
using System.Threading;
using System.Threading.Tasks;

namespace Aging.ResourceContracts
{
    /// <summary>与现有 OwnerType æ•°å€¼å¯¹é½ï¼šProduction=0, Maintenance=1。</summary>
    public enum OwnerTypeV3 { Production = 0, Maintenance = 1 }

    /// <summary>MVP ç›¸ä½ï¼šFree å¯ç”¨ / Active æŒæœ‰ / RecoveryRequired è¿‡æœŸå¾…回收（INV-03）。</summary>
    public enum LeasePhase { Free = 0, Active = 1, RecoveryRequired = 2 }

    /// <summary>每资源一张租约凭证；栅栏=(AuthorityId, Epoch, ResourceKey, LeaseId, Generation)。</summary>
    public sealed class LeaseGrant
    {
        public string AuthorityId { get; }
        public string ResourceKey { get; }
        public string LeaseId { get; }
        public string OwnerId { get; }
        public OwnerTypeV3 OwnerType { get; }
        public long Epoch { get; }
        public long Generation { get; }
        public long ExpiresUtcMs { get; }

        public LeaseGrant(string authorityId, string resourceKey, string leaseId,
            string ownerId, OwnerTypeV3 ownerType, long epoch, long generation, long expiresUtcMs)
        {
            AuthorityId = authorityId; ResourceKey = resourceKey; LeaseId = leaseId;
            OwnerId = ownerId; OwnerType = ownerType; Epoch = epoch;
            Generation = generation; ExpiresUtcMs = expiresUtcMs;
        }
    }

    public sealed class AcquireRequest
    {
        public string OwnerId { get; set; } = "";
        public OwnerTypeV3 OwnerType { get; set; }
        /// <summary>boot_id + pid，同机进程区分。</summary>
        public string ProcessInstanceId { get; set; } = "";
        public string MachineName { get; set; } = Environment.MachineName;
        public int HostProcessId { get; set; } = System.Diagnostics.Process.GetCurrentProcess().Id;
        /// <summary>申请理由（维护会话填操作员与原因，进 lease_history）。</summary>
        public string Reason { get; set; } = "";
        /// <summary>Ordinals å‡åºã€åŽ»é‡åŽç”³è¯·ï¼ˆç»„申请 = å•äº‹åŠ¡å…¨æœ‰å…¨æ— ï¼‰ã€‚</summary>
        public string[] ResourceKeys { get; set; } = new string[0];
        public int WaitTimeoutMs { get; set; } = 1000;
        public int TtlSeconds { get; set; } = 30;
    }

    public enum AcquireResultCode { Acquired, Reused, ConflictHeld, RecoveryBlocked, Timeout }

    public sealed class ConflictInfo
    {
        public string OwnerId { get; set; } = "";
        public OwnerTypeV3 OwnerType { get; set; }
        public string MachineName { get; set; } = "";
        public int HostProcessId { get; set; }
        public string Reason { get; set; } = "";
        public long ExpiresUtcMs { get; set; }
    }

    public sealed class AcquireOutcome
    {
        public AcquireResultCode Code { get; set; }
        public LeaseGrant[] Grants { get; set; } = new LeaseGrant[0];
        public ConflictInfo? Holder { get; set; }
        /// <summary>RecoveryBlocked æ—¶æŒ‡å‘ recovery_checkpoint çš„键。</summary>
        public string? RecoveryCheckpointKey { get; set; }
    }

    /// <summary>租约协调器：仲裁域唯一入口。实现方：DbLeaseStore。</summary>
    public interface ILeaseCoordinator
    {
        /// <summary>权威域当前 epoch（重启后递增，旧 Grant è‡ªåŠ¨å¤±æ•ˆï¼‰ã€‚</summary>
        long CurrentEpoch { get; }

        AcquireOutcome Acquire(AcquireRequest request);
        /// <summary>同 LeaseId+Generation ç»­æœŸï¼›è¿”回 false=已被回收/超越（本地须熔断）。</summary>
        bool Renew(LeaseGrant grant, int extendSeconds);
        bool Release(LeaseGrant grant, string note);
        ConflictInfo? ProbeConflict(string resourceKey);
        LeasePhase PhaseOf(string resourceKey);
        int SweepExpired();
        /// <summary>RecoveryRequired â†’ Free：宿主完成读回探测后登记证据并放行。</summary>
        bool ApproveRecovery(string resourceKey, string readbackJson, string approvedBy);
        /// <summary>测试用：强制提升 epoch，使所有活跃 Grant å¤±æ•ˆã€‚</summary>
        void BumpEpochForTest(string reason);
    }
}

 CanSimulator/CanBusSimulator.cs

@@ -66,6 +66,12 @@
        public int SimulatedLatencyMs { get; set; } = 0;

        /// <summary>
        /// æ€»çº¿çº§åº”答器：开启后，任何节点发出的帧会被原样回显给发送者自身
        /// ï¼ˆæ¨¡æ‹Ÿå•ä¸ªä»Žè®¾å¤‡åº”答，无需第二个节点在线）。来源标记为 RESPONDER。
        /// </summary>
        public bool EchoResponderToSender { get; set; } = false;

        /// <summary>
        /// å·²æ³¨å†Œçš„节点
        /// </summary>
        private readonly ConcurrentDictionary<string, CanNode> _nodes = new();
@@ -233,7 +239,7 @@
            TotalFramesTransmitted++;
            LastActivityTime = DateTime.Now;

            // è·¯ç”±åˆ°æ‰€æœ‰å…¶ä»–节点
            // è·¯ç”±åˆ°æ‰€æœ‰å…¶ä»–节点；若接收节点启用自动响应，由其回复
            int routed = 0;
            foreach (var kvp in _nodes)
            {
@@ -244,6 +250,10 @@
                    kvp.Value.ReceiveFrame(frame);
                    routed++;
                    TotalFramesReceived++;

                    // æŽ¥æ”¶æ–¹è‡ªåŠ¨å“åº”：模拟从设备收到命令后答复（面板“自动响应”语义）
                    if (kvp.Value.AutoResponseEnabled)
                        SendAutoResponse(kvp.Value, frame);
                }
                catch (Exception ex)
                {
@@ -251,32 +261,60 @@
                }
            }

            // æ£€æŸ¥æºèŠ‚点是否启用自动响应模式
            if (_nodes.TryGetValue(frame.SourceNodeId, out var sourceNode) && sourceNode.AutoResponseEnabled)
            // æ€»çº¿çº§åº”答器：把该帧原样回显给发送者自身（绕过"不回源"，直接投递）
            if (EchoResponderToSender && _nodes.TryGetValue(frame.SourceNodeId, out var senderNode))
            {
                try
                {
                    // æ¨¡æ‹Ÿå“åº”延迟
                    if (sourceNode.AutoResponseDelayMs > 0)
                    {
                        Thread.Sleep(sourceNode.AutoResponseDelayMs);
                    }

                    // åˆ›å»ºå“åº”帧（复制原始帧数据，来源为源节点）
                    var responseFrame = new CanFrame
                    var echo = new CanFrame
                    {
                        FrameId = frame.FrameId,
                        Format = frame.Format,
                        Type = frame.Type,
                        Data = (byte[])frame.Data.Clone(),
                        SourceNodeId = sourceNode.NodeId,
                        SourceNodeId = "RESPONDER",
                        Timestamp = DateTime.Now
                    };
                    senderNode.ReceiveFrame(echo);
                    TotalFramesReceived++;
                }
                catch (Exception ex)
                {
                    Log.Error($"[CanBus] åº”答器回显给 {frame.SourceNodeId} å¤±è´¥: {ex.Message}");
                }
            }

            Log.Debug($"[CanBus] å¸§ {frame.FrameIdHex} ä»Ž {frame.SourceNodeId} è·¯ç”±åˆ° {routed} ä¸ªèŠ‚点");
            FrameTransmitted?.Invoke(this, new CanBusFrameEventArgs(frame, frame.SourceNodeId));
        }

        /// <summary>
        /// æŽ¥æ”¶èŠ‚点自动响应：把收到帧原样回给其它节点（含发帧方），并记入自身邮箱与总线日志
        /// </summary>
        private void SendAutoResponse(CanNode responder, CanFrame incoming)
        {
            try
            {
                // æ¨¡æ‹Ÿå“åº”延迟
                if (responder.AutoResponseDelayMs > 0)
                {
                    Thread.Sleep(responder.AutoResponseDelayMs);
                }

                var responseFrame = new CanFrame
                {
                    FrameId = incoming.FrameId,
                    Format = incoming.Format,
                    Type = incoming.Type,
                    Data = (byte[])incoming.Data.Clone(),
                    SourceNodeId = responder.NodeId,
                        Timestamp = DateTime.Now
                    };

                    // å°†å“åº”帧路由到所有其他节点（不包括响应源自身）
                // å“åº”帧路由到其它节点（含最初的发帧方）
                    foreach (var kvp in _nodes)
                    {
                        if (kvp.Key == sourceNode.NodeId) continue;
                    if (kvp.Key == responder.NodeId) continue;
                        try
                        {
                            kvp.Value.ReceiveFrame(responseFrame);
@@ -288,24 +326,20 @@
                        }
                    }

                    // å°†å“åº”帧送入源节点的接收邮箱（让源节点能看到自己的响应）
                    sourceNode.ReceiveFrame(responseFrame);
                // å“åº”帧送入应答节点自身接收邮箱（调试页可见自己发出的响应）
                responder.ReceiveFrame(responseFrame);
                    TotalFramesReceived++;

                    // è®°å½•å“åº”帧到总线日志
                    _busLog.Enqueue(responseFrame);
                    TotalFramesTransmitted++;

                    Log.Debug($"[CanBus] èŠ‚点 {sourceNode.NodeId} è‡ªåŠ¨å“åº”帧 {responseFrame.FrameIdHex}");
                Log.Debug($"[CanBus] æŽ¥æ”¶èŠ‚点 {responder.NodeId} è‡ªåŠ¨å“åº”帧 {responseFrame.FrameIdHex}");
                }
                catch (Exception ex)
                {
                    Log.Error($"[CanBus] æºèŠ‚点自动响应失败: {ex.Message}");
                Log.Error($"[CanBus] èŠ‚点 {responder.NodeId} è‡ªåŠ¨å“åº”失败: {ex.Message}");
                }
            }

            Log.Debug($"[CanBus] å¸§ {frame.FrameIdHex} ä»Ž {frame.SourceNodeId} è·¯ç”±åˆ° {routed} ä¸ªèŠ‚点");
            FrameTransmitted?.Invoke(this, new CanBusFrameEventArgs(frame, frame.SourceNodeId));
        }

        /// <summary>

 CanSimulator/SimulatorFraming.cs

New file
@@ -0,0 +1,86 @@
using System;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace CanSimulator
{
    /// <summary>
    /// CAN æ¨¡æ‹Ÿå™¨ TCP çº¿åè®®åˆ†å¸§ç¼–解码器。
    /// çº¿æ ¼å¼ï¼š4 å­—节大端长度前缀 + UTF8 æ–‡æœ¬è¡Œï¼ˆä¸Ž BrokerIpc åŒæƒ¯ç”¨æ³•ï¼‰ã€‚
    /// è¯»ä¾§è´Ÿè´£ç²˜åŒ…/半包重组：循环读满长度前缀与帧体后返回完整文本。
    /// </summary>
    public static class SimulatorFraming
    {
        /// <summary>长度前缀字节数</summary>
        public const int HeaderSize = 4;

        /// <summary>单帧最大字节数（防畸形长度前缀导致内存爆掉；命令串与 LOG å“åº”远小于此值）</summary>
        public const int MaxFrameBytes = 1024 * 1024;

        /// <summary>把一条文本消息编码为完整帧（含长度前缀）</summary>
        public static byte[] Encode(string text)
        {
            if (text == null) throw new ArgumentNullException(nameof(text));
            byte[] body = Encoding.UTF8.GetBytes(text);
            if (body.Length > MaxFrameBytes)
                throw new InvalidOperationException($"帧体超限: {body.Length} > {MaxFrameBytes}");
            var frame = new byte[HeaderSize + body.Length];
            WriteBigEndian(frame, 0, body.Length);
            Buffer.BlockCopy(body, 0, frame, HeaderSize, body.Length);
            return frame;
        }

        /// <summary>解码已去掉长度前缀的帧体</summary>
        public static string Decode(byte[] buffer, int offset, int count)
            => Encoding.UTF8.GetString(buffer, offset, count);

        /// <summary>
        /// ä»Žæµä¸­è¯»å–一个完整帧。
        /// è¿”回 null è¡¨ç¤ºå¯¹ç«¯å·²å…³é—­æˆ–帧中途 EOF（连接失效，调用方应触发重连）；
        /// é•¿åº¦å‰ç¼€éžæ³•ï¼ˆâ‰¤0 æˆ–超 MaxFrameBytes）抛 InvalidDataException（协议失步）。
        /// </summary>
        public static async Task<string?> ReadFrameAsync(Stream s, CancellationToken ct)
        {
            var header = new byte[HeaderSize];
            if (!await ReadExactAsync(s, header, HeaderSize, ct).ConfigureAwait(false))
                return null;
            int len = ReadBigEndian(header, 0);
            if (len <= 0 || len > MaxFrameBytes)
                throw new InvalidDataException($"非法帧长度前缀: {len}");

            var body = new byte[len];
            if (!await ReadExactAsync(s, body, len, ct).ConfigureAwait(false))
                return null; // å¸§ä½“中途 EOF
            return Decode(body, 0, len);
        }

        /// <summary>循环读满 count å­—节；期间 EOF（读到 0 å­—节）或 IO å¼‚常时返回 false，由调用方按连接失效处理</summary>
        private static async Task<bool> ReadExactAsync(Stream s, byte[] buf, int count, CancellationToken ct)
        {
            int off = 0;
            while (off < count)
            {
                int n;
                try { n = await s.ReadAsync(buf, off, count - off, ct).ConfigureAwait(false); }
                catch (IOException) { return false; }
                if (n <= 0) return false;
                off += n;
            }
            return true;
        }

        // net472 æ—  System.Buffers.Binary，手写大端读写
        private static void WriteBigEndian(byte[] buf, int offset, int value)
        {
            buf[offset] = (byte)(value >> 24);
            buf[offset + 1] = (byte)(value >> 16);
            buf[offset + 2] = (byte)(value >> 8);
            buf[offset + 3] = (byte)value;
        }

        private static int ReadBigEndian(byte[] buf, int offset)
            => (buf[offset] << 24) | (buf[offset + 1] << 16) | (buf[offset + 2] << 8) | buf[offset + 3];
    }
}

 CanSimulatorServer/CanSimulatorServer.App/App.config

New file
@@ -0,0 +1,11 @@
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <appSettings>
    <!-- CAN æ¨¡æ‹Ÿå™¨æœåŠ¡ç›‘听端口（客户端由主程序/DeviceBroker çš„ CanSimulator.Port æŒ‡å‘） -->
    <add key="ServerPort" value="9000"/>
    <!-- é»˜è®¤ä»…监听回环；跨机部署时改 true -->
    <add key="ListenOnAllInterfaces" value="false"/>
    <!-- log4net：按日期落文件（%LOCALAPPDATA%\CanSimulatorServer\） -->
    <add key="log4net.Config" value="log4net.config"/>
  </appSettings>
</configuration>

 CanSimulatorServer/CanSimulatorServer.App/App.cs

New file
@@ -0,0 +1,39 @@
using System;
using System.Windows;
using log4net.Config;

namespace CanSimulatorServer.App
{
    /// <summary>
    /// CAN æ¨¡æ‹Ÿå™¨æœåŠ¡è¿›ç¨‹å…¥å£ï¼ˆçº¯æ‰‹åŠ¨å¯åŠ¨ï¼Œä¸»ç¨‹åºä¸Ž DeviceBroker å‡ä¸æ‹‰èµ·ï¼‰ã€‚
    /// è¯»å– App.config çš„ ServerPort / ListenOnAllInterfaces，拉起 TcpSimulatorHost å¹¶æ˜¾ç¤ºç›‘控 UI。
    /// </summary>
    public class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);
            XmlConfigurator.Configure();

            MainWindow = new MainWindow
            {
                Title = "CAN æ¨¡æ‹Ÿå™¨æœåŠ¡ (CanSimulatorServer)",
                Width = 1000,
                Height = 680,
                WindowStartupLocation = WindowStartupLocation.CenterScreen
            };
            MainWindow.Show();
        }
    }

    /// <summary>无 XAML å¯åŠ¨å™¨ï¼šSDK å·¥ç¨‹æ˜¾å¼å…¥å£ã€‚</summary>
    public static class Entry
    {
        [STAThread]
        public static void Main()
        {
            var app = new App();
            app.Run();
        }
    }
}

 CanSimulatorServer/CanSimulatorServer.App/CanSimulatorServer.App.csproj

New file
@@ -0,0 +1,36 @@
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net472</TargetFramework>
    <StartupObject>CanSimulatorServer.App.Entry</StartupObject>
    <Nullable>enable</Nullable>
    <LangVersion>10.0</LangVersion>
    <ImplicitUsings>enable</ImplicitUsings>
    <AssemblyName>CanSimulatorServer</AssemblyName>
    <RootNamespace>CanSimulatorServer.App</RootNamespace>
    <PlatformTarget>x64</PlatformTarget>
    <AutoGenerateBindingRedirects>True</AutoGenerateBindingRedirects>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="log4net" Version="3.0.4" />
  </ItemGroup>

  <ItemGroup>
    <Reference Include="PresentationCore" />
    <Reference Include="PresentationFramework" />
    <Reference Include="WindowsBase" />
    <Reference Include="System.Xaml" />
  </ItemGroup>

  <ItemGroup>
    <Content Include="log4net.config" CopyToOutputDirectory="PreserveNewest" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\CanSimulatorServer.Core\CanSimulatorServer.Core.csproj" />
    <ProjectReference Include="..\..\CanSimulator\CanSimulator.csproj" />
  </ItemGroup>

</Project>

 CanSimulatorServer/CanSimulatorServer.App/MainWindow.cs

New file
@@ -0,0 +1,311 @@
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Configuration;
using System.Linq;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Threading;
using CanSimulator;
using log4net;

namespace CanSimulatorServer.App
{
    /// <summary>
    /// æ¨¡æ‹Ÿå™¨æœåŠ¡ç›‘控窗口：状态栏 + è¿žæŽ¥èŠ‚点树 + å®žæ—¶å¸§è¡¨ + æ—¥å¿—区。
    /// çº¯ä»£ç æž„建 UI（不走 XAML æ ‡è®°ç¼–译链路）；帧表经 100ms å®šæ—¶å™¨æ‰¹é‡åˆ·æ–°ï¼Œä¸Šé™ 2000 è¡Œã€‚
    /// </summary>
    public class MainWindow : Window
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(MainWindow));

        private const int MaxFrameRows = 2000;

        private readonly TcpSimulatorHost _host = new();
        private readonly ConcurrentQueue<FrameRow> _pendingRows = new();
        private readonly ObservableCollection<FrameRow> _rows = new();
        private readonly DispatcherTimer _uiTimer = new();
        private int _tickCount;

        private TextBlock _statusText = null!;
        private TextBlock _statsText = null!;
        private TreeView _nodeTree = null!;
        private ListView _frameList = null!;
        private TextBox _logBox = null!;
        private Button _startBtn = null!;
        private Button _stopBtn = null!;
        private CheckBox _echoChk = null!;
        private bool _echoWanted;
        private readonly int _port;
        private readonly bool _listenAll;

        private sealed class FrameRow
        {
            public string Time { get; set; } = "";
            public string Bus { get; set; } = "";
            public string Src { get; set; } = "";
            public string FrameId { get; set; } = "";
            public string Data { get; set; } = "";
            public string Kind { get; set; } = "TX";
        }

        public MainWindow()
        {
            _port = ReadIntConfig("ServerPort", 9000);
            _listenAll = string.Equals(ConfigurationManager.AppSettings["ListenOnAllInterfaces"],
                "true", StringComparison.OrdinalIgnoreCase);

            BuildUi();
            HookHostEvents();

            _uiTimer.Interval = TimeSpan.FromMilliseconds(100);
            _uiTimer.Tick += (s, e) => DrainPendingRows();
            _uiTimer.Start();

            Loaded += async (s, e) => await StartHostAsync();
            Closing += (s, e) => { _host.Dispose(); };
        }

        // ==================== å®¿ä¸»ç”Ÿå‘½å‘¨æœŸ ====================

        private async Task StartHostAsync()
        {
            try
            {
                await _host.StartAsync(_port, _listenAll);
                _statusText.Text = $"监听中  {(_listenAll ? "0.0.0.0" : "127.0.0.1")}:{_port}";
                _statusText.Foreground = Brushes.ForestGreen;
                _startBtn.IsEnabled = false;
                _stopBtn.IsEnabled = true;
                AppendLog($"服务端已启动，监听 {_port}（{(_listenAll ? "全部接口" : "仅本机")}）");
            }
            catch (Exception ex)
            {
                _statusText.Text = "启动失败：端口被占用？";
                _statusText.Foreground = Brushes.Firebrick;
                AppendLog($"[FATAL] å¯åŠ¨å¤±è´¥: {ex.Message}");
                _startBtn.IsEnabled = true;
                Log.Error("宿主启动失败", ex);
            }
        }

        private void HookHostEvents()
        {
            _host.SessionAttached += session =>
            {
                Dispatcher.BeginInvoke(new Action(() =>
                {
                    AppendLog($"节点接入：{session.ClientTag}");
                    RefreshTree();
                }));
            };
        }

        /// <summary>总线帧事件挂接（宿主启动后总线才存在，故在定时器里惰性补挂）</summary>
        private void EnsureBusSubscriptions()
        {
            foreach (var bus in _host.Manager.AllBuses())
            {
                if (_subscribedBuses.Add(bus.BusName))
                {
                    bus.FrameTransmitted += (s, e) => EnqueueBusRow(bus.BusName, e.Frame, e.SourceNodeId);
                    bus.EchoResponderToSender = _echoWanted; // æ–°å»ºæ€»çº¿ç»§æ‰¿å½“前应答器开关
                }
            }
        }
        private readonly HashSet<string> _subscribedBuses = new(StringComparer.OrdinalIgnoreCase);

        // ==================== UI æž„建 ====================

        private void BuildUi()
        {
            var root = new Grid { Margin = new Thickness(10) };
            root.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
            root.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) });
            root.RowDefinitions.Add(new RowDefinition { Height = new GridLength(160) });

            // â”€â”€ é¡¶éƒ¨çŠ¶æ€/按钮栏 â”€â”€
            var bar = new StackPanel { Orientation = Orientation.Horizontal };
            _statusText = new TextBlock
            {
                Text = "未启动",
                FontWeight = FontWeights.Bold,
                VerticalAlignment = VerticalAlignment.Center,
                Margin = new Thickness(0, 0, 16, 0)
            };
            _statsText = new TextBlock { VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(0, 0, 16, 0) };
            _startBtn = new Button { Content = "启动监听", Width = 90, Height = 28, Margin = new Thickness(0, 0, 6, 0) };
            _startBtn.Click += async (s, e) => await StartHostAsync();
            _stopBtn = new Button { Content = "停止监听", Width = 90, Height = 28, Margin = new Thickness(0, 0, 6, 0), IsEnabled = false };
            _stopBtn.Click += (s, e) =>
            {
                _host.Dispose();
                _statusText.Text = "已停止";
                _statusText.Foreground = Brushes.Gray;
                _startBtn.IsEnabled = true;
                _stopBtn.IsEnabled = false;
                AppendLog("服务端已停止（注意：已运行客户端将断线重连）");
            };
            var clearBtn = new Button { Content = "清空帧表", Width = 90, Height = 28 };
            clearBtn.Click += (s, e) => { _rows.Clear(); while (_pendingRows.TryDequeue(out _)) { } };
            _echoChk = new CheckBox
            {
                Content = "总线应答器(回显发送者)",
                VerticalAlignment = VerticalAlignment.Center,
                Margin = new Thickness(12, 0, 0, 0),
                IsChecked = false
            };
            _echoChk.Click += (s, e) =>
            {
                _echoWanted = _echoChk.IsChecked == true;
                foreach (var bus in _host.Manager.AllBuses())
                    bus.EchoResponderToSender = _echoWanted;
                AppendLog($"总线应答器已{(_echoWanted ? "开启" : "关闭")}（作用于当前所有总线）");
            };
            bar.Children.Add(_statusText);
            bar.Children.Add(_statsText);
            bar.Children.Add(_startBtn);
            bar.Children.Add(_stopBtn);
            bar.Children.Add(clearBtn);
            bar.Children.Add(_echoChk);
            Grid.SetRow(bar, 0);
            root.Children.Add(bar);

            // â”€â”€ ä¸­éƒ¨ï¼šå·¦èŠ‚点树 + å³å¸§è¡¨ â”€â”€
            var split = new Grid();
            split.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(280) });
            split.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });

            _nodeTree = new TreeView();
            var treeBorder = new Border
            {
                Child = _nodeTree,
                BorderBrush = Brushes.LightGray,
                BorderThickness = new Thickness(1),
                Margin = new Thickness(0, 8, 8, 0)
            };
            Grid.SetColumn(treeBorder, 0);

            _frameList = new ListView { View = BuildGridView() };
            _frameList.ItemsSource = _rows;
            var listBorder = new Border
            {
                Child = _frameList,
                BorderBrush = Brushes.LightGray,
                BorderThickness = new Thickness(1),
                Margin = new Thickness(0, 8, 0, 0)
            };
            Grid.SetColumn(listBorder, 1);

            split.Children.Add(treeBorder);
            split.Children.Add(listBorder);
            Grid.SetRow(split, 1);
            root.Children.Add(split);

            // â”€â”€ åº•éƒ¨æ—¥å¿— â”€â”€
            _logBox = new TextBox
            {
                IsReadOnly = true,
                VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
                FontFamily = new FontFamily("Consolas"),
                FontSize = 11,
                Margin = new Thickness(0, 8, 0, 0)
            };
            Grid.SetRow(_logBox, 2);
            root.Children.Add(_logBox);

            Content = root;
        }

        private static GridView BuildGridView()
        {
            var gv = new GridView();
            AddCol(gv, "时间", 85, nameof(FrameRow.Time));
            AddCol(gv, "总线", 95, nameof(FrameRow.Bus));
            AddCol(gv, "源节点", 60, nameof(FrameRow.Src));
            AddCol(gv, "帧ID", 70, nameof(FrameRow.FrameId));
            AddCol(gv, "数据", 200, nameof(FrameRow.Data));
            AddCol(gv, "类型", 70, nameof(FrameRow.Kind));
            return gv;
        }

        private static void AddCol(GridView gv, string header, double width, string binding)
        {
            gv.Columns.Add(new GridViewColumn
            {
                Header = header,
                Width = width,
                DisplayMemberBinding = new System.Windows.Data.Binding(binding)
            });
        }

        // ==================== å¸§è¡¨ä¸Žæ ‘刷新 ====================

        /// <summary>总线级观察：路由发生即记一行（含自动响应帧）</summary>
        private void EnqueueBusRow(string busName, CanFrame frame, string srcNodeId)
        {
            _pendingRows.Enqueue(new FrameRow
            {
                Time = frame.Timestamp.ToString("HH:mm:ss.fff"),
                Bus = busName,
                Src = srcNodeId,
                FrameId = frame.FrameIdHex,
                Data = frame.DataHex,
                Kind = "TX路由"
            });
        }

        private void DrainPendingRows()
        {
            EnsureBusSubscriptions();

            int n = 0;
            while (_pendingRows.TryDequeue(out var row) && n < 50)
            {
                _rows.Insert(0, row);
                n++;
            }
            while (_rows.Count > MaxFrameRows)
                _rows.RemoveAt(_rows.Count - 1);

            RefreshStatsLine();

            // æ¯ç§’刷新一次节点树（反映断开会话，避免只在接入事件中刷新）
            if (++_tickCount % 10 == 0) RefreshTree();
        }

        private void RefreshStatsLine()
        {
            var buses = _host.Manager.AllBuses().ToList();
            long tx = buses.Sum(b => b.TotalFramesTransmitted);
            long rx = buses.Sum(b => b.TotalFramesReceived);
            _statsText.Text = $"会话={_host.ActiveSessionCount} ç´¯è®¡={_host.AcceptedCount} " +
                              $"总线={buses.Count} TX={tx} RX={rx}";
        }

        private void RefreshTree()
        {
            _nodeTree.Items.Clear();
            foreach (var bus in _host.Manager.AllBuses())
            {
                var busNode = new TreeViewItem { Header = bus.BusName + $"（{bus.State}）" };
                foreach (var node in bus.GetAllNodes())
                    busNode.Items.Add(new TreeViewItem { Header = $"节点 {node.NodeId} Â· {node.Name}" });
                _nodeTree.Items.Add(busNode);
                busNode.IsExpanded = true;
            }
        }

        private void AppendLog(string msg)
        {
            _logBox.AppendText($"{DateTime.Now:HH:mm:ss.fff} {msg}{Environment.NewLine}");
            _logBox.ScrollToEnd();
        }

        private static int ReadIntConfig(string key, int fallback)
            => int.TryParse(ConfigurationManager.AppSettings[key], out int v) ? v : fallback;
    }
}

 CanSimulatorServer/CanSimulatorServer.App/log4net.config

New file
@@ -0,0 +1,17 @@
<?xml version="1.0" encoding="utf-8"?>
<log4net>
  <appender name="RollingFile" type="log4net.Appender.RollingFileAppender">
    <file type="log4net.Util.PatternString" value="%env{LOCALAPPDATA}\CanSimulatorServer\server.log"/>
    <appendToFile value="true"/>
    <rollingStyle value="Size"/>
    <maxSizeRollBackups value="5"/>
    <maximumFileSize value="2MB"/>
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%date{HH:mm:ss.fff} %-5level %logger - %message%newline"/>
    </layout>
  </appender>
  <root>
    <level value="INFO"/>
    <appender-ref ref="RollingFile"/>
  </root>
</log4net>

 CanSimulatorServer/CanSimulatorServer.Core/CanBusManager.cs

New file
@@ -0,0 +1,71 @@
using System;
using System.Collections.Concurrent;
using CanSimulator;

namespace CanSimulatorServer
{
    /// <summary>
    /// æœåŠ¡ç«¯æ€»çº¿æ³¨å†Œè¡¨ï¼šæŒ‰åç§°æ‡’创建 CanBusSimulator（复用进程内路由/自动响应逻辑），
    /// å¹¶ä»¥ (bus, nodeIndex) ä¸ºå…¨å±€å”¯ä¸€é”®ä»²è£èŠ‚点挂载。
    /// æ€»çº¿åœ¨é¦–次被挂载时自动启动（与旧进程内驱动行为一致；UI å¯åœæŒ‰é’®å¯åŽç»­æŽ¥å…¥ï¼‰ã€‚
    /// </summary>
    public sealed class CanBusManager
    {
        private readonly ConcurrentDictionary<string, CanBusSimulator> _buses =
            new(StringComparer.OrdinalIgnoreCase);

        /// <summary>挂载节点：同 (bus,nodeIndex) å·²è¢«å ç”¨æ—¶è¿”回 false（NODE_BUSY è¯­ä¹‰ï¼‰ã€‚</summary>
        /// <param name="onFrameReceived">帧到达该节点时的回调（服务端用于 TCP æŽ¨é€ï¼‰</param>
        public bool TryAttach(string busName, int nodeIndex, string clientTag,
            Action<CanFrame> onFrameReceived, out CanNode? node, out CanBusSimulator? bus)
        {
            bus = GetOrCreateBus(busName);
            string nodeId = NodeIdOf(nodeIndex);

            // å”¯ä¸€æ€§ä»²è£ï¼šå·²å­˜åœ¨åŒç¼–号节点则拒绝
            var existing = bus.GetNode(nodeId);
            if (existing != null)
            {
                node = null;
                return false;
            }

            var n = bus.RegisterNode(nodeId, $"{busName}/N{nodeIndex}({clientTag})");
            n.SetPromiscuousMode();   // æœåŠ¡ç«¯èŠ‚点默认收所有帧（滤波器命令可在其后覆盖）
            n.Activate();
            n.FrameReceived += (_, f) => onFrameReceived(f);

            node = n;
            return true;
        }

        /// <summary>注销节点（连接断开时调用），空总线保留（再次挂载零开销）。</summary>
        public void Detach(string busName, CanNode node)
        {
            if (_buses.TryGetValue(busName, out var bus))
            {
                bus.UnregisterNode(node.NodeId);
            }
        }

        public CanBusSimulator? FindBus(string busName)
            => _buses.TryGetValue(busName, out var b) ? b : null;

        public System.Collections.Generic.IReadOnlyCollection<CanBusSimulator> AllBuses()
            => (System.Collections.Generic.IReadOnlyCollection<CanBusSimulator>)_buses.Values;

        private CanBusSimulator GetOrCreateBus(string busName)
        {
            var bus = _buses.GetOrAdd(busName, name =>
            {
                var b = new CanBusSimulator(name);
                b.Start(); // è‡ªåŠ¨å¯åŠ¨ï¼šTCP æ¨¡å¼ä¸‹æ€»çº¿ç”Ÿå‘½å‘¨æœŸç”±æŒ‚载驱动
                return b;
            });
            return bus;
        }

        /// <summary>节点在总线上的身份：以编号寻址（与真实 CAN èŠ‚点地址语义一致）</summary>
        public static string NodeIdOf(int nodeIndex) => $"{nodeIndex}";
    }
}

 CanSimulatorServer/CanSimulatorServer.Core/CanCommandExecutor.cs

New file
@@ -0,0 +1,188 @@
using System;
using System.Collections.Generic;
using System.Linq;
using CanSimulator;

namespace CanSimulatorServer
{
    /// <summary>
    /// æœåŠ¡ç«¯å‘½ä»¤ä¸²æ‰§è¡Œå™¨ï¼šå¯¹æŒ‚载节点执行 SEND/QUERY å‘½ä»¤ï¼Œè¯­ä¹‰ä¸ŽåŽŸ CanDriverAdapter
    /// ä¿æŒä¸€è‡´ï¼ˆå‘½ä»¤ä¸²ç›´ä¼ åè®®çš„核心）。返回值约定：
    /// OK å‰ç¼€ = æˆåŠŸå“åº”ï¼›ERR å‰ç¼€ = ä¸šåŠ¡å¤±è´¥ï¼›å…¶ä½™ = è£¸æ•°æ®ï¼ˆç”±ä¼šè¯å±‚è¡¥ OK: å‰ç¼€ï¼‰ã€‚
    /// </summary>
    public sealed class CanCommandExecutor
    {
        private readonly CanNode _node;
        private readonly CanBusSimulator _bus;

        public CanCommandExecutor(CanNode node, CanBusSimulator bus)
        {
            _node = node ?? throw new ArgumentNullException(nameof(node));
            _bus = bus ?? throw new ArgumentNullException(nameof(bus));
        }

        /// <summary>执行一行命令（SEND:… æˆ– QUERY:…），异常转为 ERR å“åº”，不抛出。</summary>
        public string Execute(string line)
        {
            try
            {
                if (line.StartsWith("SEND:", StringComparison.OrdinalIgnoreCase))
                    return HandleSend(line);

                if (line.StartsWith("QUERY:", StringComparison.OrdinalIgnoreCase))
                {
                    string query = line.Substring("QUERY:".Length);
                    return HandleQuery(query);
                }

                return $"ERR:UNKNOWN_CMD:{line}";
            }
            catch (ArgumentException ex)
            {
                return $"ERR:BAD_FRAME:{ex.Message}";
            }
            catch (Exception ex)
            {
                return $"ERR:EXEC:{ex.Message}";
            }
        }

        private string HandleSend(string line)
        {
            // SEND:frameId:data（data å†…可含空格，不参与分段）
            var parts = line.Split(':');
            if (parts.Length < 3)
                throw new ArgumentException("SEND æ ¼å¼åº”为 SEND:frameId:data");

            uint frameId = CanFrame.ParseFrameId(parts[1]);
            byte[] data = CanFrame.ParseData(string.Join(":", parts.Skip(2)));
            if (data.Length > 8)
                throw new ArgumentException($"数据长度超限: {data.Length} å­—节（最大 8）");

            var frame = new CanFrame
            {
                FrameId = frameId,
                Format = frameId > 0x7FF ? CanFrameFormat.Extended : CanFrameFormat.Standard,
                Type = CanFrameType.Data,
                Data = data
            };
            _node.SendFrame(frame); // è§¦å‘总线路由（其它节点收帧 â†’ å„自推送）与自动响应
            return $"OK:TX:{frame.FrameIdHex}:{frame.Dlc}";
        }

        private string HandleQuery(string query)
        {
            var parts = query.Split(':');
            string op = parts[0].ToUpperInvariant();

            switch (op)
            {
                case "RECV":
                {
                    if (_node.TryDequeueReceived(out var f) && f != null)
                        return $"OK:RECV:{f.FrameIdHex}:{f.DataHex}:{f.Timestamp:HH:mm:ss.fff}";
                    return "OK:RECV:EMPTY";
                }
                case "RECV_ALL":
                {
                    var mailbox = _node.PeekReceiveMailbox();
                    _node.ClearReceiveMailbox();
                    if (mailbox.Count == 0) return "OK:RECV_ALL:0";
                    var items = mailbox.Select(f => $"{f.FrameIdHex}:{f.DataHex}:{f.Timestamp:HH:mm:ss.fff}");
                    return $"OK:RECV_ALL:{mailbox.Count}:{string.Join("|", items)}";
                }
                case "STATUS":
                    return "OK:STATUS:" + DescribeStatus();
                case "FILTER":
                {
                    if (parts.Length < 3)
                        throw new ArgumentException("FILTER æ ¼å¼åº”为 FILTER:id:mask");
                    uint fid = CanFrame.ParseFrameId(parts[1]);
                    uint mask = CanFrame.ParseFrameId(parts[2]);
                    _node.AddFilter(new AcceptanceFilter
                    {
                        FilterId = fid,
                        Mask = mask,
                        IsExtended = fid > 0x7FF
                    });
                    return $"OK:滤波器已添加 ID=0x{fid:X3}, Mask=0x{mask:X3}";
                }
                case "FILTER_CLEAR":
                    _node.ClearFilters();
                    return "OK:滤波器已清除";
                case "PROMISCUOUS":
                    _node.SetPromiscuousMode();
                    return "OK:混杂模式已启用";
                case "BUS_ECHO":
                {
                    if (parts.Length < 2)
                        return $"OK:BUS_ECHO:{(_bus.EchoResponderToSender ? "ON" : "OFF")}";
                    string mode = parts[1].Trim().ToUpperInvariant();
                    switch (mode)
                    {
                        case "ON": case "1": case "TRUE": case "ENABLE":
                            _bus.EchoResponderToSender = true;
                            return "OK:总线应答器已开启（回显给发送者）";
                        case "OFF": case "0": case "FALSE": case "DISABLE":
                            _bus.EchoResponderToSender = false;
                            return "OK:总线应答器已关闭";
                        default:
                            throw new ArgumentException($"BUS_ECHO å‚数错误: {mode}");
                    }
                }
                case "AUTO_RESPONSE":
                {
                    if (parts.Length < 2)
                        return $"OK:AUTO_RESPONSE:{(_node.AutoResponseEnabled ? "ON" : "OFF")}";
                    string mode = parts[1].Trim().ToUpperInvariant();
                    switch (mode)
                    {
                        case "ON": case "1": case "TRUE": case "ENABLE":
                            _node.AutoResponseEnabled = true;
                            return "OK:自动响应模式已启用";
                        case "OFF": case "0": case "FALSE": case "DISABLE":
                            _node.AutoResponseEnabled = false;
                            return "OK:自动响应模式已禁用";
                        default:
                            throw new ArgumentException($"AUTO_RESPONSE å‚数错误: {mode}");
                    }
                }
                case "RESPONSE_DELAY":
                {
                    if (parts.Length < 2)
                        return $"OK:RESPONSE_DELAY:{_node.AutoResponseDelayMs}ms";
                    if (!int.TryParse(parts[1].Trim(), out int d) || d < 0)
                        throw new ArgumentException($"RESPONSE_DELAY å‚数错误: {parts[1]}");
                    _node.AutoResponseDelayMs = d;
                    return $"OK:响应延迟已设置为 {d}ms";
                }
                case "LOG":
                {
                    var log = _bus.GetBusLog(50);
                    if (log.Count == 0) return "OK:LOG:EMPTY";
                    var entries = log.Select(f =>
                        $"[{f.Timestamp:HH:mm:ss.fff}]{f.SourceNodeId}>{f.FrameIdHex}:{f.DataHex}");
                    return $"OK:LOG:{log.Count}:{string.Join("|", entries)}";
                }
                case "BUS_STATUS":
                    return "OK:" + _bus.GetStatusSummary();
                default:
                    return $"ERR:UNKNOWN_CMD:{query}";
            }
        }

        private string DescribeStatus()
        {
            string nodeStatus = _node.GetStatusSummary();          // Node={nodeId}, Active=…, Rx=…
            string busStatus = _bus.GetStatusSummary();            // Bus=…, State=…, Nodes=…
            return $"{nodeStatus}|{busStatus}";
        }

        /// <summary>把接收帧格式化为 EV:RECV æŽ¨é€è¡Œï¼ˆæ—¶é—´æˆ³ä¸Žæ•°æ®ä¸å«å†’号）。</summary>
        public static string FormatPush(CanFrame frame)
        {
            string src = string.IsNullOrEmpty(frame.SourceNodeId) ? "0" : frame.SourceNodeId;
            return $"EV:RECV:{frame.FrameIdHex}:{frame.DataHex}:{frame.Timestamp:HH.mm.ss.fff}:{src}";
        }
    }
}

 CanSimulatorServer/CanSimulatorServer.Core/CanSimulatorServer.Core.csproj

New file
@@ -0,0 +1,20 @@
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Library</OutputType>
    <TargetFramework>net472</TargetFramework>
    <Nullable>enable</Nullable>
    <LangVersion>10.0</LangVersion>
    <ImplicitUsings>enable</ImplicitUsings>
    <RootNamespace>CanSimulatorServer</RootNamespace>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="log4net" Version="3.0.4" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\..\CanSimulator\CanSimulator.csproj" />
  </ItemGroup>

</Project>

 CanSimulatorServer/CanSimulatorServer.Core/ServerSession.cs

New file
@@ -0,0 +1,238 @@
using System;
using System.IO;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using CanSimulator;
using log4net;

namespace CanSimulatorServer
{
    /// <summary>
    /// å•è¿žæŽ¥ä¼šè¯ï¼šHELLO çŠ¶æ€æœº + å‘½ä»¤æ‰§è¡Œï¼ˆä¿åºå“åº”） + å¸§æŽ¨é€ï¼ˆå†™é”ä¸²è¡ŒåŒ–保序）。
    /// è¯»å¾ªçŽ¯å•çº¿ç¨‹å¤„理请求；响应与推送经同一写锁发出，客户端按到达顺序分流。
    /// </summary>
    public sealed class ServerSession : IDisposable
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(ServerSession));

        private readonly TcpClient _client;
        private readonly CanBusManager _manager;
        private readonly Action<ServerSession> _onClosed;
        private readonly CancellationTokenSource _cts = new();
        private readonly SemaphoreSlim _writeLock = new(1, 1);

        private string? _busName;
        private CanNode? _node;
        private CanCommandExecutor? _executor;
        private long _droppedPushes;

        /// <summary>推送暂存门：命令处理期间路由产生的帧先入队，响应写完后再冲，
        /// ä¿è¯å®¢æˆ·ç«¯â€œé¦–行必为响应、推送随后”的保序契约</summary>
        private readonly object _pushGate = new();
        private bool _inCommand;
        private readonly System.Collections.Generic.List<string> _heldPushes = new();
        private const int HeldPushCapacity = 1000;

        public string ClientTag { get; private set; } = "";
        public int NodeIndex { get; private set; } = -1;
        public bool Attached => _node != null;
        public long DroppedPushes => Interlocked.Read(ref _droppedPushes);

        /// <summary>节点帧到达事件（UI å¸§è¡¨è®¢é˜…）</summary>
        public event Action<string, string, int>? FramePushed; // (bus, pushLine, nodeIndex)

        /// <summary>总线观察级帧事件（路由发生后向 UI æŠ¥å‘Šï¼Œç”±å®¿ä¸»æŒ‚接）</summary>
        internal ServerSession(TcpClient client, CanBusManager manager, Action<ServerSession> onClosed)
        {
            _client = client;
            _manager = manager;
            _onClosed = onClosed;
        }

        public void Start()
        {
            _ = Task.Run(() => RunAsync(_cts.Token));
        }

        private async Task RunAsync(CancellationToken ct)
        {
            Stream? stream = null;
            try
            {
                stream = _client.GetStream();
                while (!ct.IsCancellationRequested)
                {
                    string? line = await SimulatorFraming.ReadFrameAsync(stream, ct).ConfigureAwait(false);
                    if (line == null) break; // EOF / æˆªæ–­ â†’ ä¼šè¯ç»“束

                    string? response = Process(line);
                    if (response != null)
                    {
                        await WriteAsync(response, ct).ConfigureAwait(false);
                        await FlushHeldPushesAsync(ct).ConfigureAwait(false); // å“åº”先行，补发处理期间暂存的帧
                    }
                }
            }
            catch (InvalidDataException)
            {
                // åè®®å¤±æ­¥ï¼šæ–­å¼€è¯¥ä¼šè¯ï¼Œå®¿ä¸»ç»§ç»­ç›‘听
            }
            catch (IOException) { }
            catch (OperationCanceledException) { }
            catch (Exception ex)
            {
                Log.Warn($"[SimServer] ä¼šè¯å¼‚常结束: {ex.Message}");
            }
            finally
            {
                Close();
            }
        }

        /// <summary>处理一行请求，返回响应文本（无需响应时返回 null）。</summary>
        private string? Process(string line)
        {
            if (line.StartsWith("HELLO:", StringComparison.OrdinalIgnoreCase))
                return HandleHello(line);

            if (line.StartsWith("DISCONNECT", StringComparison.OrdinalIgnoreCase))
            {
                // æ˜¾å¼æ–­å¼€ï¼šå›ž OK åŽç”± EOF/关闭收尾
                return "OK:DISCONNECTED";
            }

            if (_node == null)
                return "ERR:NOT_HANDSHAKED";

            if (line.StartsWith("SEND:", StringComparison.OrdinalIgnoreCase) ||
                line.StartsWith("QUERY:", StringComparison.OrdinalIgnoreCase))
            {
                string resp;
                lock (_pushGate) { _inCommand = true; }   // å¤„理期间的推送改走暂存
                try
                {
                    resp = _executor!.Execute(line);
                }
                finally
                {
                    lock (_pushGate) { _inCommand = false; }
                }
                // è£¸æ•°æ®ï¼ˆéž OK/ERR å‰ç¼€ï¼‰è¡¥ OK:
                if (!resp.StartsWith("OK", StringComparison.Ordinal) &&
                    !resp.StartsWith("ERR", StringComparison.Ordinal))
                    resp = "OK:" + resp;
                return resp;
            }

            return $"ERR:UNKNOWN_CMD:{line}";
        }

        private string? HandleHello(string line)
        {
            if (_node != null)
                return "ERR:ALREADY_HELLO";

            var parts = line.Split(':'); // HELLO:bus:node:tag
            if (parts.Length < 4 || !int.TryParse(parts[2], out int nodeIndex) || nodeIndex < 0)
                return "ERR:BAD_FRAME:HELLO æ ¼å¼åº”为 HELLO:bus:nodeIndex:tag";

            string bus = parts[1];
            ClientTag = parts[3];
            bool ok = _manager.TryAttach(bus, nodeIndex, ClientTag, OnNodeFrame, out var node, out var busInst);
            if (!ok) return "ERR:NODE_BUSY";

            _node = node;
            _busName = bus;
            NodeIndex = nodeIndex;
            _executor = new CanCommandExecutor(node!, busInst!);
            return $"OK:HELLO:{bus}:{nodeIndex}";
        }

        /// <summary>总线路由到本节点的帧 â†’ æŽ¨é€ï¼ˆå‘½ä»¤å¤„理中暂存，否则即发即走）</summary>
        private void OnNodeFrame(CanFrame frame)
        {
            string push = CanCommandExecutor.FormatPush(frame);
            FramePushed?.Invoke(_busName ?? "?", push, NodeIndex);

            lock (_pushGate)
            {
                if (_inCommand)
                {
                    if (_heldPushes.Count >= HeldPushCapacity)
                    {
                        _heldPushes.RemoveAt(0); // æ»¡åˆ™ä¸¢æœ€è€ï¼Œç”±å®¢æˆ·ç«¯ RECV_ALL å…œåº•è¡¥è´¦
                        Interlocked.Increment(ref _droppedPushes);
                    }
                    _heldPushes.Add(push);
                    return;
                }
            }

            // ç©ºé—²æœŸï¼šå³å‘即走，写锁串行化保帧序；失败计入丢帧
            _ = WriteAsync(push, CancellationToken.None).ContinueWith(t =>
            {
                if (t.IsFaulted) Interlocked.Increment(ref _droppedPushes);
            }, TaskScheduler.Default);
        }

        private async Task FlushHeldPushesAsync(CancellationToken ct)
        {
            string[] pending;
            lock (_pushGate)
            {
                if (_heldPushes.Count == 0) return;
                pending = _heldPushes.ToArray();
                _heldPushes.Clear();
            }
            foreach (var p in pending)
                await WriteAsync(p, ct).ConfigureAwait(false);
        }

        private async Task WriteAsync(string text, CancellationToken ct)
        {
            byte[] frame = SimulatorFraming.Encode(text);
            await _writeLock.WaitAsync(ct).ConfigureAwait(false);
            try
            {
                if (_client.Connected)
                {
                    var s = _client.GetStream();
                    await s.WriteAsync(frame, 0, frame.Length, ct).ConfigureAwait(false);
                    await s.FlushAsync(ct).ConfigureAwait(false);
                }
            }
            finally
            {
                _writeLock.Release();
            }
        }

        public void Close()
        {
            try
            {
                if (_node != null && _busName != null)
                    _manager.Detach(_busName, _node);
                _node = null;
                _cts.Cancel();
                _client.Close();
            }
            catch (Exception ex)
            {
                Log.Debug($"[SimServer] ä¼šè¯å…³é—­å¼‚常: {ex.Message}");
            }
            finally
            {
                _onClosed(this);
            }
        }

        public void Dispose()
        {
            Close();
            _cts.Dispose();
            _writeLock.Dispose();
        }
    }
}

 CanSimulatorServer/CanSimulatorServer.Core/TcpSimulatorHost.cs

New file
@@ -0,0 +1,92 @@
using System;
using System.Collections.Concurrent;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using log4net;

namespace CanSimulatorServer
{
    /// <summary>
    /// æ¨¡æ‹Ÿå™¨ TCP å®¿ä¸»ï¼šç›‘听端口、接受连接、为每连接建立会话，并持有总线注册表。
    /// port=0 æ—¶ç”±ç³»ç»Ÿåˆ†é…ä¸´æ—¶ç«¯å£ï¼ˆPort å±žæ€§è¯»å–实际值，测试回环用）。
    /// UI å®¿ä¸»ä¸Žæµ‹è¯• fixture å…±ç”¨æœ¬ç±»ï¼Œä¿è¯æœåŠ¡ç«¯è¡Œä¸ºå•ä¸€è·¯å¾„。
    /// </summary>
    public sealed class TcpSimulatorHost : IDisposable
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(TcpSimulatorHost));

        private TcpListener? _listener;
        private readonly ConcurrentDictionary<ServerSession, byte> _sessions = new();
        private readonly CancellationTokenSource _cts = new();
        private int _acceptedCount;

        public CanBusManager Manager { get; } = new();

        /// <summary>实际监听端口（StartAsync åŽæœ‰æ•ˆï¼‰</summary>
        public int Port { get; private set; }

        public int ActiveSessionCount => _sessions.Count;
        public int AcceptedCount => _acceptedCount;

        /// <summary>新会话建立事件（UI èŠ‚点树订阅）</summary>
        public event Action<ServerSession>? SessionAttached;

        public Task StartAsync(int port = 0, bool listenAll = false)
        {
            if (_listener != null) throw new InvalidOperationException("宿主已在运行");

            var ip = listenAll ? IPAddress.Any : IPAddress.Loopback;
            _listener = new TcpListener(ip, port);
            _listener.Start();
            Port = ((IPEndPoint)_listener.LocalEndpoint).Port;

            Log.Info($"[SimServer] ç›‘听 {ip}:{Port}");
            _ = Task.Run(() => AcceptLoopAsync(_cts.Token));
            return Task.CompletedTask;
        }

        private async Task AcceptLoopAsync(CancellationToken ct)
        {
            while (!ct.IsCancellationRequested)
            {
                TcpClient? client = null;
                try
                {
                    client = await _listener!.AcceptTcpClientAsync().ConfigureAwait(false);
                    Interlocked.Increment(ref _acceptedCount);
                    var session = new ServerSession(client, Manager, s => _sessions.TryRemove(s, out _));
                    if (_sessions.TryAdd(session, 0))
                    {
                        SessionAttached?.Invoke(session);
                        session.Start();
                    }
                    client = null;
                }
                catch (OperationCanceledException) { break; }
                catch (SocketException) { break; } // listener å·²åœæ­¢
                catch (Exception ex)
                {
                    Log.Warn($"[SimServer] æŽ¥å—连接失败: {ex.Message}");
                    client?.Close();
                    try { await Task.Delay(200, ct).ConfigureAwait(false); }
                    catch (OperationCanceledException) { break; }
                }
            }
        }

        public void Dispose()
        {
            try { _cts.Cancel(); } catch { }
            try { _listener?.Stop(); } catch { }
            foreach (var s in _sessions.Keys)
            {
                try { s.Dispose(); } catch { }
            }
            _sessions.Clear();
            _cts.Dispose();
            Log.Info("[SimServer] å®¿ä¸»å·²åœæ­¢");
        }
    }
}

 DeviceBroker/App.config

New file
@@ -0,0 +1,8 @@
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <appSettings>
    <!-- CAN æ¨¡æ‹Ÿå™¨ç‹¬ç«‹ TCP æœåŠ¡åœ°å€ï¼šBroker å®¿ä¸»å†…的物理会话驱动连此端口 -->
    <add key="CanSimulator.Host" value="127.0.0.1" />
    <add key="CanSimulator.Port" value="9000" />
  </appSettings>
</configuration>

 DeviceBroker/BrokerServer.cs

New file
@@ -0,0 +1,453 @@
using System;
using System.Buffers.Binary;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.IO;
using System.IO.Pipes;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Linq;
using Aging.Infrastructure.Broker;
using Aging.Infrastructure.Contracts;
using Aging.Infrastructure.Core;
using Aging.Infrastructure.Drivers;
using Aging.ResourceContracts;
using log4net;

namespace DeviceBroker
{
    /// <summary>
    /// DeviceBroker å®¿ä¸»ï¼šå”¯ä¸€æŒæœ‰ Broker åŸŸè®¾å¤‡ç‰©ç†ä¼šè¯çš„进程（V3.0 æ··åˆæž¶æž„）。
    /// å‡ºé˜Ÿæ—¶åŒé‡æ ¡éªŒï¼šarb.db æ …栏（epoch/generation/相位，INV-01/03）+ configHash å¯¹è´¦ï¼ˆINV-04），
    /// SessionGate æŠŠâ€œé€‰æ‹©é€šé“ + å†™å…¥/查询 + è¯»å–响应”视为不可拆分原子片段串行执行（§04）。
    /// MVP ä¸º OneShot å‘½ä»¤åŒæ­¥æ¨¡åž‹ï¼šå‘¨æœŸä»»åŠ¡/订阅/Outbox æŽ¨è¿Ÿï¼ˆP2+）。
    /// </summary>
    public sealed class BrokerServer
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(BrokerServer));

        private static readonly string[] AllowedOps = { "CONNECT", "DISCONNECT", "SEND", "QUERY", "STATUS" };

        private readonly string _brokerId;
        private readonly string _pipeName;
        private readonly string _configDbPath;
        private readonly DbLeaseStore _lease;

        private sealed class ManagedDevice
        {
            public string DeviceId = "";
            public string Transport = "";
            public string Endpoint = "";
            public string SessionKey = "";
            public IDeviceDriver? Driver;
            public bool Connected;
        }

        private readonly Dictionary<string, ManagedDevice> _devices =
            new(StringComparer.OrdinalIgnoreCase);
        private readonly ConcurrentDictionary<string, SemaphoreSlim> _gates = new();
        private readonly SemaphoreSlim _driverCreateLock = new(1, 1);

        private long _hashStampMs;
        private volatile string _cachedHash = "";

        public BrokerServer(string configDbPath, string arbDbPath, string brokerId)
        {
            _configDbPath = configDbPath;
            _brokerId = brokerId;
            _pipeName = BrokerPipeName.For(brokerId);
            _lease = new DbLeaseStore(arbDbPath, brokerId);
            // å®¿ä¸»é‡å¯å¯¹è´¦ï¼šå›žæ”¶ä¸Šæ¬¡è¿›ç¨‹æ®‹ç•™çš„待回收租约（INV-03 è‡ªåŠ¨åŒ–形式，证据落库）
            _lease.ReconcileAfterBoot($"broker:{brokerId}/{System.Diagnostics.Process.GetCurrentProcess().Id}");
        }

        public long Epoch => _lease.CurrentEpoch;

        /// <summary>加载本 Broker åŸŸè®¾å¤‡æ¸…单（ExecutionMode=Broker ä¸” BrokerId åŒ¹é…ï¼‰ã€‚</summary>
        public void LoadDevices()
        {
            _devices.Clear();
            using var conn = new System.Data.SQLite.SQLiteConnection(
                $"Data Source={_configDbPath};Version=3;Read Only=True;");
            conn.Open();
            using var cmd = conn.CreateCommand();
            cmd.CommandText = @"SELECT DeviceId, Transport, Endpoint, PhysicalSessionKey, BrokerId, AuthorityId
                                FROM DeviceDefinition WHERE ExecutionMode = 'Broker';";
            using var rd = cmd.ExecuteReader();
            var dt = new DataTable();
            dt.Load(rd);
            foreach (DataRow row in dt.Rows)
            {
                var brokerId = row["BrokerId"].ToString() ?? "";
                if (!string.Equals(brokerId, _brokerId, StringComparison.OrdinalIgnoreCase))
                    continue; // å±žå…¶ä»– Broker åŸŸï¼Œæœ¬å®¿ä¸»æ‹’绝代收
                _devices[row["DeviceId"].ToString()!] = new ManagedDevice
                {
                    DeviceId = row["DeviceId"].ToString() ?? "",
                    Transport = row["Transport"].ToString() ?? "",
                    Endpoint = row["Endpoint"].ToString() ?? "",
                    SessionKey = string.IsNullOrWhiteSpace(row["PhysicalSessionKey"].ToString())
                        ? row["DeviceId"].ToString()! // æ— ä¼šè¯é”®æ—¶é€€åŒ–为按设备串行
                        : row["PhysicalSessionKey"].ToString()!,
                };
            }
            Log.Info($"[Broker] {_brokerId} è½½å…¥ {_devices.Count} å° Broker è®¾å¤‡, epoch={_lease.CurrentEpoch}");
        }

        /// <summary>接受循环：每个连接一个处理任务；管道保持多实例可用。</summary>
        public async Task RunAsync(CancellationToken ct)
        {
            Log.Info($"[Broker] ç›‘听管道 [{_pipeName}]");
            while (!ct.IsCancellationRequested)
            {
                NamedPipeServerStream? stream = null;
                try
                {
                    stream = new NamedPipeServerStream(_pipeName,
                        PipeDirection.InOut, 8, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
                    await stream.WaitForConnectionAsync(ct).ConfigureAwait(false);
                    var s = stream;
                    stream = null;
                    _ = Task.Run(() => HandleConnectionAsync(s, ct), CancellationToken.None);
                }
                catch (OperationCanceledException)
                {
                    break;
                }
                catch (Exception ex)
                {
                    Log.Error($"[Broker] æŽ¥å—连接异常: {ex.Message}", ex);
                    stream?.Dispose();
                    try { await Task.Delay(500, ct).ConfigureAwait(false); }
                    catch (OperationCanceledException) { break; }
                }
            }
        }

        private async Task HandleConnectionAsync(NamedPipeServerStream stream, CancellationToken ct)
        {
            var lenBuf = new byte[4];
            try
            {
                using (stream)
                {
                    while (!ct.IsCancellationRequested && stream.IsConnected)
                    {
                        if (!await ReadExactAsync(stream, lenBuf, 4, ct).ConfigureAwait(false)) break;
                        int len = BinaryPrimitives.ReadInt32BigEndian(lenBuf);
                        if (len <= 0 || len > BrokerIpc.MaxFrameBytes) break;
                        var payload = new byte[len];
                        if (!await ReadExactAsync(stream, payload, len, ct).ConfigureAwait(false)) break;

                        IpcEnvelope request;
                        try
                        {
                            request = BrokerIpc.DecodeEnvelope(Encoding.UTF8.GetString(payload));
                        }
                        catch (Exception)
                        {
                            break; // åè®®å¤±æ­¥ï¼Œæ–­å¼€è¯¥è¿žæŽ¥
                        }

                        IpcEnvelope response = await DispatchAsync(request, ct).ConfigureAwait(false);
                        var frame = BrokerIpc.EncodeFrame(BrokerIpc.EncodeEnvelope(response));
                        await stream.WriteAsync(frame, 0, frame.Length, ct).ConfigureAwait(false);
                        await stream.FlushAsync(ct).ConfigureAwait(false);
                    }
                }
            }
            catch (OperationCanceledException) { }
            catch (IOException) { }
            catch (Exception ex)
            {
                Log.Warn($"[Broker] è¿žæŽ¥å¤„理结束: {ex.Message}");
            }
        }

        private async Task<IpcEnvelope> DispatchAsync(IpcEnvelope request, CancellationToken ct)
        {
            if (request.ProtocolVersion != BrokerIpc.ProtocolVersion)
                return Reply(request, BrokerIpc.SerializeBody(new BrokerIpc.ResultBody
                {
                    State = "Failed",
                    ErrorCode = "PROTOCOL_MISMATCH",
                    Readback = $"Broker åè®® v{BrokerIpc.ProtocolVersion}，拒绝 v{request.ProtocolVersion}"
                }));

            switch (request.MessageType)
            {
                case IpcMessageTypes.Hello:
                    return Reply(request, BrokerIpc.SerializeBody(new HelloResult
                    {
                        ServerEpoch = _lease.CurrentEpoch,
                        ConfigHash = CurrentHash(),
                        ProtocolVersion = BrokerIpc.ProtocolVersion,
                        BrokerId = _brokerId
                    }));

                case IpcMessageTypes.SubmitTask:
                    var body = BrokerIpc.DeserializeBody<BrokerIpc.SubmitBody>(request.BodyJson);
                    if (body == null)
                        return Reply(request, Result("Failed", "BAD_BODY", "SubmitBody è§£æžå¤±è´¥"));
                    return Reply(request, await ExecuteOneShotAsync(body, request, ct).ConfigureAwait(false));

                case IpcMessageTypes.ProbeReadback:
                    var pb = BrokerIpc.DeserializeBody<BrokerIpc.SubmitBody>(request.BodyJson);
                    return Reply(request, await ProbeReadbackAsync(pb?.DeviceId ?? "").ConfigureAwait(false));

                case IpcMessageTypes.CancelTask:
                    // MVP ä¸æ”¯æŒä¸­æ–­åœ¨é€”原子片段（INV-06：不得假装已取消）
                    return Reply(request, Result("Failed", "NOT_SUPPORTED", "MVP ä¸æ”¯æŒå–消；片段将在 deadline å†…完成"));

                default:
                    return Reply(request, Result("Failed", "UNKNOWN_MESSAGE", request.MessageType));
            }
        }

        // ==================== OneShot æ‰§è¡Œæ ¸å¿ƒ ====================

        private async Task<BrokerIpc.ResultBody> ExecuteOneShotAsync(
            BrokerIpc.SubmitBody body, IpcEnvelope request, CancellationToken ct)
        {
            // 0) OpCode ç™½åå•
            if (!AllowedOps.Contains(body.OperationCode) ||
                !_devices.TryGetValue(body.DeviceId, out var device))
            {
                return Result("Failed", "DEVICE_NOT_BROKERED",
                    $"设备 {body.DeviceId} ä¸å±žäºŽæœ¬ Broker åŸŸæˆ–操作 {body.OperationCode} ä¸åœ¨ç™½åå•");
            }

            // 1) INV-04：configHash å¯¹è´¦ï¼ˆç©ºå“ˆå¸Œè§†ä¸ºæ—§å®¢æˆ·ç«¯ï¼Œæ”¾è¡Œå¹¶è®°å½•ï¼‰
            var hash = CurrentHash();
            if (!string.IsNullOrWhiteSpace(request.ConfigHash) &&
                !string.Equals(request.ConfigHash, hash, StringComparison.OrdinalIgnoreCase))
            {
                return Result("RejectedConfigMismatch", "CONFIG_MISMATCH",
                    $"客户端快照 {Trim(request.ConfigHash)} â‰  Broker ç”Ÿæ•ˆ {Trim(hash)}，先 Apply å† I/O");
            }

            // 2) æ …栏再校验：CONNECT/DISCONNECT ä»…登记或释放宿主物理会话、无总线输出，豁免租约；
            //    çº¯è¯»å›žæ”¶é‚®ç®±ï¼ˆRECV/RECV_ALL/LOG/BUS_STATUS）为被动监控无写副作用，也豁免（支持调试页只读监听）；
            //    SEND åŠå…¶å®ƒ QUERY（可能触发设备行为，如 AUTO_RESPONSE/FILTER）必须有活跃租约（INV-01）
            string leaseKey = string.IsNullOrWhiteSpace(body.ResourceKey) ? body.DeviceId : body.ResourceKey;
            bool readOnlyDrain = body.OperationCode == "QUERY" &&
                (body.Payload.StartsWith("RECV", StringComparison.OrdinalIgnoreCase) ||
                 body.Payload.StartsWith("LOG", StringComparison.OrdinalIgnoreCase) ||
                 body.Payload.StartsWith("BUS_STATUS", StringComparison.OrdinalIgnoreCase) ||
                 body.Payload.StartsWith("STATUS", StringComparison.OrdinalIgnoreCase));
            if (body.OperationCode != "DISCONNECT" && body.OperationCode != "CONNECT" && !readOnlyDrain)
            {
                var phase = _lease.PhaseOf(leaseKey);
                if (phase == LeasePhase.RecoveryRequired)
                {
                    return Result("RejectedStaleLease", "RECOVERY_REQUIRED",
                        $"资源 {leaseKey} è¿‡æœŸå¾…回收(INV-03)，禁止 I/O");
                }
                var holder = _lease.ProbeConflict(leaseKey);
                if (phase != LeasePhase.Active || holder == null)
                {
                    return Result("RejectedStaleLease", "NO_ACTIVE_LEASE",
                        $"资源 {leaseKey} æ— æ´»è·ƒç§Ÿçº¦ï¼Œå®¢æˆ·ç«¯é¡»å…ˆ Acquire（禁止无租约直接 I/O）");
                }
                // MVP：同机 arb.db å¼±èº«ä»½æ ¡éªŒâ€”—只做存在性/相位检查；
                // owner↔clientInstanceId ç²¾ç¡®å¯¹é½å¾… epoch ç­¾åå‡­æ®ï¼ˆV3.0 Â§13 P2）。
            }

            // 3) SessionGate：同一物理会话原子的“寻道+执行”片段串行
            var gate = _gates.GetOrAdd(device.SessionKey, _ => new SemaphoreSlim(1, 1));
            bool entered;
            try { entered = await gate.WaitAsync(5000, CancellationToken.None).ConfigureAwait(false); }
            catch (ObjectDisposedException) { entered = false; }
            if (!entered)
            {
                // æœªè¿›å…¥ç‰‡æ®µ â†’ ç¡®å®šæœªæ‰§è¡Œï¼Œå¯å®‰å…¨åˆ¤å¿™
                return Result("Failed", "RESOURCE_BUSY",
                    $"会话 {device.SessionKey} ç‰‡æ®µé˜Ÿåˆ—等待超时，未执行可安全重试");
            }

            try
            {
                return await RunFragmentAsync(device, body, ct).ConfigureAwait(false);
            }
            finally
            {
                gate.Release();
            }
        }

        private async Task<BrokerIpc.ResultBody> RunFragmentAsync(
            ManagedDevice device, BrokerIpc.SubmitBody body, CancellationToken ct)
        {
            try
            {
                if (body.OperationCode == "CONNECT" || (device.Driver == null && body.OperationCode != "DISCONNECT"))
                {
                    await EnsureConnectedAsync(device, ct).ConfigureAwait(false);
                }

                switch (body.OperationCode)
                {
                    case "CONNECT":
                        return Result("Succeeded", "", $"OK:CONNECTED:{device.DeviceId}", _lease.CurrentEpoch);
                    case "DISCONNECT":
                        if (device.Connected)
                        {
                            await device.Driver!.DisconnectAsync().ConfigureAwait(false);
                            device.Connected = false;
                        }
                        return Result("Succeeded", "", $"OK:DISCONNECTED:{device.DeviceId}", _lease.CurrentEpoch);
                    case "SEND":
                        {
                            EnsureConnectedOrThrow(device);
                            var resp = await device.Driver!.SendCommandAsync(body.Payload, ct).ConfigureAwait(false);
                            return Result("Succeeded", "", AppendPushes(device, resp), _lease.CurrentEpoch);
                        }
                    case "QUERY":
                        {
                            EnsureConnectedOrThrow(device);
                            var resp = await device.Driver!.QueryAsync(body.Payload, ct).ConfigureAwait(false);
                            return Result("Succeeded", "", AppendPushes(device, resp), _lease.CurrentEpoch);
                        }
                    case "STATUS":
                        {
                            var st = device.Driver?.GetStatus();
                            return Result("Succeeded", "",
                                st == null ? "STATUS:NOT_CREATED"
                                    : $"STATUS:{st.IsConnected}|{st.LastError}", _lease.CurrentEpoch);
                        }
                    default:
                        return Result("Failed", "BAD_OP", body.OperationCode);
                }
            }
            catch (OperationCanceledException)
            {
                // ç‰‡æ®µä¸­é€”取消：物理侧可能已执行 â†’ INV-06
                return Result("Unknown", "DEADLINE", $"{body.OperationCode} è¶… deadline，结果未知");
            }
            catch (Exception ex)
            {
                bool ioMayHappened = body.OperationCode is "SEND" or "QUERY";
                return Result(ioMayHappened ? "Unknown" : "Failed", "DRIVER_ERROR",
                    $"{body.OperationCode} æ‰§è¡Œå¼‚常: {ex.Message}", _lease.CurrentEpoch);
            }
        }

        /// <summary>
        /// æŽå¸¦æŽ¨é€ï¼ˆÂ§5.4）：将宿主物理驱动自上次响应以来收到的 EV:RECV å¸§ï¼Œ
        /// ä»¥ "|PUSHED:n|EV:RECV…" åŽç¼€æ‹¼åˆ°å“åº” readback，客户端 BrokerRpcTransport è§£æžä¸Šå±ã€‚
        /// </summary>
        private static string AppendPushes(ManagedDevice device, string resp)
        {
            if (device.Driver is CanDeviceDriver can)
            {
                var lines = can.DrainPendingPushLines();
                if (lines.Count > 0)
                    return resp + "|PUSHED:" + lines.Count + "|" + string.Join("|", lines);
            }
            return resp;
        }

        private void EnsureConnectedOrThrow(ManagedDevice device)
        {
            if (!device.Connected || device.Driver == null)
                throw new InvalidOperationException($"设备 {device.DeviceId} æœªè¿žæŽ¥ï¼Œè¯·å…ˆ CONNECT");
        }

        private async Task EnsureConnectedAsync(ManagedDevice device, CancellationToken ct)
        {
            if (device.Connected && device.Driver != null) return;
            await _driverCreateLock.WaitAsync(ct).ConfigureAwait(false);
            try
            {
                if (device.Connected && device.Driver != null) return;
                device.Driver ??= DriverFactory.CreateDriver(device.DeviceId, device.Transport, device.Endpoint);
                await device.Driver.ConnectAsync(ct).ConfigureAwait(false);
                device.Connected = true;
                Log.Info($"[Broker] ç‰©ç†ä¼šè¯å·²å»ºç«‹: {device.DeviceId} ({device.Transport} {device.Endpoint})");
            }
            finally
            {
                _driverCreateLock.Release();
            }
        }

        /// <summary>恢复回收前读回探测：宿主读回设备状态作为合格证据（INV-03 äººå·¥å›žæ”¶é“¾çš„ Broker ä¾§ï¼‰ã€‚</summary>
        private async Task<BrokerIpc.ResultBody> ProbeReadbackAsync(string deviceId)
        {
            if (!_devices.TryGetValue(deviceId, out var device) || device.Driver == null)
                return Result("Failed", "NO_DRIVER", $"设备 {deviceId} æ— æ´»åŠ¨é©±åŠ¨");
            try
            {
                var readback = await device.Driver.QueryAsync("STATUS", CancellationToken.None).ConfigureAwait(false);
                return Result("Succeeded", "", readback, _lease.CurrentEpoch);
            }
            catch (Exception ex)
            {
                return Result("Failed", "READBACK_ERROR", ex.Message);
            }
        }

        // ==================== æ‚项 ====================

        private string CurrentHash()
        {
            long now = BrokerIpc.NowUtcMs();
            if (now - Interlocked.Read(ref _hashStampMs) > 2000)
            {
                try
                {
                    _cachedHash = DeviceConfigHash.Compute(_configDbPath);
                }
                catch (Exception ex)
                {
                    Log.Warn($"[Broker] configHash é‡ç®—失败: {ex.Message}");
                }
                Interlocked.Exchange(ref _hashStampMs, now);
            }
            return _cachedHash;
        }

        private static BrokerIpc.ResultBody Result(string state, string code, string readback, long epoch = 0)
            => new BrokerIpc.ResultBody
            {
                State = state,
                ErrorCode = code,
                Readback = readback,
                ServerEpoch = epoch
            };

        private static IpcEnvelope Reply(IpcEnvelope request, string bodyJson) => new IpcEnvelope
        {
            ProtocolVersion = BrokerIpc.ProtocolVersion,
            MessageType = "Result",
            RequestId = Guid.NewGuid().ToString("N"),
            CorrelationId = request.RequestId,
            ClientInstanceId = request.ClientInstanceId,
            AuthorityId = request.AuthorityId,
            BodyJson = bodyJson
        };

        private static IpcEnvelope Reply(IpcEnvelope request, BrokerIpc.ResultBody body)
            => Reply(request, BrokerIpc.SerializeBody(body));

        private static async Task<bool> ReadExactAsync(Stream s, byte[] buf, int count, CancellationToken ct)
        {
            int off = 0;
            while (off < count)
            {
                int n;
                try { n = await s.ReadAsync(buf, off, count - off, ct).ConfigureAwait(false); }
                catch (IOException) { return false; }
                if (n <= 0) return false;
                off += n;
            }
            return true;
        }

        private static string Trim(string h)
            => string.IsNullOrEmpty(h) ? "" : (h.Length > 8 ? h.Substring(0, 8) : h);
    }
}

 DeviceBroker/DeviceBroker.csproj

New file
@@ -0,0 +1,21 @@
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net472</TargetFramework>
    <Nullable>enable</Nullable>
    <LangVersion>10.0</LangVersion>
    <ImplicitUsings>enable</ImplicitUsings>
    <AssemblyName>DeviceBroker</AssemblyName>
    <RootNamespace>DeviceBroker</RootNamespace>
    <PlatformTarget>x64</PlatformTarget>
    <AutoGenerateBindingRedirects>True</AutoGenerateBindingRedirects>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\Aging.Infrastructure\Aging.Infrastructure.csproj" />
    <ProjectReference Include="..\Aging.ResourceContracts\Aging.ResourceContracts.csproj" />
    <ProjectReference Include="..\CanSimulator\CanSimulator.csproj" />
  </ItemGroup>

</Project>

 DeviceBroker/Program.cs

New file
@@ -0,0 +1,79 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using log4net;

namespace DeviceBroker
{
    /// <summary>
    /// DeviceBroker å®¿ä¸»å…¥å£ã€‚
    /// ç”¨æ³•: DeviceBroker.exe [--db data.db路径] [--arb arb.db路径] [--broker broker-b01]
    /// é»˜è®¤è·¯å¾„与集成测试环境一致（%LOCALAPPDATA%\PluginIntegrationTest）。
    /// </summary>
    public static class Program
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(Program));

        public static async Task Main(string[] args)
        {
            var map = ParseArgs(args);
            string appData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
            string defaultDir = Path.Combine(appData, "PluginIntegrationTest");
            string dbPath = Get(map, "--db", Path.Combine(defaultDir, "data.db"));
            string arbPath = Get(map, "--arb", Path.Combine(defaultDir, "arb.db"));
            string brokerId = Get(map, "--broker", "broker-b01");

            Console.WriteLine($"DeviceBroker [{brokerId}]");
            Console.WriteLine($"  é…ç½®åº“: {dbPath}");
            Console.WriteLine($"  ä»²è£åº“: {arbPath}");

            if (!File.Exists(dbPath))
            {
                Console.WriteLine($"[FATAL] é…ç½®åº“不存在，请先在注册页保存设备配置。{dbPath}");
                Environment.ExitCode = 2;
                return;
            }

            using var cts = new CancellationTokenSource();
            Console.CancelKeyPress += (_, e) =>
            {
                e.Cancel = true;   // ä¼˜é›…退出：租约靠 TTL è¿‡æœŸ + äººå·¥å›žæ”¶ï¼Œä¸åšè¿›ç¨‹å†…强放
                cts.Cancel();
                Console.WriteLine("[Broker] æ”¶åˆ°é€€å‡ºè¯·æ±‚，在途片段按 deadline æ”¶å£â€¦");
            };

            try
            {
                var server = new BrokerServer(dbPath, arbPath, brokerId);
                server.LoadDevices();
                Console.WriteLine($"[Broker] epoch={server.Epoch}，Ctrl+C é€€å‡º");
                await server.RunAsync(cts.Token).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                Log.Fatal("[Broker] å®¿ä¸»å¼‚常退出", ex);
                Console.WriteLine($"[FATAL] {ex.Message}");
                Environment.ExitCode = 1;
            }
        }

        private static string Get(Dictionary<string, string> map, string key, string fallback)
            => map.TryGetValue(key, out var v) && !string.IsNullOrWhiteSpace(v) ? v : fallback;

        private static Dictionary<string, string> ParseArgs(string[] args)
        {
            var map = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            for (int i = 0; i + 1 < args.Length; i++)
            {
                if (args[i].StartsWith("--"))
                {
                    map[args[i]] = args[i + 1];
                    i++;
                }
            }
            return map;
        }
    }
}

 Plugin.DeviceConfig/DeviceConfig.xaml

@@ -101,6 +101,7 @@
                                <RowDefinition Height="36"/>
                                <RowDefinition Height="36"/>
                                <RowDefinition Height="36"/>
                                <RowDefinition Height="36"/>
                            </Grid.RowDefinitions>

                            <TextBlock Grid.Row="0" Grid.Column="0" Text="设备ID" VerticalAlignment="Center" Style="{StaticResource ListTableTextBlock}"/>
@@ -126,6 +127,14 @@
                            <TextBlock Grid.Row="2" Grid.Column="2" Text="生效版本" VerticalAlignment="Center" Style="{StaticResource ListTableTextBlock}"/>
                            <TextBox Grid.Row="2" Grid.Column="3" x:Name="tbEffectiveVersion" VerticalAlignment="Center"
                                     Style="{StaticResource EditorTextBoxStyle}" IsReadOnly="True" Margin="4,0"/>

                            <TextBlock Grid.Row="3" Grid.Column="0" Text="执行位置" VerticalAlignment="Center" Style="{StaticResource ListTableTextBlock}"/>
                            <TextBox Grid.Row="3" Grid.Column="1" x:Name="tbExecutionMode" VerticalAlignment="Center"
                                     Style="{StaticResource EditorTextBoxStyle}" IsReadOnly="True" Margin="4,0"/>

                            <TextBlock Grid.Row="3" Grid.Column="2" Text="仲裁域/会话" VerticalAlignment="Center" Style="{StaticResource ListTableTextBlock}"/>
                            <TextBox Grid.Row="3" Grid.Column="3" x:Name="tbAuthorityInfo" VerticalAlignment="Center"
                                     Style="{StaticResource EditorTextBoxStyle}" IsReadOnly="True" Margin="4,0"/>
                        </Grid>
                    </GroupBox>


 Plugin.DeviceConfig/DeviceConfig.xaml.cs

@@ -221,6 +221,13 @@

                var chList = _model.GetChannelsByDevice(dev.DeviceId);
                Channels = new ObservableCollection<DeviceChannel>(chList);

                // V3.0 æ‰§è¡Œä½ç½®å±•ç¤º
                tbExecutionMode.Text = dev.ExecutionMode == ExecutionModeKind.Broker
                    ? "Broker å…±äº«" : "Local ç›´è¿ž";
                tbAuthorityInfo.Text = dev.ExecutionMode == ExecutionModeKind.Broker
                    ? $"{dev.AuthorityId} Â· {dev.PhysicalSessionKey}"
                    : (string.IsNullOrWhiteSpace(dev.AuthorityId) ? V3AuthorityCatalog.LocalAuthorityId : dev.AuthorityId);
            }
            catch (Exception ex)
            {
@@ -326,6 +333,11 @@
                    DriverType = SelectedDevice.DriverType,
                    Transport = SelectedDevice.Transport,
                    Endpoint = SelectedDevice.Endpoint,
                    ExecutionMode = SelectedDevice.ExecutionMode,
                    AuthorityId = SelectedDevice.AuthorityId,
                    BrokerId = SelectedDevice.BrokerId,
                    OwnerProcessId = SelectedDevice.OwnerProcessId,
                    PhysicalSessionKey = SelectedDevice.PhysicalSessionKey,
                    EffectiveVersion = SelectedDevice.EffectiveVersion,
                    CreatedAt = SelectedDevice.CreatedAt,
                    UpdatedAt = SelectedDevice.UpdatedAt
@@ -408,6 +420,8 @@
            tbTransport.Text = string.Empty;
            tbEndpoint.Text = string.Empty;
            tbEffectiveVersion.Text = string.Empty;
            tbExecutionMode.Text = string.Empty;
            tbAuthorityInfo.Text = string.Empty;
            Channels = new ObservableCollection<DeviceChannel>();
        }

@@ -494,6 +508,21 @@
                    ToastHelper.Warning("没有可发布的草稿版本");
                    return;
                }

                // V3.0 Â§05 å‘布门禁：执行位置绑定校验不通过则阻止发布
                var gateErrors = _model.ValidatePublishGate();
                if (gateErrors.Count > 0)
                {
                    var detail = string.Join("\n", gateErrors.Take(8));
                    if (gateErrors.Count > 8)
                    {
                        detail += $"\n… å…± {gateErrors.Count} é¡¹é”™è¯¯";
                    }
                    log.Warn($"发布门禁拦截: {string.Join("; ", gateErrors)}");
                    MsgBoxHelper.Error(Window.GetWindow(this), $"发布门禁校验未通过：\n{detail}");
                    return;
                }

                var hash = _model.ComputeConfigHash();
                draft.Hash = hash;
                draft.Status = VersionStatus.Published;

 Plugin.DeviceConfig/DeviceEditModal.xaml

@@ -27,6 +27,7 @@
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>

        <!-- è®¾å¤‡åŸºæœ¬ä¿¡æ¯ -->
@@ -65,8 +66,69 @@
            </Grid>
        </GroupBox>

        <!-- æ‰§è¡Œä½ç½®ï¼ˆV3.0 Â§05） -->
        <GroupBox Grid.Row="1" Header="执行位置" FontWeight="SemiBold" Margin="0,0,0,12">
            <Grid Margin="8">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="100"/>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="100"/>
                    <ColumnDefinition Width="*"/>
                </Grid.ColumnDefinitions>
                <Grid.RowDefinitions>
                    <RowDefinition Height="36"/>
                    <RowDefinition Height="36"/>
                    <RowDefinition Height="36"/>
                </Grid.RowDefinitions>

                <TextBlock Grid.Row="0" Grid.Column="0" Text="执行模式 *" VerticalAlignment="Center" Style="{StaticResource ListTableTextBlock}"/>
                <StackPanel Grid.Row="0" Grid.Column="1" Grid.ColumnSpan="3" Orientation="Horizontal" VerticalAlignment="Center"
                            dp:StackPanelHelper.ChildSpace="16" Margin="4,0">
                    <RadioButton x:Name="rbLocal" Content="本地仪器 (Local ç›´è¿ž)" GroupName="ExecMode" IsChecked="True"
                                 Checked="ExecMode_Changed" VerticalAlignment="Center"/>
                    <RadioButton x:Name="rbBroker" Content="共享仪器 (Broker ä»£ç†)" GroupName="ExecMode"
                                 Checked="ExecMode_Changed" VerticalAlignment="Center"/>
                </StackPanel>

                <TextBlock Grid.Row="1" Grid.Column="0" Text="仲裁域 *" VerticalAlignment="Center" Style="{StaticResource ListTableTextBlock}"/>
                <ComboBox Grid.Row="1" Grid.Column="1" x:Name="cbAuthority" VerticalAlignment="Center" Margin="4,0"
                         SelectionChanged="CbAuthority_SelectionChanged"/>

                <TextBlock Grid.Row="1" Grid.Column="2" Text="访问策略" VerticalAlignment="Center" Style="{StaticResource ListTableTextBlock}"/>
                <TextBox Grid.Row="1" Grid.Column="3" x:Name="tbAccessPolicy" VerticalAlignment="Center" IsReadOnly="True"
                         Style="{StaticResource EditorTextBoxStyle}" Margin="4,0"/>

                <!-- Broker æ¨¡å¼ä¸“属字段：默认隐藏 -->
                <Grid Grid.Row="2" Grid.ColumnSpan="4" x:Name="spBroker" Visibility="Collapsed">
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="100"/>
                        <ColumnDefinition Width="*"/>
                        <ColumnDefinition Width="100"/>
                        <ColumnDefinition Width="*"/>
                    </Grid.ColumnDefinitions>
                    <Grid.RowDefinitions>
                        <RowDefinition Height="36"/>
                        <RowDefinition Height="36"/>
                    </Grid.RowDefinitions>

                    <TextBlock Grid.Row="0" Grid.Column="0" Text="BrokerId *" VerticalAlignment="Center" Style="{StaticResource ListTableTextBlock}"/>
                    <ComboBox Grid.Row="0" Grid.Column="1" x:Name="cbBrokerId" VerticalAlignment="Center" Margin="4,0"/>

                    <TextBlock Grid.Row="0" Grid.Column="2" Text="宿主进程" VerticalAlignment="Center" Style="{StaticResource ListTableTextBlock}"/>
                    <TextBox Grid.Row="0" Grid.Column="3" x:Name="tbOwnerProcessId" VerticalAlignment="Center" IsReadOnly="True"
                             Style="{StaticResource EditorTextBoxStyle}" Margin="4,0"
                             pu:TextBoxHelper.Watermark="Broker å®¿ä¸» PID（MVP å ä½å½“前进程）"/>

                    <TextBlock Grid.Row="1" Grid.Column="0" Text="物理会话键 *" VerticalAlignment="Center" Style="{StaticResource ListTableTextBlock}"/>
                    <ComboBox Grid.Row="1" Grid.Column="1" Grid.ColumnSpan="3" x:Name="cbSessionKey" VerticalAlignment="Center"
                             IsEditable="True" Margin="4,0"
                             pu:TextBoxHelper.Watermark="由端点规范化的固定字符串，如 can/CAN_BUS_1/main"/>
                </Grid>
            </Grid>
        </GroupBox>

        <!-- é€šé“列表 -->
        <GroupBox Grid.Row="1" Header="通道列表" FontWeight="SemiBold" Margin="0,0,0,12">
        <GroupBox Grid.Row="2" Header="通道列表" FontWeight="SemiBold" Margin="0,0,0,12">
            <Grid Margin="8">
                <Grid.RowDefinitions>
                    <RowDefinition Height="Auto"/>
@@ -172,7 +234,7 @@
        </GroupBox>

        <!-- åº•éƒ¨æŒ‰é’® -->
        <StackPanel Grid.Row="3" Orientation="Horizontal" HorizontalAlignment="Right" dp:StackPanelHelper.ChildSpace="10" Margin="0,12,0,0">
        <StackPanel Grid.Row="4" Orientation="Horizontal" HorizontalAlignment="Right" dp:StackPanelHelper.ChildSpace="10" Margin="0,12,0,0">
            <Button x:Name="saveBtn" Click="SaveBtn_Click" Content="保存"
                    Style="{StaticResource AddBtn}" Width="90"/>
            <Button x:Name="cancelBtn" Click="CancelBtn_Click" Content="取消"

 Plugin.DeviceConfig/DeviceEditModal.xaml.cs

@@ -3,6 +3,7 @@
using Plugin.DeviceConfig.Entity;
using Plugin.DeviceConfig.Model;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
@@ -19,6 +20,7 @@
        private DeviceDefinition _device;
        private ObservableCollection<DeviceChannel> _channels = new();
        private bool _isNew;
        private bool _execModeSyncing;

        public DeviceEditModal()
        {
@@ -40,6 +42,11 @@
            cbTransport.ItemsSource = Enum.GetValues(typeof(TransportType)).Cast<TransportType>().ToList();
            cbTransport.SelectionChanged += CbTransport_SelectionChanged;

            // æ‰§è¡Œä½ç½®ï¼šä»²è£åŸŸ/BrokerId å€™é€‰ç”±é…ç½®æžšä¸¾
            cbAuthority.ItemsSource = V3AuthorityCatalog.AuthorityIds;
            cbBrokerId.ItemsSource = V3AuthorityCatalog.BrokerIds;
            tbOwnerProcessId.Text = System.Diagnostics.Process.GetCurrentProcess().Id.ToString();

            // å¡«å……数据
            tbDeviceId.Text = device.DeviceId;
            tbDeviceId.IsReadOnly = !_isNew;
@@ -47,6 +54,29 @@
            tbDriverType.Text = device.DriverType;
            cbTransport.SelectedItem = device.Transport;
            tbEndpoint.Text = device.Endpoint;

            // æ‰§è¡Œä½ç½®å›žæ˜¾ï¼šæ—§æ•°æ® AuthorityId ä¸ºç©ºæ—¶é»˜è®¤æœ¬æœº Local åŸŸ
            _execModeSyncing = true;
            rbLocal.IsChecked = device.ExecutionMode == ExecutionModeKind.Local;
            rbBroker.IsChecked = device.ExecutionMode == ExecutionModeKind.Broker;
            cbAuthority.SelectedItem = string.IsNullOrWhiteSpace(device.AuthorityId)
                ? V3AuthorityCatalog.LocalAuthorityId : device.AuthorityId;
            if (cbAuthority.SelectedItem == null)
            {
                // å­˜é‡å€¼ä¸åœ¨å½“前候选枚举中：保留展示并追加
                var list = V3AuthorityCatalog.AuthorityIds.ToList();
                list.Add(device.AuthorityId);
                cbAuthority.ItemsSource = list;
                cbAuthority.SelectedItem = device.AuthorityId;
            }
            cbBrokerId.SelectedItem = device.BrokerId;
            if (!string.IsNullOrWhiteSpace(device.OwnerProcessId))
            {
                tbOwnerProcessId.Text = device.OwnerProcessId;
            }
            _execModeSyncing = false;
            RefreshExecModeUi();
            RefreshSessionKeyCandidates();

            // é»˜è®¤é©±åŠ¨ç±»åž‹å»ºè®® & ç«¯ç‚¹æç¤º
            UpdateDriverHint();
@@ -63,6 +93,9 @@
                _channels = new ObservableCollection<DeviceChannel>();
            }
            channelListView.ItemsSource = _channels;

            // é€šé“ SessionKey å·²åŠ è½½ï¼Œé‡æ–°ç”Ÿæˆä¼šè¯é”®å€™é€‰ï¼ˆBroker æ¨¡å¼ï¼‰
            RefreshSessionKeyCandidates();

            return ShowDialog();
        }
@@ -211,6 +244,120 @@

        #endregion

        #region æ‰§è¡Œä½ç½®ï¼ˆV3.0 Â§05）

        /// <summary>当前是否 Broker æ¨¡å¼</summary>
        private bool IsBrokerMode => rbBroker.IsChecked == true;

        private void ExecMode_Changed(object sender, RoutedEventArgs e)
        {
            // XAML åˆå§‹åŒ–阶段 rbLocal.IsChecked=True ä¼šæå‰è§¦å‘，此时其余控件字段尚未创建
            if (_execModeSyncing || rbBroker == null || cbAuthority == null) return;
            _execModeSyncing = true;
            // Broker è®¾å¤‡çš„ AuthorityId å³å…¶ Broker åŸŸï¼›åˆ‡å›ž Local æ—¶ä½¿ç”¨æœ¬æœºé»˜è®¤åŸŸ
            if (IsBrokerMode)
            {
                // å½“前仍为 local åŸŸï¼ˆæˆ–未选）→ åˆ‡åˆ°é¦–个 Broker åŸŸ
                if (V3AuthorityCatalog.IsLocalAuthority(cbAuthority.SelectedItem as string) || cbAuthority.SelectedItem == null)
                {
                    cbAuthority.SelectedItem = V3AuthorityCatalog.BrokerIds.FirstOrDefault()
                        ?? V3AuthorityCatalog.AuthorityIds.LastOrDefault(a => !V3AuthorityCatalog.IsLocalAuthority(a));
                }
            }
            else
            {
                cbAuthority.SelectedItem = V3AuthorityCatalog.LocalAuthorityId;
            }
            _execModeSyncing = false;
            RefreshExecModeUi();
        }

        private void CbAuthority_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (_execModeSyncing || rbLocal == null || rbBroker == null || cbBrokerId == null) return;
            var auth = cbAuthority.SelectedItem as string;
            if (string.IsNullOrEmpty(auth)) return;
            _execModeSyncing = true;
            // é€‰ä¸­ local- åŸŸâ†’Local；选中 Broker åŸŸâ†’Broker å¹¶åŒæ­¥ BrokerId
            if (V3AuthorityCatalog.IsLocalAuthority(auth))
            {
                rbLocal.IsChecked = true;
            }
            else
            {
                rbBroker.IsChecked = true;
                cbBrokerId.SelectedItem = V3AuthorityCatalog.BrokerIds.Contains(auth) ? auth : cbBrokerId.SelectedItem;
            }
            _execModeSyncing = false;
            RefreshExecModeUi();
        }

        /// <summary>根据模式切换 Broker å­—段可见性与只读派生的访问策略</summary>
        private void RefreshExecModeUi()
        {
            spBroker.Visibility = IsBrokerMode ? Visibility.Visible : Visibility.Collapsed;
            tbAccessPolicy.Text = (IsBrokerMode ? ExecutionModeKind.Broker : ExecutionModeKind.Local)
                switch
                {
                    ExecutionModeKind.Broker => "共享仲裁 Â· Broker SessionGate ä»£ç†",
                    _ => "独占直连 Â· æœ¬è¿›ç¨‹æŒæœ‰ç‰©ç†ä¼šè¯"
                };
            if (IsBrokerMode)
            {
                RefreshSessionKeyCandidates();
            }
        }

        /// <summary>
        /// PhysicalSessionKey å€™é€‰ï¼šç”±ç«¯ç‚¹è§„范化的写死字符串（V3.0 Â§04：地址别名必须归一为同一物理身份）
        /// </summary>
        private void RefreshSessionKeyCandidates()
        {
            var deviceId = tbDeviceId.Text?.Trim() ?? string.Empty;
            var transport = cbTransport.SelectedItem is TransportType tt ? tt : TransportType.Tcp;
            var endpoint = tbEndpoint.Text?.Trim() ?? string.Empty;

            var candidates = new List<string>();
            if (transport == TransportType.Can)
            {
                var bus = endpoint.Split(':')[0].Trim();
                if (!string.IsNullOrEmpty(bus)) candidates.Add($"can/{bus}/main");
            }
            else if (transport == TransportType.Tcp && endpoint.Contains(":"))
            {
                candidates.Add($"tcp/{endpoint}/main");
            }
            else if (transport == TransportType.Serial)
            {
                var com = endpoint.Split(':')[0].Trim();
                if (!string.IsNullOrEmpty(com)) candidates.Add($"serial/{com}/main");
            }
            else if (transport == TransportType.Visa)
            {
                candidates.Add($"visa/{deviceId}/main");
            }
            else if (transport == TransportType.SDK)
            {
                candidates.Add($"sdk/{deviceId}/main");
            }
            if (!string.IsNullOrEmpty(deviceId)) candidates.Add($"{deviceId}/main");

            // å·²å­˜é€šé“ SessionKey ä¹Ÿåˆ—入候选（去重）
            foreach (var key in _channels.Select(c => c.SessionKey)
                         .Where(k => !string.IsNullOrWhiteSpace(k)).Distinct())
            {
                candidates.Add(key);
            }
            candidates = candidates.Distinct(StringComparer.OrdinalIgnoreCase).ToList();

            string? current = _device?.PhysicalSessionKey;
            cbSessionKey.ItemsSource = candidates;
            cbSessionKey.Text = !string.IsNullOrWhiteSpace(current) ? current
                : (candidates.Count > 0 ? candidates[0] : string.Empty);
        }

        #endregion

        #region ä¿å­˜/取消

        private void SaveBtn_Click(object sender, RoutedEventArgs e)
@@ -275,12 +422,42 @@
                    }
                }

                // æ‰§è¡Œä½ç½®ï¼ˆV3.0 Â§05）校验
                var authorityId = cbAuthority.SelectedItem as string ?? string.Empty;
                if (string.IsNullOrWhiteSpace(authorityId))
                {
                    ToastHelper.Warning("仲裁域不能为空，请从候选中选择");
                    return;
                }
                string brokerId = string.Empty, sessionKey = string.Empty, ownerPid = string.Empty;
                if (IsBrokerMode)
                {
                    brokerId = cbBrokerId.SelectedItem as string ?? string.Empty;
                    if (string.IsNullOrWhiteSpace(brokerId))
                    {
                        ToastHelper.Warning("共享仪器（Broker）必须指定 BrokerId");
                        return;
                    }
                    sessionKey = cbSessionKey.Text?.Trim() ?? string.Empty;
                    if (string.IsNullOrWhiteSpace(sessionKey))
                    {
                        ToastHelper.Warning("共享仪器（Broker）必须指定物理会话键");
                        return;
                    }
                    ownerPid = tbOwnerProcessId.Text?.Trim() ?? string.Empty;
                }

                // ä¿å­˜è®¾å¤‡
                _device.DeviceId = deviceId;
                _device.Kind = kind;
                _device.DriverType = tbDriverType.Text?.Trim() ?? string.Empty;
                _device.Transport = transport;
                _device.Endpoint = endpoint;
                _device.ExecutionMode = IsBrokerMode ? ExecutionModeKind.Broker : ExecutionModeKind.Local;
                _device.AuthorityId = authorityId;
                _device.BrokerId = brokerId;
                _device.PhysicalSessionKey = sessionKey;
                _device.OwnerProcessId = ownerPid;

                _model.SaveDevice(_device);

@@ -309,6 +486,10 @@
        private void CbTransport_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            UpdateEndpointHint();
            if (IsBrokerMode)
            {
                RefreshSessionKeyCandidates();
            }
        }

        /// <summary>

 Plugin.DeviceConfig/Entity/DeviceDefinition.cs

@@ -16,6 +16,15 @@
    }

    /// <summary>
    /// V3.0 æ‰§è¡Œä½ç½®æžšä¸¾ï¼šLocal=进程独占直连；Broker=跨进程共享，由 DeviceBroker å®¿ä¸»ä»£ç†
    /// </summary>
    public enum ExecutionModeKind
    {
        Local,
        Broker
    }

    /// <summary>
    /// ä¼ è¾“方式枚举
    /// </summary>
    public enum TransportType
@@ -68,6 +77,45 @@
        private string endpoint = string.Empty;

        /// <summary>
        /// æ‰§è¡Œä½ç½®: Local / Broker（V3.0 Â§05，默认 Local）
        /// </summary>
        [ObservableProperty]
        private ExecutionModeKind executionMode = ExecutionModeKind.Local;

        /// <summary>
        /// ä»²è£åŸŸæ ‡è¯†ï¼ˆå¿…填，候选值由配置枚举；同一 PhysicalSessionKey åªèƒ½å½’属一个仲裁域宿主）
        /// </summary>
        [ObservableProperty]
        private string authorityId = string.Empty;

        /// <summary>
        /// Broker å®¿ä¸»æ ‡è¯†ï¼ˆä»… Broker æ¨¡å¼ï¼›é¡»ä¸Žä»²è£åŸŸä¸€è‡´ï¼‰
        /// </summary>
        [ObservableProperty]
        private string brokerId = string.Empty;

        /// <summary>
        /// Broker å®¿ä¸»è¿›ç¨‹å·ï¼ˆä»… Broker è®°å½•ç”¨ï¼Œè¿è¡ŒæœŸä»¥ Broker å®žé™… PID ä¸ºå‡†ï¼›MVP å ä½å½“前进程）
        /// </summary>
        [ObservableProperty]
        private string ownerProcessId = string.Empty;

        /// <summary>
        /// ç‰©ç†ä¼šè¯é”®ï¼ˆä»… Broker；地址规范化后的固定字符串，如 can/CAN_BUS_1/main）
        /// </summary>
        [ObservableProperty]
        private string physicalSessionKey = string.Empty;

        /// <summary>
        /// è®¿é—®æŽ§åˆ¶ç­–略：只读派生，不可手工编辑（V3.0 Â§05）
        /// </summary>
        public string AccessPolicy => ExecutionMode switch
        {
            ExecutionModeKind.Broker => "共享仲裁 Â· Broker SessionGate ä»£ç†",
            _ => "独占直连 Â· æœ¬è¿›ç¨‹æŒæœ‰ç‰©ç†ä¼šè¯"
        };

        /// <summary>
        /// ç”Ÿæ•ˆç‰ˆæœ¬å·
        /// </summary>
        [ObservableProperty]

 Plugin.DeviceConfig/Model/DeviceConfigModel.cs

@@ -49,6 +49,11 @@
                        DriverType TEXT NOT NULL,
                        Transport TEXT NOT NULL,
                        Endpoint TEXT NOT NULL,
                        ExecutionMode TEXT NOT NULL DEFAULT 'Local',
                        AuthorityId TEXT NOT NULL DEFAULT '',
                        BrokerId TEXT NOT NULL DEFAULT '',
                        OwnerProcessId TEXT NOT NULL DEFAULT '',
                        PhysicalSessionKey TEXT NOT NULL DEFAULT '',
                        EffectiveVersion TEXT NOT NULL DEFAULT '',
                        CreatedAt TEXT NOT NULL,
                        UpdatedAt TEXT NOT NULL
@@ -101,10 +106,39 @@
                };

                helper.ExecuteBatchSql(sqls);

                // V3.0 Â§05：执行位置字段迁移（旧库补列，新库已在建表语句中包含）
                MigrateExecutionColumns(helper);
            }
            catch (Exception ex)
            {
                throw new Exception($"初始化设备配置数据库失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// V3.0：旧版 DeviceDefinition è¡¨è¡¥å……执行位置五列（SQLite æ— è¡Œçº§é”å‡è®¾ï¼Œé€åˆ— PRAGMA æ£€æŸ¥åŽ ALTER）
        /// </summary>
        private static void MigrateExecutionColumns(HMI.Core.Util.SqliteHelper helper)
        {
            var dt = helper.GetDataTable("PRAGMA table_info(DeviceDefinition);");
            var existing = new HashSet<string>(
                dt.Rows.Cast<DataRow>().Select(r => r["name"].ToString()), StringComparer.OrdinalIgnoreCase);

            var additions = new (string Col, string Ddl)[]
            {
                ("ExecutionMode", "ALTER TABLE DeviceDefinition ADD COLUMN ExecutionMode TEXT NOT NULL DEFAULT 'Local';"),
                ("AuthorityId", "ALTER TABLE DeviceDefinition ADD COLUMN AuthorityId TEXT NOT NULL DEFAULT '';"),
                ("BrokerId", "ALTER TABLE DeviceDefinition ADD COLUMN BrokerId TEXT NOT NULL DEFAULT '';"),
                ("OwnerProcessId", "ALTER TABLE DeviceDefinition ADD COLUMN OwnerProcessId TEXT NOT NULL DEFAULT '';"),
                ("PhysicalSessionKey", "ALTER TABLE DeviceDefinition ADD COLUMN PhysicalSessionKey TEXT NOT NULL DEFAULT '';"),
            };
            foreach (var (col, ddl) in additions)
            {
                if (!existing.Contains(col))
                {
                    helper.ExecuteSql(ddl);
                }
            }
        }

@@ -156,13 +190,18 @@
                device.UpdatedAt = DateTime.Now;

                var sql = $@"INSERT OR REPLACE INTO DeviceDefinition 
                    (DeviceId, Kind, DriverType, Transport, Endpoint, EffectiveVersion, CreatedAt, UpdatedAt) 
                    (DeviceId, Kind, DriverType, Transport, Endpoint, ExecutionMode, AuthorityId, BrokerId, OwnerProcessId, PhysicalSessionKey, EffectiveVersion, CreatedAt, UpdatedAt) 
                    VALUES (
                        '{Escape(device.DeviceId)}',
                        '{device.Kind}',
                        '{Escape(device.DriverType)}',
                        '{device.Transport}',
                        '{Escape(device.Endpoint)}',
                        '{device.ExecutionMode}',
                        '{Escape(device.AuthorityId)}',
                        '{Escape(device.BrokerId)}',
                        '{Escape(device.OwnerProcessId)}',
                        '{Escape(device.PhysicalSessionKey)}',
                        '{Escape(device.EffectiveVersion)}',
                        '{device.CreatedAt:yyyy-MM-dd HH:mm:ss}',
                        '{device.UpdatedAt:yyyy-MM-dd HH:mm:ss}'
@@ -203,12 +242,23 @@
                    DriverType = row["DriverType"].ToString() ?? string.Empty,
                    Transport = Enum.TryParse<TransportType>(row["Transport"].ToString(), out var tp) ? tp : TransportType.Tcp,
                    Endpoint = row["Endpoint"].ToString() ?? string.Empty,
                    ExecutionMode = HasColumn(row.Table, "ExecutionMode") && Enum.TryParse<ExecutionModeKind>(row["ExecutionMode"].ToString(), out var em)
                        ? em : ExecutionModeKind.Local,
                    AuthorityId = HasColumn(row.Table, "AuthorityId") ? row["AuthorityId"].ToString() ?? string.Empty : string.Empty,
                    BrokerId = HasColumn(row.Table, "BrokerId") ? row["BrokerId"].ToString() ?? string.Empty : string.Empty,
                    OwnerProcessId = HasColumn(row.Table, "OwnerProcessId") ? row["OwnerProcessId"].ToString() ?? string.Empty : string.Empty,
                    PhysicalSessionKey = HasColumn(row.Table, "PhysicalSessionKey") ? row["PhysicalSessionKey"].ToString() ?? string.Empty : string.Empty,
                    EffectiveVersion = row["EffectiveVersion"].ToString() ?? string.Empty,
                    CreatedAt = DateTime.TryParse(row["CreatedAt"].ToString(), out var ca) ? ca : DateTime.Now,
                    UpdatedAt = DateTime.TryParse(row["UpdatedAt"].ToString(), out var ua) ? ua : DateTime.Now,
                });
            }
            return list;
        }

        private static bool HasColumn(DataTable dt, string columnName)
        {
            return dt.Columns.Cast<DataColumn>().Any(c => c.ColumnName.Equals(columnName, StringComparison.OrdinalIgnoreCase));
        }

        #endregion
@@ -603,7 +653,13 @@
                var deviceDt = helper.GetDataTable("SELECT * FROM DeviceDefinition ORDER BY DeviceId;");
                foreach (DataRow row in deviceDt.Rows)
                {
                    sb.Append($"DEVICE:{row["DeviceId"]}|{row["Kind"]}|{row["DriverType"]}|{row["Transport"]}|{row["Endpoint"]};");
                    // V3.0：执行位置字段进入配置哈希（INV-04：Broker è¿žæŽ¥æº configHash å¯¹è´¦ï¼‰ï¼›
                    // OwnerProcessId å±žè¿è¡ŒæœŸä¿¡æ¯ï¼Œä¸å‚与哈希，避免宿主重启导致哈希漂移
                    string execMode = HasColumn(deviceDt, "ExecutionMode") ? row["ExecutionMode"].ToString() : "Local";
                    string authId = HasColumn(deviceDt, "AuthorityId") ? row["AuthorityId"].ToString() : "";
                    string bkId = HasColumn(deviceDt, "BrokerId") ? row["BrokerId"].ToString() : "";
                    string sessKey = HasColumn(deviceDt, "PhysicalSessionKey") ? row["PhysicalSessionKey"].ToString() : "";
                    sb.Append($"DEVICE:{row["DeviceId"]}|{row["Kind"]}|{row["DriverType"]}|{row["Transport"]}|{row["Endpoint"]}|{execMode}|{authId}|{bkId}|{sessKey};");
                }

                var channelDt = helper.GetDataTable("SELECT * FROM DeviceChannel ORDER BY DeviceId, ChannelId;");
@@ -630,6 +686,86 @@

        #endregion

        #region å‘布门禁（V3.0 Â§05）

        /// <summary>
        /// å‘布前校验执行位置绑定：仲裁域必填且合法、Broker åŸŸä¸€è‡´æ€§ã€ä¼šè¯å”¯ä¸€å®¿ä¸»ã€‚
        /// è¿”回错误列表，为空则允许发布。
        /// </summary>
        public List<string> ValidatePublishGate()
        {
            var errors = new List<string>();
            try
            {
                var devices = GetAllDevices();
                var authorityCatalog = V3AuthorityCatalog.AuthorityIds;

                // 1. é€è®¾å¤‡æ ¡éªŒæ‰§è¡Œä½ç½®å­—段
                foreach (var dev in devices)
                {
                    if (string.IsNullOrWhiteSpace(dev.AuthorityId))
                    {
                        errors.Add($"设备 [{dev.DeviceId}] æœªé€‰æ‹©ä»²è£åŸŸï¼ˆAuthorityId å¿…填，旧数据请重新保存）");
                        continue;
                    }
                    if (!authorityCatalog.Contains(dev.AuthorityId, StringComparer.OrdinalIgnoreCase))
                    {
                        errors.Add($"设备 [{dev.DeviceId}] ä»²è£åŸŸ [{dev.AuthorityId}] ä¸åœ¨é…ç½®æžšä¸¾å€™é€‰ä¸­");
                        continue;
                    }

                    if (dev.ExecutionMode == ExecutionModeKind.Local)
                    {
                        // Local è®¾å¤‡å¿…须由本机 Local åŸŸä»²è£ï¼ˆå·²åˆ†é…ç»™å”¯ä¸€æ‰§è¡Œè¿›ç¨‹ï¼‰
                        if (!V3AuthorityCatalog.IsLocalAuthority(dev.AuthorityId))
                        {
                            errors.Add($"设备 [{dev.DeviceId}] ä¸º Local ç›´è¿žï¼Œä»²è£åŸŸåº”为 local- å‰ç¼€ï¼Œå®žé™…为 [{dev.AuthorityId}]");
                        }
                    }
                    else
                    {
                        if (string.IsNullOrWhiteSpace(dev.BrokerId))
                        {
                            errors.Add($"设备 [{dev.DeviceId}] ä¸º Broker å…±äº«ï¼Œå¿…须指定 BrokerId");
                        }
                        else if (!V3AuthorityCatalog.BrokerIds.Contains(dev.BrokerId, StringComparer.OrdinalIgnoreCase))
                        {
                            errors.Add($"设备 [{dev.DeviceId}] BrokerId [{dev.BrokerId}] ä¸åœ¨é…ç½®æžšä¸¾å€™é€‰ä¸­");
                        }
                        // BrokerId ä¸Žè®¾å¤‡åŸŸä¸€è‡´ï¼šBroker è®¾å¤‡çš„ AuthorityId å³å…¶ Broker åŸŸ
                        else if (!string.Equals(dev.BrokerId, dev.AuthorityId, StringComparison.OrdinalIgnoreCase))
                        {
                            errors.Add($"设备 [{dev.DeviceId}] BrokerId [{dev.BrokerId}] ä¸Žä»²è£åŸŸ [{dev.AuthorityId}] ä¸ä¸€è‡´");
                        }
                        if (string.IsNullOrWhiteSpace(dev.PhysicalSessionKey))
                        {
                            errors.Add($"设备 [{dev.DeviceId}] ä¸º Broker å…±äº«ï¼Œå¿…须指定物理会话键 PhysicalSessionKey");
                        }
                    }
                }

                // 2. åŒä¸€ç‰©ç†ä¼šè¯åªèƒ½æœ‰ä¸€ä¸ªå®¿ä¸»ï¼šç›¸åŒ SessionKey çš„设备必须归属同一仲裁域
                var sessionGroups = devices
                    .Where(d => !string.IsNullOrWhiteSpace(d.PhysicalSessionKey))
                    .GroupBy(d => d.PhysicalSessionKey, StringComparer.OrdinalIgnoreCase);
                foreach (var grp in sessionGroups)
                {
                    var domains = grp.Select(d => d.AuthorityId).Distinct(StringComparer.OrdinalIgnoreCase).ToList();
                    if (domains.Count > 1)
                    {
                        errors.Add($"物理会话 [{grp.Key}] è¢«å¤šä¸ªä»²è£åŸŸå¼•ç”¨: {string.Join(", ", domains)}（同一会话只能有一个宿主）");
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception($"发布门禁校验失败: {ex.Message}", ex);
            }
            return errors;
        }

        #endregion

        #region è¾…助方法

        /// <summary>

 Plugin.DeviceConfig/Plugin.DeviceConfig.csproj

@@ -18,6 +18,11 @@
  </ItemGroup>

  <ItemGroup>
    <!-- V3AuthorityCatalog è¯»å–宿主 appSettings å€™é€‰æžšä¸¾ -->
    <Reference Include="System.Configuration" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\HMI.Base\HMI.Base.csproj" />
    <ProjectReference Include="..\HMI.Core\HMI.Core.csproj" />
    <ProjectReference Include="..\HMI.UI\HMI.UI.csproj" />

 Plugin.DeviceConfig/V3AuthorityCatalog.cs

New file
@@ -0,0 +1,52 @@
using System;
using System.Configuration;
using System.Linq;

namespace Plugin.DeviceConfig
{
    /// <summary>
    /// V3.0 ä»²è£åŸŸ / Broker å®¿ä¸»å€™é€‰æžšä¸¾ã€‚
    /// å€™é€‰å€¼ä»Žå®¿ä¸»é…ç½®æ–‡ä»¶ appSettings è¯»å–（键：V3.AuthorityIds / V3.BrokerIds，分号分隔），
    /// æœªé…ç½®æ—¶å›žé€€å†…置默认值，与 InfrastructureBootstrapper çš„本地仲裁域 "local-main" ä¿æŒä¸€è‡´ã€‚
    /// </summary>
    public static class V3AuthorityCatalog
    {
        private const string FallbackAuthorityIds = "local-main;broker-b01";
        private const string FallbackBrokerIds = "broker-b01";

        /// <summary>全部合法仲裁域标识（Local åŸŸä»¥ local- å‰ç¼€æ ‡è¯†ï¼ŒBroker åŸŸå³å„ Broker è‡ªèº«ï¼‰</summary>
        public static string[] AuthorityIds => Read("V3.AuthorityIds", FallbackAuthorityIds);

        /// <summary>全部合法 Broker å®¿ä¸»æ ‡è¯†</summary>
        public static string[] BrokerIds => Read("V3.BrokerIds", FallbackBrokerIds);

        /// <summary>本机默认 Local ä»²è£åŸŸï¼ˆå€™é€‰æžšä¸¾ä¸­ç¬¬ä¸€ä¸ª local- å‰ç¼€é¡¹ï¼‰</summary>
        public static string LocalAuthorityId =>
            AuthorityIds.FirstOrDefault(a => a.StartsWith("local-", StringComparison.OrdinalIgnoreCase))
            ?? AuthorityIds[0];

        /// <summary>判断给定标识是否为 Local ä»²è£åŸŸ</summary>
        public static bool IsLocalAuthority(string? authorityId) =>
            !string.IsNullOrWhiteSpace(authorityId) &&
            authorityId!.StartsWith("local-", StringComparison.OrdinalIgnoreCase);

        private static string[] Read(string key, string fallback)
        {
            string? raw = null;
            try
            {
                raw = ConfigurationManager.AppSettings[key];
            }
            catch
            {
                // å®¿ä¸»æœªæä¾›é…ç½®æ–‡ä»¶æ—¶é™é»˜å›žé€€é»˜è®¤æžšä¸¾
            }
            // net472 å¼•ç”¨ç¨‹åºé›†æ—  NotNullWhen æ ‡æ³¨ï¼Œæ˜¾å¼å›žé€€åŽè§£å¼•ç”¨
            var value = string.IsNullOrWhiteSpace(raw) ? fallback : raw!;
            return value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
                      .Select(s => s.Trim())
                      .Where(s => s.Length > 0)
                      .ToArray();
        }
    }
}

 Plugin.DeviceDebug/DeviceDebug.xaml

@@ -5,12 +5,10 @@
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:hb="clr-namespace:HMI.Base;assembly=HMI.Base"
             xmlns:ui="clr-namespace:HMI.UI;assembly=HMI.UI"
             xmlns:uic="clr-namespace:HMI.UI.Converter;assembly=HMI.UI"
             xmlns:pw="https://opensource.panuon.com/wpf"
             xmlns:pu="https://opensource.panuon.com/wpf-ui"
             xmlns:dp="clr-namespace:HMI.UI.DpUtil;assembly=HMI.UI"
             xmlns:local="clr-namespace:Plugin.DeviceDebug"
             xmlns:panels="clr-namespace:Plugin.DeviceDebug.Panels"
             mc:Ignorable="d"
             Loaded="SimpleMaskControl_Loaded"
             d:DesignHeight="600" d:DesignWidth="1000">
@@ -25,153 +23,34 @@
                <Setter Property="Padding" Value="8,4"/>
                <Setter Property="VerticalAlignment" Value="Center"/>
            </Style>
            <BooleanToVisibilityConverter x:Key="BoolToVis"/>
        </ResourceDictionary>
    </hb:SimpleMaskControl.Resources>

    <Grid dp:GridHelper.Space="8">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <!-- é¡¶éƒ¨æ ‡é¢˜æ  -->
        <!-- é¡¶éƒ¨ï¼šæ ‡é¢˜ + è®¾å¤‡é€‰æ‹© + åŠ å…¥/关闭 -->
        <DockPanel Grid.Row="0">
            <StackPanel dp:StackPanelHelper.ChildSpace="10" DockPanel.Dock="Right" Orientation="Horizontal">
                <ComboBox x:Name="deviceSelector" Width="240" 
                          ItemsSource="{Binding DeviceList}"
                          SelectedItem="{Binding SelectedDevice}"
                          SelectionChanged="DeviceSelector_SelectionChanged"
                          VerticalContentAlignment="Center" Padding="6,4"/>
                <Button x:Name="addDeviceBtn" Content="加入调试" Width="90" Height="28"
                        Click="AddDeviceBtn_Click"
                        Background="#4CAF50" Foreground="White" BorderThickness="0" Cursor="Hand" FontWeight="SemiBold"/>
                <Button x:Name="closeTabBtn" Content="关闭当前页" Width="100" Height="28"
                        Click="CloseTabBtn_Click"
                        Background="#FF5722" Foreground="White" BorderThickness="0" Cursor="Hand"/>
                <Button Style="{StaticResource RfhBtn}" x:Name="rfhBtn" Click="RfhBtn_Click"/>
            </StackPanel>
            <TextBlock Style="{StaticResource TitleBox}" Text="硬件调试"/>
            <TextBlock Style="{StaticResource TitleBox}" Text="硬件调试（可多设备并发）"/>
        </DockPanel>

        <!-- è®¾å¤‡ä¿¡æ¯æ  -->
        <Border Grid.Row="1" BorderBrush="#CCCCCC" BorderThickness="1" Padding="10,6" Background="#F9F9F9"
                Visibility="{Binding HasDevice, Converter={StaticResource BoolToVis}}">
            <WrapPanel dp:StackPanelHelper.ChildSpace="20">
                <StackPanel Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="4">
                    <TextBlock Text="设备ID:" FontWeight="Bold" Foreground="#555"/>
                    <TextBlock Text="{Binding CurrentDeviceId}" Style="{StaticResource ListTableTextBlock}"/>
                </StackPanel>
                <StackPanel Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="4">
                    <TextBlock Text="型号:" FontWeight="Bold" Foreground="#555"/>
                    <TextBlock Text="{Binding CurrentDeviceKind}" Style="{StaticResource ListTableTextBlock}"/>
                </StackPanel>
                <StackPanel Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="4">
                    <TextBlock Text="连接状态:" FontWeight="Bold" Foreground="#555"/>
                    <TextBlock Text="{Binding ConnectionStateText}" Foreground="{Binding ConnectionBrush}"/>
                </StackPanel>
                <StackPanel Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="4">
                    <TextBlock Text="版本:" FontWeight="Bold" Foreground="#555"/>
                    <TextBlock Text="{Binding CurrentEffectiveVersion}" Style="{StaticResource ListTableTextBlock}"/>
                </StackPanel>
                <StackPanel Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="4">
                    <TextBlock Text="预约状态:" FontWeight="Bold" Foreground="#555"/>
                    <TextBlock Text="{Binding ReservationStatusText}" Style="{StaticResource ListTableTextBlock}"/>
                </StackPanel>
                <StackPanel Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="4">
                    <TextBlock Text="会话状态:" FontWeight="Bold" Foreground="#555"/>
                    <TextBlock Text="{Binding SessionStateText}" Foreground="{Binding SessionStateBrush}" FontWeight="Bold"/>
                </StackPanel>
            </WrapPanel>
        </Border>

        <!-- æ“ä½œæŒ‰é’®æ  -->
        <StackPanel Grid.Row="2" Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="10"
                    Visibility="{Binding HasDevice, Converter={StaticResource BoolToVis}}">
            <Button x:Name="enterMaintenanceBtn" Content="进入维护控制" Padding="14,6"
                    IsEnabled="{Binding CanEnterMaintenance}"
                    Click="EnterMaintenanceBtn_Click"
                    Background="#2196F3" Foreground="White" BorderThickness="0" Cursor="Hand"/>
            <Button x:Name="exitMaintenanceBtn" Content="退出维护" Padding="14,6"
                    IsEnabled="{Binding CanExitMaintenance}"
                    Click="ExitMaintenanceBtn_Click"
                    Background="#FF5722" Foreground="White" BorderThickness="0" Cursor="Hand"/>
        </StackPanel>

        <!-- ä¸»ä½“区域 -->
        <Grid Grid.Row="3">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*"/>
                <ColumnDefinition Width="350"/>
            </Grid.ColumnDefinitions>

            <!-- å·¦ä¾§é¢æ¿å®¹å™¨ -->
            <Border Grid.Column="0" BorderBrush="#DDDDDD" BorderThickness="1" Margin="0,0,8,0">
                <ContentControl x:Name="panelContainer">
                    <TextBlock Text="请选择设备" HorizontalAlignment="Center" VerticalAlignment="Center"
                               FontSize="16" Foreground="#999"/>
                </ContentControl>
            </Border>

            <!-- å³ä¾§æ“ä½œæ—¥å¿— -->
            <Border Grid.Column="1" BorderBrush="#DDDDDD" BorderThickness="1">
                <Grid>
                    <Grid.RowDefinitions>
                        <RowDefinition Height="Auto"/>
                        <RowDefinition Height="*"/>
                    </Grid.RowDefinitions>
                    <Border Grid.Row="0" Background="#F0F0F0" Padding="8,6">
                        <TextBlock Text="操作日志" FontWeight="Bold" FontSize="14"/>
                    </Border>
                    <ListView Grid.Row="1" x:Name="operationLogList"
                              ItemsSource="{Binding OperationLogs}"
                              Style="{StaticResource DefaultListTable}"
                              VirtualizingPanel.IsVirtualizing="True"
                              VirtualizingPanel.VirtualizationMode="Standard">
                        <ListView.View>
                            <GridView AllowsColumnReorder="False">
                                <GridViewColumn Width="60" Header="类型">
                                    <GridViewColumn.CellTemplate>
                                        <DataTemplate>
                                            <Border Style="{StaticResource CellBorder}">
                                                <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                           Text="{Binding CommandType}"/>
                                            </Border>
                                        </DataTemplate>
                                    </GridViewColumn.CellTemplate>
                                </GridViewColumn>
                                <GridViewColumn Width="120" Header="参数">
                                    <GridViewColumn.CellTemplate>
                                        <DataTemplate>
                                            <Border Style="{StaticResource CellBorder}">
                                                <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                           Text="{Binding Parameters}" TextTrimming="CharacterEllipsis"
                                                           ToolTip="{Binding Parameters}"/>
                                            </Border>
                                        </DataTemplate>
                                    </GridViewColumn.CellTemplate>
                                </GridViewColumn>
                                <GridViewColumn Width="60" Header="结果">
                                    <GridViewColumn.CellTemplate>
                                        <DataTemplate>
                                            <Border Style="{StaticResource CellBorder}">
                                                <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                           Text="{Binding Outcome}"/>
                                            </Border>
                                        </DataTemplate>
                                    </GridViewColumn.CellTemplate>
                                </GridViewColumn>
                                <GridViewColumn Width="100" Header="时间">
                                    <GridViewColumn.CellTemplate>
                                        <DataTemplate>
                                            <Border Style="{StaticResource CellBorder}">
                                                <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                           Text="{Binding Timestamp, StringFormat=HH:mm:ss}"/>
                                            </Border>
                                        </DataTemplate>
                                    </GridViewColumn.CellTemplate>
                                </GridViewColumn>
                            </GridView>
                        </ListView.View>
                    </ListView>
                </Grid>
            </Border>
        </Grid>
        <!-- å¤šè®¾å¤‡æ ‡ç­¾åŒº -->
        <TabControl Grid.Row="1" x:Name="debugTabs" Background="White" BorderThickness="0"/>
    </Grid>
</hb:SimpleMaskControl>

 Plugin.DeviceDebug/DeviceDebug.xaml.cs

@@ -4,58 +4,41 @@
using HMI.Core.Util;
using HMI.UI.Util;
using log4net;
using Plugin.DeviceDebug.Entity;
using Plugin.DeviceDebug.Model;
using Plugin.DeviceDebug.Panels;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace Plugin.DeviceDebug
{
    /// <summary>
    /// DeviceDebug.xaml çš„交互逻辑
    /// ç¡¬ä»¶è°ƒè¯•æ’件（壳）：装配并持有共享基础设施（会话管理器/设备服务/配置库路径），
    /// ä»¥ TabControl æ‰¿è½½å¤šä¸ª <see cref="DeviceDebugTab"/>，支持同时调试多个设备，
    /// æ¯ä¸ª Tab æ‹¥æœ‰ç‹¬ç«‹ä¼šè¯ä¸Žç»´æŠ¤ç§Ÿçº¦ã€‚设备下拉仅列出尚未打开的设备。
    /// </summary>
    [ObservableObject]
    public partial class DeviceDebug : SimpleMaskControl
    {
        private static readonly ILog _log = LogManager.GetLogger(typeof(DeviceDebug));
        private static readonly ILog log = LogManager.GetLogger(typeof(DeviceDebug));
        private DeviceDebugModel _debugModel;
        private DebugSessionManager _sessionManager;

        // åŸºç¡€è®¾æ–½å±‚服务
        private IDeviceManager? _deviceManager;
        private IDeviceService? _deviceService;
        private IResourceManager? _resourceManager;
        private IDeviceManager _deviceManager;
        private IDeviceService _deviceService;
        private IResourceManager _resourceManager;

        // è®¾å¤‡é…ç½®æ•°æ®åº“路径（与 DeviceConfig æ’件共享）
        private string _deviceConfigDbPath;

        // å…¨é‡è®¾å¤‡ï¼ˆ"id [kind]"）与已打开标签映射（deviceId â†’ TabItem）
        private readonly List<string> _allDevices = new();
        private readonly Dictionary<string, TabItem> _openTabs = new(StringComparer.OrdinalIgnoreCase);

        [ObservableProperty] private ObservableCollection<string> _deviceList = new();
        [ObservableProperty] private string _selectedDevice;
        [ObservableProperty] private DebugSession _currentSession;
        [ObservableProperty] private ObservableCollection<DebugOperation> _operationLogs = new();
        [ObservableProperty] private string _connectionStateText = "未连接";
        [ObservableProperty] private string _sessionStateText = "";
        [ObservableProperty] private string _reservationStatusText = "";
        [ObservableProperty] private string _currentDeviceId = "";
        [ObservableProperty] private string _currentDeviceKind = "";
        [ObservableProperty] private string _currentEffectiveVersion = "";
        [ObservableProperty] private string _currentEndpoint = "";
        [ObservableProperty] private string _currentDriverType = "";
        [ObservableProperty] private Brush _connectionBrush = new SolidColorBrush(Colors.Gray);
        [ObservableProperty] private Brush _sessionStateBrush = new SolidColorBrush(Colors.Gray);
        [ObservableProperty] private bool _canEnterMaintenance;
        [ObservableProperty] private bool _canExitMaintenance;
        [ObservableProperty] private bool _hasDevice;

        // ç¼“存当前选中的设备类型
        private string _currentDeviceKindStr;

        public DeviceDebug()
        {
@@ -63,13 +46,10 @@
            InitializeComponent();
        }

        /// <summary>
        /// å¼ºåˆ¶åˆ·æ–°è®¾å¤‡åˆ—表（供集成测试预置设备后调用）
        /// </summary>
        public void ForceRefreshForTest()
        {
            try { LoadDeviceList(); }
            catch (Exception ex) { _log.Error("ForceRefreshForTest Error.", ex); }
            catch (Exception ex) { log.Error("ForceRefreshForTest Error.", ex); }
        }

        public override void InitFinish()
@@ -77,21 +57,16 @@
            base.InitFinish();
            try
            {
                // åˆå§‹åŒ–调试数据库
                _debugModel = new DeviceDebugModel();
                string dbPath = Path.Combine(BaseFolder, "debug.db");
                _debugModel.InitDatabase(dbPath);

                // ä»Ž UtilContainer èŽ·å–基础设施服务
                var container = new UtilContainer();
                _deviceManager = container.GetUtil<IDeviceManager>("DeviceManager");
                _deviceService = container.GetUtil<IDeviceService>("DeviceService");
                _resourceManager = container.GetUtil<IResourceManager>("ResourceManager");

                // åˆ›å»ºä¼šè¯ç®¡ç†å™¨ï¼ˆä¼ å…¥ ResourceManager）
                _sessionManager = new DebugSessionManager(_debugModel, _resourceManager);

                // è®¾å¤‡é…ç½®æ•°æ®åº“路径（与 DeviceConfig å…±äº«ï¼‰
                _deviceConfigDbPath = Path.Combine(BaseFolder, "data.db");

                log.Info("硬件调试模块初始化完成");
@@ -103,9 +78,14 @@
            }
        }

        /// <summary>
        /// åŠ è½½è®¾å¤‡åˆ—表
        /// </summary>
        private void SimpleMaskControl_Loaded(object sender, RoutedEventArgs e)
        {
            LoadDeviceList();
            Loaded -= SimpleMaskControl_Loaded;
        }

        private void RfhBtn_Click(object sender, RoutedEventArgs e) => LoadDeviceList();

        private void LoadDeviceList()
        {
            try
@@ -120,16 +100,12 @@
                var sqliteHelper = new SqliteHelper(_deviceConfigDbPath);
                var dt = sqliteHelper.GetDataTable("SELECT DeviceId, Kind FROM DeviceDefinition ORDER BY DeviceId");

                var list = new ObservableCollection<string>();
                _allDevices.Clear();
                foreach (System.Data.DataRow row in dt.Rows)
                {
                    string deviceId = row["DeviceId"].ToString();
                    string kind = row["Kind"].ToString();
                    list.Add($"{deviceId} [{kind}]");
                }
                    _allDevices.Add($"{row["DeviceId"]} [{row["Kind"]}]");

                DeviceList = list;
                log.Info($"加载设备列表完成，共 {list.Count} ä¸ªè®¾å¤‡");
                RefreshAvailableList();
                log.Info($"加载设备列表完成，共 {_allDevices.Count} ä¸ªè®¾å¤‡");
            }
            catch (Exception ex)
            {
@@ -138,20 +114,23 @@
            }
        }

        /// <summary>
        /// è§£æžè®¾å¤‡é€‰æ‹©å­—符串，获取 DeviceId
        /// </summary>
        private string ParseDeviceId(string selection)
        /// <summary>下拉仅列出未打开的设备（一会一设备）。</summary>
        private void RefreshAvailableList()
        {
            var avail = _allDevices
                .Where(d => !_openTabs.ContainsKey(ParseDeviceId(d)))
                .ToList();
            DeviceList = new ObservableCollection<string>(avail);
        }

        private static string ParseDeviceId(string selection)
        {
            if (string.IsNullOrEmpty(selection)) return string.Empty;
            int idx = selection.IndexOf(" [");
            return idx > 0 ? selection.Substring(0, idx) : selection;
        }

        /// <summary>
        /// è§£æžè®¾å¤‡é€‰æ‹©å­—符串，获取 Kind
        /// </summary>
        private string ParseDeviceKind(string selection)
        private static string ParseDeviceKind(string selection)
        {
            if (string.IsNullOrEmpty(selection)) return string.Empty;
            int start = selection.IndexOf(" [");
@@ -161,508 +140,64 @@
            return string.Empty;
        }

        /// <summary>
        /// åŠ è½½è®¾å¤‡è¯¦ç»†ä¿¡æ¯
        /// </summary>
        private void LoadDeviceInfo(string deviceId)
        {
            try
            {
                if (!File.Exists(_deviceConfigDbPath)) return;

                var sqliteHelper = new SqliteHelper(_deviceConfigDbPath);
                var dt = sqliteHelper.GetDataTable(
                    $"SELECT DeviceId, Kind, EffectiveVersion, Endpoint, DriverType FROM DeviceDefinition WHERE DeviceId = '{deviceId}'");

                if (dt.Rows.Count > 0)
                {
                    var row = dt.Rows[0];
                    CurrentDeviceId = row["DeviceId"].ToString();
                    CurrentDeviceKind = row["Kind"].ToString();
                    CurrentEffectiveVersion = row["EffectiveVersion"]?.ToString() ?? "";
                    CurrentEndpoint = row["Endpoint"]?.ToString() ?? "";
                    CurrentDriverType = row["DriverType"]?.ToString() ?? "";

                    // ç¼“存设备类型
                    _currentDeviceKindStr = CurrentDeviceKind;
                }
            }
            catch (Exception ex)
            {
                log.Error($"加载设备信息失败: {deviceId}", ex);
            }
        }

        /// <summary>
        /// é€‰æ‹©è®¾å¤‡æ—¶ï¼šæ‰“开会话（ReadOnly），加载对应面板
        /// </summary>
        private void OnDeviceSelected()
        private void AddDeviceBtn_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (string.IsNullOrEmpty(SelectedDevice))
                {
                    HasDevice = false;
                    panelContainer.Content = new TextBlock
                    {
                        Text = "请选择设备",
                        HorizontalAlignment = HorizontalAlignment.Center,
                        VerticalAlignment = VerticalAlignment.Center,
                        FontSize = 16,
                        Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#999"))
                    };
                    ToastHelper.Warning("请先在设备下拉中选择设备");
                    return;
                }

                string deviceId = ParseDeviceId(SelectedDevice);
                string kind = ParseDeviceKind(SelectedDevice);

                // åŠ è½½è®¾å¤‡è¯¦ç»†ä¿¡æ¯
                LoadDeviceInfo(deviceId);

                HasDevice = true;

                // æ‰“开会话（ReadOnly）
                CurrentSession = _sessionManager.OpenSession(deviceId, "", "operator", CurrentEffectiveVersion);

                // é€šè¿‡ DeviceManager è¿žæŽ¥è®¾å¤‡
                if (_deviceManager != null)
                // å·²æ‰“开则聚焦其 Tab（防御性：下拉本已过滤）
                if (_openTabs.TryGetValue(deviceId, out var existing))
                {
                    try
                    {
                        _deviceManager.ConnectAsync(deviceId, CancellationToken.None)
                            .GetAwaiter().GetResult();
                        ConnectionStateText = "已连接";
                        ConnectionBrush = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#4CAF50"));
                    }
                    catch (Exception ex)
                    {
                        log.Warn($"通过 DeviceManager è¿žæŽ¥è®¾å¤‡å¤±è´¥: {ex.Message}");
                        ConnectionStateText = "连接失败";
                        ConnectionBrush = new SolidColorBrush(Colors.OrangeRed);
                    }
                }

                // åŠ è½½æ“ä½œæ—¥å¿—
                LoadOperationLogs();

                // æ›´æ–°æŒ‰é’®çŠ¶æ€
                UpdateButtonStates();

                // åŠ è½½å¯¹åº”面板
                LoadPanel(kind);

                log.Info($"已选择设备: {deviceId}, ç±»åž‹: {kind}");
            }
            catch (Exception ex)
            {
                log.Error("选择设备失败", ex);
                ToastHelper.Error($"选择设备失败: {ex.Message}");
            }
        }

        /// <summary>
        /// æ ¹æ®è®¾å¤‡ç±»åž‹åŠ è½½å¯¹åº”的调试面板
        /// </summary>
        private void LoadPanel(string deviceKind)
        {
            try
            {
                UIElement panel = null;

                switch (deviceKind)
                {
                    case "PowerSupply":
                        var powerPanel = new PowerSupplyDebugPanel();
                        powerPanel.IsMaintenanceMode = CurrentSession?.State == DebugSessionState.MaintenanceActive;
                        powerPanel.OnCommandExecute += Panel_OnCommandExecute;
                        panel = powerPanel;
                        break;
                    case "CanDevice":
                        var canPanel = new CanDebugPanel
                        {
                            DeviceId = CurrentDeviceId,
                            InitialBusName = ParseCanBusName(CurrentEndpoint),
                            InitialNodeIndex = ParseCanNodeIndex(CurrentEndpoint),
                            AutoConnectOnLoad = true
                        };
                        canPanel.IsMaintenanceMode = CurrentSession?.State == DebugSessionState.MaintenanceActive;
                        canPanel.OnCommandExecute += Panel_OnCommandExecute;
                        panel = canPanel;
                        break;
                    case "PlcDevice":
                        var plcPanel = new PlcDebugPanel();
                        plcPanel.IsMaintenanceMode = CurrentSession?.State == DebugSessionState.MaintenanceActive;
                        plcPanel.OnCommandExecute += Panel_OnCommandExecute;
                        panel = plcPanel;
                        break;
                    default:
                        panel = new TextBlock
                        {
                            Text = $"不支持的设备类型: {deviceKind}",
                            HorizontalAlignment = HorizontalAlignment.Center,
                            VerticalAlignment = VerticalAlignment.Center,
                            FontSize = 14,
                            Foreground = new SolidColorBrush(Colors.OrangeRed)
                        };
                        break;
                }

                panelContainer.Content = panel;
            }
            catch (Exception ex)
            {
                log.Error($"加载调试面板失败: {deviceKind}", ex);
                ToastHelper.Error($"加载面板失败: {ex.Message}");
            }
        }

        /// <summary>
        /// é¢æ¿å‘½ä»¤æ‰§è¡Œäº‹ä»¶å¤„理
        /// </summary>
        private void Panel_OnCommandExecute(object sender, DebugCommand command)
        {
            try
            {
                if (CurrentSession == null)
                {
                    ToastHelper.Warning("请先选择设备");
                    return;
                }

                // éªŒè¯å‘½ä»¤æƒé™
                if (!_sessionManager.ValidateCommand(CurrentSession.SessionId, command))
                {
                    ToastHelper.Warning("当前会话状态不允许执行此操作，请先进入维护模式");
                    return;
                }

                // é€šè¿‡ DeviceService æ‰§è¡Œå®žé™…命令
                if (_deviceService != null)
                {
                    ExecuteViaDeviceService(command);
                }
                else
                {
                    // é™çº§æ¨¡å¼ï¼šåŸºç¡€è®¾æ–½æœªåˆå§‹åŒ–时保留原有行为
                    log.Warn("DeviceService æœªåˆå§‹åŒ–，使用降级模式记录命令");
                    ExecuteFallback(command);
                }
            }
            catch (Exception ex)
            {
                log.Error($"执行命令失败: {command.CommandType}", ex);
                ToastHelper.Error($"命令执行失败: {ex.Message}");

                // è®°å½•å¤±è´¥æ“ä½œ
                var operation = new DebugOperation
                {
                    SessionId = CurrentSession?.SessionId ?? "",
                    CommandType = command.CommandType,
                    Parameters = SerializeParameters(command),
                    Outcome = "Failed",
                    ErrorMessage = ex.Message,
                    Timestamp = DateTime.Now
                };
                _debugModel.RecordOperation(operation);
                OperationLogs.Insert(0, operation);
            }
        }

        /// <summary>
        /// é€šè¿‡ DeviceService æ‰§è¡Œè®¾å¤‡å‘½ä»¤
        /// </summary>
        private void ExecuteViaDeviceService(DebugCommand command)
        {
            try
            {
                var ownerToken = new ResourceOwnerToken(
                    OwnerType.Maintenance,
                    CurrentSession.SessionId);

                var deviceCommand = BuildDeviceCommand(command);

                var result = _deviceService.ExecuteCommandAsync(
                    command.DeviceId,
                    deviceCommand,
                    ownerToken,
                    CancellationToken.None).GetAwaiter().GetResult();

                var operation = new DebugOperation
                {
                    SessionId = CurrentSession.SessionId,
                    CommandType = command.CommandType,
                    Parameters = SerializeParameters(command),
                    Outcome = result.Success ? "Success" : "Failed",
                    DeviceReadback = result.Readback ?? "",
                    ErrorCode = result.ErrorCode ?? "",
                    ErrorMessage = result.ErrorMessage ?? "",
                    Timestamp = DateTime.Now
                };

                _debugModel.RecordOperation(operation);
                OperationLogs.Insert(0, operation);

                if (result.Success)
                    ToastHelper.Success($"命令 {command.CommandType} æ‰§è¡ŒæˆåŠŸ");
                else
                    ToastHelper.Warning($"命令执行失败: {result.ErrorMessage}");

                log.Info($"执行命令: {command.CommandType}, è®¾å¤‡: {command.DeviceId}, ç»“æžœ: {(result.Success ? "成功" : "失败")}");
            }
            catch (Exception ex)
            {
                log.Error($"DeviceService æ‰§è¡Œå‘½ä»¤å¤±è´¥: {ex.Message}", ex);
                ToastHelper.Error($"设备通信失败: {ex.Message}");

                var operation = new DebugOperation
                {
                    SessionId = CurrentSession.SessionId,
                    CommandType = command.CommandType,
                    Parameters = SerializeParameters(command),
                    Outcome = "Failed",
                    ErrorMessage = ex.Message,
                    Timestamp = DateTime.Now
                };
                _debugModel.RecordOperation(operation);
                OperationLogs.Insert(0, operation);
            }
        }

        /// <summary>
        /// é™çº§æ¨¡å¼ï¼šæ—  DeviceService æ—¶çš„后备处理
        /// </summary>
        private void ExecuteFallback(DebugCommand command)
        {
            var operation = new DebugOperation
            {
                SessionId = CurrentSession.SessionId,
                CommandType = command.CommandType,
                Parameters = SerializeParameters(command),
                Outcome = "Success",
                Timestamp = DateTime.Now
            };

            _debugModel.RecordOperation(operation);
            OperationLogs.Insert(0, operation);

            ToastHelper.Success($"命令 {command.CommandType} å·²å‘送（降级模式）");
            log.Info($"[降级模式] æ‰§è¡Œå‘½ä»¤: {command.CommandType}, è®¾å¤‡: {command.DeviceId}");
        }

        /// <summary>
        /// æ ¹æ®å‘½ä»¤ç±»åž‹æž„建实际设备命令字符串
        /// </summary>
        private string BuildDeviceCommand(DebugCommand command)
        {
            if (command is PowerSetCommand psc)
            {
                return $"VOLT {psc.Voltage};CURR {psc.CurrentLimit};OUTP {(psc.Output ? "ON" : "OFF")}";
            }
            else if (command is PowerMeasureCommand)
            {
                return "MEAS:ALL?";
            }
            else if (command is CanSendCommand csc)
            {
                return $"CAN:SEND {csc.Frame}";
            }
            else if (command is PlcWriteCommand pwc)
            {
                return $"WRITE:{pwc.IoAddress}:{(pwc.Value ? "TRUE" : "FALSE")}";
            }
            return command.CommandType;
        }

        /// <summary>
        /// åºåˆ—化命令参数为JSON字符串
        /// </summary>
        private string SerializeParameters(DebugCommand command)
        {
            try
            {
                switch (command)
                {
                    case PowerSetCommand psc:
                        return $"{{Voltage:{psc.Voltage},CurrentLimit:{psc.CurrentLimit},Output:{psc.Output}}}";
                    case PowerMeasureCommand _:
                        return "{}";
                    case CanSendCommand csc:
                        return $"{{Frame:{csc.Frame},Data:{BitConverter.ToString(csc.Data)}}}";
                    case PlcWriteCommand pwc:
                        return $"{{IoAddress:{pwc.IoAddress},Value:{pwc.Value}}}";
                    default:
                        return "{}";
                }
            }
            catch
            {
                return "{}";
            }
        }

        /// <summary>
        /// åŠ è½½æ“ä½œæ—¥å¿—
        /// </summary>
        private void LoadOperationLogs()
        {
            try
            {
                if (CurrentSession == null) return;

                var ops = _debugModel.GetOperationsBySession(CurrentSession.SessionId);
                OperationLogs = new ObservableCollection<DebugOperation>(ops.Take(100));
            }
            catch (Exception ex)
            {
                log.Error("加载操作日志失败", ex);
            }
        }

        /// <summary>
        /// æ›´æ–°æŒ‰é’®å¯ç”¨çŠ¶æ€
        /// </summary>
        private void UpdateButtonStates()
        {
            if (CurrentSession == null)
            {
                CanEnterMaintenance = false;
                CanExitMaintenance = false;
                SessionStateText = "";
                return;
            }

            var state = CurrentSession.State;
            CanEnterMaintenance = state == DebugSessionState.ReadOnly;
            CanExitMaintenance = state == DebugSessionState.MaintenanceActive;

            // æ›´æ–°ä¼šè¯çŠ¶æ€æ–‡æœ¬å’Œé¢œè‰²
            SessionStateText = state.ToString();
            SessionStateBrush = state switch
            {
                DebugSessionState.ReadOnly => new SolidColorBrush((Color)ColorConverter.ConvertFromString("#2196F3")),
                DebugSessionState.MaintenanceActive => new SolidColorBrush((Color)ColorConverter.ConvertFromString("#4CAF50")),
                DebugSessionState.Faulted => new SolidColorBrush(Colors.Red),
                DebugSessionState.RecoveryRequired => new SolidColorBrush(Colors.Orange),
                _ => new SolidColorBrush(Colors.Gray)
            };

            // æ›´æ–°é¢æ¿çš„维护模式
            if (panelContainer.Content is PowerSupplyDebugPanel powerPanel)
                powerPanel.IsMaintenanceMode = state == DebugSessionState.MaintenanceActive;
            else if (panelContainer.Content is CanDebugPanel canPanel)
                canPanel.IsMaintenanceMode = state == DebugSessionState.MaintenanceActive;
            else if (panelContainer.Content is PlcDebugPanel plcPanel)
                plcPanel.IsMaintenanceMode = state == DebugSessionState.MaintenanceActive;
        }

        #region äº‹ä»¶å¤„理

        private void SimpleMaskControl_Loaded(object sender, RoutedEventArgs e)
        {
            LoadDeviceList();
            Loaded -= SimpleMaskControl_Loaded;
        }

        private void DeviceSelector_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            OnDeviceSelected();
        }

        private void RfhBtn_Click(object sender, RoutedEventArgs e)
        {
            LoadDeviceList();
        }

        private void EnterMaintenanceBtn_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (CurrentSession == null) return;

                // è¯·æ±‚维护模式
                if (_sessionManager.RequestMaintenance(CurrentSession.SessionId))
                {
                    // æ¿€æ´»ç»´æŠ¤æ¨¡å¼
                    _sessionManager.ActivateMaintenance(CurrentSession.SessionId);
                    UpdateButtonStates();

                    // é‡æ–°åŠ è½½é¢æ¿ä»¥æ›´æ–°IsMaintenanceMode
                    LoadPanel(CurrentDeviceKind);

                    ToastHelper.Success("已进入维护控制模式");
                    log.Info($"会话 {CurrentSession.SessionId} è¿›å…¥ç»´æŠ¤æ¨¡å¼");
                }
                else
                {
                    ToastHelper.Warning("无法进入维护模式，请检查设备状态");
                }
            }
            catch (Exception ex)
            {
                log.Error("进入维护模式失败", ex);
                ToastHelper.Error($"进入维护模式失败: {ex.Message}");
            }
        }

        private void ExitMaintenanceBtn_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (CurrentSession == null) return;

                if (MsgBoxHelper.WarnMessage(Window.GetWindow(this), "确定要退出维护模式吗？") == MessageBoxResult.OK)
                {
                    _sessionManager.CloseSession(CurrentSession.SessionId);
                    CurrentSession = null;
                    UpdateButtonStates();

                    // æ¸…空面板
                    panelContainer.Content = new TextBlock
                    {
                        Text = "请选择设备",
                        HorizontalAlignment = HorizontalAlignment.Center,
                        VerticalAlignment = VerticalAlignment.Center,
                        FontSize = 16,
                        Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#999"))
                    };

                    HasDevice = false;
                    debugTabs.SelectedItem = existing;
                    SelectedDevice = null;

                    ToastHelper.Success("已退出维护模式");
                    log.Info("已退出维护模式");
                    return;
                }

                var tabContent = new DeviceDebugTab();
                tabContent.Initialize(_debugModel, _sessionManager, _deviceManager, _deviceService,
                    _deviceConfigDbPath, deviceId, kind);

                var tab = new TabItem { Header = deviceId, Content = tabContent, Tag = deviceId };
                debugTabs.Items.Add(tab);
                debugTabs.SelectedItem = tab;
                _openTabs[deviceId] = tab;

                RefreshAvailableList();
                SelectedDevice = null;
                log.Info($"已加入调试设备: {deviceId}（当前 {debugTabs.Items.Count} ä¸ªæ ‡ç­¾ï¼‰");
            }
            catch (Exception ex)
            {
                log.Error("退出维护模式失败", ex);
                ToastHelper.Error($"退出维护模式失败: {ex.Message}");
                log.Error("加入调试设备失败", ex);
                ToastHelper.Error($"加入调试失败: {ex.Message}");
            }
        }

        /// <summary>
        /// ä»Ž CAN Endpoint è§£æžæ€»çº¿åç§°ï¼ˆæ ¼å¼: æ€»çº¿å:节点编号）
        /// </summary>
        private string ParseCanBusName(string endpoint)
        private void CloseTabBtn_Click(object sender, RoutedEventArgs e)
        {
            if (string.IsNullOrEmpty(endpoint)) return "CAN_BUS_1";
            int idx = endpoint.IndexOf(':');
            return idx > 0 ? endpoint.Substring(0, idx) : endpoint;
        }

        /// <summary>
        /// ä»Ž CAN Endpoint è§£æžèŠ‚点编号
        /// </summary>
        private int? ParseCanNodeIndex(string endpoint)
            try
        {
            if (string.IsNullOrEmpty(endpoint)) return 0;
            int idx = endpoint.IndexOf(':');
            if (idx > 0 && idx < endpoint.Length - 1 && int.TryParse(endpoint.Substring(idx + 1), out int n))
                return n;
            return 0;
                if (debugTabs.SelectedItem is not TabItem tab) return;
                string deviceId = tab.Tag as string ?? "";
                if (tab.Content is DeviceDebugTab content)
                    content.CloseSessionSilently();   // å…³é—­å³é‡Šæ”¾ç»´æŠ¤ç§Ÿçº¦ï¼Œæœç»æ³„漏
                debugTabs.Items.Remove(tab);
                if (!string.IsNullOrEmpty(deviceId)) _openTabs.Remove(deviceId);
                RefreshAvailableList();
                log.Info($"已关闭调试标签并释放会话: {deviceId}");
        }

        #endregion
            catch (Exception ex)
            {
                log.Error("关闭调试标签失败", ex);
                ToastHelper.Error($"关闭失败: {ex.Message}");
            }
        }
    }
}

 Plugin.DeviceDebug/DeviceDebugTab.xaml

New file
@@ -0,0 +1,113 @@
<UserControl x:Class="Plugin.DeviceDebug.DeviceDebugTab"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:ui="clr-namespace:HMI.UI;assembly=HMI.UI"
             xmlns:pw="https://opensource.panuon.com/wpf"
             xmlns:pu="https://opensource.panuon.com/wpf-ui"
             xmlns:dp="clr-namespace:HMI.UI.DpUtil;assembly=HMI.UI"
             mc:Ignorable="d"
             d:DesignHeight="600" d:DesignWidth="1000">
    <UserControl.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="/HMI.UI;component/Style/PanuonListView.xaml"/>
            </ResourceDictionary.MergedDictionaries>
            <BooleanToVisibilityConverter x:Key="BoolToVis"/>
        </ResourceDictionary>
    </UserControl.Resources>

    <Grid dp:GridHelper.Space="8">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <!-- è®¾å¤‡ä¿¡æ¯æ  -->
        <Border Grid.Row="0" BorderBrush="#CCCCCC" BorderThickness="1" Padding="10,6" Background="#F9F9F9"
                Visibility="{Binding HasDevice, Converter={StaticResource BoolToVis}}">
            <WrapPanel dp:StackPanelHelper.ChildSpace="20">
                <StackPanel Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="4">
                    <TextBlock Text="设备ID:" FontWeight="Bold" Foreground="#555"/>
                    <TextBlock Text="{Binding CurrentDeviceId}" Style="{StaticResource ListTableTextBlock}"/>
                </StackPanel>
                <StackPanel Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="4">
                    <TextBlock Text="型号:" FontWeight="Bold" Foreground="#555"/>
                    <TextBlock Text="{Binding CurrentDeviceKind}" Style="{StaticResource ListTableTextBlock}"/>
                </StackPanel>
                <StackPanel Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="4">
                    <TextBlock Text="连接状态:" FontWeight="Bold" Foreground="#555"/>
                    <TextBlock Text="{Binding ConnectionStateText}" Foreground="{Binding ConnectionBrush}"/>
                </StackPanel>
                <StackPanel Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="4">
                    <TextBlock Text="版本:" FontWeight="Bold" Foreground="#555"/>
                    <TextBlock Text="{Binding CurrentEffectiveVersion}" Style="{StaticResource ListTableTextBlock}"/>
                </StackPanel>
                <StackPanel Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="4">
                    <TextBlock Text="预约状态:" FontWeight="Bold" Foreground="#555"/>
                    <TextBlock Text="{Binding ReservationStatusText}" Style="{StaticResource ListTableTextBlock}"/>
                </StackPanel>
                <StackPanel Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="4">
                    <TextBlock Text="会话状态:" FontWeight="Bold" Foreground="#555"/>
                    <TextBlock Text="{Binding SessionStateText}" Foreground="{Binding SessionStateBrush}" FontWeight="Bold"/>
                </StackPanel>
            </WrapPanel>
        </Border>

        <!-- æ“ä½œæŒ‰é’®æ  -->
        <StackPanel Grid.Row="1" Orientation="Horizontal" dp:StackPanelHelper.ChildSpace="10"
                    Visibility="{Binding HasDevice, Converter={StaticResource BoolToVis}}">
            <Button x:Name="enterMaintenanceBtn" Content="进入维护控制" Padding="14,6"
                    IsEnabled="{Binding CanEnterMaintenance}"
                    Click="EnterMaintenanceBtn_Click"
                    Background="#2196F3" Foreground="White" BorderThickness="0" Cursor="Hand"/>
            <Button x:Name="exitMaintenanceBtn" Content="退出维护" Padding="14,6"
                    IsEnabled="{Binding CanExitMaintenance}"
                    Click="ExitMaintenanceBtn_Click"
                    Background="#FF5722" Foreground="White" BorderThickness="0" Cursor="Hand"/>
        </StackPanel>

        <!-- ä¸»ä½“区域：左面板 + å³æ—¥å¿— -->
        <Grid Grid.Row="2">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*"/>
                <ColumnDefinition Width="350"/>
            </Grid.ColumnDefinitions>

            <Border Grid.Column="0" BorderBrush="#DDDDDD" BorderThickness="1" Margin="0,0,8,0">
                <ContentControl x:Name="panelContainer">
                    <TextBlock Text="正在初始化…" HorizontalAlignment="Center" VerticalAlignment="Center"
                               FontSize="16" Foreground="#999"/>
                </ContentControl>
            </Border>

            <Border Grid.Column="1" BorderBrush="#DDDDDD" BorderThickness="1">
                <Grid>
                    <Grid.RowDefinitions>
                        <RowDefinition Height="Auto"/>
                        <RowDefinition Height="*"/>
                    </Grid.RowDefinitions>
                    <Border Grid.Row="0" Background="#F0F0F0" Padding="8,6">
                        <TextBlock Text="操作日志" FontWeight="Bold" FontSize="14"/>
                    </Border>
                    <ListView Grid.Row="1" x:Name="operationLogList"
                              ItemsSource="{Binding OperationLogs}"
                              Style="{StaticResource DefaultListTable}"
                              VirtualizingPanel.IsVirtualizing="True"
                              VirtualizingPanel.VirtualizationMode="Standard">
                        <ListView.View>
                            <GridView AllowsColumnReorder="False">
                                <GridViewColumn Width="60" Header="类型" DisplayMemberBinding="{Binding CommandType}"/>
                                <GridViewColumn Width="120" Header="参数" DisplayMemberBinding="{Binding Parameters}"/>
                                <GridViewColumn Width="60" Header="结果" DisplayMemberBinding="{Binding Outcome}"/>
                                <GridViewColumn Width="100" Header="时间" DisplayMemberBinding="{Binding Timestamp, StringFormat=HH:mm:ss}"/>
                            </GridView>
                        </ListView.View>
                    </ListView>
                </Grid>
            </Border>
        </Grid>
    </Grid>
</UserControl>

 Plugin.DeviceDebug/DeviceDebugTab.xaml.cs

New file
@@ -0,0 +1,458 @@
using Aging.Infrastructure.Contracts;
using CommunityToolkit.Mvvm.ComponentModel;
using HMI.Core.Util;
using HMI.UI.Util;
using log4net;
using Plugin.DeviceDebug.Entity;
using Plugin.DeviceDebug.Model;
using Plugin.DeviceDebug.Panels;
using System;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace Plugin.DeviceDebug
{
    /// <summary>
    /// å•è®¾å¤‡è°ƒè¯•å·¥ä½œåŒºï¼ˆè‡ªå¸¦ç‹¬ç«‹è°ƒè¯•ä¼šè¯ä¸Žç»´æŠ¤ç§Ÿçº¦ï¼‰ã€‚ç”± DeviceDebug å£³æŒ‰ Tab æ‰¿è½½ï¼Œ
    /// æ”¯æŒåŒæ—¶æ‰“开多个设备互不干扰。会话状态机沿用 DebugSessionManager（共享单例，
    /// å†…存按 sessionId ç¼“存多会话），进入/退出维护只作用于本设备资源键。
    /// </summary>
    [ObservableObject]
    public partial class DeviceDebugTab : UserControl
    {
        private static readonly ILog log = LogManager.GetLogger(typeof(DeviceDebugTab));

        // å…±äº«æœåŠ¡ï¼ˆç”±å£³æ³¨å…¥ï¼Œç”Ÿå‘½å‘¨æœŸå±žå£³ï¼‰
        private DeviceDebugModel _debugModel;
        private DebugSessionManager _sessionManager;
        private IDeviceManager _deviceManager;
        private IDeviceService _deviceService;
        private string _deviceConfigDbPath;

        [ObservableProperty] private DebugSession _currentSession;
        [ObservableProperty] private ObservableCollection<DebugOperation> _operationLogs = new();
        [ObservableProperty] private string _connectionStateText = "未连接";
        [ObservableProperty] private string _sessionStateText = "";
        [ObservableProperty] private string _reservationStatusText = "";
        [ObservableProperty] private string _currentDeviceId = "";
        [ObservableProperty] private string _currentDeviceKind = "";
        [ObservableProperty] private string _currentEffectiveVersion = "";
        [ObservableProperty] private string _currentEndpoint = "";
        [ObservableProperty] private string _currentDriverType = "";
        [ObservableProperty] private Brush _connectionBrush = new SolidColorBrush(Colors.Gray);
        [ObservableProperty] private Brush _sessionStateBrush = new SolidColorBrush(Colors.Gray);
        [ObservableProperty] private bool _canEnterMaintenance;
        [ObservableProperty] private bool _canExitMaintenance;
        [ObservableProperty] private bool _hasDevice;

        /// <summary>本 Tab å…³è”的设备ID（供壳过滤已打开设备、关闭时定位会话）。</summary>
        public string BoundDeviceId { get; private set; } = "";

        public DeviceDebugTab()
        {
            DataContext = this;
            InitializeComponent();
        }

        /// <summary>
        /// æ³¨å…¥å…±äº«æœåŠ¡å¹¶æ‰“开该设备的调试会话（ReadOnly）+ åŠ è½½é¢æ¿ã€‚
        /// </summary>
        public void Initialize(DeviceDebugModel debugModel, DebugSessionManager sessionManager,
            IDeviceManager deviceManager, IDeviceService deviceService, string deviceConfigDbPath,
            string deviceId, string kind)
        {
            _debugModel = debugModel;
            _sessionManager = sessionManager;
            _deviceManager = deviceManager;
            _deviceService = deviceService;
            _deviceConfigDbPath = deviceConfigDbPath;
            BoundDeviceId = deviceId;
            OpenDevice(deviceId, kind);
        }

        private void OpenDevice(string deviceId, string kind)
        {
            try
            {
                LoadDeviceInfo(deviceId);
                HasDevice = true;

                CurrentSession = _sessionManager.OpenSession(deviceId, "", "operator", CurrentEffectiveVersion);

                if (_deviceManager != null)
                {
                    try
                    {
                        _deviceManager.ConnectAsync(deviceId, CancellationToken.None).GetAwaiter().GetResult();
                        ConnectionStateText = "已连接";
                        ConnectionBrush = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#4CAF50"));
                    }
                    catch (Exception ex)
                    {
                        log.Warn($"通过 DeviceManager è¿žæŽ¥è®¾å¤‡å¤±è´¥: {ex.Message}");
                        ConnectionStateText = "连接失败";
                        ConnectionBrush = new SolidColorBrush(Colors.OrangeRed);
                    }
                }

                LoadOperationLogs();
                UpdateButtonStates();
                LoadPanel(kind);
                log.Info($"调试 Tab å·²æ‰“开设备: {deviceId}, ç±»åž‹: {kind}");
            }
            catch (Exception ex)
            {
                log.Error("打开设备调试失败", ex);
                ToastHelper.Error($"打开设备失败: {ex.Message}");
            }
        }

        private void LoadDeviceInfo(string deviceId)
        {
            try
            {
                var sqliteHelper = new SqliteHelper(_deviceConfigDbPath);
                var dt = sqliteHelper.GetDataTable(
                    $"SELECT DeviceId, Kind, EffectiveVersion, Endpoint, DriverType FROM DeviceDefinition WHERE DeviceId = '{deviceId}'");
                if (dt.Rows.Count > 0)
                {
                    var row = dt.Rows[0];
                    CurrentDeviceId = row["DeviceId"].ToString();
                    CurrentDeviceKind = row["Kind"].ToString();
                    CurrentEffectiveVersion = row["EffectiveVersion"]?.ToString() ?? "";
                    CurrentEndpoint = row["Endpoint"]?.ToString() ?? "";
                    CurrentDriverType = row["DriverType"]?.ToString() ?? "";
                }
            }
            catch (Exception ex)
            {
                log.Error($"加载设备信息失败: {deviceId}", ex);
            }
        }

        private void LoadPanel(string deviceKind)
        {
            try
            {
                UIElement panel = null;
                switch (deviceKind)
                {
                    case "PowerSupply":
                        var powerPanel = new PowerSupplyDebugPanel
                        {
                            IsMaintenanceMode = CurrentSession?.State == DebugSessionState.MaintenanceActive
                        };
                        powerPanel.OnCommandExecute += Panel_OnCommandExecute;
                        panel = powerPanel;
                        break;
                    case "CanDevice":
                        var canPanel = new CanDebugPanel
                        {
                            DeviceId = CurrentDeviceId,
                            InitialBusName = ParseCanBusName(CurrentEndpoint),
                            InitialNodeIndex = ParseCanNodeIndex(CurrentEndpoint),
                            AutoConnectOnLoad = true
                        };
                        // å…±äº«/Broker è®¾å¤‡å¤ç”¨ DeviceManager å·²æ³¨å†Œé©±åŠ¨ï¼Œç¦æ­¢è‡ªå»ºç‰©ç†ä¼šè¯
                        try
                        {
                            var registeredDriver = _deviceManager?.GetDriver(CurrentDeviceId);
                            if (registeredDriver != null)
                            {
                                canPanel.ExistingDriver = registeredDriver;
                                log.Info($"设备 {CurrentDeviceId} è°ƒè¯•é¢æ¿å¤ç”¨å·²æ³¨å†Œé©±åŠ¨: {registeredDriver.GetType().Name}");
                            }
                        }
                        catch (Exception ex)
                        {
                            log.Warn($"获取已注册驱动失败，面板降级本地直驱: {ex.Message}");
                        }
                        canPanel.IsMaintenanceMode = CurrentSession?.State == DebugSessionState.MaintenanceActive;
                        canPanel.OnCommandExecute += Panel_OnCommandExecute;
                        panel = canPanel;
                        break;
                    case "PlcDevice":
                        var plcPanel = new PlcDebugPanel
                        {
                            IsMaintenanceMode = CurrentSession?.State == DebugSessionState.MaintenanceActive
                        };
                        plcPanel.OnCommandExecute += Panel_OnCommandExecute;
                        panel = plcPanel;
                        break;
                    default:
                        panel = new TextBlock
                        {
                            Text = $"不支持的设备类型: {deviceKind}",
                            HorizontalAlignment = HorizontalAlignment.Center,
                            VerticalAlignment = VerticalAlignment.Center,
                            FontSize = 14,
                            Foreground = new SolidColorBrush(Colors.OrangeRed)
                        };
                        break;
                }
                panelContainer.Content = panel;
            }
            catch (Exception ex)
            {
                log.Error($"加载调试面板失败: {deviceKind}", ex);
                ToastHelper.Error($"加载面板失败: {ex.Message}");
            }
        }

        private void Panel_OnCommandExecute(object sender, DebugCommand command)
        {
            try
            {
                if (CurrentSession == null)
                {
                    ToastHelper.Warning("请先选择设备");
                    return;
                }
                if (!_sessionManager.ValidateCommand(CurrentSession.SessionId, command))
                {
                    ToastHelper.Warning("当前会话状态不允许执行此操作，请先进入维护模式");
                    return;
                }
                if (_deviceService != null)
                    ExecuteViaDeviceService(command);
                else
                {
                    log.Warn("DeviceService æœªåˆå§‹åŒ–，使用降级模式记录命令");
                    ExecuteFallback(command);
                }
            }
            catch (Exception ex)
            {
                log.Error($"执行命令失败: {command.CommandType}", ex);
                ToastHelper.Error($"命令执行失败: {ex.Message}");
                var operation = new DebugOperation
                {
                    SessionId = CurrentSession?.SessionId ?? "",
                    CommandType = command.CommandType,
                    Parameters = SerializeParameters(command),
                    Outcome = "Failed",
                    ErrorMessage = ex.Message,
                    Timestamp = DateTime.Now
                };
                _debugModel.RecordOperation(operation);
                OperationLogs.Insert(0, operation);
            }
        }

        private void ExecuteViaDeviceService(DebugCommand command)
        {
            try
            {
                var ownerToken = new ResourceOwnerToken(OwnerType.Maintenance, CurrentSession.SessionId);
                var deviceCommand = BuildDeviceCommand(command);
                var result = _deviceService.ExecuteCommandAsync(
                    command.DeviceId, deviceCommand, ownerToken, CancellationToken.None).GetAwaiter().GetResult();

                var operation = new DebugOperation
                {
                    SessionId = CurrentSession.SessionId,
                    CommandType = command.CommandType,
                    Parameters = SerializeParameters(command),
                    Outcome = result.Success ? "Success" : "Failed",
                    DeviceReadback = result.Readback ?? "",
                    ErrorCode = result.ErrorCode ?? "",
                    ErrorMessage = result.ErrorMessage ?? "",
                    Timestamp = DateTime.Now
                };
                _debugModel.RecordOperation(operation);
                OperationLogs.Insert(0, operation);

                if (result.Success) ToastHelper.Success($"命令 {command.CommandType} æ‰§è¡ŒæˆåŠŸ");
                else ToastHelper.Warning($"命令执行失败: {result.ErrorMessage}");
                log.Info($"执行命令: {command.CommandType}, è®¾å¤‡: {command.DeviceId}, ç»“æžœ: {(result.Success ? "成功" : "失败")}");
            }
            catch (Exception ex)
            {
                log.Error($"DeviceService æ‰§è¡Œå‘½ä»¤å¤±è´¥: {ex.Message}", ex);
                ToastHelper.Error($"设备通信失败: {ex.Message}");
                var operation = new DebugOperation
                {
                    SessionId = CurrentSession.SessionId,
                    CommandType = command.CommandType,
                    Parameters = SerializeParameters(command),
                    Outcome = "Failed",
                    ErrorMessage = ex.Message,
                    Timestamp = DateTime.Now
                };
                _debugModel.RecordOperation(operation);
                OperationLogs.Insert(0, operation);
            }
        }

        private void ExecuteFallback(DebugCommand command)
        {
            var operation = new DebugOperation
            {
                SessionId = CurrentSession.SessionId,
                CommandType = command.CommandType,
                Parameters = SerializeParameters(command),
                Outcome = "Success",
                Timestamp = DateTime.Now
            };
            _debugModel.RecordOperation(operation);
            OperationLogs.Insert(0, operation);
            ToastHelper.Success($"命令 {command.CommandType} å·²å‘送（降级模式）");
        }

        private string BuildDeviceCommand(DebugCommand command)
        {
            if (command is PowerSetCommand psc)
                return $"VOLT {psc.Voltage};CURR {psc.CurrentLimit};OUTP {(psc.Output ? "ON" : "OFF")}";
            if (command is PowerMeasureCommand)
                return "MEAS:ALL?";
            if (command is CanSendCommand csc)
                return $"CAN:SEND {csc.Frame}";
            if (command is PlcWriteCommand pwc)
                return $"WRITE:{pwc.IoAddress}:{(pwc.Value ? "TRUE" : "FALSE")}";
            return command.CommandType;
        }

        private string SerializeParameters(DebugCommand command)
        {
            try
            {
                switch (command)
                {
                    case PowerSetCommand psc:
                        return $"{{Voltage:{psc.Voltage},CurrentLimit:{psc.CurrentLimit},Output:{psc.Output}}}";
                    case PowerMeasureCommand _:
                        return "{}";
                    case CanSendCommand csc:
                        return $"{{Frame:{csc.Frame},Data:{BitConverter.ToString(csc.Data)}}}";
                    case PlcWriteCommand pwc:
                        return $"{{IoAddress:{pwc.IoAddress},Value:{pwc.Value}}}";
                    default:
                        return "{}";
                }
            }
            catch { return "{}"; }
        }

        private void LoadOperationLogs()
        {
            try
            {
                if (CurrentSession == null) return;
                var ops = _debugModel.GetOperationsBySession(CurrentSession.SessionId);
                OperationLogs = new ObservableCollection<DebugOperation>(ops.Take(100));
            }
            catch (Exception ex) { log.Error("加载操作日志失败", ex); }
        }

        private void UpdateButtonStates()
        {
            if (CurrentSession == null)
            {
                CanEnterMaintenance = false;
                CanExitMaintenance = false;
                SessionStateText = "";
                return;
            }
            var state = CurrentSession.State;
            CanEnterMaintenance = state == DebugSessionState.ReadOnly;
            CanExitMaintenance = state == DebugSessionState.MaintenanceActive;
            SessionStateText = state.ToString();
            SessionStateBrush = state switch
            {
                DebugSessionState.ReadOnly => new SolidColorBrush((Color)ColorConverter.ConvertFromString("#2196F3")),
                DebugSessionState.MaintenanceActive => new SolidColorBrush((Color)ColorConverter.ConvertFromString("#4CAF50")),
                DebugSessionState.Faulted => new SolidColorBrush(Colors.Red),
                DebugSessionState.RecoveryRequired => new SolidColorBrush(Colors.Orange),
                _ => new SolidColorBrush(Colors.Gray)
            };

            if (panelContainer.Content is PowerSupplyDebugPanel powerPanel)
                powerPanel.IsMaintenanceMode = state == DebugSessionState.MaintenanceActive;
            else if (panelContainer.Content is CanDebugPanel canPanel)
                canPanel.IsMaintenanceMode = state == DebugSessionState.MaintenanceActive;
            else if (panelContainer.Content is PlcDebugPanel plcPanel)
                plcPanel.IsMaintenanceMode = state == DebugSessionState.MaintenanceActive;
        }

        private void EnterMaintenanceBtn_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (CurrentSession == null) return;
                if (_sessionManager.RequestMaintenance(CurrentSession.SessionId))
                {
                    _sessionManager.ActivateMaintenance(CurrentSession.SessionId);
                    UpdateButtonStates();
                    LoadPanel(CurrentDeviceKind);
                    ToastHelper.Success("已进入维护控制模式");
                    log.Info($"会话 {CurrentSession.SessionId} è¿›å…¥ç»´æŠ¤æ¨¡å¼");
                }
                else
                {
                    ToastHelper.Warning("无法进入维护模式，请检查设备状态");
                }
            }
            catch (Exception ex)
            {
                log.Error("进入维护模式失败", ex);
                ToastHelper.Error($"进入维护模式失败: {ex.Message}");
            }
        }

        private void ExitMaintenanceBtn_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (CurrentSession == null) return;
                if (MsgBoxHelper.WarnMessage(Window.GetWindow(this), "确定要退出维护模式吗？") == MessageBoxResult.OK)
                    CloseSessionSilently();
            }
            catch (Exception ex)
            {
                log.Error("退出维护模式失败", ex);
                ToastHelper.Error($"退出维护模式失败: {ex.Message}");
            }
        }

        /// <summary>
        /// å…³é—­æœ¬ Tab ä¼šè¯å¹¶é‡Šæ”¾ç»´æŠ¤ç§Ÿçº¦ï¼ˆä¾›é€€å‡ºç»´æŠ¤æŒ‰é’®ä¸Žå£³å…³é—­ Tab å…±ç”¨ï¼‰ã€‚
        /// ç» sessionId å¤ç”¨ token é‡Šæ”¾ï¼Œæœç»ç§Ÿçº¦æ³„漏导致的“第二次进维护失败”。
        /// </summary>
        public void CloseSessionSilently()
        {
            try
            {
                if (CurrentSession != null)
                {
                    _sessionManager.CloseSession(CurrentSession.SessionId);
                    CurrentSession = null;
                    log.Info($"设备 {BoundDeviceId} ä¼šè¯å·²å…³é—­ï¼Œç»´æŠ¤ç§Ÿçº¦å·²é‡Šæ”¾");
                }
            }
            catch (Exception ex)
            {
                log.Warn($"关闭会话异常: {ex.Message}");
            }
        }

        private string ParseCanBusName(string endpoint)
        {
            if (string.IsNullOrEmpty(endpoint)) return "CAN_BUS_1";
            int idx = endpoint.IndexOf(':');
            return idx > 0 ? endpoint.Substring(0, idx) : endpoint;
        }

        private int? ParseCanNodeIndex(string endpoint)
        {
            if (string.IsNullOrEmpty(endpoint)) return 0;
            int idx = endpoint.IndexOf(':');
            if (idx > 0 && idx < endpoint.Length - 1 && int.TryParse(endpoint.Substring(idx + 1), out int n))
                return n;
            return 0;
        }
    }
}

 Plugin.DeviceDebug/Model/DebugSessionManager.cs

@@ -19,6 +19,20 @@
        // å†…存中的活跃会话缓存
        private readonly Dictionary<string, DebugSession> _activeSessions = new();

        /// <summary>
        /// ç»´æŠ¤ç§Ÿçº¦å¿ƒè·³ï¼šä¸Ž LayeredResourceManager.DefaultTtlSeconds(300s) å¯¹é½ï¼Œ
        /// æ¯ 120s ç»­æœŸä¸€æ¬¡ï¼Œé˜²æ­¢é•¿æ—¶é—´ç»´æŠ¤ä¼šè¯çš„ arb.db ç§Ÿçº¦è¿‡æœŸè¿›å…¥ RecoveryRequired åŽç¦æ­¢ I/O。
        /// </summary>
        private System.Threading.Timer _renewTimer;
        private const int MaintenanceTtlSeconds = 300;
        private const int RenewIntervalMs = 120_000;

        /// <summary>
        /// ä¼šè¯â†’资源令牌缓存：LayeredResourceManager çš„租约按 TokenId ç´¢å¼•ï¼Œ
        /// è€Œ ResourceOwnerToken.TokenId æ¯æ¬¡ new éƒ½æ˜¯æ–° GUID，必须复用同一实例才能释放到租约
        /// </summary>
        private readonly Dictionary<string, ResourceOwnerToken> _sessionOwnerTokens = new();

        public DebugSessionManager(DeviceDebugModel model, IResourceManager? resourceManager = null)
        {
            _model = model;
@@ -36,8 +50,22 @@
                var existingSession = GetActiveSessionByDevice(deviceId);
                if (existingSession != null)
                {
                    // è¿›ç¨‹å†…存中存在 = æœ¬ä¼šè¯çœŸæ´»è·ƒï¼Œç›´æŽ¥å¤ç”¨
                    if (_activeSessions.ContainsKey(existingSession.SessionId))
                    {
                    log.Warn($"设备 {deviceId} å·²æœ‰æ´»è·ƒä¼šè¯: {existingSession.SessionId}");
                    return existingSession;
                    }

                    // ä»…存在于数据库且不在本进程内存 = æ—§è¿›ç¨‹é€€å‡ºå‰çš„残留会话：
                    // å…¶å†…存上下文/维护租约（arb.db ä¾§é  TTL è¿‡æœŸ+回收）已随进程消亡，
                    // å¿…须回收为 Closed å†æ–°å»ºï¼Œå¦åˆ™ RequestMaintenance æ°¸è¿œâ€œä¼šè¯ä¸å­˜åœ¨â€æ‹’绝
                    _activeSessions[existingSession.SessionId] = existingSession;
                    existingSession.State = DebugSessionState.Closed;
                    existingSession.ClosedAt = DateTime.Now;
                    _model.UpdateSession(existingSession);
                    _activeSessions.Remove(existingSession.SessionId);
                    log.Warn($"已回收设备 {deviceId} çš„残留会话 {existingSession.SessionId}（进程重启导致死会话），新建会话替代");
                }

                var session = new DebugSession
@@ -75,8 +103,15 @@
            {
                if (!_activeSessions.TryGetValue(sessionId, out var session))
                {
                    // å…œåº•ï¼šä¼šè¯å¯èƒ½åœ¨æ•°æ®åº“（如 UI æŒæœ‰çš„ sessionID å±žäºŽé‡å¯å‰æ®‹ç•™ï¼‰â†’ æ¢å¤è¿›ç¼“存后继续
                    session = _model.GetSession(sessionId);
                    if (session == null || session.State == DebugSessionState.Closed)
                    {
                    log.Warn($"会话不存在: {sessionId}");
                    return false;
                    }
                    _activeSessions[sessionId] = session;
                    log.Warn($"会话 {sessionId} ä»Žæ•°æ®åº“恢复进内存缓存后继续维护请求");
                }

                // éªŒè¯çŠ¶æ€è½¬æ¢
@@ -90,7 +125,12 @@
                if (_resourceManager != null)
                {
                    var resourceKey = new ResourceKey(session.DeviceId, "Generic");
                    var ownerToken = new ResourceOwnerToken(OwnerType.Maintenance, session.SessionId);
                    // å¤ç”¨å·²ç¼“存令牌（残留会话从 DB æ¢å¤åŽé¦–次进入时同样新建并存入）
                    if (!_sessionOwnerTokens.TryGetValue(sessionId, out var ownerToken))
                    {
                        ownerToken = new ResourceOwnerToken(OwnerType.Maintenance, session.SessionId);
                        _sessionOwnerTokens[sessionId] = ownerToken;
                    }

                    try
                    {
@@ -100,6 +140,7 @@
                    }
                    catch (ResourceConflictException)
                    {
                        _sessionOwnerTokens.Remove(sessionId);
                        log.Warn($"设备 {session.DeviceId} å·²è¢«ç”Ÿäº§é¢„约占用，拒绝维护请求");
                        return false;
                    }
@@ -152,6 +193,9 @@
                // æŒä¹…化
                _model.UpdateSession(session);

                // å¯åŠ¨ç»´æŠ¤ç§Ÿçº¦å¿ƒè·³ç»­æœŸï¼ˆé˜²æ­¢ TTL è¿‡æœŸï¼‰
                EnsureRenewHeartbeat();

                log.Info($"会话 {sessionId} æ¿€æ´»ç»´æŠ¤æ¨¡å¼");
            }
            catch (Exception ex)
@@ -159,6 +203,48 @@
                log.Error($"激活维护模式失败: {ex.Message}", ex);
                throw;
            }
        }

        /// <summary>首次进入维护时启动周期续期定时器（幂等）。</summary>
        private void EnsureRenewHeartbeat()
        {
            if (_renewTimer != null) return;
            _renewTimer = new System.Threading.Timer(_ => RenewActiveMaintenance(),
                null, RenewIntervalMs, RenewIntervalMs);
            log.Info("维护租约心跳已启动");
        }

        /// <summary>周期回调：对所有 MaintenanceActive ä¼šè¯ç»­æœŸå…¶ arb.db ç§Ÿçº¦ã€‚</summary>
        private void RenewActiveMaintenance()
        {
            var lrm = _resourceManager as Aging.Infrastructure.Core.LayeredResourceManager;
            if (lrm == null) return; // éžåˆ†å±‚实现（无 Coordinator）时降级不续期
            try
            {
                foreach (var kv in _activeSessions.ToArray())
                {
                    var s = kv.Value;
                    if (s.State != DebugSessionState.MaintenanceActive) continue;
                    if (!_sessionOwnerTokens.TryGetValue(s.SessionId, out var token)) continue;
                    if (!lrm.TryGetGrants(token.TokenId, out var grants) || grants == null) continue;
                    foreach (var g in grants)
                    {
                        try { lrm.Coordinator.Renew(g, MaintenanceTtlSeconds); }
                        catch (Exception ex) { log.Warn($"续期设备 {s.DeviceId} ç§Ÿçº¦å¤±è´¥: {ex.Message}"); }
                    }
                }
            }
            catch (Exception ex) { log.Error($"维护租约心跳异常: {ex.Message}", ex); }
        }

        /// <summary>无维护中会话时停止心跳，避免空转。</summary>
        private void StopRenewHeartbeatIfIdle()
        {
            if (_renewTimer == null) return;
            if (_activeSessions.Values.Any(s => s.State == DebugSessionState.MaintenanceActive)) return;
            try { _renewTimer.Dispose(); } catch { }
            _renewTimer = null;
            log.Info("无维护中会话，维护租约心跳已停止");
        }

        /// <summary>
@@ -193,11 +279,17 @@
                    try
                    {
                        var resourceKey = new ResourceKey(session.DeviceId, "Generic");
                        var ownerToken = new ResourceOwnerToken(OwnerType.Maintenance, session.SessionId);
                        // å¿…须复用进入维护时的同一令牌实例：LayeredResourceManager æŒ‰ TokenId(GUID) ç´¢å¼•ç§Ÿçº¦ï¼Œ
                        // é‡æ–° new ä¼šå¯¼è‡´ FindGrant è½ç©ºã€ç§Ÿçº¦æ°¸ä¸é‡Šæ”¾â†’过期后 RecoveryRequired æ°¸ä¹…阻塞后续维护
                        if (!_sessionOwnerTokens.TryGetValue(sessionId, out var ownerToken))
                        {
                            ownerToken = new ResourceOwnerToken(OwnerType.Maintenance, session.SessionId);
                        }

                        _resourceManager.ReleaseReservationAsync(
                            ownerToken, resourceKey, CancellationToken.None).GetAwaiter().GetResult();

                        _sessionOwnerTokens.Remove(sessionId);
                        log.Info($"已释放设备 {session.DeviceId} çš„资源预约");
                    }
                    catch (Exception ex)
@@ -215,6 +307,9 @@
                // ä»Žç¼“存中移除
                _activeSessions.Remove(sessionId);

                // è‹¥æ— ç»´æŠ¤ä¸­ä¼šè¯åˆ™åœæ­¢å¿ƒè·³
                StopRenewHeartbeatIfIdle();

                log.Info($"会话 {sessionId} å·²å…³é—­");
            }
            catch (Exception ex)

 Plugin.DeviceDebug/Panels/CanChannelView.xaml

New file
@@ -0,0 +1,220 @@
<UserControl x:Class="Plugin.DeviceDebug.Panels.CanChannelView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:ui="clr-namespace:HMI.UI;assembly=HMI.UI"
             xmlns:dp="clr-namespace:HMI.UI.DpUtil;assembly=HMI.UI"
             mc:Ignorable="d" 
             d:DesignHeight="700" d:DesignWidth="700">
    <UserControl.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="/HMI.UI;component/Style/PanuonListView.xaml"/>
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </UserControl.Resources>

    <Grid dp:GridHelper.Space="10" Margin="10">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <!-- æ ‡é¢˜ -->
        <Border Grid.Row="0" Background="#FF9800" CornerRadius="4" Padding="12,8">
            <TextBlock Text="CAN é€šè®¯è°ƒè¯•é¢æ¿" FontSize="16" FontWeight="Bold" Foreground="White"/>
        </Border>

        <!-- æ¨¡æ‹Ÿå™¨è¿žæŽ¥æŽ§åˆ¶åŒº -->
        <Border Grid.Row="1" BorderBrush="#DDD" BorderThickness="1" CornerRadius="4" Padding="12" Background="#FAFAFA">
            <Grid dp:GridHelper.Space="8">
                <Grid.RowDefinitions>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                </Grid.RowDefinitions>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="80"/>
                    <ColumnDefinition Width="150"/>
                    <ColumnDefinition Width="80"/>
                    <ColumnDefinition Width="100"/>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="Auto"/>
                </Grid.ColumnDefinitions>

                <!-- ç¬¬ä¸€è¡Œï¼šæ€»çº¿åç§°å’ŒèŠ‚点编号 -->
                <TextBlock Grid.Row="0" Grid.Column="0" Text="总线名称:" VerticalAlignment="Center" FontWeight="SemiBold"/>
                <TextBox Grid.Row="0" Grid.Column="1" x:Name="busNameInput" 
                         VerticalContentAlignment="Center" Padding="6,4" Text="CAN_BUS_1"/>

                <TextBlock Grid.Row="0" Grid.Column="2" Text="节点编号:" VerticalAlignment="Center" FontWeight="SemiBold" Margin="8,0,0,0"/>
                <TextBox Grid.Row="0" Grid.Column="3" x:Name="nodeIndexInput" 
                         VerticalContentAlignment="Center" Padding="6,4" Text="0"/>

                <Button Grid.Row="0" Grid.Column="5" x:Name="connectBtn" Content="连接" Width="80" Height="30"
                        Click="ConnectBtn_Click" 
                        Background="#4CAF50" Foreground="White" BorderThickness="0" Cursor="Hand" FontWeight="SemiBold"/>

                <!-- ç¬¬äºŒè¡Œï¼šçŠ¶æ€æ˜¾ç¤ºå’ŒæŽ§åˆ¶æŒ‰é’® -->
                <TextBlock Grid.Row="1" Grid.Column="0" Text="状态:" VerticalAlignment="Center" FontWeight="SemiBold"/>
                <StackPanel Grid.Row="1" Grid.Column="1" Grid.ColumnSpan="2" Orientation="Horizontal" VerticalAlignment="Center">
                    <Ellipse x:Name="statusIndicator" Width="12" Height="12" Fill="#9E9E9E" Margin="0,0,6,0"/>
                    <TextBlock x:Name="statusText" Text="未连接" VerticalAlignment="Center"/>
                </StackPanel>

                <TextBlock Grid.Row="1" Grid.Column="3" Text="统计:" VerticalAlignment="Center" FontWeight="SemiBold" Margin="8,0,0,0"/>
                <TextBlock Grid.Row="1" Grid.Column="4" x:Name="statsText" Text="TX: 0  RX: 0" 
                           VerticalAlignment="Center" Foreground="#666"/>

                <StackPanel Grid.Row="1" Grid.Column="5" Orientation="Horizontal">
                    <ToggleButton x:Name="autoResponseToggleBtn" Content="自动响应: å…³" Width="100" Height="28" Margin="0,0,4,0"
                                  Click="AutoResponseToggleBtn_Click" IsEnabled="False" IsChecked="False"
                                  Background="#9E9E9E" Foreground="White" BorderThickness="0" Cursor="Hand" FontWeight="SemiBold"/>
                    <ToggleButton x:Name="maintenanceToggleBtn" Content="维护模式: å¼€" Width="100" Height="28" Margin="0,0,4,0"
                                  Click="MaintenanceToggleBtn_Click" IsEnabled="False" IsChecked="True"
                                  Background="#4CAF50" Foreground="White" BorderThickness="0" Cursor="Hand" FontWeight="SemiBold"/>
                    <Button x:Name="disconnectBtn" Content="断开" Width="60" Height="28" Margin="0,0,4,0"
                            Click="DisconnectBtn_Click" IsEnabled="False"
                            Background="#F44336" Foreground="White" BorderThickness="0" Cursor="Hand"/>
                    <Button x:Name="promiscuousBtn" Content="混杂模式" Width="80" Height="28"
                            Click="PromiscuousBtn_Click" IsEnabled="False"
                            Background="#2196F3" Foreground="White" BorderThickness="0" Cursor="Hand"/>
                </StackPanel>
            </Grid>
        </Border>

        <!-- å‘送区 -->
        <Border Grid.Row="2" BorderBrush="#DDD" BorderThickness="1" CornerRadius="4" Padding="12">
            <Grid dp:GridHelper.Space="8">
                <Grid.RowDefinitions>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                </Grid.RowDefinitions>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="80"/>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="Auto"/>
                </Grid.ColumnDefinitions>

                <!-- å¸§ID -->
                <TextBlock Grid.Row="0" Grid.Column="0" Text="帧 ID:" VerticalAlignment="Center" FontWeight="Bold"/>
                <TextBox Grid.Row="0" Grid.Column="1" x:Name="frameIdInput"
                         IsEnabled="{Binding IsMaintenanceMode, RelativeSource={RelativeSource AncestorType=UserControl}}"
                         VerticalContentAlignment="Center" Padding="6,4" Text="0x100"/>

                <!-- æ•°æ® -->
                <TextBlock Grid.Row="1" Grid.Column="0" Text="数据(Hex):" VerticalAlignment="Center" FontWeight="Bold"/>
                <TextBox Grid.Row="1" Grid.Column="1" x:Name="dataInput"
                         IsEnabled="{Binding IsMaintenanceMode, RelativeSource={RelativeSource AncestorType=UserControl}}"
                         VerticalContentAlignment="Center" Padding="6,4" Text="00 00 00 00 00 00 00 00"/>

                <!-- å‘送按钮 -->
                <Button Grid.Row="1" Grid.Column="2" x:Name="sendBtn" Content="发送" Width="80" Height="30"
                        IsEnabled="{Binding IsMaintenanceMode, RelativeSource={RelativeSource AncestorType=UserControl}}"
                        Click="SendBtn_Click" 
                        Background="#FF9800" Foreground="White" BorderThickness="0" Cursor="Hand" FontWeight="SemiBold"/>
            </Grid>
        </Border>

        <!-- æŽ¥æ”¶åŒº -->
        <Border Grid.Row="3" BorderBrush="#DDD" BorderThickness="1" CornerRadius="4">
            <Grid>
                <Grid.RowDefinitions>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="*"/>
                </Grid.RowDefinitions>

                <DockPanel Grid.Row="0" Margin="8,6">
                    <Button x:Name="clearBtn" Content="清空" Padding="12,4" DockPanel.Dock="Right"
                            Click="ClearBtn_Click"
                            Background="#9E9E9E" Foreground="White" BorderThickness="0" Cursor="Hand"/>
                    <TextBlock Text="接收记录" FontWeight="Bold" FontSize="14" VerticalAlignment="Center"/>
                </DockPanel>

                <ListView Grid.Row="1" x:Name="receiveList"
                          Style="{StaticResource DefaultListTable}"
                          VirtualizingPanel.IsVirtualizing="True"
                          VirtualizingPanel.VirtualizationMode="Standard">
                    <ListView.View>
                        <GridView AllowsColumnReorder="False">
                            <GridViewColumn Width="90" Header="时间">
                                <GridViewColumn.CellTemplate>
                                    <DataTemplate>
                                        <Border Style="{StaticResource CellBorder}">
                                            <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                       Text="{Binding Timestamp, StringFormat=HH:mm:ss.fff}"/>
                                        </Border>
                                    </DataTemplate>
                                </GridViewColumn.CellTemplate>
                            </GridViewColumn>
                            <GridViewColumn Width="80" Header="帧ID">
                                <GridViewColumn.CellTemplate>
                                    <DataTemplate>
                                        <Border Style="{StaticResource CellBorder}">
                                            <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                       Text="{Binding FrameId}"/>
                                        </Border>
                                    </DataTemplate>
                                </GridViewColumn.CellTemplate>
                            </GridViewColumn>
                            <GridViewColumn Width="50" Header="DLC">
                                <GridViewColumn.CellTemplate>
                                    <DataTemplate>
                                        <Border Style="{StaticResource CellBorder}">
                                            <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                       Text="{Binding Dlc}"/>
                                        </Border>
                                    </DataTemplate>
                                </GridViewColumn.CellTemplate>
                            </GridViewColumn>
                            <GridViewColumn Width="200" Header="数据">
                                <GridViewColumn.CellTemplate>
                                    <DataTemplate>
                                        <Border Style="{StaticResource CellBorder}">
                                            <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                       Text="{Binding Data}" FontFamily="Consolas"/>
                                        </Border>
                                    </DataTemplate>
                                </GridViewColumn.CellTemplate>
                            </GridViewColumn>
                            <GridViewColumn Width="50" Header="方向">
                                <GridViewColumn.CellTemplate>
                                    <DataTemplate>
                                        <Border Style="{StaticResource CellBorder}">
                                            <TextBlock Text="{Binding Direction}">
                                                <TextBlock.Style>
                                                    <Style TargetType="TextBlock" BasedOn="{StaticResource ListTableTextBlock}">
                                                        <Style.Triggers>
                                                            <DataTrigger Binding="{Binding Direction}" Value="TX">
                                                                <Setter Property="Foreground" Value="#2196F3"/>
                                                            </DataTrigger>
                                                            <DataTrigger Binding="{Binding Direction}" Value="RX">
                                                                <Setter Property="Foreground" Value="#4CAF50"/>
                                                            </DataTrigger>
                                                        </Style.Triggers>
                                                    </Style>
                                                </TextBlock.Style>
                                            </TextBlock>
                                        </Border>
                                    </DataTemplate>
                                </GridViewColumn.CellTemplate>
                            </GridViewColumn>
                            <GridViewColumn Width="100" Header="来源">
                                <GridViewColumn.CellTemplate>
                                    <DataTemplate>
                                        <Border Style="{StaticResource CellBorder}">
                                            <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                       Text="{Binding Source}"/>
                                        </Border>
                                    </DataTemplate>
                                </GridViewColumn.CellTemplate>
                            </GridViewColumn>
                        </GridView>
                    </ListView.View>
                </ListView>
            </Grid>
        </Border>
    </Grid>
</UserControl>

 Plugin.DeviceDebug/Panels/CanChannelView.xaml.cs

New file
@@ -0,0 +1,485 @@
using Aging.Infrastructure.Drivers;
using log4net;
using Plugin.DeviceDebug.Entity;
using System;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Linq;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Threading;

namespace Plugin.DeviceDebug.Panels
{
    /// <summary>
    /// CAN å¸§æ˜¾ç¤ºæ¨¡åž‹
    /// </summary>
    public class CanFrameDisplay
    {
        public DateTime Timestamp { get; set; }
        public string FrameId { get; set; } = string.Empty;
        public int Dlc { get; set; }
        public string Data { get; set; } = string.Empty;
        public string Direction { get; set; } = string.Empty; // TX / RX
        public string Source { get; set; } = string.Empty;
    }

    /// <summary>
    /// å•é€šé“ CAN è°ƒè¯•è§†å›¾ï¼ˆæ‰¿è½½è¿žæŽ¥æŽ§åˆ¶/发送/接收记录/状态统计全部逻辑）。
    /// ç”± <see cref="CanDebugPanel"/> å¤šé€šé“壳按 Tab æ‰˜ç®¡ï¼›ä¹Ÿå¯ç‹¬ç«‹ä½¿ç”¨ï¼ˆæ—§å•é¢æ¿è¯­ä¹‰ï¼‰ã€‚
    /// é©±åŠ¨ç»Ÿä¸€ä¸º <see cref="CanDeviceDriver"/>，Local/Broker å·®å¼‚对视图完全透明。
    /// </summary>
    public partial class CanChannelView : UserControl
    {
        private static readonly ILog log = LogManager.GetLogger(typeof(CanChannelView));

        /// <summary>是否为维护模式（控制输入可用性）</summary>
        public static readonly DependencyProperty IsMaintenanceModeProperty =
            DependencyProperty.Register(nameof(IsMaintenanceMode), typeof(bool), typeof(CanChannelView),
                new PropertyMetadata(false));

        public bool IsMaintenanceMode
        {
            get => (bool)GetValue(IsMaintenanceModeProperty);
            set => SetValue(IsMaintenanceModeProperty, value);
        }

        /// <summary>命令执行事件</summary>
        public event EventHandler<DebugCommand>? OnCommandExecute;

        /// <summary>接收帧列表</summary>
        public ObservableCollection<CanFrameDisplay> ReceivedFrames { get; } = new();

        /// <summary>
        /// CAN é©±åŠ¨ï¼šä¼˜å…ˆå¤ç”¨ DeviceManager å·²æ³¨å†Œé©±åŠ¨ï¼ˆBroker å…±äº«è®¾å¤‡ä¸ºä»£ç†é©±åŠ¨ï¼‰ï¼Œ
        /// æ— åˆ™è‡ªå»ºç»Ÿä¸€é©±åŠ¨ï¼ˆLocal TCP NodeChannel è¿žæ¨¡æ‹Ÿå™¨ï¼‰
        /// </summary>
        private Aging.Infrastructure.Contracts.IDeviceDriver? _driver;

        /// <summary>驱动所有权：外部注入的代理驱动归 DeviceManager，断开时不得 Dispose</summary>
        private bool _ownsDriver;

        /// <summary>外部已注册驱动（共享设备由 DeviceDebug ä¼ å…¥ç»Ÿä¸€ CanDeviceDriver，禁止自建物理会话）</summary>
        public Aging.Infrastructure.Contracts.IDeviceDriver? ExistingDriver { get; set; }

        /// <summary>轮询定时器（代理驱动兜底补显接收帧）</summary>
        private DispatcherTimer? _pollTimer;

        private bool _isConnected;

        /// <summary>设备ID（从 DeviceDebug ä¼ å…¥ï¼‰</summary>
        public string DeviceId
        {
            get => _deviceId;
            set
            {
                _deviceId = value;
                if (!string.IsNullOrEmpty(value))
                {
                    UpdateDeviceIdDisplay();
                }
            }
        }
        private string _deviceId = string.Empty;

        /// <summary>从设备 Endpoint è§£æžå‡ºçš„总线名称</summary>
        public string InitialBusName { get; set; }

        /// <summary>从设备 Endpoint è§£æžå‡ºçš„节点编号</summary>
        public int? InitialNodeIndex { get; set; }

        /// <summary>是否自动连接（从 DeviceDebug æ‰“开时=true）</summary>
        public bool AutoConnectOnLoad { get; set; }

        public CanChannelView()
        {
            InitializeComponent();
            receiveList.ItemsSource = ReceivedFrames;
            InitializePollTimer();
            Loaded += CanChannelView_Loaded;
        }

        private void CanChannelView_Loaded(object sender, RoutedEventArgs e)
        {
            Loaded -= CanChannelView_Loaded;

            if (!string.IsNullOrEmpty(InitialBusName))
                busNameInput.Text = InitialBusName;
            if (InitialNodeIndex.HasValue)
                nodeIndexInput.Text = InitialNodeIndex.Value.ToString();

            if (AutoConnectOnLoad)
            {
                Dispatcher.BeginInvoke(new Action(() =>
                {
                    try { DoConnect(); }
                    catch (Exception ex) { log.Warn($"自动连接失败: {ex.Message}"); }
                }), DispatcherPriority.Background);
            }
        }

        private void UpdateDeviceIdDisplay()
        {
            if (!string.IsNullOrEmpty(_deviceId) && busNameInput != null)
                log.Info($"[CanChannelView] å…³è”设备: {_deviceId}");
        }

        private void InitializePollTimer()
        {
            _pollTimer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(100) };
            _pollTimer.Tick += PollTimer_Tick;
        }

        private void PollTimer_Tick(object? sender, EventArgs e)
        {
            if (!_isConnected || _driver == null) return;
            try
            {
                // ç»Ÿè®¡æ¯ tick åˆ·æ–°ï¼›STATUS æŸ¥è¯¢åŒæ—¶è§¦å‘ Broker å®¿ä¸»æŽå¸¦å›žæŽ¨ï¼ˆäº‹ä»¶é“¾è·¯ï¼‰
                UpdateStats();
            }
            catch (Exception ex)
            {
                log.Error($"轮询更新失败: {ex.Message}");
            }
        }

        /// <summary>
        /// å…œåº•è¡¥æ˜¾ï¼ˆä»…当事件链路未覆盖时手动调用）：统一驱动已对 Local/Broker å‡æä¾›
        /// DriverFrameReceived äº‹ä»¶ï¼Œé¢æ¿é»˜è®¤åªèµ°äº‹ä»¶æ˜¾ç¤ºï¼Œé¿å…ä¸Žè½®è¯¢åŒæŠ¥é‡å¤ã€‚
        /// </summary>
        private void DrainBrokerMailbox()
        {
            string resp;
            try
            {
                resp = _driver!.QueryAsync("RECV_ALL", CancellationToken.None).GetAwaiter().GetResult();
            }
            catch (Exception ex)
            {
                log.Debug($"接收兜底查询失败（不影响事件链路，下轮重试）: {ex.Message}");
                return;
            }

            if (string.IsNullOrEmpty(resp) || !resp.StartsWith("RECV_ALL:")) return;
            var head = resp.Substring("RECV_ALL:".Length);
            var split = head.IndexOf(':');
            string body = split >= 0 ? head.Substring(split + 1) : "";
            if (!int.TryParse(split >= 0 ? head.Substring(0, split) : head, out int count) || count <= 0) return;

            foreach (var entry in body.Split('|'))
            {
                var f = entry.Split(':');
                if (f.Length < 2 || string.IsNullOrEmpty(f[0])) continue;
                AddReceivedFrame(f[0], f[1], "RX", "BUS");
            }
        }

        private void ConnectBtn_Click(object sender, RoutedEventArgs e)
        {
            try { DoConnect(); }
            catch (Exception ex)
            {
                log.Error($"CAN è¿žæŽ¥å¤±è´¥: {ex.Message}", ex);
                MessageBox.Show($"连接失败: {ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                UpdateConnectionStatus(false);
            }
        }

        private void DoConnect()
        {
            if (_isConnected) return;

            string busName = busNameInput.Text.Trim();
            if (!int.TryParse(nodeIndexInput.Text.Trim(), out int nodeIndex))
                throw new ArgumentException("节点编号格式错误");

            string deviceId = string.IsNullOrEmpty(_deviceId)
                ? $"CAN_Test_{nodeIndex}_{DateTime.Now:HHmmss}"
                : _deviceId;

            if (ExistingDriver != null)
            {
                // å…±äº«/代理设备：复用宿主通路，不新建本地物理会话
                _driver = ExistingDriver;
                _ownsDriver = false;
                if (!_driver.IsConnected)
                    _driver.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();
                // ç»Ÿä¸€é©±åŠ¨å¯¹ Broker ä¹Ÿæä¾›æŽ¥æ”¶äº‹ä»¶ï¼ˆç»å®¿ä¸»æŽå¸¦å›žæµï¼‰ï¼Œä¸Žæœ¬åœ°ä¸€è‡´åœ°è®¢é˜…
                if (_driver is CanDeviceDriver shared)
                    shared.DriverFrameReceived += OnDriverFrameReceived;
                log.Info($"[CanChannelView] å¤ç”¨å·²æ³¨å†Œé©±åŠ¨: {deviceId} ({_driver.GetType().Name})");
            }
            else
            {
                var adapter = new CanDeviceDriver(deviceId, $"{busName}:{nodeIndex}");
                adapter.DriverFrameReceived += OnDriverFrameReceived;
                _driver = adapter;
                _ownsDriver = true;
                adapter.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();
            }
            _isConnected = true;

            // æ¨¡æ‹Ÿå™¨æ¨¡å¼ä¸‹è¿žæŽ¥åŽè‡ªåŠ¨å¯ç”¨ç»´æŠ¤æ¨¡å¼ï¼ˆå…è®¸å‘送）
            IsMaintenanceMode = true;
            if (maintenanceToggleBtn != null)
            {
                maintenanceToggleBtn.IsChecked = true;
                maintenanceToggleBtn.IsEnabled = true;
            }

            UpdateConnectionStatus(true);
            _pollTimer?.Start();
            log.Info($"CAN é©±åŠ¨å·²è¿žæŽ¥: Bus={busName}, Node={nodeIndex}, DeviceId={deviceId}");
        }

        private void OnDriverFrameReceived(object? sender, CanSimulator.CanFrame frame)
        {
            try
            {
                AddReceivedFrame(frame.FrameIdHex, frame.DataHex, "RX", frame.SourceNodeId);
                log.Debug($"[即时显示] æŽ¥æ”¶å¸§: {frame}");
            }
            catch (Exception ex)
            {
                log.Error($"即时显示帧失败: {ex.Message}", ex);
            }
        }

        private void DisconnectBtn_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                _pollTimer?.Stop();
                if (_driver != null)
                {
                    if (_driver is CanDeviceDriver adapter)
                        adapter.DriverFrameReceived -= OnDriverFrameReceived;
                    _driver.DisconnectAsync().GetAwaiter().GetResult();
                    if (_ownsDriver)
                        _driver.Dispose();
                }
                _driver = null;
                _ownsDriver = false;
                _isConnected = false;
                IsMaintenanceMode = false;
                UpdateConnectionStatus(false);
                log.Info("CAN é©±åŠ¨å·²æ–­å¼€");
            }
            catch (Exception ex)
            {
                log.Error($"CAN æ–­å¼€å¤±è´¥: {ex.Message}", ex);
            }
        }

        private void PromiscuousBtn_Click(object sender, RoutedEventArgs e)
        {
            if (!_isConnected || _driver == null) return;
            try
            {
                _driver.QueryAsync("PROMISCUOUS", CancellationToken.None).GetAwaiter().GetResult();
                log.Info("已设置混杂模式（接收所有帧）");
                MessageBox.Show("已设置混杂模式，将接收所有 CAN å¸§", "提示", MessageBoxButton.OK, MessageBoxImage.Information);
            }
            catch (Exception ex)
            {
                log.Error($"设置混杂模式失败: {ex.Message}");
            }
        }

        private void MaintenanceToggleBtn_Click(object sender, RoutedEventArgs e)
        {
            bool isOn = maintenanceToggleBtn.IsChecked == true;
            IsMaintenanceMode = isOn;
            if (isOn)
            {
                maintenanceToggleBtn.Content = "维护模式: å¼€";
                maintenanceToggleBtn.Background = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#4CAF50"));
                log.Info("维护模式已开启（可发送 CAN å¸§ï¼‰");
            }
            else
            {
                maintenanceToggleBtn.Content = "维护模式: å…³";
                maintenanceToggleBtn.Background = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#9E9E9E"));
                log.Info("维护模式已关闭（只读监控）");
            }
        }

        private void AutoResponseToggleBtn_Click(object sender, RoutedEventArgs e)
        {
            if (!_isConnected || _driver == null) return;
            try
            {
                bool isOn = autoResponseToggleBtn.IsChecked == true;
                string cmd = isOn ? "AUTO_RESPONSE:ON" : "AUTO_RESPONSE:OFF";
                _driver.QueryAsync(cmd, CancellationToken.None).GetAwaiter().GetResult();

                if (isOn)
                {
                    autoResponseToggleBtn.Content = "自动响应: å¼€";
                    autoResponseToggleBtn.Background = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF9800"));
                    log.Info("自动响应模式已开启（收到帧将自动回复）");
                }
                else
                {
                    autoResponseToggleBtn.Content = "自动响应: å…³";
                    autoResponseToggleBtn.Background = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#9E9E9E"));
                    log.Info("自动响应模式已关闭");
                }
            }
            catch (Exception ex)
            {
                log.Error($"切换自动响应模式失败: {ex.Message}");
                MessageBox.Show($"切换失败: {ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void UpdateConnectionStatus(bool connected)
        {
            _isConnected = connected;
            if (connected)
            {
                statusIndicator.Fill = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#4CAF50"));
                statusText.Text = "已连接";
                connectBtn.IsEnabled = false;
                disconnectBtn.IsEnabled = true;
                promiscuousBtn.IsEnabled = true;
                maintenanceToggleBtn.IsEnabled = true;
                autoResponseToggleBtn.IsEnabled = true;
                busNameInput.IsEnabled = false;
                nodeIndexInput.IsEnabled = false;
            }
            else
            {
                statusIndicator.Fill = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#9E9E9E"));
                statusText.Text = "未连接";
                connectBtn.IsEnabled = true;
                disconnectBtn.IsEnabled = false;
                promiscuousBtn.IsEnabled = false;
                maintenanceToggleBtn.IsEnabled = false;
                autoResponseToggleBtn.IsEnabled = false;
                busNameInput.IsEnabled = true;
                nodeIndexInput.IsEnabled = true;
            }
        }

        private void UpdateStats()
        {
            if (_driver == null) return;
            try
            {
                var response = _driver.QueryAsync("STATUS", CancellationToken.None).GetAwaiter().GetResult();
                statsText.Text = $"TX: {GetStatValue(response, "Tx")}  RX: {GetStatValue(response, "Rx")}  Err: {GetStatValue(response, "Err")}";
            }
            catch { /* å¿½ç•¥ç»Ÿè®¡æ›´æ–°å¤±è´¥ */ }
        }

        private string GetStatValue(string statusStr, string key)
        {
            try
            {
                foreach (var part in statusStr.Split(','))
                {
                    var kv = part.Trim().Split('=');
                    if (kv.Length == 2 && kv[0].Trim() == key)
                        return kv[1].Trim();
                }
            }
            catch { }
            return "0";
        }

        public void AddReceivedFrame(string frameId, string data, string direction = "RX", string source = "")
        {
            try
            {
                var frame = new CanFrameDisplay
                {
                    Timestamp = DateTime.Now,
                    FrameId = frameId,
                    Dlc = data.Split(new[] { ' ', '-' }, StringSplitOptions.RemoveEmptyEntries).Length,
                    Data = data,
                    Direction = direction,
                    Source = source
                };

                // å¿…须用异步 BeginInvoke：推送常在驱动后台读循环线程触发，若用同步 Invoke，
                // ä¼šä¸Žâ€œUI çº¿ç¨‹é˜»å¡žç­‰å¾…该读循环投递 RPC å“åº””形成环形等待 â†’ å¼€å¯åº”答器后推送骤增即冻结。
                if (Application.Current == null) return;
                Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                {
                    ReceivedFrames.Insert(0, frame);
                    while (ReceivedFrames.Count > 500)
                        ReceivedFrames.RemoveAt(ReceivedFrames.Count - 1);
                }));
            }
            catch (Exception ex)
            {
                log.Error($"添加接收帧失败: {ex.Message}", ex);
            }
        }

        private void SendBtn_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (!IsMaintenanceMode)
                {
                    MessageBox.Show("当前为只读模式，无法发送数据", "提示", MessageBoxButton.OK, MessageBoxImage.Warning);
                    return;
                }
                if (!_isConnected || _driver == null)
                {
                    MessageBox.Show("请先连接 CAN æ€»çº¿", "提示", MessageBoxButton.OK, MessageBoxImage.Warning);
                    return;
                }

                string frameIdStr = frameIdInput.Text.Trim();
                string dataStr = dataInput.Text.Trim();
                uint frameId = CanSimulator.CanFrame.ParseFrameId(frameIdStr);
                byte[] dataBytes = CanSimulator.CanFrame.ParseData(dataStr);
                if (dataBytes.Length > 8)
                {
                    MessageBox.Show("数据长度不能超过 8 å­—节", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                string command = $"SEND:{frameIdStr}:{dataStr}";
                var response = _driver.SendCommandAsync(command, CancellationToken.None).GetAwaiter().GetResult();
                AddReceivedFrame($"0x{frameId:X3}", BitConverter.ToString(dataBytes).Replace("-", " "), "TX", "LOCAL");
                log.Info($"发送 CAN å¸§: ID=0x{frameId:X3}, Data={BitConverter.ToString(dataBytes)}, Response={response}");
            }
            catch (Exception ex)
            {
                log.Error($"发送 CAN å¸§å¤±è´¥: {ex.Message}", ex);
                MessageBox.Show($"发送失败: {ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        /// <summary>供多通道壳在关闭标签时安全断开本通道（不弹 UI é”™è¯¯ï¼‰ã€‚</summary>
        public void DisconnectInternalSafe()
        {
            try
            {
                if (_isConnected) DisconnectBtn_Click(this, new RoutedEventArgs());
                _pollTimer?.Stop();
            }
            catch (Exception ex) { log.Warn($"通道安全断开异常: {ex.Message}"); }
        }

        private void ClearBtn_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                ReceivedFrames.Clear();
                log.Info("清空 CAN æŽ¥æ”¶è®°å½•");
            }
            catch (Exception ex)
            {
                log.Error($"清空接收记录失败: {ex.Message}", ex);
            }
        }
    }
}

 Plugin.DeviceDebug/Panels/CanDebugPanel.xaml

@@ -3,218 +3,27 @@
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:ui="clr-namespace:HMI.UI;assembly=HMI.UI"
             xmlns:dp="clr-namespace:HMI.UI.DpUtil;assembly=HMI.UI"
             mc:Ignorable="d" 
             d:DesignHeight="700" d:DesignWidth="700">
    <UserControl.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="/HMI.UI;component/Style/PanuonListView.xaml"/>
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </UserControl.Resources>

    <Grid dp:GridHelper.Space="10" Margin="10">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <!-- æ ‡é¢˜ -->
        <Border Grid.Row="0" Background="#FF9800" CornerRadius="4" Padding="12,8">
            <TextBlock Text="CAN é€šè®¯è°ƒè¯•é¢æ¿" FontSize="16" FontWeight="Bold" Foreground="White"/>
        </Border>

        <!-- æ¨¡æ‹Ÿå™¨è¿žæŽ¥æŽ§åˆ¶åŒº -->
        <Border Grid.Row="1" BorderBrush="#DDD" BorderThickness="1" CornerRadius="4" Padding="12" Background="#FAFAFA">
            <Grid dp:GridHelper.Space="8">
                <Grid.RowDefinitions>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                </Grid.RowDefinitions>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="80"/>
                    <ColumnDefinition Width="150"/>
                    <ColumnDefinition Width="80"/>
                    <ColumnDefinition Width="100"/>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="Auto"/>
                </Grid.ColumnDefinitions>

                <!-- ç¬¬ä¸€è¡Œï¼šæ€»çº¿åç§°å’ŒèŠ‚点编号 -->
                <TextBlock Grid.Row="0" Grid.Column="0" Text="总线名称:" VerticalAlignment="Center" FontWeight="SemiBold"/>
                <TextBox Grid.Row="0" Grid.Column="1" x:Name="busNameInput" 
                         VerticalContentAlignment="Center" Padding="6,4" Text="CAN_BUS_1"/>

                <TextBlock Grid.Row="0" Grid.Column="2" Text="节点编号:" VerticalAlignment="Center" FontWeight="SemiBold" Margin="8,0,0,0"/>
                <TextBox Grid.Row="0" Grid.Column="3" x:Name="nodeIndexInput" 
                         VerticalContentAlignment="Center" Padding="6,4" Text="0"/>

                <Button Grid.Row="0" Grid.Column="5" x:Name="connectBtn" Content="连接" Width="80" Height="30"
                        Click="ConnectBtn_Click" 
                        Background="#4CAF50" Foreground="White" BorderThickness="0" Cursor="Hand" FontWeight="SemiBold"/>

                <!-- ç¬¬äºŒè¡Œï¼šçŠ¶æ€æ˜¾ç¤ºå’ŒæŽ§åˆ¶æŒ‰é’® -->
                <TextBlock Grid.Row="1" Grid.Column="0" Text="状态:" VerticalAlignment="Center" FontWeight="SemiBold"/>
                <StackPanel Grid.Row="1" Grid.Column="1" Grid.ColumnSpan="2" Orientation="Horizontal" VerticalAlignment="Center">
                    <Ellipse x:Name="statusIndicator" Width="12" Height="12" Fill="#9E9E9E" Margin="0,0,6,0"/>
                    <TextBlock x:Name="statusText" Text="未连接" VerticalAlignment="Center"/>
                </StackPanel>

                <TextBlock Grid.Row="1" Grid.Column="3" Text="统计:" VerticalAlignment="Center" FontWeight="SemiBold" Margin="8,0,0,0"/>
                <TextBlock Grid.Row="1" Grid.Column="4" x:Name="statsText" Text="TX: 0  RX: 0" 
                           VerticalAlignment="Center" Foreground="#666"/>

                <StackPanel Grid.Row="1" Grid.Column="5" Orientation="Horizontal">
                    <ToggleButton x:Name="autoResponseToggleBtn" Content="自动响应: å…³" Width="100" Height="28" Margin="0,0,4,0"
                                  Click="AutoResponseToggleBtn_Click" IsEnabled="False" IsChecked="False"
                                  Background="#9E9E9E" Foreground="White" BorderThickness="0" Cursor="Hand" FontWeight="SemiBold"/>
                    <ToggleButton x:Name="maintenanceToggleBtn" Content="维护模式: å¼€" Width="100" Height="28" Margin="0,0,4,0"
                                  Click="MaintenanceToggleBtn_Click" IsEnabled="False" IsChecked="True"
                                  Background="#4CAF50" Foreground="White" BorderThickness="0" Cursor="Hand" FontWeight="SemiBold"/>
                    <Button x:Name="disconnectBtn" Content="断开" Width="60" Height="28" Margin="0,0,4,0"
                            Click="DisconnectBtn_Click" IsEnabled="False"
                            Background="#F44336" Foreground="White" BorderThickness="0" Cursor="Hand"/>
                    <Button x:Name="promiscuousBtn" Content="混杂模式" Width="80" Height="28"
                            Click="PromiscuousBtn_Click" IsEnabled="False"
                            Background="#2196F3" Foreground="White" BorderThickness="0" Cursor="Hand"/>
                </StackPanel>
            </Grid>
        </Border>

        <!-- å‘送区 -->
        <Border Grid.Row="2" BorderBrush="#DDD" BorderThickness="1" CornerRadius="4" Padding="12">
            <Grid dp:GridHelper.Space="8">
                <Grid.RowDefinitions>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                </Grid.RowDefinitions>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="80"/>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="Auto"/>
                </Grid.ColumnDefinitions>

                <!-- å¸§ID -->
                <TextBlock Grid.Row="0" Grid.Column="0" Text="帧 ID:" VerticalAlignment="Center" FontWeight="Bold"/>
                <TextBox Grid.Row="0" Grid.Column="1" x:Name="frameIdInput"
                         IsEnabled="{Binding IsMaintenanceMode, RelativeSource={RelativeSource AncestorType=UserControl}}"
                         VerticalContentAlignment="Center" Padding="6,4" Text="0x100"/>

                <!-- æ•°æ® -->
                <TextBlock Grid.Row="1" Grid.Column="0" Text="数据(Hex):" VerticalAlignment="Center" FontWeight="Bold"/>
                <TextBox Grid.Row="1" Grid.Column="1" x:Name="dataInput"
                         IsEnabled="{Binding IsMaintenanceMode, RelativeSource={RelativeSource AncestorType=UserControl}}"
                         VerticalContentAlignment="Center" Padding="6,4" Text="00 00 00 00 00 00 00 00"/>

                <!-- å‘送按钮 -->
                <Button Grid.Row="1" Grid.Column="2" x:Name="sendBtn" Content="发送" Width="80" Height="30"
                        IsEnabled="{Binding IsMaintenanceMode, RelativeSource={RelativeSource AncestorType=UserControl}}"
                        Click="SendBtn_Click" 
                        Background="#FF9800" Foreground="White" BorderThickness="0" Cursor="Hand" FontWeight="SemiBold"/>
            </Grid>
        </Border>

        <!-- æŽ¥æ”¶åŒº -->
        <Border Grid.Row="3" BorderBrush="#DDD" BorderThickness="1" CornerRadius="4">
            <Grid>
             d:DesignHeight="720" d:DesignWidth="720">
    <Grid Margin="6">
                <Grid.RowDefinitions>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="*"/>
                </Grid.RowDefinitions>

                <DockPanel Grid.Row="0" Margin="8,6">
                    <Button x:Name="clearBtn" Content="清空" Padding="12,4" DockPanel.Dock="Right"
                            Click="ClearBtn_Click"
        <!-- é€šé“工具条 -->
        <Border Grid.Row="0" Background="#F5F5F5" BorderBrush="#DDD" BorderThickness="0,0,0,1" Padding="6,4">
            <StackPanel Orientation="Horizontal">
                <Button x:Name="addChannelBtn" Content="+ æ·»åŠ é€šé“" Width="100" Height="26" Margin="0,0,6,0"
                        Click="AddChannelBtn_Click"
                        Background="#2196F3" Foreground="White" BorderThickness="0" Cursor="Hand" FontWeight="SemiBold"/>
                <Button x:Name="closeChannelBtn" Content="关闭当前通道" Width="110" Height="26"
                        Click="CloseChannelBtn_Click"
                            Background="#9E9E9E" Foreground="White" BorderThickness="0" Cursor="Hand"/>
                    <TextBlock Text="接收记录" FontWeight="Bold" FontSize="14" VerticalAlignment="Center"/>
                </DockPanel>
            </StackPanel>
        </Border>

                <ListView Grid.Row="1" x:Name="receiveList"
                          Style="{StaticResource DefaultListTable}"
                          VirtualizingPanel.IsVirtualizing="True"
                          VirtualizingPanel.VirtualizationMode="Standard">
                    <ListView.View>
                        <GridView AllowsColumnReorder="False">
                            <GridViewColumn Width="90" Header="时间">
                                <GridViewColumn.CellTemplate>
                                    <DataTemplate>
                                        <Border Style="{StaticResource CellBorder}">
                                            <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                       Text="{Binding Timestamp, StringFormat=HH:mm:ss.fff}"/>
                                        </Border>
                                    </DataTemplate>
                                </GridViewColumn.CellTemplate>
                            </GridViewColumn>
                            <GridViewColumn Width="80" Header="帧ID">
                                <GridViewColumn.CellTemplate>
                                    <DataTemplate>
                                        <Border Style="{StaticResource CellBorder}">
                                            <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                       Text="{Binding FrameId}"/>
                                        </Border>
                                    </DataTemplate>
                                </GridViewColumn.CellTemplate>
                            </GridViewColumn>
                            <GridViewColumn Width="50" Header="DLC">
                                <GridViewColumn.CellTemplate>
                                    <DataTemplate>
                                        <Border Style="{StaticResource CellBorder}">
                                            <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                       Text="{Binding Dlc}"/>
                                        </Border>
                                    </DataTemplate>
                                </GridViewColumn.CellTemplate>
                            </GridViewColumn>
                            <GridViewColumn Width="200" Header="数据">
                                <GridViewColumn.CellTemplate>
                                    <DataTemplate>
                                        <Border Style="{StaticResource CellBorder}">
                                            <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                       Text="{Binding Data}" FontFamily="Consolas"/>
                                        </Border>
                                    </DataTemplate>
                                </GridViewColumn.CellTemplate>
                            </GridViewColumn>
                            <GridViewColumn Width="50" Header="方向">
                                <GridViewColumn.CellTemplate>
                                    <DataTemplate>
                                        <Border Style="{StaticResource CellBorder}">
                                            <TextBlock Text="{Binding Direction}">
                                                <TextBlock.Style>
                                                    <Style TargetType="TextBlock" BasedOn="{StaticResource ListTableTextBlock}">
                                                        <Style.Triggers>
                                                            <DataTrigger Binding="{Binding Direction}" Value="TX">
                                                                <Setter Property="Foreground" Value="#2196F3"/>
                                                            </DataTrigger>
                                                            <DataTrigger Binding="{Binding Direction}" Value="RX">
                                                                <Setter Property="Foreground" Value="#4CAF50"/>
                                                            </DataTrigger>
                                                        </Style.Triggers>
                                                    </Style>
                                                </TextBlock.Style>
                                            </TextBlock>
                                        </Border>
                                    </DataTemplate>
                                </GridViewColumn.CellTemplate>
                            </GridViewColumn>
                            <GridViewColumn Width="100" Header="来源">
                                <GridViewColumn.CellTemplate>
                                    <DataTemplate>
                                        <Border Style="{StaticResource CellBorder}">
                                            <TextBlock Style="{StaticResource ListTableTextBlock}" 
                                                       Text="{Binding Source}"/>
                                        </Border>
                                    </DataTemplate>
                                </GridViewColumn.CellTemplate>
                            </GridViewColumn>
                        </GridView>
                    </ListView.View>
                </ListView>
            </Grid>
        </Border>
        <!-- å¤šé€šé“标签页 -->
        <TabControl Grid.Row="1" x:Name="channelTabs" Background="White" BorderThickness="0"/>
    </Grid>
</UserControl>

 Plugin.DeviceDebug/Panels/CanDebugPanel.xaml.cs

@@ -1,44 +1,25 @@
using Aging.Infrastructure.Drivers;
using log4net;
using Plugin.DeviceDebug.Entity;
using System;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Linq;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Threading;

namespace Plugin.DeviceDebug.Panels
{
    /// <summary>
    /// CAN å¸§æ˜¾ç¤ºæ¨¡åž‹
    /// </summary>
    public class CanFrameDisplay
    {
        public DateTime Timestamp { get; set; }
        public string FrameId { get; set; } = string.Empty;
        public int Dlc { get; set; }
        public string Data { get; set; } = string.Empty;
        public string Direction { get; set; } = string.Empty; // TX / RX
        public string Source { get; set; } = string.Empty;
    }

    /// <summary>
    /// CanDebugPanel.xaml çš„交互逻辑
    /// CAN è°ƒè¯•é¢æ¿å¤šé€šé“壳：以 TabControl æ‰¿è½½è‹¥å¹² <see cref="CanChannelView"/>，
    /// æ”¯æŒåŒå±å¹¶åˆ—多个 CAN é€šé“独立收发（验收场景 4）。
    /// å¯¹å¤–保持与旧单面板一致的属性契约（DeviceId/InitialBusName/InitialNodeIndex/
    /// AutoConnectOnLoad/ExistingDriver/IsMaintenanceMode/OnCommandExecute），
    /// DeviceDebug é€‰è®¾å¤‡æ—¶è¿™äº›é…ç½®è¢«è½¬å‘到"设备通道"（首个 Tab）。
    /// </summary>
    public partial class CanDebugPanel : UserControl
    {
        private static readonly ILog log = LogManager.GetLogger(typeof(CanDebugPanel));

        /// <summary>
        /// æ˜¯å¦ä¸ºç»´æŠ¤æ¨¡å¼ï¼ˆæŽ§åˆ¶è¾“入可用性）
        /// </summary>
        public static readonly DependencyProperty IsMaintenanceModeProperty =
            DependencyProperty.Register(nameof(IsMaintenanceMode), typeof(bool), typeof(CanDebugPanel),
                new PropertyMetadata(false));
                new PropertyMetadata(false, OnMaintenanceModeChanged));

        public bool IsMaintenanceMode
        {
@@ -46,498 +27,135 @@
            set => SetValue(IsMaintenanceModeProperty, value);
        }

        /// <summary>
        /// å‘½ä»¤æ‰§è¡Œäº‹ä»¶
        /// </summary>
        private static void OnMaintenanceModeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var panel = (CanDebugPanel)d;
            if (panel._deviceChannel != null)
                panel._deviceChannel.IsMaintenanceMode = (bool)e.NewValue;
        }

        /// <summary>命令执行事件（任一通道触发均上抛，供 DeviceDebug ç»Ÿä¸€å¤„理）</summary>
        public event EventHandler<DebugCommand>? OnCommandExecute;

        /// <summary>
        /// æŽ¥æ”¶å¸§åˆ—表
        /// </summary>
        public ObservableCollection<CanFrameDisplay> ReceivedFrames { get; } = new();
        private CanChannelView? _deviceChannel;
        private int _manualSeq;

        /// <summary>
        /// CAN é©±åŠ¨é€‚配器
        /// </summary>
        private CanDriverAdapter? _driver;

        /// <summary>
        /// è½®è¯¢å®šæ—¶å™¨ï¼ˆç”¨äºŽæ£€æŸ¥æŽ¥æ”¶é‚®ç®±ï¼‰
        /// </summary>
        private DispatcherTimer? _pollTimer;

        /// <summary>
        /// æ˜¯å¦å·²è¿žæŽ¥
        /// </summary>
        private bool _isConnected;

        /// <summary>
        /// è®¾å¤‡ID（从 DeviceDebug ä¼ å…¥ï¼Œé¢æ¿è‡ªåŠ¨æ‹¼æŽ¥ deviceId）
        /// </summary>
        public string DeviceId
        {
            get => _deviceId;
            set
            {
                _deviceId = value;
                if (!string.IsNullOrEmpty(value))
                {
                    // å°†è®¾å¤‡ID前缀拼接到默认设备标识中，避免与模拟器面板重名
                    UpdateDeviceIdDisplay();
                }
            }
        }
        // å¾…转发到设备通道的配置（可能早于通道创建）
        private string _deviceId = string.Empty;

        /// <summary>
        /// ä»Žè®¾å¤‡ Endpoint è§£æžå‡ºçš„总线名称
        /// </summary>
        public string InitialBusName { get; set; }

        /// <summary>
        /// ä»Žè®¾å¤‡ Endpoint è§£æžå‡ºçš„节点编号
        /// </summary>
        public int? InitialNodeIndex { get; set; }

        /// <summary>
        /// æ˜¯å¦è‡ªåŠ¨è¿žæŽ¥ï¼ˆä»Ž DeviceDebug æ‰“开时=true）
        /// </summary>
        public bool AutoConnectOnLoad { get; set; }
        private string _initialBusName;
        private int? _initialNodeIndex;
        private bool _autoConnectOnLoad;
        private Aging.Infrastructure.Contracts.IDeviceDriver? _existingDriver;

        public CanDebugPanel()
        {
            InitializeComponent();
            receiveList.ItemsSource = ReceivedFrames;
            InitializePollTimer();
            Loaded += CanDebugPanel_Loaded;
        }

        private void CanDebugPanel_Loaded(object sender, RoutedEventArgs e)
        /// <summary>设备ID（转发到设备通道）</summary>
        public string DeviceId
        {
            Loaded -= CanDebugPanel_Loaded;

            // ä»Žè®¾å¤‡ä¿¡æ¯åˆå§‹åŒ–总线/节点输入
            if (!string.IsNullOrEmpty(InitialBusName))
            {
                busNameInput.Text = InitialBusName;
            }
            if (InitialNodeIndex.HasValue)
            {
                nodeIndexInput.Text = InitialNodeIndex.Value.ToString();
            get => _deviceId;
            set { _deviceId = value; EnsureDeviceChannel().DeviceId = value; }
            }

            // è‡ªåŠ¨è¿žæŽ¥
            if (AutoConnectOnLoad)
        /// <summary>总线名称（转发到设备通道）</summary>
        public string InitialBusName
            {
                Dispatcher.BeginInvoke(new Action(() =>
                {
                    try { DoConnect(); }
                    catch (Exception ex) { log.Warn($"自动连接失败: {ex.Message}"); }
                }), DispatcherPriority.Background);
            }
            get => _initialBusName;
            set { _initialBusName = value; EnsureDeviceChannel().InitialBusName = value; }
        }

        private void UpdateDeviceIdDisplay()
        /// <summary>节点编号（转发到设备通道）</summary>
        public int? InitialNodeIndex
        {
            if (!string.IsNullOrEmpty(_deviceId) && busNameInput != null)
            {
                // ä¿ç•™é»˜è®¤æ€»çº¿åï¼Œä»…记录 deviceId ä»¥ä¾›æ—¥å¿—使用
                log.Info($"[CanDebugPanel] å…³è”设备: {_deviceId}");
            }
            get => _initialNodeIndex;
            set { _initialNodeIndex = value; EnsureDeviceChannel().InitialNodeIndex = value; }
        }

        /// <summary>
        /// åˆå§‹åŒ–轮询定时器
        /// </summary>
        private void InitializePollTimer()
        /// <summary>加载即自动连接（转发到设备通道）</summary>
        public bool AutoConnectOnLoad
        {
            _pollTimer = new DispatcherTimer
            {
                Interval = TimeSpan.FromMilliseconds(100) // 100ms è½®è¯¢ä¸€æ¬¡
            };
            _pollTimer.Tick += PollTimer_Tick;
            get => _autoConnectOnLoad;
            set { _autoConnectOnLoad = value; EnsureDeviceChannel().AutoConnectOnLoad = value; }
        }

        /// <summary>
        /// è½®è¯¢å®šæ—¶å™¨å›žè°ƒ - ä»…更新统计信息（帧显示由事件驱动）
        /// </summary>
        private void PollTimer_Tick(object? sender, EventArgs e)
        /// <summary>外部已注册驱动（转发到设备通道，共享设备复用宿主通路）</summary>
        public Aging.Infrastructure.Contracts.IDeviceDriver? ExistingDriver
        {
            if (!_isConnected || _driver == null) return;

            try
            {
                // æ›´æ–°ç»Ÿè®¡
                UpdateStats();
            }
            catch (Exception ex)
            {
                log.Error($"轮询统计更新失败: {ex.Message}");
            }
            get => _existingDriver;
            set { _existingDriver = value; EnsureDeviceChannel().ExistingDriver = value; }
        }

        /// <summary>
        /// è¿žæŽ¥æŒ‰é’®ç‚¹å‡»
        /// </summary>
        private void ConnectBtn_Click(object sender, RoutedEventArgs e)
        /// <summary>惰性创建"设备通道"（首个 Tab），并挂接命令事件与当前维护态。</summary>
        private CanChannelView EnsureDeviceChannel()
        {
            try
            {
                DoConnect();
            }
            catch (Exception ex)
            {
                log.Error($"CAN è¿žæŽ¥å¤±è´¥: {ex.Message}", ex);
                MessageBox.Show($"连接失败: {ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                UpdateConnectionStatus(false);
            }
            if (_deviceChannel != null) return _deviceChannel;

            _deviceChannel = new CanChannelView();
            WireChannel(_deviceChannel, MakeHeader(_deviceId, _initialBusName, _initialNodeIndex));
            // åº”用已到达的维护态
            _deviceChannel.IsMaintenanceMode = IsMaintenanceMode;
            var devTab = MakeTab(_deviceChannel);
            devTab.Header = MakeHeader(_deviceId, _initialBusName, _initialNodeIndex);
            channelTabs.Items.Add(devTab);
            return _deviceChannel;
        }

        /// <summary>
        /// å®žé™…连接逻辑（从 UI æˆ–自动连接调用）
        /// </summary>
        private void DoConnect()
        private void WireChannel(CanChannelView view, string header)
        {
            if (_isConnected) return;

            string busName = busNameInput.Text.Trim();
            if (!int.TryParse(nodeIndexInput.Text.Trim(), out int nodeIndex))
            {
                throw new ArgumentException("节点编号格式错误");
            view.OnCommandExecute += (s, e) => OnCommandExecute?.Invoke(this, e);
            }

            // ä¼˜å…ˆä½¿ç”¨ DeviceDebug ä¼ å…¥çš„设备 ID，否则自动生成一个
            string deviceId = string.IsNullOrEmpty(_deviceId)
                ? $"CAN_Test_{nodeIndex}_{DateTime.Now:HHmmss}"
                : _deviceId;

            _driver = new CanDriverAdapter(deviceId, busName, nodeIndex);

            // è®¢é˜…驱动的帧接收事件（即时显示接收到的帧）
            _driver.DriverFrameReceived += OnDriverFrameReceived;

            // è¿žæŽ¥
            _driver.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();
            _isConnected = true;

            // æ¨¡æ‹Ÿå™¨æ¨¡å¼ä¸‹ï¼Œè¿žæŽ¥åŽè‡ªåŠ¨å¯ç”¨ç»´æŠ¤æ¨¡å¼ï¼ˆå…è®¸å‘送）
            IsMaintenanceMode = true;
            if (maintenanceToggleBtn != null)
        private TabItem MakeTab(CanChannelView view)
            {
                maintenanceToggleBtn.IsChecked = true;
                maintenanceToggleBtn.IsEnabled = true;
            // å¤ç”¨è§†å›¾è‡ªèº«çš„标题区不显示设备名，这里用 Tab å¤´æ ‡æ³¨é€šé“身份
            return new TabItem { Content = view };
            }

            // æ›´æ–° UI
            UpdateConnectionStatus(true);
            _pollTimer?.Start();

            log.Info($"CAN é©±åŠ¨å·²è¿žæŽ¥: Bus={busName}, Node={nodeIndex}, DeviceId={deviceId}");
        private static string MakeHeader(string deviceId, string bus, int? node)
        {
            string id = string.IsNullOrEmpty(deviceId) ? "通道" : deviceId;
            if (!string.IsNullOrEmpty(bus))
                return $"{id} @{bus}:{node}";
            return id;
        }

        /// <summary>
        /// é©±åŠ¨å¸§æŽ¥æ”¶äº‹ä»¶å¤„理 - å³æ—¶æ˜¾ç¤ºæŽ¥æ”¶åˆ°çš„帧
        /// </summary>
        private void OnDriverFrameReceived(object? sender, CanSimulator.CanFrame frame)
        /// <summary>手动添加一个可编辑的空白通道（Local TCP ç›´è¿žï¼Œç”¨æˆ·è‡ªå¡«æ€»çº¿/节点后连接）。</summary>
        private void AddChannelBtn_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                // åˆ¤æ–­æ–¹å‘：如果帧的来源是当前节点，则为自动响应（显示为 RX）
                string direction = "RX";
                string source = frame.SourceNodeId;

                AddReceivedFrame(
                    frame.FrameIdHex,
                    frame.DataHex,
                    direction,
                    source
                );

                log.Debug($"[即时显示] æŽ¥æ”¶å¸§: {frame}");
            }
            catch (Exception ex)
            {
                log.Error($"即时显示帧失败: {ex.Message}", ex);
            }
            var view = new CanChannelView { AutoConnectOnLoad = false };
            _manualSeq++;
            string header = $"CAN é€šé“ #{_manualSeq}";   // æ‰‹åŠ¨é€šé“具体总线/节点由用户页内填写，标签不预设
            WireChannel(view, header);
            var tab = MakeTab(view);
            tab.Header = header;
            channelTabs.Items.Add(tab);
            channelTabs.SelectedItem = tab;
            log.Info($"[CanDebugPanel] æ‰‹åŠ¨æ·»åŠ é€šé“ {header}");
        }

        /// <summary>
        /// æ–­å¼€æŒ‰é’®ç‚¹å‡»
        /// </summary>
        private void DisconnectBtn_Click(object sender, RoutedEventArgs e)
        /// <summary>关闭当前选中的通道（设备通道不可关闭，避免误退出 DeviceDebug ä¼šè¯è§†å›¾ï¼‰ã€‚</summary>
        private void CloseChannelBtn_Click(object sender, RoutedEventArgs e)
        {
            try
            if (channelTabs.SelectedItem is not TabItem tab) return;
            if (tab.Content == _deviceChannel)
            {
                _pollTimer?.Stop();
                if (_driver != null)
                {
                    _driver.DriverFrameReceived -= OnDriverFrameReceived;
                    _driver.DisconnectAsync().GetAwaiter().GetResult();
                    _driver.Dispose();
                }
                _driver = null;
                _isConnected = false;
                IsMaintenanceMode = false;

                UpdateConnectionStatus(false);
                log.Info("CAN é©±åŠ¨å·²æ–­å¼€");
            }
            catch (Exception ex)
            {
                log.Error($"CAN æ–­å¼€å¤±è´¥: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// æ··æ‚模式按钮点击
        /// </summary>
        private void PromiscuousBtn_Click(object sender, RoutedEventArgs e)
        {
            if (!_isConnected || _driver == null) return;

            try
            {
                _driver.QueryAsync("PROMISCUOUS", CancellationToken.None).GetAwaiter().GetResult();
                log.Info("已设置混杂模式（接收所有帧）");
                MessageBox.Show("已设置混杂模式，将接收所有 CAN å¸§", "提示", MessageBoxButton.OK, MessageBoxImage.Information);
            }
            catch (Exception ex)
            {
                log.Error($"设置混杂模式失败: {ex.Message}");
            }
        }

        /// <summary>
        /// ç»´æŠ¤æ¨¡å¼åˆ‡æ¢æŒ‰é’®ç‚¹å‡»
        /// </summary>
        private void MaintenanceToggleBtn_Click(object sender, RoutedEventArgs e)
        {
            bool isOn = maintenanceToggleBtn.IsChecked == true;
            IsMaintenanceMode = isOn;

            if (isOn)
            {
                maintenanceToggleBtn.Content = "维护模式: å¼€";
                maintenanceToggleBtn.Background = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#4CAF50"));
                log.Info("维护模式已开启（可发送 CAN å¸§ï¼‰");
            }
            else
            {
                maintenanceToggleBtn.Content = "维护模式: å…³";
                maintenanceToggleBtn.Background = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#9E9E9E"));
                log.Info("维护模式已关闭（只读监控）");
            }
        }

        /// <summary>
        /// è‡ªåŠ¨å“åº”模式切换按钮点击
        /// </summary>
        private void AutoResponseToggleBtn_Click(object sender, RoutedEventArgs e)
        {
            if (!_isConnected || _driver == null) return;

            try
            {
                bool isOn = autoResponseToggleBtn.IsChecked == true;

                // é€šè¿‡é©±åŠ¨å‘送命令启用/禁用自动响应
                string cmd = isOn ? "AUTO_RESPONSE:ON" : "AUTO_RESPONSE:OFF";
                _driver.QueryAsync(cmd, CancellationToken.None).GetAwaiter().GetResult();

                if (isOn)
                {
                    autoResponseToggleBtn.Content = "自动响应: å¼€";
                    autoResponseToggleBtn.Background = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF9800"));
                    log.Info("自动响应模式已开启（收到帧将自动回复）");
                }
                else
                {
                    autoResponseToggleBtn.Content = "自动响应: å…³";
                    autoResponseToggleBtn.Background = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#9E9E9E"));
                    log.Info("自动响应模式已关闭");
                }
            }
            catch (Exception ex)
            {
                log.Error($"切换自动响应模式失败: {ex.Message}");
                MessageBox.Show($"切换失败: {ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        /// <summary>
        /// æ›´æ–°è¿žæŽ¥çŠ¶æ€æ˜¾ç¤º
        /// </summary>
        private void UpdateConnectionStatus(bool connected)
        {
            _isConnected = connected;
            if (connected)
            {
                statusIndicator.Fill = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#4CAF50"));
                statusText.Text = "已连接";
                connectBtn.IsEnabled = false;
                disconnectBtn.IsEnabled = true;
                promiscuousBtn.IsEnabled = true;
                maintenanceToggleBtn.IsEnabled = true;
                autoResponseToggleBtn.IsEnabled = true;
                busNameInput.IsEnabled = false;
                nodeIndexInput.IsEnabled = false;
            }
            else
            {
                statusIndicator.Fill = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#9E9E9E"));
                statusText.Text = "未连接";
                connectBtn.IsEnabled = true;
                disconnectBtn.IsEnabled = false;
                promiscuousBtn.IsEnabled = false;
                maintenanceToggleBtn.IsEnabled = false;
                autoResponseToggleBtn.IsEnabled = false;
                busNameInput.IsEnabled = true;
                nodeIndexInput.IsEnabled = true;
            }
        }

        /// <summary>
        /// æ›´æ–°ç»Ÿè®¡ä¿¡æ¯
        /// </summary>
        private void UpdateStats()
        {
            if (_driver == null) return;

            try
            {
                var status = _driver.GetStatus();
                var response = _driver.QueryAsync("STATUS", CancellationToken.None).GetAwaiter().GetResult();
                // è§£æžçŠ¶æ€: "STATUS:Node=..., Active=True, Rx=0, Tx=0, Err=0, Mailbox=0|Bus=..."
                statsText.Text = $"TX: {GetStatValue(response, "Tx")}  RX: {GetStatValue(response, "Rx")}  Err: {GetStatValue(response, "Err")}";
            }
            catch
            {
                // å¿½ç•¥ç»Ÿè®¡æ›´æ–°å¤±è´¥
            }
        }

        /// <summary>
        /// ä»ŽçŠ¶æ€å­—符串中提取数值值
        /// </summary>
        private string GetStatValue(string statusStr, string key)
        {
            try
            {
                var parts = statusStr.Split(',');
                foreach (var part in parts)
                {
                    var kv = part.Trim().Split('=');
                    if (kv.Length == 2 && kv[0].Trim() == key)
                    {
                        return kv[1].Trim();
                    }
                }
            }
            catch { }
            return "0";
        }

        /// <summary>
        /// æ·»åŠ æŽ¥æ”¶å¸§
        /// </summary>
        public void AddReceivedFrame(string frameId, string data, string direction = "RX", string source = "")
        {
            try
            {
                var frame = new CanFrameDisplay
                {
                    Timestamp = DateTime.Now,
                    FrameId = frameId,
                    Dlc = data.Split(new[] { ' ', '-' }, StringSplitOptions.RemoveEmptyEntries).Length,
                    Data = data,
                    Direction = direction,
                    Source = source
                };

                Application.Current.Dispatcher.Invoke(() =>
                {
                    ReceivedFrames.Insert(0, frame);

                    // é™åˆ¶æ˜¾ç¤ºæ•°é‡
                    if (ReceivedFrames.Count > 500)
                    {
                        var toRemove = ReceivedFrames.Skip(500).ToList();
                        foreach (var item in toRemove)
                        {
                            ReceivedFrames.Remove(item);
                        }
                    }
                });
            }
            catch (Exception ex)
            {
                log.Error($"添加接收帧失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// å‘送按钮点击
        /// </summary>
        private void SendBtn_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (!IsMaintenanceMode)
                {
                    MessageBox.Show("当前为只读模式，无法发送数据", "提示", MessageBoxButton.OK, MessageBoxImage.Warning);
                MessageBox.Show("设备通道不可在此关闭，请从设备选择切换。", "提示",
                    MessageBoxButton.OK, MessageBoxImage.Information);
                    return;
                }
            if (tab.Content is CanChannelView view)
                view.DisconnectInternalSafe();
            channelTabs.Items.Remove(tab);
        }

                if (!_isConnected || _driver == null)
        /// <summary>更新设备通道 Tab å¤´ï¼ˆåœ¨é…ç½®é½å¤‡åŽè°ƒç”¨ä¸€æ¬¡å³å¯ï¼‰ã€‚</summary>
        public void RefreshDeviceHeader()
                {
                    MessageBox.Show("请先连接 CAN æ€»çº¿", "提示", MessageBoxButton.OK, MessageBoxImage.Warning);
                    return;
                }

                string frameIdStr = frameIdInput.Text.Trim();
                string dataStr = dataInput.Text.Trim();

                // éªŒè¯å¸§ ID
                uint frameId = CanSimulator.CanFrame.ParseFrameId(frameIdStr);

                // éªŒè¯æ•°æ®
                byte[] dataBytes = CanSimulator.CanFrame.ParseData(dataStr);
                if (dataBytes.Length > 8)
                {
                    MessageBox.Show("数据长度不能超过 8 å­—节", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                // é€šè¿‡é©±åŠ¨å‘送
                string command = $"SEND:{frameIdStr}:{dataStr}";
                var response = _driver.SendCommandAsync(command, CancellationToken.None).GetAwaiter().GetResult();

                // æ·»åŠ åˆ°æ˜¾ç¤ºåˆ—表（TX）
                AddReceivedFrame($"0x{frameId:X3}", BitConverter.ToString(dataBytes).Replace("-", " "), "TX", "LOCAL");

                log.Info($"发送 CAN å¸§: ID=0x{frameId:X3}, Data={BitConverter.ToString(dataBytes)}, Response={response}");
            }
            catch (Exception ex)
            {
                log.Error($"发送 CAN å¸§å¤±è´¥: {ex.Message}", ex);
                MessageBox.Show($"发送失败: {ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        /// <summary>
        /// æ¸…空按钮点击
        /// </summary>
        private void ClearBtn_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                ReceivedFrames.Clear();
                log.Info("清空 CAN æŽ¥æ”¶è®°å½•");
            }
            catch (Exception ex)
            {
                log.Error($"清空接收记录失败: {ex.Message}", ex);
            }
            if (_deviceChannel == null || channelTabs.Items.Count == 0) return;
            if (channelTabs.Items[0] is TabItem t)
                t.Header = MakeHeader(_deviceId, _initialBusName, _initialNodeIndex);
        }
    }
}

 Plugin.IntegrationTest/App.config

New file
@@ -0,0 +1,12 @@
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <appSettings>
    <!-- V3.0 Â§05：仲裁域候选枚举（分号分隔，local- å‰ç¼€ä¸º Local ç›´è¿žåŸŸï¼Œå…¶ä½™ä¸º Broker åŸŸï¼‰ -->
    <add key="V3.AuthorityIds" value="local-main;broker-b01" />
    <!-- V3.0 Â§05：Broker å®¿ä¸»å€™é€‰æžšä¸¾ -->
    <add key="V3.BrokerIds" value="broker-b01" />
    <!-- CAN æ¨¡æ‹Ÿå™¨ç‹¬ç«‹ TCP æœåŠ¡åœ°å€ï¼ˆLocal é©±åŠ¨ä¸Ž Broker å®¿ä¸»å‡è¿žæ­¤ç«¯å£ï¼‰ -->
    <add key="CanSimulator.Host" value="127.0.0.1" />
    <add key="CanSimulator.Port" value="9000" />
  </appSettings>
</configuration>

 Plugin.IntegrationTest/MainWindow.xaml

@@ -116,6 +116,90 @@
                    <Border x:Name="canSimulatorHost" Grid.Row="1" Background="White" Margin="4"/>
                </Grid>
            </TabItem>

            <!-- Tab 5: å…¨è‡ªåŠ¨æµ‹è¯• -->
            <TabItem Header="  å…¨è‡ªåŠ¨æµ‹è¯•  " FontSize="13">
                <Grid Margin="8">
                    <Grid.RowDefinitions>
                        <RowDefinition Height="Auto"/>
                        <RowDefinition Height="Auto"/>
                        <RowDefinition Height="*"/>
                    </Grid.RowDefinitions>

                    <!-- æ­¥éª¤ä¿¡æ¯åŒº -->
                    <Border Grid.Row="0" Background="#FFF3E0" CornerRadius="4" Padding="14,10" Margin="0,0,0,8">
                        <StackPanel>
                            <TextBlock Text="CAN è€åŒ–自动化步骤示例（方案 B + C）" FontSize="16" FontWeight="Bold" Foreground="#E65100" Margin="0,0,0,8"/>
                            <WrapPanel>
                                <TextBlock Text="发送设备:" FontWeight="SemiBold" VerticalAlignment="Center" Margin="0,0,6,6"/>
                                <ComboBox x:Name="autoTxDeviceCombo" Width="150" Height="28" Margin="0,0,16,6"/>

                                <TextBlock Text="目标设备:" FontWeight="SemiBold" VerticalAlignment="Center" Margin="0,0,6,6"/>
                                <ComboBox x:Name="autoRxDeviceCombo" Width="150" Height="28" Margin="0,0,16,6"/>

                                <TextBlock Text="循环次数:" FontWeight="SemiBold" VerticalAlignment="Center" Margin="0,0,6,6"/>
                                <TextBox x:Name="autoLoopCount" Width="60" Height="28" Text="5" VerticalContentAlignment="Center" Padding="4,0" Margin="0,0,16,6"/>

                                <TextBlock Text="帧间隔(ms):" FontWeight="SemiBold" VerticalAlignment="Center" Margin="0,0,6,6"/>
                                <TextBox x:Name="autoInterval" Width="70" Height="28" Text="300" VerticalContentAlignment="Center" Padding="4,0" Margin="0,0,16,6"/>
                            </WrapPanel>

                            <StackPanel Orientation="Horizontal" Margin="0,8,0,0">
                                <Button x:Name="autoRunBtn" Content="▶ è¿è¡Œè‡ªåŠ¨åŒ–步骤" Width="180" Height="36" Margin="0,0,10,0"
                                        Click="AutoRunBtn_Click" Background="#FF9800" Foreground="White"
                                        BorderThickness="0" Cursor="Hand" FontWeight="SemiBold" FontSize="13"/>
                                <Button x:Name="perDeviceBtn" Content="▶ é€è®¾å¤‡ä¸€æ¬¡æ”¶å‘(CAN-001~004)" Width="250" Height="36" Margin="0,0,10,0"
                                        Click="PerDeviceCanTest_Click" Background="#3F51B5" Foreground="White"
                                        BorderThickness="0" Cursor="Hand" FontWeight="SemiBold" FontSize="13"/>
                                <Button x:Name="autoStopBtn" Content="■ ä¸­æ­¢" Width="90" Height="36" Margin="0,0,10,0"
                                        Click="AutoStopBtn_Click" Background="#F44336" Foreground="White"
                                        BorderThickness="0" Cursor="Hand" FontWeight="SemiBold" IsEnabled="False"/>
                                <ProgressBar x:Name="autoProgress" Width="300" Height="18" Margin="0,0,10,0"/>
                                <TextBlock x:Name="autoProgressText" Text="就绪" VerticalAlignment="Center" Foreground="#666"/>
                            </StackPanel>
                        </StackPanel>
                    </Border>

                    <!-- ä»£ç é¢„览 -->
                    <Expander Grid.Row="1" Header="查看等价代码（方案 B + C ä½¿ç”¨ç¤ºä¾‹ï¼‰" IsExpanded="False" Margin="0,0,0,8">
                        <Border Background="#263238" Padding="12" CornerRadius="4" MaxHeight="280">
                            <ScrollViewer VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto">
                                <TextBlock FontFamily="Consolas" FontSize="12" Foreground="#ECEFF1">
<Run Foreground="#80CBC4">// ä¸šåŠ¡ä»£ç åªçœ‹åˆ°ç±»åž‹åŒ–服务（方案 C）和作域（方案 B）</Run>
<Run>&#10;</Run><Run Foreground="#FFCC80">using </Run><Run Foreground="#C5E1A5">var </Run><Run>lease = </Run><Run Foreground="#FFCC80">await </Run><Run>auto.AcquireAsync(</Run><Run Foreground="#C5E1A5">"CAN-001"</Run><Run>, </Run><Run Foreground="#C5E1A5">"CAN_Aging"</Run><Run>, ct);</Run>
<Run>&#10;</Run><Run Foreground="#C5E1A5">await </Run><Run>canBus.SetAutoResponseAsync(lease, enabled:</Run><Run Foreground="#F48FB1">true</Run><Run>);</Run>
<Run>&#10;</Run><Run Foreground="#89DDFF">for </Run><Run>(</Run><Run Foreground="#C5E1A5">int </Run><Run>i = 0; i &lt; cycles; i++)</Run>
<Run>&#10;</Run><Run>{</Run>
<Run>&#10;</Run><Run>    </Run><Run Foreground="#C5E1A5">await </Run><Run>canBus.SendFrameAsync(lease, 0x100 + i, data);</Run>
<Run>&#10;</Run><Run>    </Run><Run Foreground="#C5E1A5">var </Run><Run>echo = </Run><Run Foreground="#C5E1A5">await </Run><Run>canBus.ReceiveFrameAsync(lease, ct);</Run>
<Run>&#10;</Run><Run>    Verify(echo != </Run><Run Foreground="#FF5370">null</Run><Run>);  </Run><Run Foreground="#546E7A">// æ–­è¨€</Run>
<Run>&#10;</Run><Run>}</Run>
                                </TextBlock>
                            </ScrollViewer>
                        </Border>
                    </Expander>

                    <!-- æ—¥å¿—区 -->
                    <Border Grid.Row="2" BorderBrush="#DDD" BorderThickness="1" CornerRadius="4">
                        <Grid>
                            <Grid.RowDefinitions>
                                <RowDefinition Height="Auto"/>
                                <RowDefinition Height="*"/>
                            </Grid.RowDefinitions>
                            <DockPanel Grid.Row="0" Margin="10,6">
                                <TextBlock Text="自动化执行日志" FontWeight="Bold" FontSize="14"/>
                                <Button Content="清空" Padding="10,3" DockPanel.Dock="Right" Click="AutoClearLog_Click"
                                        Background="#9E9E9E" Foreground="White" BorderThickness="0" Cursor="Hand"/>
                            </DockPanel>
                            <TextBox Grid.Row="1" x:Name="autoLog"
                                     IsReadOnly="True" VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto"
                                     FontFamily="Consolas" FontSize="12"
                                     Background="#1E1E1E" Foreground="#D4D4D4"
                                     BorderThickness="0" Padding="10" TextWrapping="NoWrap" AcceptsReturn="True"/>
                        </Grid>
                    </Border>
                </Grid>
            </TabItem>
        </TabControl>

        <!-- åº•éƒ¨ç»“果栏 -->

 Plugin.IntegrationTest/MainWindow.xaml.cs

@@ -8,8 +8,12 @@
using System.Windows;
using System.Windows.Media;
using System.Windows.Threading;
using Aging.Infrastructure;
using Aging.Infrastructure.Contracts;
using Aging.Infrastructure.Drivers;
using Aging.Infrastructure.Services;
using CanSimulator;
using HMI.Core.Util;
using log4net;
using Plugin.DeviceConfig.Entity;
using Plugin.DeviceConfig.Model;
@@ -38,6 +42,14 @@
        private CanBusSimulator? _canBus;
        private CanDebugPanel? _canDebugPanel;

        // V3.0：DeviceBroker å®¿ä¸»å­è¿›ç¨‹ï¼ˆå­˜åœ¨ Broker è®¾å¤‡æ—¶è‡ªåŠ¨æ‹‰èµ·ï¼‰
        private System.Diagnostics.Process? _brokerProcess;

        // è‡ªåŠ¨åŒ–测试服务
        private IAutoDeviceFacade? _autoFacade;
        private ICanBusService? _canBusService;
        private CancellationTokenSource? _autoCts;

        public MainWindow()
        {
            InitializeComponent();
@@ -51,9 +63,22 @@

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            // æ¸…理 CAN æ¨¡æ‹Ÿå™¨
            _canBus?.Dispose();
            CanDriverAdapter.ResetAllBuses();
            // å–消正在运行的自动化测试
            try { _autoCts?.Cancel(); } catch { }

            // åœæ­¢ DeviceBroker å®¿ä¸»ï¼ˆå…¶æŒæœ‰çš„物理会话随进程退出释放，租约靠 TTL è¿‡æœŸ+人工回收）
            try
            {
                if (_brokerProcess != null && !_brokerProcess.HasExited)
                {
                    _brokerProcess.Kill();
                    _brokerProcess.WaitForExit(3000);
                }
                _brokerProcess?.Dispose();
            }
            catch { }

            // CAN æ¨¡æ‹Ÿå™¨å·²å¤–部化为独立服务进程，本进程无进程内总线需清理

            // ä¸åˆ é™¤æµ‹è¯•ç›®å½•ï¼Œä¿ç•™æ•°æ®ä»¥ä¾¿é‡å¯åŽæ¢å¤
            // ï¼ˆå¦‚需手动重置，使用工具栏中的 "重置数据" æŒ‰é’®ï¼‰
@@ -74,22 +99,26 @@

            try
            {
                // åˆå§‹åŒ–仪器仪表注册插件
                // åˆå§‹åŒ–仪器仪表注册插件（建库 data.db）
                _deviceConfigPlugin = new Plugin.DeviceConfig.DeviceConfig();
                _deviceConfigPlugin.SetBaseFolder(_testDir);
                _deviceConfigPlugin.SetLogger(_testLog);
                _deviceConfigPlugin.InitFinish();
                deviceConfigHost.Child = _deviceConfigPlugin;

                // åˆå§‹åŒ–硬件调试插件
                // é¢„ç½® CAN æµ‹è¯•è®¾å¤‡ï¼ˆå¿…须在基础设施初始化前写入，Bootstrapper æ®æ­¤æ³¨å†Œä»£ç†é©±åŠ¨ï¼‰
                SeedPresetCanDevices();

                // åˆå§‹åŒ–基础设施 & è‡ªåŠ¨åŒ–服务（必须在 DeviceDebug.InitFinish ä¹‹å‰ï¼š
                // å®ƒä»Ž UtilContainer æ‹‰å– DeviceManager/ResourceManager，注册在 Bootstrapper.Initialize å®Œæˆï¼‰
                InitializeAutoServices();

                // åˆå§‹åŒ–硬件调试插件（此时基础设施服务已就绪，维护租约/驱动复用链路可用）
                _deviceDebugPlugin = new Plugin.DeviceDebug.DeviceDebug();
                _deviceDebugPlugin.SetBaseFolder(_testDir);
                _deviceDebugPlugin.SetLogger(_testLog);
                _deviceDebugPlugin.InitFinish();
                deviceDebugHost.Child = _deviceDebugPlugin;

                // é¢„ç½® CAN æµ‹è¯•è®¾å¤‡ï¼ˆæ–¹ä¾¿ç›´æŽ¥éªŒè¯é©±åŠ¨ä¸Žé¢æ¿ï¼‰
                SeedPresetCanDevices();

                // åˆ·æ–°æ’件内部列表（需手动调用插件方法）
                _deviceConfigPlugin.ForceRefreshForTest();
@@ -107,7 +136,8 @@
                Log("  2. å·²é¢„ç½® CAN-001 (CAN_BUS_1:0) å’Œ CAN-002 (CAN_BUS_1:1) ä¾›æµ‹è¯•");
                Log("  3. åˆ‡æ¢åˆ° '硬件调试' Tab，选择 CAN-001 ä¼šè‡ªåŠ¨æ‰“å¼€ CAN é¢æ¿å¹¶è¿žæŽ¥æ€»çº¿");
                Log("  4. åˆ‡æ¢åˆ° 'CAN æ¨¡æ‹Ÿå™¨' Tab å¯æ‰‹åŠ¨æŽ§åˆ¶æ€»çº¿æˆ–另一个节点发送数据");
                Log("  5. å¯éšæ—¶ç‚¹å‡» '运行自动化测试' éªŒè¯æ ¸å¿ƒé€»è¾‘");
                Log("  5. åˆ‡æ¢åˆ° '全自动测试' Tab å¯ä½“验方案 B+C çš„自动化步骤");
                Log("  6. å¯éšæ—¶ç‚¹å‡» '运行自动化测试' éªŒè¯æ ¸å¿ƒé€»è¾‘");
            }
            catch (Exception ex)
            {
@@ -628,6 +658,402 @@
            }
        }

        #region å…¨è‡ªåŠ¨æµ‹è¯•ï¼ˆæ–¹æ¡ˆ B+C）

        /// <summary>
        /// åˆå§‹åŒ–自动化服务：
        ///   1) å¯åŠ¨ Infrastructure Bootstrapper（ResourceManager/DeviceManager/DeviceService/AutoDeviceFacade/CanBusService）
        ///   2) ä¸ºé¢„ç½® CAN è®¾å¤‡æ³¨å†Œé©±åŠ¨
        ///   3) å°†è®¾å¤‡åˆ—表填到 UI ä¸‹æ‹‰æ¡†
        /// </summary>
        private void InitializeAutoServices()
        {
            try
            {
                // åˆå§‹åŒ–基础设施（幂等，已初始化时自动跳过）
                string dbPath = Path.Combine(_testDir, "data.db");
                try { InfrastructureBootstrapper.Initialize(dbPath); }
                catch (Exception ex) { Log($"[WARN] Bootstrapper åˆå§‹åŒ–异常: {ex.Message}"); }

                // ä»Ž UtilContainer æ‹‰å–服务实例
                var container = new UtilContainer();
                _autoFacade = container.GetUtil<IAutoDeviceFacade>("AutoDeviceFacade");
                _canBusService = container.GetUtil<ICanBusService>("CanBusService");

                // ä¸ºé¢„置设备注册驱动（自动启动 CAN æ€»çº¿ï¼‰
                RegisterCanDriver("CAN-001", "CAN_BUS_1:0");
                RegisterCanDriver("CAN-002", "CAN_BUS_1:1");

                // åˆå§‹åŒ–设备下拉列表
                autoTxDeviceCombo.ItemsSource = new[] { "CAN-001", "CAN-002" };
                autoRxDeviceCombo.ItemsSource = new[] { "CAN-002", "CAN-001" };
                autoTxDeviceCombo.SelectedIndex = 0;
                autoRxDeviceCombo.SelectedIndex = 0;

                if (_autoFacade != null && _canBusService != null)
                {
                    Log("[INFO] AutoDeviceFacade å’Œ CanBusService å·²å°±ç»ª");
                    Log("[INFO] CAN-001 / CAN-002 é©±åŠ¨å·²æ³¨å†Œ");
                }
                else
                {
                    Log("[ERROR] è‡ªåŠ¨åŒ–服务未正确初始化，全自动测试 Tab ä¸å¯ç”¨");
                    autoRunBtn.IsEnabled = false;
                }

                // V3.0：若配置库存在 Broker åŸŸè®¾å¤‡ï¼Œè‡ªåŠ¨æ‹‰èµ· DeviceBroker.exe å®¿ä¸»
                TryStartDeviceBroker();
            }
            catch (Exception ex)
            {
                Log($"[ERROR] åˆå§‹åŒ–自动化服务失败: {ex.Message}");
                Log(ex.StackTrace ?? "");
                autoRunBtn.IsEnabled = false;
            }
        }

        /// <summary>
        /// V3.0：若 data.db ä¸­å­˜åœ¨ ExecutionMode=Broker çš„设备，自动拉起 DeviceBroker.exe å®¿ä¸»å­è¿›ç¨‹ã€‚
        /// å®¿ä¸»é»˜è®¤å‚数指向本环境同一 data.db/arb.db（同机仲裁域）；找不到可执行文件时降级为警告，
        /// Broker è®¾å¤‡å°†æŠ¥ BROKER_UNREACHABLE，Local è®¾å¤‡ä¸å—影响。
        /// </summary>
        private void TryStartDeviceBroker()
        {
            try
            {
                var model = new DeviceConfigModel();
                string dbPath = Path.Combine(_testDir, "data.db");
                if (!File.Exists(dbPath)) return;
                model.InitDatabase(dbPath);
                var brokerDevices = model.GetAllDevices()
                    .Where(d => d.ExecutionMode == Plugin.DeviceConfig.Entity.ExecutionModeKind.Broker)
                    .ToList();
                if (brokerDevices.Count == 0)
                {
                    Log("[INFO] æ—  Broker åŸŸè®¾å¤‡ï¼Œæœªå¯åŠ¨ DeviceBroker å®¿ä¸»");
                    return;
                }

                string exe = FindDeviceBrokerExe();
                if (exe == null)
                {
                    Log("[WARN] æœªæ‰¾åˆ° DeviceBroker.exe，Broker è®¾å¤‡é“¾è·¯ä¸å¯ç”¨ï¼ˆè¯·æž„建 DeviceBroker å·¥ç¨‹ï¼‰");
                    return;
                }

                var psi = new System.Diagnostics.ProcessStartInfo(exe)
                {
                    Arguments = $"--db \"{dbPath}\" --arb \"{Path.Combine(_testDir, "arb.db")}\" --broker broker-b01",
                    UseShellExecute = false,
                    CreateNoWindow = true,
                };
                _brokerProcess = System.Diagnostics.Process.Start(psi);
                Log($"[INFO] DeviceBroker å®¿ä¸»å·²å¯åŠ¨ (PID={_brokerProcess?.Id})，Broker è®¾å¤‡: " +
                    string.Join(", ", brokerDevices.Select(d => d.DeviceId)));
            }
            catch (Exception ex)
            {
                Log($"[WARN] å¯åŠ¨ DeviceBroker å¤±è´¥: {ex.Message}");
            }
        }

        private static string FindDeviceBrokerExe()
        {
            string baseDir = AppDomain.CurrentDomain.BaseDirectory;
            var candidates = new[]
            {
                Path.Combine(baseDir, "DeviceBroker.exe"),
                Path.Combine(baseDir, @"DeviceBroker\DeviceBroker.exe"),
                Path.GetFullPath(Path.Combine(baseDir, @"..\..\..\..\DeviceBroker\bin\Debug\net472\DeviceBroker.exe")),
                Path.GetFullPath(Path.Combine(baseDir, @"..\..\..\DeviceBroker\bin\Debug\net472\DeviceBroker.exe")),
            };
            foreach (var c in candidates)
            {
                try { if (File.Exists(c)) return c; } catch { }
            }
            return null;
        }

        /// <summary>
        /// å‘ DeviceManager æ³¨å†Œ CAN é©±åŠ¨ï¼ˆä½¿ç”¨ DriverFactory）
        /// </summary>
        private void RegisterCanDriver(string deviceId, string endpoint)
        {
            try
            {
                InfrastructureBootstrapper.RegisterDevice(deviceId, "CAN", endpoint);
            }
            catch (Exception ex)
            {
                Log($"[WARN] æ³¨å†Œè®¾å¤‡ {deviceId} é©±åŠ¨å¤±è´¥: {ex.Message}");
            }
        }

        /// <summary>
        /// è¿è¡Œè‡ªåŠ¨åŒ–步骤（封装完整流程：开总线 â†’ ç§Ÿçº¦ â†’ å‘送 â†’ å›žæ”¶ â†’ é‡Šæ”¾ï¼‰
        /// </summary>
        private async void AutoRunBtn_Click(object sender, RoutedEventArgs e)
        {
            if (_autoFacade == null || _canBusService == null)
            {
                AutoLog("[ERROR] æœåŠ¡æœªåˆå§‹åŒ–");
                return;
            }

            string txDevice = autoTxDeviceCombo.SelectedItem as string ?? "CAN-001";
            string rxDevice = autoRxDeviceCombo.SelectedItem as string ?? "CAN-002";

            if (!int.TryParse(autoLoopCount.Text, out int loops) || loops <= 0)
            {
                AutoLog("[ERROR] å¾ªçŽ¯æ¬¡æ•°å¿…须为正整数");
                return;
            }
            if (!int.TryParse(autoInterval.Text, out int intervalMs) || intervalMs < 0)
            {
                intervalMs = 200;
            }

            // ç¡®ä¿æ€»çº¿å·²å¯åŠ¨ï¼ˆä½¿ç”¨ CAN-001 é©±åŠ¨æ—¶ä¼šè‡ªåŠ¨å¯åŠ¨ï¼‰
            EnsureBusRunning();

            // å¯ç”¨ä¸­æ­¢æŒ‰é’®
            autoRunBtn.IsEnabled = false;
            autoStopBtn.IsEnabled = true;
            autoProgress.Maximum = loops;
            autoProgress.Value = 0;
            _autoCts = new CancellationTokenSource();
            var ct = _autoCts.Token;

            AutoLog("══════════════════════════════════════════════════════");
            AutoLog($"  CAN è€åŒ–自动化步骤开始");
            AutoLog($"  å‘送设备: {txDevice}, ç›®æ ‡è®¾å¤‡: {rxDevice}");
            AutoLog($"  å¾ªçŽ¯æ¬¡æ•°: {loops}, å¸§é—´éš”: {intervalMs}ms");
            AutoLog("══════════════════════════════════════════════════════");

            int successCount = 0;
            int failCount = 0;
            var swTotal = System.Diagnostics.Stopwatch.StartNew();

            // ===== æ–¹æ¡ˆ B：作用域租约（一次申请，多次使用） =====
            try
            {
                using var lease = await _autoFacade.AcquireAsync(txDevice, "CAN_Aging", ct);
                AutoLog($"[租约] å·²èŽ·å¾— {txDevice} ä½œç”¨åŸŸç§Ÿçº¦: Session={lease.SessionId.Substring(0, 8)}, æ—¶åˆ» {lease.AcquiredAt:HH:mm:ss.fff}");

                // ===== æ–¹æ¡ˆ C：使用类型化服务 =====
                // ç›®æ ‡è®¾å¤‡å…ˆå¯ç”¨è‡ªåŠ¨å“åº”（以便回环验证）
                using var rxLease = await _autoFacade.AcquireAsync(rxDevice, "CAN_Aging_Rx", ct);
                AutoLog($"[租约] å·²èŽ·å¾— {rxDevice} ä½œç”¨åŸŸç§Ÿçº¦: Session={rxLease.SessionId.Substring(0, 8)}");
                await _canBusService.SetAutoResponseAsync(rxLease, true, ct);
                AutoLog($"[配置] å·²ä¸º {rxDevice} å¯ç”¨è‡ªåŠ¨å“åº”模式");

                for (int i = 0; i < loops; i++)
                {
                    if (ct.IsCancellationRequested) break;

                    uint frameId = (uint)(0x100 + i);
                    byte[] payload = new byte[] { (byte)i, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x5A };

                    // å‘送（走 txDevice ç§Ÿçº¦ï¼‰
                    bool sent = await _canBusService.SendFrameAsync(lease, frameId, payload, ct);
                    AutoLog($"[T+{i,3:D3}] TX  {frameId:X3} | {BitConverter.ToString(payload).Replace("-", " ")}  {(sent ? "✓" : "✗")}");

                    // æŽ¥æ”¶å›žå“ï¼ˆèµ° rxDevice ç§Ÿçº¦ï¼‰
                    await Task.Delay(intervalMs, ct);
                    var echo = await _canBusService.ReceiveFrameAsync(rxLease, ct);

                    if (echo != null)
                    {
                        AutoLog($"[R+{i,3:D3}] RX  {echo.FrameIdHex} | {echo.DataHex}  åŒ¹é…={(echo.FrameId == frameId ? "✓" : "✗")}");
                        if (echo.FrameId == frameId && echo.Data.SequenceEqual(payload)) successCount++;
                        else failCount++;
                    }
                    else
                    {
                        AutoLog($"[R+{i,3:D3}] RX  æ— å›žå“");
                        failCount++;
                    }

                    autoProgress.Value = i + 1;
                    autoProgressText.Text = $"{i + 1}/{loops} å®Œæˆ";
                }

                // æ”¶å°¾ï¼šå…³é—­è‡ªåŠ¨å“åº”
                await _canBusService.SetAutoResponseAsync(rxLease, false, ct);
                AutoLog($"[配置] å·²ä¸º {rxDevice} å…³é—­è‡ªåŠ¨å“åº”模式");
            }
            catch (OperationCanceledException)
            {
                AutoLog("[中止] ç”¨æˆ·æ‰‹åŠ¨ä¸­æ­¢æµ‹è¯•");
            }
            catch (TimeoutException ex)
            {
                AutoLog($"[失败] ç§Ÿçº¦ç”³è¯·è¶…æ—¶: {ex.Message}");
                failCount++;
            }
            catch (InvalidOperationException ex)
            {
                AutoLog($"[失败] èµ„源冲突: {ex.Message}");
                failCount++;
            }
            catch (Exception ex)
            {
                AutoLog($"[异常] {ex.GetType().Name}: {ex.Message}");
                failCount++;
            }
            finally
            {
                swTotal.Stop();
                // ä½¿ç”¨ lease.Dispose() ä¼šè‡ªåŠ¨é‡Šæ”¾ç§Ÿçº¦ï¼Œæ— éœ€æ‰‹åŠ¨å†™ä»£ç 
                _autoCts?.Dispose();
                _autoCts = null;

                AutoLog("");
                AutoLog("══════════════════════════════════════════════════════");
                AutoLog($"  æ­¥éª¤å®Œæˆ | æˆåŠŸ {successCount} | å¤±è´¥ {failCount} | æ€»è€—æ—¶ {swTotal.ElapsedMilliseconds}ms");
                AutoLog($"  ç§Ÿçº¦å·²è‡ªåŠ¨é‡Šæ”¾ï¼ˆusing ä½œç”¨åŸŸç»“束）");
                AutoLog("══════════════════════════════════════════════════════");

                autoRunBtn.IsEnabled = true;
                autoStopBtn.IsEnabled = false;
                autoProgressText.Text = "就绪";
            }
        }

        /// <summary>
        /// å…¨è‡ªåŠ¨Â·é€è®¾å¤‡ä¸€æ¬¡æ”¶å‘：模拟 TestPlan çš„ TestStep，对 CAN-001~004 é€ä¸€
        /// é€šè¿‡ç±»åž‹åŒ–服务/门面调用 CAN é©±åŠ¨ï¼Œå®Œæˆâ€œå‘送命令→接收回显”一次完整往返。
        /// ä¾èµ–总线应答器（BUS_ECHO）使单设备自发自收，无需对端设备。
        /// </summary>
        private async void PerDeviceCanTest_Click(object sender, RoutedEventArgs e)
        {
            if (_autoFacade == null || _canBusService == null)
            {
                AutoLog("[ERROR] æœåŠ¡æœªåˆå§‹åŒ–");
                return;
            }

            var devices = new[] { "CAN-001", "CAN-002", "CAN-003", "CAN-004" };
            perDeviceBtn.IsEnabled = false;
            autoStopBtn.IsEnabled = true;
            _autoCts = new CancellationTokenSource();
            var ct = _autoCts.Token;
            autoProgress.Maximum = devices.Length * 3 + 2;
            autoProgress.Value = 0;

            int passed = 0, failed = 0;
            var sw = System.Diagnostics.Stopwatch.StartNew();
            AutoLog("════════════════════════════════════════════════");
            AutoLog("  å…¨è‡ªåŠ¨Â·é€è®¾å¤‡ä¸€æ¬¡æ”¶å‘（模拟 TestPlan TestStep）");
            AutoLog("════════════════════════════════════════════════");

            // å…¨å±€å‰ç½®ï¼šå¯ç”¨æ€»çº¿åº”答器（使每次发送都能收到回显）
            await RunStepAsync("全局", "启用总线应答器 BUS_ECHO:ON", async () =>
                (await _autoFacade.QueryAsync(devices[0], "BUS_ECHO:ON", ct)).Success,
                ok => { if (ok) passed++; else failed++; autoProgress.Value++; });

            for (int idx = 0; idx < devices.Length; idx++)
            {
                if (ct.IsCancellationRequested) break;
                string dev = devices[idx];
                uint frameId = (uint)(0x300 + idx);
                byte[] payload = new byte[] { (byte)idx, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };

                // TestStep 1：发送命令帧（OneShot：内部 é¢„约→执行→释放）
                await RunStepAsync(dev, $"发送 0x{frameId:X3}", async () =>
                    await _canBusService.SendFrameAsync(dev, frameId, payload, ct),
                    ok => { if (ok) passed++; else failed++; autoProgress.Value++; });

                // TestStep 2：触发宿主 drain（Broker è®¾å¤‡å›žæ˜¾ç»æ­¤æŽå¸¦å›žå®¢æˆ·ç«¯ç¼“冲）
                await RunStepAsync(dev, "触发回显捎带(STATUS)", async () =>
                    (await _autoFacade.QueryAsync(dev, "STATUS", ct)).Success,
                    ok => { if (ok) passed++; else failed++; autoProgress.Value++; });

                // TestStep 3：接收回显并校验帧 ID
                await RunStepAsync(dev, "接收并校验回显", async () =>
                {
                    for (int t = 0; t < 10; t++)
                    {
                        var recv = await _canBusService.ReceiveFrameAsync(dev, ct);
                        if (recv != null)
                        {
                            bool match = recv.FrameId == frameId;
                            AutoLog($"    [{dev}] RX {recv.FrameIdHex} | {recv.DataHex}  åŒ¹é…={(match ? "✓" : "✗")}");
                            return match;
                        }
                        await Task.Delay(80, ct);
                    }
                    AutoLog($"    [{dev}] æœªæ”¶åˆ°å›žæ˜¾");
                    return false;
                },
                ok => { if (ok) passed++; else failed++; autoProgress.Value++; });
            }

            // å…¨å±€æ”¶å°¾ï¼šå…³é—­æ€»çº¿åº”答器
            await RunStepAsync("全局", "关闭总线应答器 BUS_ECHO:OFF", async () =>
                (await _autoFacade.QueryAsync(devices[0], "BUS_ECHO:OFF", ct)).Success,
                ok => { if (ok) passed++; else failed++; autoProgress.Value++; });

            sw.Stop();
            AutoLog("──────────────────────────────────────────────");
            AutoLog($"  å®Œæˆ | é€šè¿‡ {passed} | å¤±è´¥ {failed} | è€—æ—¶ {sw.ElapsedMilliseconds}ms");
            AutoLog("════════════════════════════════════════════════");
            autoProgressText.Text = $"通过 {passed} / å¤±è´¥ {failed}";
            perDeviceBtn.IsEnabled = true;
            autoStopBtn.IsEnabled = false;
            _autoCts?.Dispose();
            _autoCts = null;
        }

        /// <summary>模拟 TestPlan çš„ TestStep：命名步骤 + æ–­è¨€ + è®°å½•é€šè¿‡/失败。</summary>
        private async Task RunStepAsync(string device, string name, Func<Task<bool>> body, Action<bool> onDone)
        {
            AutoLog($"▶ [TestStep] {device} :: {name}");
            bool ok;
            try { ok = await body(); }
            catch (OperationCanceledException) { AutoLog("    [中止] ç”¨æˆ·å–消"); throw; }
            catch (Exception ex) { ok = false; AutoLog($"    å¼‚常: {ex.Message}"); }
            AutoLog($"    {(ok ? "PASS âœ“" : "FAIL âœ—")}");
            onDone(ok);
        }

        /// <summary>
        /// ä¸­æ­¢å½“前自动化测试
        /// </summary>
        private void AutoStopBtn_Click(object sender, RoutedEventArgs e)
        {
            _autoCts?.Cancel();
            AutoLog("[中止] å·²å‘送取消请求...");
        }

        /// <summary>
        /// æ¸…空自动化日志
        /// </summary>
        private void AutoClearLog_Click(object sender, RoutedEventArgs e)
        {
            autoLog.Clear();
        }

        /// <summary>
        /// æ€»çº¿ç”±å¤–部 CanSimulatorServer æ‰˜ç®¡ï¼Œæœ¬åœ°æ— éœ€å†å¯åŠ¨è¿›ç¨‹å†…总线（保留空实现兼容旧调用）。
        /// </summary>
        private void EnsureBusRunning() { }

        /// <summary>
        /// å‘自动化日志区追加日志
        /// </summary>
        private void AutoLog(string msg)
        {
            string line = $"{DateTime.Now:HH:mm:ss.fff} {msg}";
            Dispatcher.Invoke(() =>
            {
                autoLog.AppendText(line + Environment.NewLine);
                autoLog.ScrollToEnd();
            });
        }

        #endregion

        #region CAN æ¨¡æ‹Ÿå™¨

        /// <summary>
@@ -663,25 +1089,17 @@
                    return;
                }

                // é€šè¿‡ DriverFactory åˆ›å»º CAN é©±åŠ¨æ¥å¯åŠ¨æ€»çº¿
                // æ€»çº¿ç”±å¤–部模拟器服务托管：此处仅验证一个节点可接入（连通性探测）
                var driver = DriverFactory.CreateDriver("CAN_SIM_0", "CAN", $"{busName}:0");
                driver.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();

                // èŽ·å–总线实例
                var buses = CanDriverAdapter.GetAllBuses();
                if (buses.TryGetValue(busName, out var bus))
                {
                    _canBus = bus;
                    bus.Start();

                    // æ›´æ–° UI
                    canBusIndicator.Fill = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#4CAF50"));
                    canBusStatusText.Text = $"运行中 ({busName})";
                canBusStatusText.Text = $"已接入外部模拟器 ({busName})";
                    canStartBtn.IsEnabled = false;
                    canStopBtn.IsEnabled = true;

                    Log($"[CAN] æ€»çº¿ {busName} å·²å¯åŠ¨");
                }
                Log($"[CAN] å·²è¿žæŽ¥å¤–部模拟器总线 {busName}");
            }
            catch (Exception ex)
            {
@@ -720,7 +1138,6 @@
        {
            try
            {
                CanDriverAdapter.ResetAllBuses();
                _canBus = null;

                // æ›´æ–° UI
@@ -729,7 +1146,7 @@
                canStartBtn.IsEnabled = true;
                canStopBtn.IsEnabled = false;

                Log("[CAN] æ‰€æœ‰æ€»çº¿å·²é‡ç½®");
                Log("[CAN] æœ¬åœ°çŠ¶æ€å·²é‡ç½®ï¼ˆå¤–部模拟器总线不受影响）");
            }
            catch (Exception ex)
            {

 Plugin.IntegrationTest/Plugin.IntegrationTest.csproj

@@ -22,13 +22,12 @@
    <ProjectReference Include="..\Aging.Infrastructure\Aging.Infrastructure.csproj" />
  </ItemGroup>

  <ItemGroup>
    <Content Include="..\Libs\SQLite.Interop.dll" Link="SQLite.Interop.dll">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Content Include="..\Libs\SQLite.Interop.dll" Link="x64\SQLite.Interop.dll">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
  <!--
    ä¸è¦æ‰‹åŠ¨å¤åˆ¶ Libs\SQLite.Interop.dll åˆ°è¾“出目录。
    æ‰˜ç®¡å±‚ System.Data.SQLite ä¸º 1.0.118，其原生 interop(1.0.118) ç”± NuGet åŒ…
    stub.system.data.sqlite.core.netframework çš„ build ç›®æ ‡è‡ªåŠ¨æ”¾å…¥è¾“出的 x64\x86\ å­ç›®å½•ã€‚
    æ­¤å‰ç”¨ Content è¦†ç›– x64\SQLite.Interop.dll ä¼šå†™å…¥è¿‡æ—¶çš„ 1.0.113，导致
    â€œæ— æ³•åœ¨ SQLite.Interop.dll ä¸­æ‰¾åˆ°å…¥å£ç‚¹â€å¹¶ä½¿æ‰€æœ‰ä¾èµ– SQLite çš„初始化失败。
  -->

</Project>

 WPFProject/TapProject.sln

@@ -107,6 +107,18 @@
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Plugin.DeviceConfig", "..\Plugin.DeviceConfig\Plugin.DeviceConfig.csproj", "{0FEB8A27-7309-11F3-45F0-91187046F7F4}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Aging.ResourceContracts", "..\Aging.ResourceContracts\Aging.ResourceContracts.csproj", "{E515619B-022C-4C6D-A24A-E104C968DC8A}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Aging.MvpTests", "..\tests\Aging.MvpTests\Aging.MvpTests.csproj", "{1313DD41-DF07-488A-9898-0C41920A9A77}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DeviceBroker", "..\DeviceBroker\DeviceBroker.csproj", "{2F0A0A40-435E-4222-A0C1-F6B81F20B93C}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CanSimulatorServer.Core", "..\CanSimulatorServer\CanSimulatorServer.Core\CanSimulatorServer.Core.csproj", "{C2F743B2-8B57-43D9-925B-C1E0BBA497E8}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CanSimulatorServer.App", "..\CanSimulatorServer\CanSimulatorServer.App\CanSimulatorServer.App.csproj", "{347529BA-83DF-4D48-89F5-BEDCAF949F82}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Plugin.IntegrationTest", "..\Plugin.IntegrationTest\Plugin.IntegrationTest.csproj", "{D9A17F63-7C1A-C46E-B7AE-B9677D56B49D}"
EndProject
Global
    GlobalSection(SolutionConfigurationPlatforms) = preSolution
        Debug|Any CPU = Debug|Any CPU
@@ -729,6 +741,78 @@
        {0FEB8A27-7309-11F3-45F0-91187046F7F4}.Release|x64.Build.0 = Release|Any CPU
        {0FEB8A27-7309-11F3-45F0-91187046F7F4}.Release|x86.ActiveCfg = Release|Any CPU
        {0FEB8A27-7309-11F3-45F0-91187046F7F4}.Release|x86.Build.0 = Release|Any CPU
        {E515619B-022C-4C6D-A24A-E104C968DC8A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
        {E515619B-022C-4C6D-A24A-E104C968DC8A}.Debug|Any CPU.Build.0 = Debug|Any CPU
        {E515619B-022C-4C6D-A24A-E104C968DC8A}.Debug|x64.ActiveCfg = Debug|Any CPU
        {E515619B-022C-4C6D-A24A-E104C968DC8A}.Debug|x64.Build.0 = Debug|Any CPU
        {E515619B-022C-4C6D-A24A-E104C968DC8A}.Debug|x86.ActiveCfg = Debug|Any CPU
        {E515619B-022C-4C6D-A24A-E104C968DC8A}.Debug|x86.Build.0 = Debug|Any CPU
        {E515619B-022C-4C6D-A24A-E104C968DC8A}.Release|Any CPU.ActiveCfg = Release|Any CPU
        {E515619B-022C-4C6D-A24A-E104C968DC8A}.Release|Any CPU.Build.0 = Release|Any CPU
        {E515619B-022C-4C6D-A24A-E104C968DC8A}.Release|x64.ActiveCfg = Release|Any CPU
        {E515619B-022C-4C6D-A24A-E104C968DC8A}.Release|x64.Build.0 = Release|Any CPU
        {E515619B-022C-4C6D-A24A-E104C968DC8A}.Release|x86.ActiveCfg = Release|Any CPU
        {E515619B-022C-4C6D-A24A-E104C968DC8A}.Release|x86.Build.0 = Release|Any CPU
        {1313DD41-DF07-488A-9898-0C41920A9A77}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
        {1313DD41-DF07-488A-9898-0C41920A9A77}.Debug|Any CPU.Build.0 = Debug|Any CPU
        {1313DD41-DF07-488A-9898-0C41920A9A77}.Debug|x64.ActiveCfg = Debug|Any CPU
        {1313DD41-DF07-488A-9898-0C41920A9A77}.Debug|x64.Build.0 = Debug|Any CPU
        {1313DD41-DF07-488A-9898-0C41920A9A77}.Debug|x86.ActiveCfg = Debug|Any CPU
        {1313DD41-DF07-488A-9898-0C41920A9A77}.Debug|x86.Build.0 = Debug|Any CPU
        {1313DD41-DF07-488A-9898-0C41920A9A77}.Release|Any CPU.ActiveCfg = Release|Any CPU
        {1313DD41-DF07-488A-9898-0C41920A9A77}.Release|Any CPU.Build.0 = Release|Any CPU
        {1313DD41-DF07-488A-9898-0C41920A9A77}.Release|x64.ActiveCfg = Release|Any CPU
        {1313DD41-DF07-488A-9898-0C41920A9A77}.Release|x64.Build.0 = Release|Any CPU
        {1313DD41-DF07-488A-9898-0C41920A9A77}.Release|x86.ActiveCfg = Release|Any CPU
        {1313DD41-DF07-488A-9898-0C41920A9A77}.Release|x86.Build.0 = Release|Any CPU
        {2F0A0A40-435E-4222-A0C1-F6B81F20B93C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
        {2F0A0A40-435E-4222-A0C1-F6B81F20B93C}.Debug|Any CPU.Build.0 = Debug|Any CPU
        {2F0A0A40-435E-4222-A0C1-F6B81F20B93C}.Debug|x64.ActiveCfg = Debug|Any CPU
        {2F0A0A40-435E-4222-A0C1-F6B81F20B93C}.Debug|x64.Build.0 = Debug|Any CPU
        {2F0A0A40-435E-4222-A0C1-F6B81F20B93C}.Debug|x86.ActiveCfg = Debug|Any CPU
        {2F0A0A40-435E-4222-A0C1-F6B81F20B93C}.Debug|x86.Build.0 = Debug|Any CPU
        {2F0A0A40-435E-4222-A0C1-F6B81F20B93C}.Release|Any CPU.ActiveCfg = Release|Any CPU
        {2F0A0A40-435E-4222-A0C1-F6B81F20B93C}.Release|Any CPU.Build.0 = Release|Any CPU
        {2F0A0A40-435E-4222-A0C1-F6B81F20B93C}.Release|x64.ActiveCfg = Release|Any CPU
        {2F0A0A40-435E-4222-A0C1-F6B81F20B93C}.Release|x64.Build.0 = Release|Any CPU
        {2F0A0A40-435E-4222-A0C1-F6B81F20B93C}.Release|x86.ActiveCfg = Release|Any CPU
        {2F0A0A40-435E-4222-A0C1-F6B81F20B93C}.Release|x86.Build.0 = Release|Any CPU
        {C2F743B2-8B57-43D9-925B-C1E0BBA497E8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
        {C2F743B2-8B57-43D9-925B-C1E0BBA497E8}.Debug|Any CPU.Build.0 = Debug|Any CPU
        {C2F743B2-8B57-43D9-925B-C1E0BBA497E8}.Debug|x64.ActiveCfg = Debug|Any CPU
        {C2F743B2-8B57-43D9-925B-C1E0BBA497E8}.Debug|x64.Build.0 = Debug|Any CPU
        {C2F743B2-8B57-43D9-925B-C1E0BBA497E8}.Debug|x86.ActiveCfg = Debug|Any CPU
        {C2F743B2-8B57-43D9-925B-C1E0BBA497E8}.Debug|x86.Build.0 = Debug|Any CPU
        {C2F743B2-8B57-43D9-925B-C1E0BBA497E8}.Release|Any CPU.ActiveCfg = Release|Any CPU
        {C2F743B2-8B57-43D9-925B-C1E0BBA497E8}.Release|Any CPU.Build.0 = Release|Any CPU
        {C2F743B2-8B57-43D9-925B-C1E0BBA497E8}.Release|x64.ActiveCfg = Release|Any CPU
        {C2F743B2-8B57-43D9-925B-C1E0BBA497E8}.Release|x64.Build.0 = Release|Any CPU
        {C2F743B2-8B57-43D9-925B-C1E0BBA497E8}.Release|x86.ActiveCfg = Release|Any CPU
        {C2F743B2-8B57-43D9-925B-C1E0BBA497E8}.Release|x86.Build.0 = Release|Any CPU
        {347529BA-83DF-4D48-89F5-BEDCAF949F82}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
        {347529BA-83DF-4D48-89F5-BEDCAF949F82}.Debug|Any CPU.Build.0 = Debug|Any CPU
        {347529BA-83DF-4D48-89F5-BEDCAF949F82}.Debug|x64.ActiveCfg = Debug|Any CPU
        {347529BA-83DF-4D48-89F5-BEDCAF949F82}.Debug|x64.Build.0 = Debug|Any CPU
        {347529BA-83DF-4D48-89F5-BEDCAF949F82}.Debug|x86.ActiveCfg = Debug|Any CPU
        {347529BA-83DF-4D48-89F5-BEDCAF949F82}.Debug|x86.Build.0 = Debug|Any CPU
        {347529BA-83DF-4D48-89F5-BEDCAF949F82}.Release|Any CPU.ActiveCfg = Release|Any CPU
        {347529BA-83DF-4D48-89F5-BEDCAF949F82}.Release|Any CPU.Build.0 = Release|Any CPU
        {347529BA-83DF-4D48-89F5-BEDCAF949F82}.Release|x64.ActiveCfg = Release|Any CPU
        {347529BA-83DF-4D48-89F5-BEDCAF949F82}.Release|x64.Build.0 = Release|Any CPU
        {347529BA-83DF-4D48-89F5-BEDCAF949F82}.Release|x86.ActiveCfg = Release|Any CPU
        {347529BA-83DF-4D48-89F5-BEDCAF949F82}.Release|x86.Build.0 = Release|Any CPU
        {D9A17F63-7C1A-C46E-B7AE-B9677D56B49D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
        {D9A17F63-7C1A-C46E-B7AE-B9677D56B49D}.Debug|Any CPU.Build.0 = Debug|Any CPU
        {D9A17F63-7C1A-C46E-B7AE-B9677D56B49D}.Debug|x64.ActiveCfg = Debug|Any CPU
        {D9A17F63-7C1A-C46E-B7AE-B9677D56B49D}.Debug|x64.Build.0 = Debug|Any CPU
        {D9A17F63-7C1A-C46E-B7AE-B9677D56B49D}.Debug|x86.ActiveCfg = Debug|Any CPU
        {D9A17F63-7C1A-C46E-B7AE-B9677D56B49D}.Debug|x86.Build.0 = Debug|Any CPU
        {D9A17F63-7C1A-C46E-B7AE-B9677D56B49D}.Release|Any CPU.ActiveCfg = Release|Any CPU
        {D9A17F63-7C1A-C46E-B7AE-B9677D56B49D}.Release|Any CPU.Build.0 = Release|Any CPU
        {D9A17F63-7C1A-C46E-B7AE-B9677D56B49D}.Release|x64.ActiveCfg = Release|Any CPU
        {D9A17F63-7C1A-C46E-B7AE-B9677D56B49D}.Release|x64.Build.0 = Release|Any CPU
        {D9A17F63-7C1A-C46E-B7AE-B9677D56B49D}.Release|x86.ActiveCfg = Release|Any CPU
        {D9A17F63-7C1A-C46E-B7AE-B9677D56B49D}.Release|x86.Build.0 = Release|Any CPU
    EndGlobalSection
    GlobalSection(SolutionProperties) = preSolution
        HideSolutionNode = FALSE

 docs/DeviceConfig_DeviceDebug_Architecture.html

New file
@@ -0,0 +1,660 @@
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>仪器注册与硬件调试调用关系梳理</title>
<script src="https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js"></script>
<style>
    * { box-sizing: border-box; }
    body {
        font-family: -apple-system, "Segoe UI", "Microsoft YaHei", "PingFang SC", sans-serif;
        max-width: 1200px;
        margin: 0 auto;
        padding: 32px 24px 80px;
        background: #FAFAFA;
        color: #212121;
        line-height: 1.75;
    }
    h1 {
        font-size: 32px;
        color: #1565C0;
        border-bottom: 3px solid #1976D2;
        padding-bottom: 12px;
        margin-bottom: 8px;
    }
    h2 {
        font-size: 24px;
        color: #0D47A1;
        margin-top: 40px;
        padding-left: 12px;
        border-left: 4px solid #FF9800;
    }
    h3 {
        font-size: 18px;
        color: #37474F;
        margin-top: 24px;
    }
    .subtitle {
        color: #757575;
        font-size: 14px;
        margin-bottom: 24px;
    }
    .card {
        background: white;
        border-radius: 8px;
        padding: 20px 24px;
        margin: 16px 0;
        box-shadow: 0 2px 8px rgba(0,0,0,0.06);
    }
    .highlight {
        background: #FFF8E1;
        border-left: 4px solid #FFC107;
        padding: 12px 16px;
        margin: 12px 0;
        border-radius: 4px;
    }
    .info {
        background: #E3F2FD;
        border-left: 4px solid #2196F3;
        padding: 12px 16px;
        margin: 12px 0;
        border-radius: 4px;
    }
    .success {
        background: #E8F5E9;
        border-left: 4px solid #4CAF50;
        padding: 12px 16px;
        margin: 12px 0;
        border-radius: 4px;
    }
    table {
        width: 100%;
        border-collapse: collapse;
        margin: 16px 0;
        background: white;
        border-radius: 6px;
        overflow: hidden;
        box-shadow: 0 1px 4px rgba(0,0,0,0.06);
    }
    th {
        background: #1976D2;
        color: white;
        padding: 12px 14px;
        text-align: left;
        font-weight: 600;
    }
    td {
        padding: 10px 14px;
        border-bottom: 1px solid #EEEEEE;
    }
    tr:nth-child(even) td { background: #FAFAFA; }
    tr:hover td { background: #E3F2FD; }
    code {
        font-family: "Consolas", "Monaco", monospace;
        background: #F5F5F5;
        color: #C62828;
        padding: 2px 6px;
        border-radius: 3px;
        font-size: 13px;
    }
    pre {
        background: #263238;
        color: #ECEFF1;
        padding: 16px 20px;
        border-radius: 6px;
        overflow-x: auto;
        font-family: "Consolas", "Monaco", monospace;
        font-size: 13px;
        line-height: 1.6;
    }
    pre code {
        background: transparent;
        color: inherit;
        padding: 0;
    }
    .mermaid {
        background: white;
        padding: 20px;
        border-radius: 8px;
        margin: 20px 0;
        text-align: center;
        box-shadow: 0 2px 8px rgba(0,0,0,0.06);
        overflow-x: auto;
    }
    ul { padding-left: 22px; }
    li { margin: 4px 0; }
    .badge {
        display: inline-block;
        padding: 2px 8px;
        border-radius: 10px;
        font-size: 12px;
        font-weight: 600;
        margin: 0 3px;
    }
    .badge-write { background: #FFCDD2; color: #B71C1C; }
    .badge-read { background: #C8E6C9; color: #1B5E20; }
    .badge-api { background: #BBDEFB; color: #0D47A1; }
    .toc {
        background: #F5F5F5;
        padding: 16px 24px;
        border-radius: 6px;
        margin: 20px 0;
    }
    .toc a {
        color: #1976D2;
        text-decoration: none;
        display: block;
        padding: 4px 0;
    }
    .toc a:hover { text-decoration: underline; }
    .arrow { color: #FF9800; font-weight: bold; }
    .flow-step {
        background: white;
        border: 1px solid #E0E0E0;
        border-radius: 6px;
        padding: 12px 16px;
        margin: 8px 0;
    }
    .flow-step strong { color: #1976D2; }
    footer {
        margin-top: 60px;
        padding-top: 20px;
        border-top: 1px solid #E0E0E0;
        color: #757575;
        font-size: 12px;
        text-align: center;
    }
</style>
</head>
<body>

<h1>仪器注册 &amp; ç¡¬ä»¶è°ƒè¯• è°ƒç”¨å…³ç³»æ¢³ç†</h1>
<div class="subtitle">TapProject Â· Plugin.DeviceConfig â†” Plugin.DeviceDebug äº¤äº’架构说明</div>

<div class="toc">
    <strong>目录</strong>
    <a href="#sec1">1. æ•´ä½“架构（三层）</a>
    <a href="#sec2">2. æ•°æ®å±‚耦合：两个插件通过 data.db å…±äº«</a>
    <a href="#sec3">3. å®Œæ•´è°ƒç”¨é“¾è·¯ï¼ˆç”¨æˆ·è§†è§’）</a>
    <a href="#sec4">4. å…³é”®æŽ¥å£ä¾èµ–（Aging.Infrastructure）</a>
    <a href="#sec5">5. ä¼šè¯çŠ¶æ€æœºï¼ˆè·¨æ¨¡å—的核心协调点）</a>
    <a href="#sec6">6. é›†æˆæµ‹è¯•é¡¹ç›®é‡Œçš„组合演示</a>
    <a href="#sec7">7. æ—¶åºå›¾ï¼šå®Œæ•´æ•°æ®æµåŠ¨</a>
    <a href="#sec8">8. æ ¸å¿ƒè®¾è®¡æ€æƒ³</a>
</div>

<!-- ========== Section 1 ========== -->
<h2 id="sec1">1. æ•´ä½“架构（三层）</h2>

<div class="mermaid">
graph TB
    subgraph UI层["UI å±‚ - Plugin.*"]
        A["Plugin.DeviceConfig<br/>仪器仪表注册"]
        B["Plugin.DeviceDebug<br/>硬件调试"]
        B1["PowerSupplyDebugPanel"]
        B2["CanDebugPanel"]
        B3["PlcDebugPanel"]
    end

    subgraph åŸºç¡€è®¾æ–½å±‚["Aging.Infrastructure<br/>共享基础设施"]
        C["IDeviceManager<br/>设备生命周期"]
        D["IDeviceService<br/>命令执行"]
        E["IResourceManager<br/>资源预约/租约"]
        F["DebugSessionManager<br/>调试会话状态机"]
        G["DriverFactory<br/>驱动工厂"]
        H["IDeviceDriver<br/>CAN/ModBus/S7/SCPI/Tcp"]
    end

    subgraph æ•°æ®å±‚["SQLite"]
        DB1[("data.db<br/>DeviceDefinition<br/>DeviceChannel<br/>SlotDeviceMapping<br/>DeviceConfigVersion<br/>DeviceGroupTemplate")]
        DB2[("debug.db<br/>debug_session<br/>debug_operation")]
    end

    A -->|Save/Query| DB1
    B -->|读设备列表| DB1
    B -->|写会话/审计| DB2
    B --> B1 & B2 & B3
    B -->|Connect/Command| C
    C -->|Create| G
    G -->|Instantiate| H
    B -->|Validate maintenance| F
    F -->|Reserve/Release| E
    D -->|SendCommandAsync| H
</div>

<div class="info">
    <strong>三层职责：</strong>
    <ul>
        <li><strong>UI å±‚</strong>：插件的 WPF ç•Œé¢ï¼Œè´Ÿè´£æ•°æ®å±•ç¤ºå’Œç”¨æˆ·äº¤äº’</li>
        <li><strong>基础设施层</strong>：Aging.Infrastructure æä¾›çš„接口/服务，负责驱动调度、权限、会话管理</li>
        <li><strong>数据层</strong>：SQLite æ•°æ®åº“，负责持久化设备配置和调试审计</li>
    </ul>
</div>

<!-- ========== Section 2 ========== -->
<h2 id="sec2">2. æ•°æ®å±‚耦合：两个插件通过 <code>data.db</code> å…±äº«</h2>

<div class="highlight">
    <strong>最关键的设计：</strong> DeviceConfig æ˜¯<strong>生产方</strong>（写入），DeviceDebug æ˜¯<strong>消费方</strong>（读取）。
    ä¸¤è€…不通过 API ç›´æŽ¥è°ƒç”¨ï¼Œè€Œæ˜¯é€šè¿‡å…±äº«çš„ <code>data.db</code> éšå¼å¥‘约。
</div>

<table>
    <thead>
        <tr><th>表名</th><th>谁写入</th><th>谁读取</th><th>说明</th></tr>
    </thead>
    <tbody>
        <tr>
            <td><code>DeviceDefinition</code></td>
            <td><span class="badge badge-write">DeviceConfig</span></td>
            <td><span class="badge badge-read">DeviceDebug</span></td>
            <td>设备主表（DeviceId / Kind / Transport / Endpoint / DriverType）</td>
        </tr>
        <tr>
            <td><code>DeviceChannel</code></td>
            <td><span class="badge badge-write">DeviceConfig</span></td>
            <td><span class="badge badge-read">DeviceDebug</span></td>
            <td>设备通道（ChannelId / Capability / ç”µåŽ‹ç”µæµä¸Šé™ï¼‰</td>
        </tr>
        <tr>
            <td><code>SlotDeviceMapping</code></td>
            <td><span class="badge badge-write">DeviceConfig</span></td>
            <td><span class="badge badge-read">DeviceDebug</span></td>
            <td>Slot â†” è®¾å¤‡é€šé“ çš„映射表</td>
        </tr>
        <tr>
            <td><code>DeviceConfigVersion</code></td>
            <td><span class="badge badge-write">DeviceConfig</span></td>
            <td><span class="badge badge-read">DeviceDebug</span></td>
            <td>配置版本（Draft/Published/Effective）</td>
        </tr>
        <tr>
            <td><code>debug_session</code></td>
            <td><span class="badge badge-write">DeviceDebug</span></td>
            <td><span class="badge badge-read">DeviceDebug</span></td>
            <td>调试会话（含状态机数据）</td>
        </tr>
        <tr>
            <td><code>debug_operation</code></td>
            <td><span class="badge badge-write">DeviceDebug</span></td>
            <td><span class="badge badge-read">DeviceDebug</span></td>
            <td>调试操作审计日志</td>
        </tr>
    </tbody>
</table>

<h3>共享机制源码</h3>

<div class="flow-step">
<strong>DeviceDebug.xaml.cs ç¬¬ 95 è¡Œé™„近：</strong>
<pre><code>_deviceConfigDbPath = Path.Combine(BaseFolder, "data.db");   <span style="color:#4CAF50">// ä¸Ž DeviceConfig åŒç›®å½•</span>
var sqliteHelper = new SqliteHelper(_deviceConfigDbPath);
var dt = sqliteHelper.GetDataTable(
    "SELECT DeviceId, Kind FROM DeviceDefinition ORDER BY DeviceId");</code></pre>
</div>

<div class="flow-step">
<strong>关键点：</strong>BaseFolder æ˜¯ä¸»ç¨‹åºåœ¨ <code>PluginLoader</code> é‡Œç»Ÿä¸€æ³¨å…¥çš„目录，两个插件都读写同一个 <code>data.db</code>。
</div>

<!-- ========== Section 3 ========== -->
<h2 id="sec3">3. å®Œæ•´è°ƒç”¨é“¾è·¯ï¼ˆç”¨æˆ·è§†è§’）</h2>

<h3>场景 A：注册设备（DeviceConfig）</h3>

<div class="mermaid">
sequenceDiagram
    participant U as ç”¨æˆ·
    participant UI as DeviceConfig<br/>UI
    participant M as DeviceEditModal
    participant Model as DeviceConfigModel
    participant DB as data.db

    U->>UI: ç‚¹å‡»"新增设备"
    UI->>M: OpenDeviceEditModal(new DeviceDefinition)
    M->>M: å¡«è¡¨ + é€šé“配置
    U->>M: ç‚¹å‡»"保存"
    M->>Model: SaveDevice(device)
    Model->>DB: INSERT OR REPLACE DeviceDefinition
    M->>Model: SaveChannel(ch)
    Model->>DB: INSERT OR REPLACE DeviceChannel
    M-->>UI: DialogResult = true
    UI->>UI: RefreshAllData()
</div>

<h3>场景 B：调试设备（DeviceDebug）</h3>

<div class="mermaid">
sequenceDiagram
    participant U as ç”¨æˆ·
    participant DD as DeviceDebug<br/>UI
    participant SM as DebugSessionManager
    participant DM as DeviceManager
    participant DF as DriverFactory
    participant DRV as CanDriverAdapter
    participant SIM as CanSimulator
    participant DB as SQLite

    U->>DD: é€‰æ‹© CAN-001 ä¸‹æ‹‰é¡¹
    DD->>DB: SELECT * FROM DeviceDefinition<br/>（读取 data.db）
    DD->>SM: OpenSession(...)
    SM->>DB: INSERT debug_session (state=ReadOnly)
    DD->>DM: ConnectAsync("CAN-001")
    DM->>DF: CreateDriver("CAN", "CAN_BUS_1:0")
    DF->>DRV: new CanDriverAdapter
    DRV->>SIM: ConnectAsync â†’ æ³¨å†ŒèŠ‚点到总线
    
    Note over DD: åŠ è½½ CanDebugPanel<br/>AutoConnectOnLoad=true
    U->>DD: è¿›å…¥ç»´æŠ¤æ¨¡å¼
    DD->>SM: RequestMaintenance(sessionId)
    SM->>DB: UPDATE debug_session SET state=Acquiring
    SM->>SM: ResourceManager.Reserve(...)
    DD->>SM: ActivateMaintenance(sessionId)
    SM->>DB: UPDATE debug_session SET state=MaintenanceActive
    DD->>DD: LoadPanel é‡æ–°åŠ è½½<br/>CanDebugPanel.IsMaintenanceMode = true
    
    U->>DD: å‘送 CAN å¸§
    DD->>SM: ValidateCommand(sessionId, cmd)
    SM-->>DD: true
    DD->>DRV: SendCommandAsync("SEND:0x100:AA BB CC DD")
    DRV->>SIM: CanNode.SendFrame(frame)
    SIM-->>DRV: DriverFrameReceived (自动响应)
    DRV-->>DD: äº‹ä»¶å›žè°ƒ
    DD->>DB: INSERT debug_operation (审计)
</div>

<!-- ========== Section 4 ========== -->
<h2 id="sec4">4. å…³é”®æŽ¥å£ä¾èµ–（Aging.Infrastructure）</h2>

<div class="card">
    <strong>说明：</strong>DeviceConfig åªåšæ•°æ®ç®¡ç†ï¼Œä¸ç›´æŽ¥è°ƒç”¨æŽ¥å£ï¼›DeviceDebug é€šè¿‡æŽ¥å£è°ƒç”¨åº•å±‚服务。
</div>

<table>
    <thead>
        <tr><th>接口</th><th>定义文件</th><th>谁用</th><th>作用</th></tr>
    </thead>
    <tbody>
        <tr>
            <td><code>IDeviceDriver</code></td>
            <td>Contracts/IDeviceDriver.cs</td>
            <td>所有驱动适配器</td>
            <td>统一的连接/命令/查询接口</td>
        </tr>
        <tr>
            <td><code>IDeviceManager</code></td>
            <td>Contracts/IDeviceManager.cs</td>
            <td>DeviceDebug</td>
            <td>设备生命周期管理（注册/连接/断开）</td>
        </tr>
        <tr>
            <td><code>IDeviceService</code></td>
            <td>Contracts/IDeviceService.cs</td>
            <td>DeviceDebug</td>
            <td>命令执行（含 OwnerToken æƒé™æ£€æŸ¥ï¼‰</td>
        </tr>
        <tr>
            <td><code>IResourceManager</code></td>
            <td>Contracts/IResourceManager.cs</td>
            <td>DebugSessionManager</td>
            <td>资源预约/释放，防止调试与生产冲突</td>
        </tr>
        <tr>
            <td><code>IOperationLease</code></td>
            <td>Contracts/IOperationLease.cs</td>
            <td>ResourceManager</td>
            <td>操作租约（超时自动释放）</td>
        </tr>
        <tr>
            <td><code>ResourceOwnerToken</code></td>
            <td>Contracts/ResourceOwnerToken.cs</td>
            <td>整个基础设施层</td>
            <td>Owner ç±»åž‹ + ID（如 Maintenance:sessionId）</td>
        </tr>
    </tbody>
</table>

<h3>DriverFactory æ”¯æŒçš„传输类型</h3>

<table>
    <thead>
        <tr><th>Transport</th><th>Adapter</th><th>底层依赖</th><th>Endpoint æ ¼å¼</th></tr>
    </thead>
    <tbody>
        <tr><td>Tcp</td><td>TcpRawDriverAdapter</td><td>ConnectionUtil.TcpClient</td><td>IP:Port</td></tr>
        <tr><td>SCPI</td><td>ScpiDriverAdapter</td><td>SCPI over TCP</td><td>IP:Port</td></tr>
        <tr><td>ModBus</td><td>ModBusDriverAdapter</td><td>HslCommunication.ModbusTcpNet</td><td>IP:Port:slaveId</td></tr>
        <tr><td>S7</td><td>S7DriverAdapter</td><td>S7netplus</td><td>IP:Port</td></tr>
        <tr><td><strong>CAN</strong></td><td><strong>CanDriverAdapter</strong></td><td><strong>CanSimulator</strong></td><td><strong>BusName:NodeIndex</strong></td></tr>
    </tbody>
</table>

<!-- ========== Section 5 ========== -->
<h2 id="sec5">5. ä¼šè¯çŠ¶æ€æœºï¼ˆè·¨æ¨¡å—的核心协调点）</h2>

<div class="mermaid">
stateDiagram-v2
    [*] --> ReadOnly: OpenSession
    ReadOnly --> AcquiringMaintenance: RequestMaintenance<br/>(检查资源预约)
    AcquiringMaintenance --> MaintenanceActive: ActivateMaintenance
    AcquiringMaintenance --> ReadOnly: æ‹’绝<br/>(被生产预约)
    MaintenanceActive --> Closing: CloseSession<br/>(安全状态检查)
    Closing --> Closed
    Closed --> [*]
    
    MaintenanceActive --> Faulted: FaultSession<br/>(通信/硬件错误)
    Faulted --> RecoveryRequired: MarkRecoveryRequired
    RecoveryRequired --> ReadOnly: æ¢å¤åŽé‡æ–°è¿žæŽ¥
    RecoveryRequired --> [*]: æ— æ³•æ¢å¤åˆ™å…³é—­
</div>

<h3>状态对上层的影响</h3>

<table>
    <thead>
        <tr><th>状态</th><th>可发送命令</th><th>UI æ˜¾ç¤º</th><th>资源占用</th></tr>
    </thead>
    <tbody>
        <tr><td>ReadOnly</td><td>❌ åªè¯»ç›‘控</td><td>面板按钮禁用</td><td>无</td></tr>
        <tr><td>AcquiringMaintenance</td><td>❌ ç”³è¯·ä¸­</td><td>过渡状态</td><td>正在抢占</td></tr>
        <tr><td>MaintenanceActive</td><td>✅ å…è®¸å†™</td><td>面板按钮启用</td><td>持有 Maintenance ç§Ÿçº¦</td></tr>
        <tr><td>Closing</td><td>❌ å…³é—­ä¸­</td><td>过渡状态</td><td>释放中</td></tr>
        <tr><td>Faulted</td><td>❌ æ•…éšœ</td><td>红色告警</td><td>已释放</td></tr>
        <tr><td>RecoveryRequired</td><td>❌ å¾…恢复</td><td>橙色警告</td><td>无</td></tr>
        <tr><td>Closed</td><td>—</td><td>会话结束</td><td>无</td></tr>
    </tbody>
</table>

<div class="success">
    <strong>设计巧妙之处：</strong>会话状态机同时决定了
    <ul>
        <li>UI å±‚：CanDebugPanel.IsMaintenanceMode â†’ å‘送按钮是否可点</li>
        <li>业务层：DeviceService æ˜¯å¦æŽ¥å—该命令 â†’ OwnerToken æƒé™éªŒè¯</li>
        <li>资源层：ResourceManager æ˜¯å¦ä»æŒæœ‰ç§Ÿçº¦ â†’ é˜²æ­¢è¢«ç”Ÿäº§æŠ¢å </li>
    </ul>
</div>

<!-- ========== Section 6 ========== -->
<h2 id="sec6">6. é›†æˆæµ‹è¯•é¡¹ç›®é‡Œçš„组合演示</h2>

<div class="mermaid">
graph LR
    subgraph "Plugin.IntegrationTest<br/>_testDir = %LOCALAPPDATA%/PluginIntegrationTest"
        Tab1["Tab 1: DeviceConfig<br/>(嵌入实例)"]
        Tab2["Tab 2: DeviceDebug<br/>(嵌入实例)"]
        Tab3["Tab 3: CanDebugPanel<br/>(独立实例)"]
        DB[("data.db<br/>+ debug.db")]
    end
    
    Tab1 -->|写入| DB
    Tab2 -->|读取| DB
    Tab3 -->|驱动调用| SIM["CanSimulator<br/>(内存虚拟总线)"]
</div>

<div class="info">
    <strong>关键点：</strong>三个 Tab å…±äº«åŒä¸€ä¸ª <code>_testDir</code> ä½œä¸º BaseFolder，所以在 Tab 1 æ·»åŠ çš„设备 â†’ åˆ·æ–°åŽ Tab 2 ç«‹å³å¯è§ â†’ é€‰ä¸­å³è‡ªåŠ¨è¿žæŽ¥ Tab 3 çš„模拟总线。
</div>

<h3>测试数据流</h3>
<ol>
    <li><strong>预置阶段</strong>：<code>SeedPresetCanDevices()</code> å†™å…¥ CAN-001 / CAN-002</li>
    <li><strong>注册阶段</strong>：在 Tab 1 ä¸­æ–°å¢žè®¾å¤‡ï¼ˆå¦‚ CAN-003 â†’ CAN_BUS_1:2）</li>
    <li><strong>调试阶段</strong>：在 Tab 2 ä¸­é€‰æ‹© CAN-003，CanDebugPanel è‡ªåŠ¨è¿žæŽ¥æ€»çº¿</li>
    <li><strong>模拟阶段</strong>：在 Tab 3 ä¸­å¯åŠ¨æ€»çº¿ï¼Œå¼€å¯è‡ªåŠ¨å“åº”</li>
    <li><strong>验证阶段</strong>：Tab 2 å‘送帧 â†’ æ”¶åˆ° Tab 3 çš„自动响应</li>
</ol>

<!-- ========== Section 7 ========== -->
<h2 id="sec7">7. æ—¶åºå›¾ï¼šå®Œæ•´æ•°æ®æµåŠ¨</h2>

<div class="mermaid">
sequenceDiagram
    autonumber
    participant U as ç”¨æˆ·
    participant DC as DeviceConfig<br/>UI
    participant DM1 as DeviceConfigModel
    participant DB1 as data.db
    participant DD as DeviceDebug<br/>UI
    participant SM as SessionManager
    participant DM2 as DeviceDebugModel
    participant DB2 as debug.db
    participant MGR as DeviceManager
    participant SVC as DeviceService
    participant DRV as CanDriverAdapter
    participant SIM as CanSimulator<br/>总线

    rect rgb(255, 248, 225)
    Note over U,DB1: é˜¶æ®µ1：注册设备
    U->>DC: æ–°å¢ž CAN-001
    DC->>DM1: SaveDevice
    DM1->>DB1: INSERT DeviceDefinition<br/>Endpoint=CAN_BUS_1:0
    end

    rect rgb(227, 242, 253)
    Note over U,SIM: é˜¶æ®µ2：打开调试会话
    U->>DD: é€‰æ‹© CAN-001
    DD->>DB1: SELECT DeviceDefinition
    DB1-->>DD: {Kind=CanDevice, Endpoint=CAN_BUS_1:0}
    DD->>SM: OpenSession
    SM->>DM2: CreateSession
    DM2->>DB2: INSERT debug_session (ReadOnly)
    DD->>MGR: ConnectAsync("CAN-001")
    MGR->>DRV: DriverFactory.CreateDriver("CAN",...)
    DRV->>SIM: æ³¨å†ŒèŠ‚点0到CAN_BUS_1总线
    end

    rect rgb(232, 245, 233)
    Note over U,DRV: é˜¶æ®µ3：进入维护模式
    U->>DD: è¿›å…¥ç»´æŠ¤
    DD->>SM: RequestMaintenance
    SM->>DB2: UPDATE state=Acquiring
    SM->>SM: ResourceManager.Reserve
    DD->>SM: ActivateMaintenance
    SM->>DB2: UPDATE state=MaintenanceActive
    DD->>DD: LoadPanel(kind)<br/>IsMaintenanceMode=true
    end

    rect rgb(255, 224, 178)
    Note over U,SIM: é˜¶æ®µ4：发送调试命令
    U->>DD: ç‚¹å‡»"发送"帧
    DD->>SM: ValidateCommand(sessionId, cmd)
    SM-->>DD: âœ… true
    DD->>SVC: ExecuteCommandAsync
    SVC->>DRV: SendCommandAsync("SEND:0x100:AA BB CC")
    DRV->>SIM: CanNode.SendFrame(frame)
    SIM->>SIM: è·¯ç”±åˆ°å…¶ä»–节点<br/>+ æ£€æŸ¥ AutoResponse
    SIM-->>DRV: DriverFrameReceived (响应帧)
    DRV-->>SVC: ç»“æžœ
    SVC-->>DD: ExecuteResult
    DD->>DM2: RecordOperation(op)
    DM2->>DB2: INSERT debug_operation
    DD->>DD: æ›´æ–°å®¡è®¡åˆ—表
    end

    rect rgb(255, 205, 210)
    Note over U,DB2: é˜¶æ®µ5：关闭会话
    U->>DD: é€€å‡ºç»´æŠ¤
    DD->>SM: CloseSession
    SM->>DB2: UPDATE state=Closed<br/>SET closed_at=now
    SM->>SM: ResourceManager.ReleaseReservation
    SM->>DRV: DisconnectAsync
    DRV->>SIM: ä»Žæ€»çº¿æ³¨é”€èŠ‚点
    end
</div>

<!-- ========== Section 8 ========== -->
<h2 id="sec8">8. æ ¸å¿ƒè®¾è®¡æ€æƒ³</h2>

<div class="card">
<h3>🎯 æ•°æ®å…±äº« = éšå¼å¥‘约</h3>
DeviceDebug åªä¾èµ– DeviceConfig å†™å¥½çš„ <code>data.db</code>，不需要 API è°ƒç”¨ã€‚两个插件的 <strong>BaseFolder ä¸€è‡´</strong>是核心前提，主程序通过 PluginLoader æ³¨å…¥ã€‚
</div>

<div class="card">
<h3>🎯 çŠ¶æ€é›†ä¸­ = DebugSessionManager</h3>
所有权限检查走同一个状态机。UI、驱动、审计三处都通过状态查询同步。避免各处零散判断导致不一致。
</div>

<div class="card">
<h3>🎯 é©±åŠ¨æŠ½è±¡ = IDeviceDriver</h3>
上层面板不知道底层是 TCP、Modbus、S7、SCPI è¿˜æ˜¯æ¨¡æ‹Ÿ CAN æ€»çº¿ã€‚<code>DriverFactory.CreateDevice(id, transport, endpoint)</code> ç»Ÿä¸€åˆ†æ´¾ã€‚
</div>

<div class="card">
<h3>🎯 èµ„源预约 = IResourceManager</h3>
调试模式和生产模式互斥，通过 <code>ResourceOwnerToken</code> + ç§Ÿçº¦æœºåˆ¶ä¿è¯ï¼š<br>
- ç”Ÿäº§ä»»åŠ¡è¿è¡Œä¸­ â†’ è°ƒè¯•è¯·æ±‚失败<br>
- è°ƒè¯•æŒæœ‰ç§Ÿçº¦ â†’ ç”Ÿäº§ä»»åŠ¡è¢«æ‹’绝<br>
- ç§Ÿçº¦è¶…时未续 â†’ å¼ºåˆ¶é‡Šæ”¾ï¼Œé¿å…æ­»é”
</div>

<div class="card">
<h3>🎯 å®¡è®¡é—­çŽ¯ = debug_operation</h3>
每一次命令都记录：<code>SessionId Â· CommandType Â· Parameters Â· Outcome Â· Readback Â· Error</code>。事后可以完整重现调试过程，是维护责任追溯的关键。
</div>

<div class="card">
<h3>🎯 ç‰ˆæœ¬ç®¡ç† = DeviceConfigVersion</h3>
配置不是"改了就生效"，而是走 <strong>Draft â†’ Published â†’ Effective</strong> ä¸‰é˜¶æ®µï¼š
<ol>
    <li>DeviceConfig ä¿å­˜è‰ç¨¿ â†’ Draft</li>
    <li>提交发布 â†’ Published（附带配置哈希）</li>
    <li>应用到生产 â†’ Effective（旧的 Published å›žé€€ï¼‰</li>
</ol>
这样能保证生产环境配置稳定，调试时可回滚。
</div>

<h2>附录：文件路径速查</h2>

<table>
    <thead>
        <tr><th>组件</th><th>路径</th></tr>
    </thead>
    <tbody>
        <tr><td>仪器仪表注册插件</td><td><code>d:\TestPlatform\TapProject\Plugin.DeviceConfig\</code></td></tr>
        <tr><td>硬件调试插件</td><td><code>d:\TestPlatform\TapProject\Plugin.DeviceDebug\</code></td></tr>
        <tr><td>基础设施 & é©±åŠ¨</td><td><code>d:\TestPlatform\TapProject\Aging.Infrastructure\</code></td></tr>
        <tr><td>CAN æ¨¡æ‹Ÿå™¨æ ¸å¿ƒ</td><td><code>d:\TestPlatform\TapProject\CanSimulator\</code></td></tr>
        <tr><td>集成测试环境</td><td><code>d:\TestPlatform\TapProject\Plugin.IntegrationTest\</code></td></tr>
        <tr><td>持久化数据目录</td><td><code>%LOCALAPPDATA%\PluginIntegrationTest\data.db</code></td></tr>
    </tbody>
</table>

<footer>
    Generated for TapProject Â· ä»ªå™¨æ³¨å†Œä¸Žç¡¬ä»¶è°ƒè¯•æ¨¡å—架构分析 Â· 2026-11-02
</footer>

<script>
    mermaid.initialize({ 
        startOnLoad: true,
        theme: 'default',
        securityLevel: 'loose',
        fontFamily: 'Segoe UI, Microsoft YaHei, sans-serif',
        flowchart: { curve: 'basis', padding: 20 },
        sequence: { showSequenceNumbers: false, actorMargin: 60 }
    });
</script>

</body>
</html>

 docs/Local + DeviceBroker »ìºÏ¼Ü¹¹ÏêϸÉè¼Æ˵Ã÷Êé V3.0.html

New file
@@ -0,0 +1,359 @@
<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="color-scheme" content="light"><title>Local + DeviceBroker æ··åˆæž¶æž„详细设计说明书 V3.0</title><style>
:root{--ink:#162c40;--muted:#586d7e;--blue:#155c88;--line:#d7e2eb;--paper:#fff;--bg:#edf2f6;--nav:#102b40}*{box-sizing:border-box}html{scroll-behavior:smooth;scroll-padding-top:28px}body{margin:0;background:var(--bg);color:var(--ink);font:16px/1.85 "Microsoft YaHei","Segoe UI",Arial,sans-serif}a{color:#11618f;text-underline-offset:3px}aside{position:fixed;inset:0 auto 0 0;width:270px;background:var(--nav);color:#eff7fc;padding:26px 20px;overflow:auto}aside .brand{font-size:20px;font-weight:700;line-height:1.5}aside .sub{color:#a9c1d2;font-size:12px;margin:9px 0 22px}aside input{width:100%;background:#fff;color:#162c40;border:0;padding:10px 12px;border-radius:4px;font:inherit;font-size:13px}nav{margin-top:18px}nav a{display:block;color:#cbdce8;text-decoration:none;font-size:13px;line-height:1.5;padding:8px 7px;border-left:2px solid transparent}nav a:hover,nav a.active{color:#fff;border-color:#66c5f2;background:#1a405b}main{margin-left:270px;padding:42px 50px 80px;max-width:1650px}.hero{background:linear-gradient(120deg,#12334d,#225f83);color:white;padding:42px 48px;position:relative;border-top:6px solid #63c2e6}.eyebrow{font:12px/1.6 Arial,sans-serif;letter-spacing:2px;color:#afd9ef}.hero h1{font-size:34px;line-height:1.5;margin:12px 0 20px;max-width:950px}.hero p{max-width:900px;color:#dcebf5}.pills{display:flex;gap:10px;flex-wrap:wrap}.pill{border:1px solid #6089a5;padding:3px 12px;font-size:12px}.toolbar{display:flex;gap:10px;flex-wrap:wrap;margin:22px 0}.toolbar span{margin-left:auto;color:var(--muted);font-size:13px}button{cursor:pointer;border:1px solid #a9bfce;background:#fff;color:#164b6d;padding:8px 14px;border-radius:4px;font:inherit;font-size:13px}button:hover{background:#eaf4fa}section{margin-top:28px;background:var(--paper);border:1px solid var(--line);padding:30px 36px;box-shadow:0 3px 15px #143b5c05}h2{margin:0 0 22px;font-size:24px;line-height:1.5;border-bottom:2px solid #d9e8f2;padding-bottom:14px;color:#144e72}h3{font-size:18px;color:#24516d;margin:28px 0 12px}p{margin:12px 0}li{margin:7px 0}ol{padding-left:25px}.table-wrap{max-width:100%;overflow-x:auto;margin:20px 0}table{width:100%;border-collapse:collapse;font-size:14px;line-height:1.7}th{background:#eaf2f8;color:#194d70;font-weight:700;text-align:left}th,td{padding:11px 14px;border:1px solid #d8e2eb;vertical-align:top;overflow-wrap:anywhere}tbody tr:nth-child(even){background:#f8fafc}code{font:13px/1.65 Consolas,"Microsoft YaHei",monospace;background:#edf3f7;padding:2px 5px;overflow-wrap:anywhere}pre{margin:0 0 20px;background:#102739;color:#e0eef7;padding:20px;overflow:auto;line-height:1.7;tab-size:4}pre code{background:none;color:inherit;padding:0;white-space:pre;overflow-wrap:normal;font-size:13px}.codebar{display:flex;justify-content:space-between;align-items:center;padding:8px 14px;background:#dce8f1;color:#24536f;font-size:12px;margin-top:20px}.copy{padding:3px 12px}.note{border-left:4px solid #c38a2e;background:#fff7e6;padding:16px 20px;margin-top:22px;font-size:14px}.muted{color:var(--muted);font-size:13px}figure{position:relative;margin:24px 0 30px;border:1px solid #d4e0ea;padding:28px 12px 10px;background:white}.diagram-image{display:block;width:100%;height:auto;background:white}figcaption{font-size:13px;color:#5a7081;padding:12px 10px;border-top:1px solid #e3ebf1}.zoom{position:absolute;top:4px;right:8px;padding:2px 9px;font-size:12px}details{border:1px solid #d5e2eb;padding:12px 16px;margin-top:18px}summary{cursor:pointer;font-weight:700;color:#1d5579}.downloads{display:flex;gap:12px;flex-wrap:wrap;margin:24px 0}footer{font-size:12px;color:#688091;margin:30px 0}.no-results{display:none;color:#fff;font-size:13px}dialog{width:96vw;max-width:1800px;border:1px solid #819fb5;padding:12px;background:#f7fafc}dialog::backdrop{background:#071a2cbd}dialog .dialog-body{overflow:auto;max-height:85vh}dialog img{display:block;min-width:1400px;width:100%}dialog button{margin-bottom:10px}body[data-filtered=true] section.hidden{display:none}@media(max-width:1150px){main{padding:25px 24px}aside{width:235px}main{margin-left:235px}section{padding:25px}.hero{padding:32px}.hero h1{font-size:29px}}@media(max-width:760px){aside{position:relative;width:auto;height:auto;padding:20px}nav{max-height:220px;overflow:auto}main{margin:0;padding:18px 12px}section{padding:22px 18px}h2{font-size:21px}.hero{padding:24px}.hero h1{font-size:26px}.toolbar span{width:100%;margin:0}th,td{min-width:100px}}@media print{aside,.toolbar,.zoom,.copy,.downloads,dialog{display:none!important}body{background:#fff;font-size:10pt}main{margin:0;padding:0;max-width:none}.hero{background:#fff!important;color:#16344d;padding:10mm 0;border-top:3px solid #155c88}.hero p,.eyebrow{color:#34556d}.hero h1{font-size:25pt}.pill{color:#234d68}section,section.hidden{display:block!important;box-shadow:none;border:0;padding:5mm 0;margin:0;break-before:auto}h2,h3{break-after:avoid}h2{font-size:16pt}table{font-size:8pt}.table-wrap{overflow:visible}tr,figure{break-inside:avoid}thead{display:table-header-group}pre{white-space:pre-wrap;background:#f2f5f7;color:#123;overflow:visible}pre code{white-space:pre-wrap;overflow-wrap:anywhere;font-size:8pt}th,td{padding:5px 7px}details{border:0;padding:0}summary{display:none}a{color:inherit}figure{padding:5px}.diagram-image{width:100%}@page{size:A4;margin:16mm 13mm}}
</style></head><body><aside><div class="brand">老化软件平台<br>仪器资源管理</div><div class="sub">DETAILED DESIGN / VERSION 3.0</div><label for="search" class="muted" style="color:#c6dce9">检索全文章节</label><input id="search" placeholder="输入资源名、接口或异常…"><nav><a href="#scope">01　设计范围与结论</a><a href="#basis">02　既有讨论、代码事实与修订依据</a><a href="#architecture">03　总体架构与依赖边界</a><a href="#routing">04　Local / Broker é€‰æ‹©ã€èµ„源键与粒度</a><a href="#configuration">05　工程师配置与发布工作流</a><a href="#config-example">06　配置契约与启动校验</a><a href="#database">07　数据库边界、实体与一致性</a><a href="#ddl">08　SQLite DDL ä¸Žç§Ÿçº¦äº‹åŠ¡</a><a href="#csharp">09　C# æŽ¥å£ä¸Žå…¼å®¹è¾¹ç•Œ</a><a href="#execution">10　执行入口、生命周期与取消语义</a><a href="#tasks">11　Broker Task æ¨¡åž‹ã€æ¨¡æ¿ä¸ŽçŠ¶æ€æœº</a><a href="#broker-runtime">12　Broker è°ƒåº¦ã€é˜Ÿåˆ—与遥测</a><a href="#ipc">13　IPC åè®®ã€èº«ä»½ä¸Žäº‹ä»¶æ¢å¤</a><a href="#arbitration">14　资源仲裁与维护交接</a><a href="#fencing">15　Fencing、超时与 Local è¾¹ç•Œ</a><a href="#recovery">16　异常恢复与重启编排</a><a href="#deployment">17　120 ç©´ä½éƒ¨ç½²æ–¹æ¡ˆä¸Žå®Œæ•´æ˜ å°„</a><a href="#capacity">18　容量估算、数据与性能预算</a><a href="#ops">19　安装、观测与运维</a><a href="#verification">20　典型运行场景与方案原理</a><a href="#tbd">21　方案适用条件与限制</a><a href="#sources">22　来源、交付范围与阅读说明</a></nav><p class="no-results">没有匹配章节</p></aside><main><header class="hero"><div class="eyebrow">PRODUCTION AGING PLATFORM / ENGINEERING DESIGN</div><h1>Local + DeviceBroker<br>混合架构详细设计说明书 V3.0</h1><p>统一业务入口，按物理会话治理连接；以租约授权、任务串行和恢复门禁支撑 120 ç©´ä½å¹¶å‘老化。</p><div class="pills"><span class="pill">详细设计评审稿</span><span class="pill">2026-11-03</span><span class="pill">.NET Framework 4.7.2</span><span class="pill">完整离线 HTML</span></div></header><div class="toolbar"><button id="print">打印 / ä¿å­˜ä¸º PDF</button><button id="clear">清除检索</button><span id="count">22 / 22 ç« </span></div><section id="scope"><h2>01　设计范围与结论</h2>
<p>本说明书将老化软件仪器资源管理收敛为“统一业务入口 + Local ç›´è¿ž + DeviceBroker ä»£ç†â€çš„混合架构。120 ä¸ªç©´ä½æ‹¥æœ‰ç‹¬ç«‹çš„ DUT ä¸šåŠ¡çŠ¶æ€ï¼Œä½†å…±äº«è®¾å¤‡æŒ‰ç‰©ç†è¿žæŽ¥ã€é€šé“与协议会话仲裁。工程师通过发布配置选择执行位置，Recipe ä½¿ç”¨é€»è¾‘能力与穴位映射，不直接选择 COM å£ã€IP æˆ–进程。</p>
<p>Local é€‚合已分配给唯一执行进程、可独立连接的设备；Broker é€‚合跨进程共享的串口/USB/CAN、共用会话的多通道电源、RS485 æ€»çº¿åŠéœ€è¦é•¿è¿žæŽ¥å’ŒåŽå°åè®®ä»»åŠ¡çš„设备。Broker æ˜¯è®¾å¤‡ I/O å®¿ä¸»ï¼Œä¸æ‰¿æ‹… DUT åˆæ ¼åˆ¤å®šã€æ•´æ¡ Recipe æˆ– MES äº‹åŠ¡ã€‚</p>
<div class="table-wrap"><table><thead><tr><th>标识</th><th>设计不变量</th><th>实现位置</th></tr></thead><tbody><tr><td>INV-01</td><td>同一 PhysicalSessionKey åªæœ‰ä¸€ä¸ªé…ç½®çš„ I/O å®¿ä¸»ï¼›ç¦æ­¢ Local ä¸Ž Broker åŒæ—¶æ‰“å¼€</td><td>发布校验、连接守卫、操作系统/网络访问控制</td></tr><tr><td>INV-02</td><td>预约授权与命令串行化分层；持有租约不等于可并发写同一物理会话</td><td>ResourceManager + SessionGate</td></tr><tr><td>INV-03</td><td>租约到期先隔离和确认设备状态，禁止仅按 TTL è‡ªåŠ¨äº¤ç»™æ–°æŒæœ‰è€…</td><td>仲裁状态机、恢复协调器</td></tr><tr><td>INV-04</td><td>启动后冻结 Recipe、Config、Driver、DBC、UDS、映射 Hash</td><td>RunSnapshot、Broker Task</td></tr><tr><td>INV-05</td><td>所有写操作在实际 I/O å®¿ä¸»æ‰§è¡Œå…¥å£æ ¡éªŒï¼›å®¢æˆ·ç«¯æ ¡éªŒä»…为提示</td><td>LocalExecutor / Broker Dispatcher</td></tr><tr><td>INV-06</td><td>命令已发送但结果未知时，记录 Unknown；禁止把超时当作未执行</td><td>Task Journal、结果投递</td></tr><tr><td>INV-07</td><td>安全急停和人员作业许可依赖独立硬件/PLC è”锁，软件租约不替代断能</td><td>设备电气与软件联锁接口</td></tr></tbody></table></div><div class="note">状态：详细设计评审稿，2026-11-03。V3.0 æ˜¯æœ¬æ¬¡è®¾è®¡ç‰ˆæœ¬ï¼Œä¸ä»£è¡¨è½¯ä»¶å·²å®žçŽ°æˆ–通过现场验收。硬件型号、CAN æ‹“扑、节拍与安全动作按第 21 ç« çš„适用条件确认。</div></section><section id="basis"><h2>02　既有讨论、代码事实与修订依据</h2>
<p>本次已读取本地 V2.1 è®¾è®¡è¯´æ˜Žä¹¦ã€å¤šè¿›ç¨‹èµ„源方案、配置/调试架构，以及下列 C# æ–‡ä»¶ã€‚保留 V2.1 çš„ AgingRun / DUTExecution、版本快照、统一 DeviceService å’Œåˆ†å±‚数据归档设计；将此前“按需 Broker”展开成可部署的混合方案。可检索的历史聊天仅提供部分近期内容，因此不将本文表述为全部历史讨论的逐字复现。</p>
<div class="table-wrap"><table><thead><tr><th>来源/证据</th><th>当前核查事实</th><th>V3.0 å¤„理</th></tr></thead><tbody><tr><td>Aging.Infrastructure/Core/ResourceManager.cs</td><td>ConcurrentDictionary ä¿å­˜é¢„约；_generation ä¸ºè¿›ç¨‹å†…字段；AcquireOperationAsync æœªå–得可贯穿 I/O çš„排他锁；ValidateOwner æœªæ£€æŸ¥ TTL</td><td>新增持久化 fence、真实 SessionGate å’Œå¼‚步校验；不声称当前代码已解决操作互斥</td></tr><tr><td>Contracts/ResourceOwnerToken.cs</td><td>Generation å¯å˜ï¼ŒExpiresAt åªè¯»ï¼›æž„造器自动创建新 TokenId</td><td>新增不可变 LeaseGrant DTO；持久化还原不能调用旧构造器生成新 token</td></tr><tr><td>Services/DeviceService.cs</td><td>先 GetDriver，再 ValidateOwner，再调用驱动；使用 deviceId:Generic</td><td>按运行快照解析通道资源键，执行入口再次校验；不允许绕开宿主</td></tr><tr><td>Services/AutoDeviceFacade.cs</td><td>释放异常仅记日志；旧接口为单设备作用域</td><td>增加释放失败状态、续期和原子组预约；保留兼容适配层但不宣称零改动</td></tr><tr><td>ConnectionUtil/PipeClient.cs</td><td>SendMessage åœ¨ WriteMessage åŽç«‹å³ return true，读响应循环不可达；_serverName æœªç”¨äºŽåˆ›å»ºå®¢æˆ·ç«¯æµ</td><td>只能复用代码框架；先补协议、响应关联、超时、连接生命周期和测试</td></tr><tr><td>Plugin.DeviceConfig/Model/DeviceConfigModel.cs</td><td>已有 DeviceDefinition、DeviceChannel、SlotDeviceMapping、DeviceConfigVersion、DeviceGroupTemplate</td><td>保留导入来源；新增不可变配置快照，不把旧表主键当作完整历史版本模型</td></tr><tr><td>Aging.Infrastructure.csproj</td><td>TargetFramework=net472，LangVersion=10.0，Microsoft.Bcl.AsyncInterfaces åŒ…已引用</td><td>接口示例使用普通 DTO / Task；新包按目标框架验证后冻结</td></tr><tr><td>MultiProcess_Instrument_Resource_Solution.html</td><td>提出 DB Lease + Generation + æŒ‰éœ€ Broker；含仅查询 DB å³ä¿è¯ç‰©ç†å®‰å…¨ç­‰è¿‡å¼ºç»“论</td><td>将 TTL、软件 fencing、物理断能分开；维护交接必须经过恢复门禁</td></tr></tbody></table></div><p>代码路径基准：<code>D:\TestPlatform\TapProject\</code>。项目文档来源为设计依据，当前 C# æ–‡ä»¶ä¸ºé™æ€å®žçŽ°è¯æ®ï¼›æœ¬æ¬¡æœªè¿è¡ŒçŽ°æœ‰è®¾å¤‡é©±åŠ¨æˆ–完整软件工程。来源清单和 SHA256 è§ç¬¬ 22 ç« ã€‚</p></section><section id="architecture"><h2>03　总体架构与依赖边界</h2><figure><button class="zoom" aria-label="放大图1">放大查看</button><img class="diagram-image" alt="图1 V3.0目标架构设计" src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<!-- Do not edit this file with editors other than draw.io -->
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" style="background: transparent; background-color: transparent; color-scheme: light dark;" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="1519px" height="883px" viewBox="-0.5 -0.5 1519 883" content="&lt;mxfile host=&quot;Electron&quot; agent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) draw.io/28.2.5 Chrome/138.0.7204.251 Electron/37.6.1 Safari/537.36&quot; version=&quot;28.2.5&quot; pages=&quot;3&quot;&gt;&#10;  &lt;diagram name=&quot;architecture&quot; id=&quot;architecture&quot;&gt;&#10;    &lt;mxGraphModel dx=&quot;-824&quot; dy=&quot;-248&quot; grid=&quot;0&quot; gridSize=&quot;10&quot; guides=&quot;1&quot; tooltips=&quot;1&quot; connect=&quot;1&quot; arrows=&quot;1&quot; fold=&quot;0&quot; page=&quot;0&quot; pageScale=&quot;1&quot; pageWidth=&quot;1600&quot; pageHeight=&quot;900&quot; background=&quot;#ffffff&quot; math=&quot;0&quot; shadow=&quot;0&quot;&gt;&#10;      &lt;root&gt;&#10;        &lt;mxCell id=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;1&quot; parent=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;title&quot; value=&quot;Local + DeviceBroker：统一业务入口与分域 I/O（目标设计）&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=28;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;fontStyle=1;strokeColor=none;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;60&quot; y=&quot;24&quot; width=&quot;1480&quot; height=&quot;60&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;config&quot; value=&quot;配置 / 发布服务&amp;lt;br&amp;gt;不可变快照 · Hash · 路由&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;60&quot; y=&quot;125&quot; width=&quot;400&quot; height=&quot;95&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;hmi&quot; value=&quot;HMI / 维护会话&amp;lt;br&amp;gt;权限 · 占用状态 · 审计&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;600&quot; y=&quot;125&quot; width=&quot;400&quot; height=&quot;95&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;run&quot; value=&quot;Run / Recipe / OpenTAP&amp;lt;br&amp;gt;120 DUTContext · 逻辑能力&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;1140&quot; y=&quot;125&quot; width=&quot;400&quot; height=&quot;95&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;facade&quot; value=&quot;DeviceService + ResourceRouter&amp;lt;br&amp;gt;按快照定位资源 / 宿主&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;600&quot; y=&quot;290&quot; width=&quot;400&quot; height=&quot;100&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#8796a5;dashed=1;exitX=0.5;exitY=1;entryX=0.2;entryY=0;&quot; parent=&quot;1&quot; source=&quot;config&quot; target=&quot;facade&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;Array as=&quot;points&quot;&gt;&#10;              &lt;mxPoint x=&quot;260&quot; y=&quot;255&quot; /&gt;&#10;              &lt;mxPoint x=&quot;680&quot; y=&quot;255&quot; /&gt;&#10;            &lt;/Array&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;exitX=0.5;exitY=1;entryX=0.5;entryY=0;&quot; parent=&quot;1&quot; source=&quot;hmi&quot; target=&quot;facade&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;Array as=&quot;points&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;exitX=0.5;exitY=1;entryX=0.8;entryY=0;&quot; parent=&quot;1&quot; source=&quot;run&quot; target=&quot;facade&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;Array as=&quot;points&quot;&gt;&#10;              &lt;mxPoint x=&quot;1340&quot; y=&quot;255&quot; /&gt;&#10;              &lt;mxPoint x=&quot;920&quot; y=&quot;255&quot; /&gt;&#10;            &lt;/Array&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;local&quot; value=&quot;LocalExecutor / LeaseStore&amp;lt;br&amp;gt;本机 arb.db · 连接守卫 · SessionGate&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;150&quot; y=&quot;470&quot; width=&quot;540&quot; height=&quot;110&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;broker&quot; value=&quot;BrokerClient → DeviceBroker&amp;lt;br&amp;gt;本域 Lease / Task / Queue / Outbox&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;910&quot; y=&quot;470&quot; width=&quot;540&quot; height=&quot;110&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e4&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot; parent=&quot;1&quot; source=&quot;facade&quot; target=&quot;local&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e5&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot; parent=&quot;1&quot; source=&quot;facade&quot; target=&quot;broker&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;localio&quot; value=&quot;唯一 Worker 内的 DeviceManager / Driver&amp;lt;br&amp;gt;固定归属的独立 TCP 会话&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;150&quot; y=&quot;670&quot; width=&quot;540&quot; height=&quot;110&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;brokerio&quot; value=&quot;Broker 内的 DeviceManager / Driver&amp;lt;br&amp;gt;共享 PSU / CAN / RS485 / PLC&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;910&quot; y=&quot;670&quot; width=&quot;540&quot; height=&quot;110&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e6&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot; parent=&quot;1&quot; source=&quot;local&quot; target=&quot;localio&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e7&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot; parent=&quot;1&quot; source=&quot;broker&quot; target=&quot;brokerio&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;legend&quot; value=&quot;实线：调用 / I/O 路径　　灰色虚线：配置依赖　　TTL 到期 → 隔离核查；连接确认退出后才交接&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=18;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;strokeColor=none;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;60&quot; y=&quot;815&quot; width=&quot;1480&quot; height=&quot;55&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;      &lt;/root&gt;&#10;    &lt;/mxGraphModel&gt;&#10;  &lt;/diagram&gt;&#10;  &lt;diagram name=&quot;handover&quot; id=&quot;handover&quot;&gt;&#10;    &lt;mxGraphModel dx=&quot;1600&quot; dy=&quot;900&quot; grid=&quot;1&quot; gridSize=&quot;10&quot; page=&quot;1&quot; pageScale=&quot;1&quot; pageWidth=&quot;1600&quot; pageHeight=&quot;900&quot; background=&quot;#ffffff&quot;&gt;&#10;      &lt;root&gt;&#10;        &lt;mxCell id=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;1&quot; parent=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;title&quot; value=&quot;资源交接：先排空、隔离与核查，再允许新 owner（目标设计）&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=28;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;fontStyle=1;strokeColor=none;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;24&quot; width=&quot;1480&quot; height=&quot;60&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;free&quot; value=&quot;Free / Ready&amp;lt;br&amp;gt;允许申请&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;80&quot; y=&quot;160&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;active&quot; value=&quot;Active&amp;lt;br&amp;gt;Grant + 周期续租&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;635&quot; y=&quot;160&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;drain&quot; value=&quot;Draining&amp;lt;br&amp;gt;停止新写 / 排空片段&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#fff2d9;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1190&quot; y=&quot;160&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1&quot; source=&quot;free&quot; target=&quot;active&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2&quot; source=&quot;active&quot; target=&quot;drain&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;expire&quot; value=&quot;租约 / 心跳异常&amp;lt;br&amp;gt;阻断后续写入&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#fff2d9;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;635&quot; y=&quot;385&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;verify&quot; value=&quot;安全交接检查&amp;lt;br&amp;gt;读回 · 连接隔离 · 联锁&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1190&quot; y=&quot;385&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3&quot; source=&quot;active&quot; target=&quot;expire&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e4&quot; source=&quot;drain&quot; target=&quot;verify&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;recovery&quot; value=&quot;RecoveryRequired&amp;lt;br&amp;gt;设备状态未知 / 禁止重授&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#fdeced;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;635&quot; y=&quot;610&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;new&quot; value=&quot;检查合格 → Free&amp;lt;br&amp;gt;重新申请新 Grant&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1190&quot; y=&quot;610&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e5&quot; source=&quot;expire&quot; target=&quot;recovery&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e6&quot; source=&quot;verify&quot; target=&quot;new&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e7&quot; source=&quot;recovery&quot; target=&quot;verify&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;exitX=1;exitY=0.5;entryX=0;entryY=0.5;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot;&gt;&#10;            &lt;Array as=&quot;points&quot;&gt;&#10;              &lt;mxPoint x=&quot;1080&quot; y=&quot;662.5&quot; /&gt;&#10;              &lt;mxPoint x=&quot;1080&quot; y=&quot;437.5&quot; /&gt;&#10;            &lt;/Array&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;limits&quot; value=&quot;异常路径说明&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;Draining 超时 / 检查失败&amp;lt;br&amp;gt;→ RecoveryRequired&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;Broker 重启：epoch + 1&amp;lt;br&amp;gt;旧 Grant 全部失效&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;Local 旧守卫未退出&amp;lt;br&amp;gt;→ 保持隔离，不按 TTL 抢占&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;80&quot; y=&quot;385&quot; width=&quot;330&quot; height=&quot;330&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;legend&quot; value=&quot;实线：正常申请或恢复推进　　异常到期不直接转 Free　　未确认的已发命令 → Unknown / 恢复检查&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=18;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;strokeColor=none;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;810&quot; width=&quot;1480&quot; height=&quot;55&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;      &lt;/root&gt;&#10;    &lt;/mxGraphModel&gt;&#10;  &lt;/diagram&gt;&#10;  &lt;diagram name=&quot;deployment120&quot; id=&quot;deployment120&quot;&gt;&#10;    &lt;mxGraphModel dx=&quot;1600&quot; dy=&quot;900&quot; grid=&quot;1&quot; gridSize=&quot;10&quot; page=&quot;1&quot; pageScale=&quot;1&quot; pageWidth=&quot;1600&quot; pageHeight=&quot;900&quot; background=&quot;#ffffff&quot;&gt;&#10;      &lt;root&gt;&#10;        &lt;mxCell id=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;1&quot; parent=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;title&quot; value=&quot;120 穴位：6 Worker + 3 Broker 域（15×8 PSU 基线 / 建议）&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=28;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;fontStyle=1;strokeColor=none;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;24&quot; width=&quot;1480&quot; height=&quot;60&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;hmi&quot; value=&quot;IPC-01：HMI / RunService / Supervisor&amp;lt;br&amp;gt;配置快照与结果索引；ResultWriter 独立落盘&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;500&quot; y=&quot;110&quot; width=&quot;600&quot; height=&quot;95&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;w1&quot; value=&quot;W01 + W02&amp;lt;br&amp;gt;S001–S040 · 2×20 DUTContext&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;315&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;b1&quot; value=&quot;Broker B01&amp;lt;br&amp;gt;唯一宿主 · 本域 DB / 队列&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;520&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;p1&quot; value=&quot;PSU01–PSU05&amp;lt;br&amp;gt;5 台 × 8 通道 = 40 穴位&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;725&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1a&quot; source=&quot;hmi&quot; target=&quot;w1&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1b&quot; source=&quot;w1&quot; target=&quot;b1&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1c&quot; source=&quot;b1&quot; target=&quot;p1&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;w2&quot; value=&quot;W03 + W04&amp;lt;br&amp;gt;S041–S080 · 2×20 DUTContext&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;600&quot; y=&quot;315&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;b2&quot; value=&quot;Broker B02&amp;lt;br&amp;gt;唯一宿主 · 本域 DB / 队列&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;600&quot; y=&quot;520&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;p2&quot; value=&quot;PSU06–PSU10&amp;lt;br&amp;gt;5 台 × 8 通道 = 40 穴位&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;600&quot; y=&quot;725&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2a&quot; source=&quot;hmi&quot; target=&quot;w2&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2b&quot; source=&quot;w2&quot; target=&quot;b2&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2c&quot; source=&quot;b2&quot; target=&quot;p2&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;w3&quot; value=&quot;W05 + W06&amp;lt;br&amp;gt;S081–S120 · 2×20 DUTContext&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1140&quot; y=&quot;315&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;b3&quot; value=&quot;Broker B03&amp;lt;br&amp;gt;唯一宿主 · 本域 DB / 队列&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1140&quot; y=&quot;520&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;p3&quot; value=&quot;PSU11–PSU15&amp;lt;br&amp;gt;5 台 × 8 通道 = 40 穴位&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1140&quot; y=&quot;725&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3a&quot; source=&quot;hmi&quot; target=&quot;w3&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3b&quot; source=&quot;w3&quot; target=&quot;b3&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3c&quot; source=&quot;b3&quot; target=&quot;p3&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;legend&quot; value=&quot;CAN / PLC / 温箱按真实物理与 SDK 域固定唯一宿主（TBD）；共享设备不因分 3 域而复制连接。&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=18;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;strokeColor=none;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;845&quot; width=&quot;1480&quot; height=&quot;45&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;      &lt;/root&gt;&#10;    &lt;/mxGraphModel&gt;&#10;  &lt;/diagram&gt;&#10;&lt;/mxfile&gt;&#10;"><defs/><g><g data-cell-id="0"><g data-cell-id="1"><g data-cell-id="title"><g><rect x="13" y="12" width="1480" height="60" fill="#ffffff" stroke="none" pointer-events="all" style="fill: light-dark(rgb(255, 255, 255), rgb(18, 18, 18));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1454px; height: 1px; padding-top: 42px; margin-left: 26px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 28px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; font-weight: bold; white-space: normal; word-wrap: normal; ">Local + DeviceBroker：统一业务入口与分域 I/O（目标设计）</div></div></div></foreignObject><image x="26" y="25.5" width="1454" height="41" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="config"><g><rect x="13" y="113" width="400" height="95" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 374px; height: 1px; padding-top: 161px; margin-left: 26px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">配置 / 发布服务<br />不可变快照 · Hash · 路由</div></div></div></foreignObject><image x="26" y="137.5" width="374" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="hmi"><g><rect x="553" y="113" width="400" height="95" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 374px; height: 1px; padding-top: 161px; margin-left: 566px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">HMI / 维护会话<br />权限 · 占用状态 · 审计</div></div></div></foreignObject><image x="566" y="137.5" width="374" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="run"><g><rect x="1093" y="113" width="400" height="95" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 374px; height: 1px; padding-top: 161px; margin-left: 1106px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Run / Recipe / OpenTAP<br />120 DUTContext · 逻辑能力</div></div></div></foreignObject><image x="1106" y="137.5" width="374" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="facade"><g><rect x="553" y="278" width="400" height="100" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 374px; height: 1px; padding-top: 328px; margin-left: 566px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">DeviceService + ResourceRouter<br />按快照定位资源 / 宿主</div></div></div></foreignObject><image x="566" y="304.5" width="374" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="e1"><g><path d="M 213 208 L 213 243 L 633 243 L 633 267.76" fill="none" stroke="#8796a5" stroke-width="2" stroke-miterlimit="10" stroke-dasharray="6 6" pointer-events="stroke" style="stroke: light-dark(rgb(135, 150, 165), rgb(99, 112, 125));"/><path d="M 633 275.76 L 629 267.76 L 637 267.76 Z" fill="#8796a5" stroke="#8796a5" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(135, 150, 165), rgb(99, 112, 125)); stroke: light-dark(rgb(135, 150, 165), rgb(99, 112, 125));"/></g></g><g data-cell-id="e2"><g><path d="M 753 208 L 753 267.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 753 275.76 L 749 267.76 L 757 267.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="e3"><g><path d="M 1293 208 L 1293 243 L 873 243 L 873 267.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 873 275.76 L 869 267.76 L 877 267.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="local"><g><rect x="103" y="458" width="540" height="110" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 514px; height: 1px; padding-top: 513px; margin-left: 116px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">LocalExecutor / LeaseStore<br />本机 arb.db · 连接守卫 · SessionGate</div></div></div></foreignObject><image x="116" y="489.5" width="514" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="broker"><g><rect x="863" y="458" width="540" height="110" fill="#e8f4ef" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(232, 244, 239), rgb(21, 32, 27)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 514px; height: 1px; padding-top: 513px; margin-left: 876px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">BrokerClient → DeviceBroker<br />本域 Lease / Task / Queue / Outbox</div></div></div></foreignObject><image x="876" y="489.5" width="514" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="e4"><g><path d="M 753 378 L 753 418 L 373 418 L 373 447.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 373 455.76 L 369 447.76 L 377 447.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="e5"><g><path d="M 753 378 L 753 418 L 1133 418 L 1133 447.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 1133 455.76 L 1129 447.76 L 1137 447.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="localio"><g><rect x="103" y="658" width="540" height="110" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 514px; height: 1px; padding-top: 713px; margin-left: 116px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">唯一 Worker 内的 DeviceManager / Driver<br />固定归属的独立 TCP 会话</div></div></div></foreignObject><image x="116" y="689.5" width="514" height="53" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAACAgAAADUCAYAAAAbMIOaAAAAAXNSR0IArs4c6QAAIABJREFUeF7snQf4BkV57c/FyFWIBbElsUVRsSQaY0FFEFAR5cbYSzQQu8FuNLGiRo2IYu8lRuyiRlBBUCBihehjxxZLLIi9JSG23D1hVpZlZ96Z2Zkt33fmeXxA/rtTfjPfTnnPvO//gZIIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiMDGE/g/G99CNVAEREAEREAEREAEREAEREAEREAEREAEREAEREAEREAEREAEREAEREAEREAERAASCGgQiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiMAWEJBAYAs6WU0UAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAQkENAZEQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREYAsISCCwBZ2sJoqACIiACIiACIiACIiACIiACIiACIiACIiACIiACIiACIiACIiACIiACIiABAIaAyIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiKwBQQkENiCTlYTRUAEREAEREAEREAEREAEREAEREAEREAEREAEREAEREAEREAEREAEREAEREACAY0BERABERABERABERABERABERABERABERABERABERABERABERABERABERABEdgCAhIIbEEnq4kiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIIGAxoAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIbAEBCQS2oJPVRBEQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQARGQQEBjQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAS2gIAEAlvQyWqiCMxAYG8A/w3gYwB+mVj+VQH8D4AvJr6nx0VABERABERABLaXwA0A/NStH349MYZ9AZzpyk5d90xcVRUnAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiKw7QQkENj2EaD2i0B5AhcB8B4APKj/DYCjALwSwEmGWOCCAB4C4KlOWHAAgB+Ur55yFAEREAEREIGNJ7Czm3tvNNDSpwF4yYYR2AXA8QCu69YabwPwOgDvB/CTym393abcdzbrHIojmT4L4B0AXi/BQGXyyl4EREAEREAEREAEREAEREAEREAEREAERCCLgAQCWdj0kgiIQIDALQG8G0D/+0KxwP0BvLz3Lp/bB8DLAFyp8zc+d0iGBwJ1jgiIgAiIgAhsO4G+0brL4+8AHLZhgPZ0QsTfGWjXcQDu7LwL1Gj2nzohwk4Dmf8rgFs0Asgf1ShYeYqACIiACIiACIiACIiACIiACIiACIiACIhADgEJBHKo6R0REAEfAR7MHwngLgMPnAFgLwBf7vyNzz8LwIMHnmeYgbsCeJNwi4AIiMBCCPw/AEcH6vJnAI5ZSF1Vje0msG0CAXofeoyny5/U/PcnVhwODwTw/JnKrtgsZS0CsxI4P4CLAdjBCWzOmrU2KlwEREAEREAEREAERCBEgPvPCwFgqDd6g5065Jt6RwREQAREIIOABAIZ0PSKCIiAl8A1AZwC4KIDT7ywWSQ+CAAN/910fReSYOid7wO4qXPXK+wiIAIiMDcBCQTm7gGVH0tgmwQC3fACfT4/BnATAJ+JBZf43AUAvBXArQbe+4Vbw3w4MU89LgLbTIAhxyjo+RsnDmhZvALA3zai4h9uMxy1XQREQAREQAREQAQWRuAKAF7j9lxt1X7q1nKvklBgYb2l6oiACIhAj4AEAhoSIiACJQnwQO/QjEPyRwB4pqciJwC4XbO4/HnJiiovERABEcggIIFABjS9MguBbRII3AzA8QOhjQj+jQDuAeBXlXrhagA+4G4694v4KID9AfykUtnKVgQ2jQC9BlBQfB9Pw94H4Pb6TW1at6s9IiACIiACIiACKyVweQA8s72yp/4Udx4+cFFspc1VtUVABERg8whIILB5faoWicBcBC7V3JQ7uTmM332gAu8EcKfm5s9/eSrH20JvBnCgFpVzdd+iyt25Ofx9GIDLBWrFuM4vn3CjwfAYdw/Uh3U5bQKKuwJ4FADemPWlFwH4xAR12cYiJBDYxl5fZ5u3RSDAvQzd+x8y0E30WMSb/cdV7ML7AXiJJ/+/A3BYxbKXkvW1Afx1gcpQxPGxjvH3802+35WL0gJk15MFBcFHecQ+bStqhwxZD635a8obg1yvcx9nJYaMo8BjyYnteEhzC/KKEZXUWjsCkh4RARHYCgIMsec7x/sggH+aicK9ANygQNn0RvZxJzb+7+by0qfcWpX/fdsTQ8ZyH0TWviSPats+StR+ERCBxROQQGDxXaQKisBqCNB4euRAbWMP6HcD8H4AvzeQBxffvIV36mpoqKJjCHBuoiuygwOZfA7A3gAYhqJ2iqkPDVQPrl2R5qZq6KYsi6fr3T0BnD5BXbaxCAkEtrHX19nmbREI/AEAHj7y9ko/1b7BHwovUDu0wZJGpfVdLFHXbzsR6j8DONGJBkrkqzyWRYBhBEKHzKwtPXZQ+POzZVV9K2vzp27vtlNE62t/jyOqYD5yQ/ed2dF8EqBB7JiI5/SICIiACGwygYu4cKFDhvjYc8BafChM+MtamQP4jQuF+l4nbqSI4KyK5S0xa14S+1CEsO6xAJ62xAaoTiIgAiIgAoAEAhoFIiACJQiENgYpB0I+kQHrKLeiJXpqPXnw4O0dgerypuE+7qC4dqsu3pT1L42Xi6sHCprqwPoxAJ4aqAfrSQW/QnLUGRWWIUwHxnW4K9d0AtsiELgLgDd48DwgcLs/neh537gmgFMAXHQgs3c7V+jbcFBofRdLsO7nQcEAXdFTmPqNGgUoz8kJ0HsU1337GSX/e+MVZA8AZ0xeQxXYJ5AiEJjbUGT1XsgbzdC7Wu9ZRPV3ERCBbSBwSwBc8w7ZFlLOAWuwqi0QGKrzRwAc4Zj8R41GLSzPa7m90IWMer0GwEELq7uqIwIiIAIi4AhIIKChIAKbQ+CSAN7quUWX2krefPuL5nD705EvhjYGd3UxgGOyskIN0Dj69AndysfUWc/UIUD3nrwVeulA9lO5b+aN/JMA0IWaL01xcz90W7WtF5XZVGgr1SFgGcJ0YFyHu3JNJ7ANAgGuGd7uPAz1CdE9/U0BnJmOLvqNB7rwBkMvpKx9ogtc6IPWd7F2tXkY+1DnZYpGSKX1Eog5zJ9KkLleitPVPEUgwFq9EcA9nJvm6WoZV9I1nPcAioJjktZ7MZT0jAiIwCYT4NkIhZoU6w6lBwF4wYwAYtYUtapH7wJ0vf+UDRc00vsr1+Gh0KBkLA8CtUaa8hUBERCBAgQkECgAUVmIwEIIxC7OYqr7n40LV8ZcZyxYK4WM+p9tXE/u62LIWvm0fw8d0CjUQCzF9T8XYwyf6obm3zphikWVHjBeZz004u+WaIKGkVs0IQbo5k6pDgHLEKYD4zrclWs6gW0QCIRu8NeOUx7ynPStxuvRTZqbMl9N77ZVvmF9F6dq1GlN6AEeRjMclYQCU1EvW07II0hbUu3fdtkWbXZuqQKBJYdeeWLz3Tg0obu03kuApUdFQAQ2ksDVnDfHiw20bglr4TkFAl0kFAo8eUOFApZIhBx+4UTbH97IX4EaJQIiIAIbQEACgQ3oRDVBBByBuQQCoXiNuarhRwB4pqdnefuE7qm40FTabAKWYf47AG7cxJb7SkUMISNbv9hXA7hnRcPEzQAc73Hhx7p83fHghlypDgHLEKYD4zrclWs6gW0QCPgMOlMYoUJrH7q+5/pnW4zU1ncxffSOe4NeJf4aANcISusiwO/W2xoPUjf3VPtTAG4N4JvratbG1jZVIEAQSxR4MIbyyY2Hg90TekrrvQRYelQERGAjCYQ8aS1hLbwUgQA7/5fuFv1z3L9v0oD4k+Zy2YmekGtsJ8cCPX0xRKiSCIiACIjAAglIILDATlGVRCCTwBwCgZBidIx7X97MO8bdwGtxcFH9OOfO978yGem1dREIGWDaltwGwNEVmxVSxveL/VwTimBvAN+vVJ+nNsIYhtnwJYYY4e07bb4qdUDjVcUyhOnAuB575ZxGYNMFAiGDzisb4/D9K34LQ7Gqt/GWjPVdTBu5ZZ7+qQuV9a4tEmqUITd/LjsD+AcnsunW5i0AHizhx/wd1KlBjkBgzP6wVuPpAYxuslOS1nsptPSsCIjAphEIedLiWcQ+zrvAnO1ekkCg5cBb9HcD8LU5wVQo+yoAXgvgep28eWb7eADP20BRRAWEylIEREAE5iMggcB87FWyCJQmMIdAIHQwNDY+PG8PHde449rBxRjmoaBuDJUeNcvObxd3Y/66gWo+zamxa7XkL9xmJyb/mpvhGE8GNIi9NKaieiabgGUI04FxNlq9WJjA2gUCVwDwMAAMYzSULtvEvLyl528njDh4+5ITIp4V6A/rtukZFcUJrBY9JHBu+nThMZObnfVdfL1bx8XkzwNnri1pJL4BAIbWOX/Mi55nnu3WCBKWjoA406sMNcV1INPPAPx8pnqoWD+BHIEAc8v1MFejL0JGrlB5Wu/V6A3lKQIisBYCXIMz3OOQTeGjAPZv1vE/mbkxIYEAz214+ejfIuvI9ehuAC7ZtPv6zZkLz15zE8O53tVdiNo0b2MXdXu33zSizh9KGJA7RPSeCIiACExLQAKBaXmrNBGoScAnEODN+5CbVcYM40FsN3HRuldzW/ZjgQqHbtB9GcC+AL4xosH0TvCoxgDwkeZW9km6ATaC5LpfpeKYB4m+9C8ADqx0cMwx/qrG0HRwAsKxwhhfUdyUfhDApT0PxPxmE5qhRz0ELEOYDow1dHwEaOykUXuqROMaD76uOlBgisG2RH25DjnFHRTF5pdreIrNf8ycEhMnfWw9Qu/zwG1PAKfXLCQhb+u7OHZepNhlDwB3aNp854ALU1+Vj2oEpvdewEF1AlI9KgKrIJD7nV6K8YiQQ0auUCdovbeKIapKioAIVCBgxZ1figgsJBAYe3bCcyKev/LM8x6NtwSGguTFpthEA/pDnPv9TRMJxDLQcyIgAiIgAgshIIHAQjpC1RCBAgR8AoHXADgokP9QnPeYBfM13YE/VaL9RJdZvMG3pMSYtMcuqUKqSxQBHsC9I/BkTUPJxRv3eBQgXD2qpmc/RCX97QGEbp8mZPfbRy0O/wrgFs1G80c5meudaAKWIUwHxtEot+7BJbq5nKoTYtYU/brkGp7GtskSndGjAdcTvBk1V/p3ZzCnp4IlJOu7OFYg0G3j+dyc/Eh3IBvbfgpNKTDgmkFJBESgDIHQd/q7AM4E8EcDRdEYcivnKa5MTfJyCRm56KGF33veGB1KWu/lMddbIiAC6ycQOgf8lgsT+tUFNLOmQKDfPAqzuTd4IoBrJ7Sd4SOf0bji/3XCO3pUBERABERABIoSkECgKE5lJgKzEphSIBDyHjArhEDhJQ+ol9rGTayXdXOebWbs0NdVaDxvaNKowAPE2ERvHTcG8JXYFyKfszwpPN/F5o3MTo9lErAMYTowzgS7Ba9JIBD2StQfAksVCNwQwMkAdpxxzG6zQKCL/TIA/j7By8/7nIBvbpe3Mw4dFS0CRQmEvtP8TlE0y/BXQ+mNTuRDN89zpVD9j2z2AHs3nsQu56mc1ntz9ZrKFQERmJsAjeCHeirxQuf9cQm34qcUCLQ4eE56kyZE0nMThAK8sHW4PKbOPaxVvgiIgAhsLwEJBLa379XyzSMwpUAgpBpeKlkJBJbaM+F60TjPQ0TeyvelVwO4Z4VNlW/zy1jGvKn/+wMV4maYN/nfWxB3KJY4i1nKTayCTV5sVhIILLZrFl8xCQTWLxDgfPSSJnzSvWYebRIInLsDrteE0ngDgCtF9MvLARyimKgRpPSICNgEQgZ23iJ9fBNa55WeGNU/dkaUz9jFVHnCErs/GACNNn/gKV0CgSrdokxFQAQWTuBSTii7+0A9f9H87abNTfoPL6QNcwgE2qbT4xXXm88EcH6DB8MN3KnxuPPWhXBTNURABERABLaMgAQCW9bhau5GE5hKILCUA/LUzpRAIJXYcp6/nzPK+Gr0OXfL5/sFqxwyyp8K4D+a8AP7eMp7WmN8eGzBulytiWv3AQAX8+T5dee1gIexSnUJSCBQl+8m5y6BwPoFAksRR0ogcN4vxc4AXhDpTUA3tTb5S6u2TUkgJBBgaBmKd5/TrOEv7anUk5r/TjHuHOkPXai8IQEAvYE9tPEe8KrG9fNOnspJIDBHr6lMERCBuQncxYkyh+rxHgC3bcRVvEyxhDSnQKBtP89x3tZceBkSVHQZUTTHEAU8Z1ISAREQAREQgUkJSCAwKW4VJgJVCUwlEJjL7e9YeBIIjCU43/vWmKN7UhrraUQvlUJGebpMpYviu3oKs2JYp9bxL5oYqK8NvES1OTfrc7ppTW3TWp+XQGCtPTd/vSUQKCMQ+LaLXc341mPSzQGwT/rJ9/3mnunJzXf2cQPv8ObPLRuh1gljKjTwrm/MSCAwDJq3tR7VhH+gSC+UeMPtZs44WLjLlJ0IbBUBSyBAj1qMr3wrD5U5Y1U/EADDcw0lrqt565NhSSQQ2KohrcaKgAgECFwQwNudIXvoMZ6N0PPjUtISBAJkwUseRwUul7S8TgNwQBOi4QdLAah6iIAIiIAIbAcBCQS2o5/Vyu0gMIVAgO6xGOv9jgGkPCD/WgZy3v66w0BcXx7kckHNG9tjEjczx47JQO/ORmAXAMcDuG6gBo8AcETBGoaM8jxQ5Bh/lqe8HzYhBvYEcHqh+jzPxfLzZcf4ri8tVJayCROQQEAjJJeA75CK35LShmXW0Ten8m+587TV9ksAuM2AO2neJN0LZQQCpYzjvt+yTyAQum1a68aUBALWiDvv37m3fSSAw4xXdQibzlZviECfgCUQ4Hefa3eGZvGlBznvH1PSvWQzJ50I4BqeQmnkolcy7j1852XyIDBlj6ksERCBJRC4oQsvsONAZT7vwgucuYSKujosRSDA6lzEhRDYz+DzFABPqBA6c0HdoqqIgAiIgAgsjYAEAkvrEdVHBPIJTCEQ4I2745pbdDsEqpl7YOKrfyljQD5ZvbkEApaRvOQtes6NdCt6sKfhdwdAEQA9CfgSn6GYZmyyxBE5hrexddrm9yUQ2ObeH9d23yHVawAcNC7rwbevCOCDHtfOufO0VU2fsSjnO+XLq9SaIFUgQDfYhw4A+B8nbqT70NLJN2b+FQBv5v6odIGZ+Vnfxak9OFHM+kIA9zHa8wDDcJmJQ6+JwNYQiBEIcL18CoAhV/4E9VF3G5WeuaZKIRfZrZHr+gCODlSo1jw6FQOVIwIiIAIpBHg+wksSh3hemjNkjK8dSxIIsI6XdyLtKwfAU5x20+ZC1mdTOkfPioAIiIAIiMAYAhIIjKGnd0VgWQRqCwToUuzNAA40mp17YCKBwLLG09JqQ3fAoZs8X282XDduDAJ0Vzo2XbxxAcdbpFcfyKg1dNEw4zO+8bVXu9irNB6NSddyB6sX8mQypaHoAgAoWOgmutbm4e8vxzRyRe9ahrDc79+SEFy0uX3L732bfu1cHfKfSvkEphYIhAw3dPdcw6POpgoEQt4Dahq3fGOmdBib/FF99pvWd3FqgQDrtKsb49cLNO7LAPYF8I2xABLeH5pHuZ44KyEPPToPgf7cyFrQyxnXQGPXemNaNOecHSMQ+LhhVCI7zkkUoE+RLBfZrZHL+q5Nud7jmR1dVPdv7TLON+NWrykxFAy/z/xnm5b6DVzjvmdorCzhO5U7Rin449jvXk75GYCf52ao97IJhNbC/A7dpBHMfiY79zovLk0gwFaS03sHvuddAq8EQA+RCh9ZZ1wsJVftCZbSE6qHCIiA12Wa0IiACKyPQG2BwJ0BvCHgarEllntgIoHA+sbclDXmzSMa5Km8Hko8YOSNSm64xiaGBzgJwO8MZNQa5GkQf2fz3N6ewj7n/kYV+JgUCnXAfKnkf/CYAjzv0g0eXcPe3sXLu5xRBnmwze9ysQk/WVE04DsobasYOgjjgeQNANzX9Q/bxUMnCh14M5mGN8YZ/4qnvVMcGA8dng5Vp8SBHw/eeMBPd7p0De/7fbF8hnn5AAAeWlCsU/q239AhYLfdoQNButO/rfP68cfN7WG6um/rTCMgxW3PBsDD9LnS1AIB33cs5zZ/LLNNFAjwe8NvwuM8EGrGW5VAIHbkDT8X4/Wqpntzjh1+UzmP3sm5Wvd54OIcxNtir3XfK4oec4zOMfNHbWOc9S0Pic7GzO/jRss5b7f9tr8LqXadAXFkvywypSH8LQAYciS3/6w2LGnOZl1DAgH+vd0ThtxS8znGrL7HRMaQUF26Rq4p1ntD/U2DAdcxt3aeFa7pQgaFxsa3m744xomTP1Z4/T32N8kxS28M9OjC2NoM7zCUuI94v2sDwwKODS1o/Za6f2cbeQ5BwRjryPVTzL6Hv/mXu/3gXG7VOV5425heMTjn/X6g4fwuvcmt47/kmWN+twmh5xOlTyEKv5S7jMK1FfehHD++9G/OZTtF+V8EUFrIPCQKa+tizWNXA3A/9xumR6+2HWc05xUfan7ThzvvKSnjdO5nH+jOHYbqMeU3PIXDEgUC/N5wT/qQQENyBRdzjVlr3Rfaw6993Ro7HufYE/jqNmZeH3uWFstLz4mACExMQB4EJgau4kSgIoGaAgErVmO3WRIIVOzkLc6axnpuPnnQ7ktPaw7FHluA0VObW2GP8eTTNciHnqPiex9nUM2tkhXqgPnSqBtygZpSNhf8t3SGsD1SXhx4lobYFwN4ZnNAwsOQkomHVyFxxtDtWrJkf7wMwJWMyoS+YbUPjLnBZjgN3hoIJR4c0HhxaibYCzthCcd511tASnY8wH10Iy74QspLgWctQ8PQLWTWnQY+xmsMHSKWcks/pqlTCwR8Y5WHNLy9QhFP6bSJAoHdnNGCa6x+quk9gGVJIDBuhPKbwFA/dwxkU6MPOZfS29bTm3XL7plNoJtzfvM416UYPSjuo4GaQjhfqimKYJmcQ98RKD9kSMiZ3zMRn+c1Cs3uDeBRhpEtpjwarigsomCghDBtiXM2OVjzdruesn6LucaQmL7oPsO9xJHOmDr0LkOT8PdBcc7DG0PpswIF5O53h7IkH66/Kfilx7QxieON+yGuJX86JiP3bu5vkusz/p64PuP4TUkUCzy38TLw94Xa4Cv7ss6IS9FwKyxNqWf32Y803hwe6tblOeKu1HIv01zaoLcLhsMLhX705XuaG+vcR3Tr+7du7hp6r5bAlHs0ikie03gSyd1/fs/NmbzMUuKby/aHjMu+fQW9D1KwEPJexLzn8KyUOsa6z4fWFlN7gUlpxxIFAqx/aG/Rti8nZMNcY9ZaC4TG+9rXrdZ4nHNP4Ktbzrxe6izN4qW/i4AIzERAAoGZwKtYEahAoKZAILRZ7Dcl98BEHgQqDIoNy5JK/JcE2lTC7bK1YO4a5K2wB49oDsWOGNEHoVAHzPY7LqyC77Z7bNEpC/7YPLvPvcAJN0ocVDJfq4/644AHr/8AgP0Rk+YSCLAfHtkY7A8zKskDOt5GpbeG1MRNKuNuP2OEMKBfJkUzFAqMve2VerjAw1GKFK4bAWEbBQI+40ZNFpsmEAjd8uGB6B2am55vixh/uY9IIJBL7pz3aHR7d8D7VUnvQyyVRoHXjBAG9FtMI87d3e3IWBqhW37Mo8RayVcXywBrGRJS5/dYJqHnYoVmqWWVMKYtec4mD2ve7q6nrN8iDcIPy/ScEds3vI1/SmOI5C3LfqJXJt7E/rD7g7X3zd3vdssdY0S32szQKfTKwN/7mJTzm+R3kIZaS5Br1YtCG94k53ewZKIRl8Zo3rgvnV7kREZj18S+enHMUHz0N4UqTiH3EzpG9akFAldwcyaFqyUSx8y9Cox71iXF2Mr14iFO2BIj2FibQCD0/a4htCwxFqw+LDFH59aT44X7Z44ZX8rxRjnXmLXWAtZ4X/O6NTQGlrAnGKpf6rxe8iwt9zej90RABCoTkECgMmBlLwITEqglELhGc2ByMgAaK2NS7oGJBAIxdLf7mdDBHskwDizdQp4+AhNdAtKNOuMd9tO33M3br7o/WGEP3upuKeXGj7M2WzR60KPCmNjFl27cffIwi+7ZayaGWmCYkhMLFJKyqeGGhjfC6No0Ns0lEGBf0hV+6GCJ7j0pDuDYSk3sa7qv3i/1xYjn6Rr7zxtDFt355yZrvHcPF+i2+4TmdvCVIwuraRSPrIL3oJHGxINiM0l4jrcHeROyn9owKXSJXTptmkCAt7D5zdppAFRNI2tbnAQC40dozM2kEqF6ONfQsMIbr6UTb9My3NBRkcZTa61U81A8FKOYXCxDQsr8XoIzw0QxbM5YQ+ZQXcZyXvqczTZb83Z3PWX9Fvtr7BL928/jic1v6FBPxvS8wbVwe/u4pkCAZ3Bcy9GrVert+hQuXDPSWMq5JPdWe8pvku2iKOEVhlenlDbQuwS9wJQIITfVnociFPYvhdwlE/eoFCXmeqbx1eU4t19l6LCpBAI1xkq3fWwHPYCkeODp84k1tsYKvLv5WwbTkuNmbF6WR8PaXonG1H+pHgTYJiv0To6Ada4xa60FrPG+5nXr0Phc0p5gqH4p83rps7Qxv2e9KwIiUJGABAIV4SprEZiYQA2BwKfc4QXd18UmCQRiSem5VALWYpb58aYdXQrnJh7C04g6lPoGfyvsAWM93rgxTvPQMydZHhOszZZVJlXNbBNdbE6ReFDJeHs02OceVLKe1jjoGu7oNYC3Y1Kl6eQNAAAgAElEQVTSHAIBxpqlOGDIENnWnfzu5p5L5cdDRbqqZhzMWom31cjuE5kFxB4usP95QJpy82vbBAKhb1MJYZGvizdJIMBDZf4m6Sq+n/hb5G0qilRqJgkEytC1DH1jRTN0TU/vRlx/1Eop86d1i591HLt+8LWTcbB5c9iXLJe5KfP7GNa8mc8ba/TyFHPbM6esMQKBNczZZGLN2/31lHVLsKahiWtdCr7o2nko8aY6w1+0yfpu5O53mb81znPGm++dMcLSmLq2a27emE+5QZ3SxrFhtdqyrDBhKXWynn2fE3HT6F4i0ZjIkHKxFzZSy2zryxBnDI8zlMZ807r50eDEkIA+sU5q3X3PUyBAD2cU2eWkWGMrvwX0aJYyl9Sag3Paab0TEv5NIeyy6hf6+5IFAjHzQGr4zLnGrLUWsMb7mtet/fG3tD3B0O/DGns1z9LG/J71rgiIQEUCEghUhKusRWBiAjUEArwhnbrhyT0wkQeBiQfMSot7KgDGTfelMTcBLYU8D01e2is4ZMTPUX632bMuFCrQIDyU6JVgH+ftIKcrYwzSOfnGvMND18NHiARiNzW8ZZ7i/aSt+9QCAcbd5M21IZe3XZ50J0pjRqo4gC74j614qNit45ec4Z7imNQUe7jA3+GLEzPfNoHALgCO94Rf4G1ZxgWukTZJIMBvJA2dQ3slxhWnmCz30DmWve+gr5bXidh69Z+zjC7WwWBuubHv0bPQSU0sbB5ADqUx3od4K5pGRQpGaqcUQ59lqK/hAcMSTcbEmY+d338+Anaqq9TconKNaWuZs8nFmrf76ynLSG95mMjtC74XEifQC9K+AL7bKWBTBAJs0hmNOGKvTC9Psb/J/SO8YI3pPwrybte41h/z27fmqjH1G3r3Kc59f+q6vZ9X7D5hbP0Z5oNeDxiWbSjlftO6efH7Sw9XXMtPkcbsOWOMrRSTUnhEj5spae51UUpdQ9/OVwO4Z8beNKX8Mc8uWSDAdlnnWqmi7rnGrLUWiBnva123dsfnUvcE/d9Q7Lxe4yxtzO9Z74qACFQkIIFARbjKWgQmJlBaIMDYujTiDW146C6crv64kOsnCQQm7vgtK+5mzvDlm7/G3AS8lDMoD7lu9B2KWBuiVOV32528IcIDfMbJHEo5cenafFIPmsj0H5ubtPwnb4l3067u0JHfC7rqjbk9kWLkGGp7zKaGbmIZOmHoG2X9ZKYUCMS6ys894IrNn0zovprGY4bY6B7AUrhAgwXdxvKGrNXH9FRA16qtm16Ld/t367fEwwXe6KbrVorXUtK2CQRCoVLoVYNCkxppUwQCDPfB8TYU47fEAXkM+9B3TgKBGILnPMO5/UOGB5VbOSFVSs4pbjdpgHy2K4PGutZgdAF3o5khWh7ceNi5hFEBrr8ZJ535hVJoPcP3+vHWU9rtezb03eE7FFJwHgmFXYqZ3+nVI9dImGOcstZADEXCOY/r0+78mPOtWNOczT615u2h9VTIzT9/F/wt0uV5yWSFNxjyXDC3QIDjjmI0Cl0ZV51Cpq6hmWszrrt5E5sewazE9R2Nsqlhz2J+kw8FQEMWzyL6iV6l6GGFRtTu75ZiEc61fxXx3Wvz5PfD5+XNaj//bgkEKGJ6R8PzXc04PBXAmb0wbvx+XMFxfACACxqF5nwD+lmmfBP4Lnm/vBG8vL8JM/WDTmY7ujB5ZNj/VrWPcX/GueWPPO0a254UV/xct9PjHD3dfa0TKqDtA3oRe3hEeJgxHp9ijK28KJDjCSHGYBozpms/E/p21vpel2zT0gUCB7hvp6/NX2nOvW7kvkUxXOYas9ZaIGa8r3Xd2vbLkvcE/bETM6/XOkuLGcd6RgREYAYCEgjMAF1FikAlAiUFAjTs8BYHDyGHEhd5TEMu6CQQqNTByvZ/CdAw+MHGYM0Dk6E05vAiJD7wCQ9iFtg5h9nWjcdcxX7sQRNvxvImCX/j3QOm0DCkSzUesj45IvboGHehMcx5+4WuOHkg1k08OKNogweVbbu6h008EOZNiWM8DbUOF1O+f4yFSoP3TYzfNl0y84ZB6m1lHurwYG0/I396iaFh6psR35jLuJs/3DSGEg9OeSCckmIOF3gYO3QQd6Qr7+Odw1yOEwpsKGogA/6+aZibK015G5zjkIfc/TTGq0kMt00RCLTfbK6rntC76VbqRqDFUwIBi1D832mE57eQhkdfijm87L4ba+igYe++zoOBdYuU3zfOoRxjnJd8KVaExVuazM+XLHf/8YTPfjJ0yzDWkBAzv+esqVi/2D7js5xv2Q80UMWugdhn9CTBNdC1AaSuR9c2Z5OTNW8PrYmsWMMxQpLUscl+oQF76OzL5yJ7DoEAvxccdxQG0GV/TGKbuL55veEpKsaDx1B51m+S5wV0o3+L3svkTQPuF4xGMNzHQW4NF/ruMZuxHiaG1vA0IFN0cBiA0xNuQl8YAL3W/aXRPn5D+B22vv8+9rEhtbgv5LfnqxGDhuJuCnX4zU5Jqd+0ft4UhHDfExIa/9Stufgcb+eHEscOxVncb7A/fGnIQ0hMuy1jK8OSsJ590TLFDdxrci/ZCgJZV64pebZGoS6/cxxzS0+hb+fY3+MUbV+6QMASVqb+5uYas9ZaIHaNvcZ1K8dx7Ppyzj1B9/dmzeu8pFTrLG2K373KEAERyCAggUAGNL0iAgslUFIgEGriac0GnWpXuiiWQGChg2GDq2WFAWDTh0IBxCAJuXkLhS4IvZfrupiHaoyd6Es0er4uplGdZ2Jjt9OIfucmvMEXE/NvH6cRmQdVlmE6112otanhDXO6uO/Gg+YGmwc5PKwJHdLRQEM3yT/ztL2UQCDWEMBDLxrvU8UB/J3woPBxgT7koSjH2QsiDuG62fCQ61Hu8MuX/Zedu96+x4nQkLIOF3howAPorocPCnfu6G4XhfLmTTsetqdyzPwJDL42pUDAd8BC17E3bg60eSOlRto0gUD3m0amV3IhNLpuqCmM4gE1D/FLxRpmuRIIlB2h1qFjqlcGCrvoSasvQuvWmmPiPu7mb0preFuMN1h9YWc4h9FrD/MPJcas5u1jXx1LHu5z7qTYjG7Gh1Ks1yNrfh8TGiGmz1h3igsZSz1GNDfUVs6RdFf/TOd6+WMRnb/GOZvNsubtIYGAFWs41SBi4eXYpBGPwpKh5DPgTikQoNGAwkqKVy2jqK+9Md7BckRB1m+yX5/ctaX13WM5sUIjH6P+Gp7rXxrKY0VA/XxjboyOidEeE1KLXmUYjo7zUaoIgZ4nKJ6jN4eYNOa3uZvzajDkZaItO3ZN368r86Yg5cqBRsQaKLtZWMZWhqHid6JNsWOfcwTn99xxF9NXJZ6xvtVDnldKlFsyj6ULBCyPkWSRcvlgrjFrrQVif39rXLeyj2LWl3PvCbq/K2ter3mWVvL3rbxEQAQKEpBAoCBMZSUCMxMoKRCgBwHeyKQIoKvy5saHN0d5eOY7OKHRj67gUhMP2Xng2T/IpBtUur6OvUkxVC7jYtPAe1ZqpfT8Igkw9nPIxSQPO+haPsWNprVQvo0b90NArLAHqcZ8K45vrugg5qCJbl3Jbqyhi79nGre7Rvohdjk3za2+ovGOh3aMw85EIzU31xQ+jE0lBAIxB4qsJ12E0kiRY9S2Nqr8lvNAkYfmqQeKrFtMG1IPjqzDhc83MeGv2rkByHmBc9TYsTp2TMS+P5VAIOQOlOEjeIvaJ4CJbYvvuU0VCLC9Qwe6VwHwJndbeMzvdYinBAJjR+O537eMfSnrBt6+PNZw60133vwGpoZaaWtt3bR8j1uPh/K33KqXDDNgfb9jDZPW/J4rEIjpM7LP9dgzNFp3cvNVzP5ljXM222z1u8+wYbV3zK3rfl+EDA6h34D1zUgx2vTr1I5zGsUp5OQeNfdb0c3bWufniIKs32S3fK4t7wWA652ctaX13WNZY8ZGu4bnZYeDG3EfhUtj0yUjYtBToMwb4ykpxqBeYn8TY1xv650rEOCegaJ2Cnp96SR3DsQ9bk6yBDLcQ/D2PsNGxCbLuEwDfyuuIBuKRSnu25QU8vYyRvgyJR+rD/dqQo/EiPhq1Tnm+5pyjmS1t9aYtdYCsQKBNa5bY9aXS9gTdMewNe5qnqXV+i0pXxEQgZEEJBAYCVCvi8CCCJQUCLQbQBrY6OawvcXEf6dxlgYr6+BkQWj+N5Z73yUpD1Ees6RKrqAudE/J/v/0zHW13LHx9jhvyXLzGptCeVq3bq2wB6nhAKz8cg7IeYDBm0k8CPKl97l4oKUMrjG35HPcPlqbmm77xoQyGOI0ViAQc/ue5VIAw29UjGGhX0/rthyf5/f78MwD3LY861A09SDaOlzotrP0WI39Tox5biqBQIjjJxuhDGOd54j4Ytq+yQKBbvu5f2Ic31f0XMGX+F215UggEDPi4p+5nbsp6XsjZV61jHAlvk8cY88G8BBPhWON+yG3/8yabpAZw3xsCsWVT3Ftbs3vKf3UbVPMnqXk7zeF51rnbLbRmrd9RnTL40Qp4xN/RzS+U2w5lLr72v7frTEzViBAL2E0dn8qZbAYz1oxnHMExtZvslsl7qvpXTBHHMB8KJCmuJgiA1/yhXyLwUiB5HXd+reEIKMt0/rOhrzQ+eod+qbyHZ7V0FMJ19pjk2Vcb/PPFQjcHAAF6L7QArzIwWe4fx+TrLk5VagRMrZ260lhDMUBFBpuUgqNwTFCnSkZWQbzuQUCnKO456do35dijet8f64xa60FUtpgfU+Xtm61vjtL2hO0YyxlXi99ljbl719liYAIJBCQQCABlh4VgYUTqCEQoKK2dfnH29hUXtOgx2QdnCwJ19CB4prqvxSWuQcDpetvLWpz4myHvBLQbSFvtfg8UFg3/lMPs/Z08YqZ71DK2RhZ450xErlJpmv4kinm0Cn1wMbq/279Sx/4jxEIxManG7uRDMWLJJvY+NUx44C3GuhtZihxztiniY3LW+sxyTpcaPNY60Z1KoGAdahMd7QMIULBUOm0DQIBGrZ4MPpXA/BKHhKHvnM5c0Dpvu7mZ30XUw4Ga9XTqmOs4dkywPH31V0rj2mPdYM0ZhxYgsrU9clQe6wbXykx5a35PbafuvX8wybkEd2l9uNEd58p7QEkpd/XOmezjda8HTKi01sVXXT7UqoXoqF8Qn1vuau31s1jBAJcD9JYmhtOIDS+QmHP+B6N5PSAEpus32SbD39j/M6OFRlbLqbpAYkeKCh4TE0U6XKezhUw+Mq7YmPg/mAjbri05wGu6+mJLlb0G/PNGivG6Fc1tJ5vn805B7DEQOwPfgPpgXJssm7ypngKYl1ija1zzh9jmfneD611YgWKteqWku/SBQIx4yxlDT3XmLXWAiltWNO6dW17gva3Ezuv8/nSZ2kpv189KwIiMCEBCQQmhK2iRKAygVoCAVabRr7rAHhpZ1NtHZxUbm5S9hIIJOHyPpxzMFCm5PPmYhnBUjYinAtf5dxNDtU3Jq/7uVsvQ++ncgv9tnLEDzHx7XJc/cf0bUxc3dQDm9hNDV2IHlA4xqNlZAodGMe4Th0rDrDiRaaORauPLW8XMQastgzrcKF97inNAe8TKhzwWm0d+/cpBALWQUXbBnoBYngGijtKHpRvg0DAEvqUErCEvnMxc9LY8ZryvvVdXEJ9rTrGGp4to2bJtlprkxjjvjUnpAq5hsaFJWpMEQFa83tsP3Xrad1Go+tp3l79ZsqgL/Ss1T9LnrOJwJq3Q2sia75K9UI01CWhvYKVv7XPHSMQKDR8BrOxwp49AsARCRWwfpPMyhJbJBSHmPKWxv4C7vY4xRdD6SvuwkWse3srlF6N/U0M95zvkSX4oOtt3sBNCQsYGk+h363lEbCfb4yxtZbAPuU3U+PZ0FonJsRRjTrl5CmBwHmp1Riz1logZW1srYuWtG5d256gHQ0x33s+W2Ouyfkd6x0REIEJCEggMAFkFSECExGoKRAYaoJ1cDJRs6OKkUAgCpP5UM7BgJlp5gPWgbR1679bbMjIGbsJsTZGPPygwMZK1iFTTvgE63Za7cV/KIYheaS6PI3d1NQQPVhGJt+hZYwnBRp7bjvSSGGp7ksfxFneM1JuTVm/IY6Vkrdzrd9i6b9PIRCIuQHWbRddmNO9eClXu9sgECA/xtN9WUBUVsJdrgQCZX+B1rc7xvBszc/0wEOXz4wLXSqFDEWxN2mtA8wUIddQu57XCPF423sopcZ9tub3mH7q1sPybsBnGS6ELn7nSGues8nLmrctQ64liKXBla7Jc5IlQLA8FFj7XKttOXUu8Y41plJ/79ZvknW2xBap7bK8IKSKHFLLz3k+9B1MMUxb8wzrVmN/w3ytuSLnHCDEJSc/q2+s84EUDxoxAoHnNl4zHlZYbGu1sfbfLa8PKaK/2nW18pdA4LyEaoxZay2QIhCI+RalzmN9CiXWrda3eql7ArKImddrzjXW71Z/FwERmIGABAIzQFeRIlCJwFIEAj8C8POMNtLQxDYMJSpdxyjLP+TiGXZd+1kHPxlN2PhXamzkc6FZt+JTDmNCt20+17j739sZJkN13aW5HXK8i2059FzsLfnLNK4WPxJwhRubT7cOoU0Qn7MOSXP7qH3PMiLzORo2XxdZUMymplT82n6VLCPT0IFxjDighEGRdQ15ssjxPhHTJQ8HwFi6Q4n9sEek6ME6XGD+Ka6qY+o+5TO1BQKWa1VfW/nd4mEfhTpj07YIBMjp8s4l7pU90MZ6A7lQ472JQjcedvdT6kHb2H613re+i0uor1XHGMOzZXjLiTNtsb2Wc4/P8TCU6JnmbUYmlqE0dp0zVIyV95Oal3iLOzZZ83tMP3XLsoxFpQ2bse1sn1vznM02WPO2ZUS3XKm/BQBFMvR6k5pCxs6YNaK1T7TallrfUs/7zgPa/F8D4KCEwqzfJLMq/Y23vtcUNtJAtKQUGi8p+2crXEGOUDyWk+UVLKUdLNPaq6eI+WPbwDmJ5z7kOJRSxo4lEFiTq/1Yfnwu5PUhVfSXUm6NZyUQODfVWmPWWgukzhHW2nIJ69a17gk4ImLm9Zh1Uo3frPIUARGYiYAEAjOBV7EiUIHAUgQCuQcmvvr/uzMwUSRQMlkHPyXL2pS8Ug8Garbbcr3Lshnv8eiISoRuqrwawD0jbwaEDPGxBzqWa9BYTwRtsy3hQurt/Qicg49Y7jJTDCsxm5qUfktpk3Vo2f/+WUZElk1xAG+0UGk+JllCjBh31Dnlh5ikfDOsw4WU33ROO2q/U1sgwBt1z8xsBA/8bgfg9Mz329emEAiwrLGiQebB7wi/j/2UYoC0xD9j4tKGjDypB20ju9V83fouLqG+Vh1j+j00j8V6GzJh9h6wjH2xbEPrkzHisZCHIobbYKzwzyQ02prfY/qpW5x1E7m2QDLU9LXP2WybNW9be0Ku5bn+O8QDKteYYY2jGOGKtU+02pYw7Is+aq37SwsEanz7rHGV2oaigD2ZheaHlLUwx9U7AhWutb9hkdaN2JR2MD9LoJUiDo/tQ+u3nzJ2LIFA6nwU24Y5n7O+yTHfzjnr3y9bAoFzE6k1Zq1vduxatVvbpa9b17wnsL6T7Ieac82SvhGqiwiIgCMggYCGgghsDgEJBNL60jr4ScttO55OPRioTaWE0dlaIKccXoQOdWIP4EOH2Tn8LXVzrY1iv++tW5ApruitPmPZqUKK2LFqGZm6B8Z0bUyPD/sFMqfL/AMA0Hg/Nlk3dRhegHHnSyfrUCD2EN3KZyoxS2k+bX41BQLXAHCyu601VP/HA6Ax6tBA42jMu2NzoPveEQCmEgiMqKL5aso3kfuoRwI4LJAr1xqHR4rMutlIIGB2VdIDIU8nzCjmJmPosDI1xnRs5a35LtbYYcWBThHptXW3hJoxTPscrPam/D53doY23xycI2CI7beY59Y+Z7ON1rwdM/9bY/OFztMV19GxqYRwxdonxrQttr4lnuNvh/MG+4ReO67qyTT2m9G+bv0mUzy2xbbT8qaW2obYclOfO18jcKH3pqu7tfyjPBmk7N8sUVPKvjS1PXy+ZEiAkIeU2BA5OW0IGYVT5hBLIJAzb+a0Z8p3Ql5d5p4zczgsXSBgrVPY5pQzjbnGrLUWyBEIWGuDnN9fyXXrmvcE1ryeOu5yfpt6RwREYGEEJBBYWIeoOiIwgoAEAiPg6dVVErDcMMbcmA4Z0FMNklZ9rHhp1s2NHFe4ND7zkN6XcjZXOYPFcvmYYlyxNjU1bjO1bY4VCFAcQHf4PKT2JR607N94Dzg1B+jAO5YII+WAIaVK1qFA7GGmlU/M7zml3lM/W0sgwN8DXYzf3NOgNgbiN90tTcae3MHz7G8APAQADTIpxpg2u20TCLDd5wfwMgAHe5jSMMC49Px+p6SQQCD2N5VS3phnre9izsHgmPoMvfuYpq9oePEly+BkHeLmGMNj2mjNd7Fhh6x8ctwGW+7hc+IUW/VMMe5YRsYPOO89NFTNkdY+Z5OZNW/HGNH5DWWIKQrUhlKqm1uK4Y508dSH8osNVbREgcBFm/n5EgA4dujB5irun74QfUPtt751/Xes3+QYV8++353lOSW1DWN+3xyfFwPA/SKFABzz/N9ujfiP80JMihUIWF5FahrV23aUCpXA/F7hQjwOMaoxbtpyQkbSlL2EZWxd2losZixazzzQeXUZ8+20ypjy70sXCITCibWcYubRmLHPZ2qNWWstkLMPsOaeOdetm74nqHmWNuXvX2WJgAgkEJBAIAGWHhWBhROQQGDhHaTqFSdgGdRjDmRCXgjeA+C2AP4rsuZWfayD7bECg6FqWrcma20U+3WxNnkpN5BK5hXZtb99zDKEcRN/nDOw3ieQOcUBt3ZxMlPr4HveEoP8CMDPSxXWyYfjngfWvhR7KGAdLsQawio0sUiWNQQCMTfYHwDgJa4FfP4OzhjDQ29fehaAR2fEfd5GgQAZWqFEGEaEAg6GmolNIQNJymFhbHljnrO+i7HfgDF1CL3Lcf9aAHcLPGTFJbZEboyRznmsdKKYh2PBJ+qx1hXd+oQO/ikIYqgbzl+xKRTjPefgluVa83tKe605pZZXnVh+a5+z2U6Lcey3KnTjn+WkhIK4ZuO56RQANKb3U8o4n1MgwFvpFADs04RKu44zTKeIAEJjMNW4XvI3GfvbmEMgwDURBRd7A7iB+x9FRrEigFDbYvajfN8yFqaIqWNZ958rJRCwDGgUpDJcFP9ZOl3aiTeH8k0JXRkyLm+iAY3idp59cPyP+XaW7s8x+S1dIGAJGXkGxW/SaZEQ5hqz1logdx+w1HXr2vcE1ryeci4XOTT1mAiIwNIJSCCw9B5S/UQgnoAEAvGs9OTmELAO8EIGcOuWUc5mJlQfyyNBiRAF/Z4N3ZqMDXtQarSU2qRbm5qaB2iWIew2jeeA3Q2X4zQk0bDCW98lkxVyo2RZKXnF/o6sw4W5jTkpbR56toZA4PaN4eDNAeMhjSQcsz/pVehmAN7iMaC0jx7lQlL03w1x2FaBAJnw+/32QF8wjAr7K5anBAJjf3HnvG8ZXfgk+yb0TbYEfOVqm5ZTisHcCjmU4srduumaG6fYmt9T2mvN17FzU1qPxD+99jmbLbXm7ViBQMgwxXJiPWjxbOvZzhPOUE+kCH+t/UVs22JGBOvN3+eDAdzZmJtj8gs9I4HAOXRoxKYQnJ6TrjsWbOD9WIGAJYxI+f7lNqeUQGAXAMdX5prTxlICgSm8OeS0b8w73Buwz4ZsBLHf4DHl13i31NlDjboxz+s1QjD+ri/oKYAedPZo9mP0AheTQu2tOWattUDuemup69a17wmstXbNs7SYcaxnREAEZiAggcAM0FWkCFQiIIFAJbDKdtEE9myU1Se5+NpDFX01gHt63GX/QXOr84Pu9mf/3dybAVZ9aEA+2kM0FHeSN09vDIAbxZS0pI1xqbpYm5qaB2iWwYHhAnjry5d4U+ZOAHgbvnSyDrNLlxebX+yhQK3Dhdh61n6utECAHigoDtjJU3HLtT0Pw48FwDjYvkRXrDw8jz2Y2maBAPdUTwbwuABP/kYPjwzfIIFAuV+kdcAYc0PL+j6Vq21aTinznSWKTLn1H2L6CwA3bULofDitKf/7dMn5PRT/mmWVNPBmNBVrn7PZZut3kcK4xE3BkmEvrP5JaZtvfHDeuAkAhv65ds4gynhHAgHgwgAe74QBIW9KGXgHX4kVCFhz1eudi/CcEFCxbSklELDEDrH1Kf1cKYFASj6l21AjP36LGHbwEE/mKV5catQvN89SZw+55VvvWeuU1FBIofbWHLPWWiD2LKDPa6nrVqu9Vr/X+nvsnqDkWrtWW5SvCIjAxAQkEJgYuIoTgYoEJBCoCFdZL5YAjVtcDDMu5FAKxTgMKeVzYyNa9eHmmzeE+slaqOe6V1/Sxtg6bKV7YxosrWSxit0cWeUM/d0SCFh58lYl/1fjcM/ia9Wt1t9jDwWszXZsPrXaMTbfkgKBGA8AMcZoHka/EwBvQvgSbxEc2NxqPD0CwBQCgVIHXL7f8pjvB2/BHuMMPkO4UgRCodspJQxTEd0Z/Yj1XZz7txvyzsNGxsz31vcpGlbhB1PHq+WpKDbMQMiYm3JLO3UtlNJea06c+3dk1a/wUInOLuX3av0uUhhfFsCJLrb7UGVjxlVoXKYIYFi+1T8pbRtqD92gv8iJ8KI7p8CD2ywQ4NknRbovw9kigalSrEDA+j2l9l1O+yQQOIfaXMbWnH4b+05IXGV5QBxbds33l3QO0m8nv0evAnBwAIDv3Mj3ylxj1vp2pawr+m1b4rrVam/NMR3KO3aNPOdZ2lxsVK4IiIBBQAIBDRER2BwCEghsTl+qJfEELMV7yBNA6MZ+yPNAqHbWZo83cm/R3FphPPhusm6N3L+JQ/zSeCy/fXJJG+NSh61zbmosQ5jVRT9ublXu38R6pqeB0sniW7q82PxiD9t4HrwAACAASURBVAWszXZsPrH1mvq5EgIBfl/uAOB1gfiqbBeN/jwE581oK+3WeL14d5PnlQMPft/dtrVuBG+7QIAI6UGEhqyh+Nf8+5cazzU3B0CvMKEU+j2MNUxZYyL179Z3cc7frjUns60xAjzr+5TKrNTzsYeBbXmMm3qyC4UzVIeYtQ9d4TKcBueyoXTXJv83Zjaw5PxuzYlz/46s+mUiHP1ayu/V+l2kMn5iI6A81NMCyzOFFaYgNeyF1T+pbes2K0acF9uRbSx37i8+6eYYerK5qieDVCNzyd9kbJus2+epbWC59BTw2MD4iq1b+xz3cRQs0vU61/RXAfAoTyYSCKTSrfd8ish0LmNrvdb7cw6Jqzif36PxkMUzlbWlJZ2D9NmFPFm2z4ZCZQ71xVxj1loLpKwr+u1a4rrVau9cv5PYPcEc8/pcTFSuCIhAJAEJBCJB6TERWAEBCQRW0EmqYhUC1u3AoU2JtTBO3ZB1GxaKK+s7JAq1IfZgKXWjOCbfnI58THNAR1HGUEqpi9V3sZujnDZYhrBnAbiXET+2lkjAOszOaW+Jd2IPBazNdmw+JepcI4+xAoHzAeAB3hGBOPesd6wButvGyziDXygGL3+jFB28KwBHAoGzY7c+sokneliAU4yAoyTLGuO5m6f1XZzzt1vqANb6PtVm7Ms/Z74bG84oxCL1lna/XSXnd2tOHGPgLdHfVv1KlJGTR8rv1fpdpDK+JoBTAmuoFwKgq+shL0x3aYzib/A0mCI3hr34bAIQq39S29YWffkmZNgJhiivX81fOk8nHwPA/33Z/X+266zew9ZvKNW4buWX8w2yuqG0QCBmXh6q0/caUfeHAHyxEUl+vBFofgbAGY0nON6o7o/B0DwYu8exfk+pfWdxHvq7PAicQ2UuY2tOv415JySu4jiP9Sw0pg613l2yQMA6v/qOCy9JT26xaa4xa327UtYVQ21d2rrVam9sf5V+LnY+nmNeL91W5ScCIlCYgAQChYEqOxGYkYAEAjPCV9GzEgi5YmbFeDv29r1DtNCN/bGu9HK8ATzPHXoOgfR5HYiBvqSNcam6zLmpsQxh3Ozv6GLD7xDooBS37TH9zGesw+xnADgtNrOCz/FAfox7+rYqYw8XCjYpK6sxAoGdAbzAcEPJStFYcEATEoDfjNREd8dvDrjHZ368qUgBDNsyZKApadT25ZVy+yvEoEaIgbY8HrbyVvp+gQpYISBKskwdC6nPW9/FOX+7FPsdGWhQ7AGsdRhIoybn8akTf/OMUZtys++GzosA56qhdBsARwcaErrlneoOt19MyfndmhNzDbyl+tiq39LnbHKwfhepjK14w99yc9RXe51gebUICQt8/Wn1T2rbWE7M3NDW573OFT7DLvwgYdBZv6FUI7OVX6xBIqEJKC0Q4B6Q65vQupz1oyDgH5uwS2REUQCFGbFJAoFzk7L68AsAnjIgcInlnfvcf7j5L8bD1lzG1ty25b53S3dWMmQboIcMegv6SW7mM79X6uyhdDPo0YTe4O4YyDjGu1X/9bnGrLUWGLsPWNq61Wrv0vcEc8zrpX9Dyk8ERKAwAQkECgNVdiIwIwEJBGaEr6JnJXABZ4yhwn0oDRkAQrf8xx52WYvu/oZvFwDHN27Bfbd3xxy4v8IZ9Ia40MDHcAc8hJwihTatKaIMi+/Y/guxsAxhPDDm7WDrBjHLyLnpHarbwwHQg4Ev5RxmTzEu2jKszfbYw4Up2zJUVq5A4I8BvCngErwtq4RnihiRAMuj4YRj7de9hpY0aq9ZIEAsVqgBq79Ksqw99q3v4ly/3V0BHNt4vbheAECs69xruZvNF/LklWp0q90nofytOTTEJHTT0HIBH9Nmq24p87tl4B3jKSqmLdYza5+z2T5r3s5Zd9zErUt9AhZ6EKBgrptCxoPccWmNn5y2MVzYi42BwfAdDwbwTWsAef5u/YZSv1VWfim/ydgmWcbllDZcEgBFFtcIFP5TAOwbigj665rYOksgcG5SdAtO7wsU8Q+lGuMmtq9in5vL2BpbvxLPWaKsoe9tiXKnymOpAgFrniOfnHBNc41Zay0wdh9gzUNTr1vXvieweK7h+zzVN0TliMDWEJBAYGu6Wg3dAgJLEQjk3nihkZTv9uP28hCdMf36MdtTujTnhlVK/np2fgLWQR7FAzQUMHEzzI0Eb5QMpae5OJVjWpXiCs3yOGDd5gvV0+Iy1QG5tRFJuRVs5VVzU2MZwtoD41h3prxdf+uIeOQxY9Gq2yOce/qYvOZ4pvbhwhxt6paZKhDg7ZKHurAc/PdQ4jzJWyglxD4XA3AUgH2MMhnPmd+57g27kkbttQsE+A3ggRjnk6H0FmeQoDhqKJVkWXvsW9+esQeDufW3jHEprnMtg9X7AHCu5u3ENaRQvGHfLW22a08AJ7l1VL+d72lioN+2ERDF3Mz0MSo5v9/OiUd9ZTEeue/3OUUfWr+bpc/ZZGTN2zlGdMsbwNCN1pAXrtxxaa2fU9sWY6hmKC7uhXON1OwT6zeUYlyPya/Gmtv63qa0wZoHKNblHpFhG8akEgIBy+hUg3W/zaHfUmyohJhxQ09qNwJw5hjold+dy9hauVnnyj4U1iW0FpiyjmPKWqJAgHMcxUgHBhqWG65prjFrrQVK7AOWtG615qil7wmsdcIUc82Y37XeFQERqEBAAoEKUJWlCMxEYCkCgZmaHyxWi5wl9krZOlkbk67RPxSTuNSt+ps5rwBD82y/jJA3g1j3xz6a1gF5CTFETE9aN0lSNlJzbmqsA/3ugTGNunRrex8DEN3QMbY7+3pMChlumO8YTxRj6hX7rvUbLnG4EFuXGs+lCASuDuDVxs3nto4UB1BkwptapVKsSIBeBB7dEQmUNGqvXSDAvuBt62N6YRt4wM5vAr1ChIxAvm9NygF9qfFg5WN9F+f47V6h4c55xXd7kW1KMRxann4+1xjO93ZhPixeS/i7FZrJd3MtZDzKue3WZ1Fyfg+tw1hujvvekn239jmbLKx5O9WI3vK9C4A3eGD3hT1cX54c8LKTOy5LCwRCbrzZVIrGuB9IcWs/hOjijcCP+16uI4ZSinGd75f8Tcb+fizjS2wbLLEJvUvwO8F1+Nh0PwAv8WQSO29b7a5tVLcE9LHtIAYrrxTPcWP7Jvf9uYytufXNeS8UMignNEtOHWq+s0SBwJ3d/BayxeR6bphrzFprgRL7gCWtW9e+J5hjXq/5O1feIiACBQhIIFAAorIQgYUQkEDA3xESCCxkkFashrVQ746B0KHx1wHcuDHgUDU/JoVECMy3e3MtFAbg3c7TwVmZlaFrZbadh2RDaarfhlWPFOP1nJsayxDWPwyPjTdLQxY9WoyJ8WhtnMeOpcwhGP3aFIcL0ZWp8GCMQODC7lY+b0nEpG8A4Jj7RMzDic/EigR4IE53yDRqSCBwXshdN6IfbuIa3w3A1yL6wvet4dy0xwj30xFFJz9ifRdLHAymVComtutvANBgd0Jkxptg7Og21XIrPOSuNWR4LLV2Kjm/W96Z5hZ1rH3O5niy5u1cgYBl9O+Oz5CY4DQABwD4QeTvvPtYaYFASFzzK+e15wMZ9ey/YhmZY43rbb4lf5OxzSvVBusbUFIkFBovsYZ1hrDhWp3ioaEUm08s5/5zlrgktfyQN71Sgvzctsa8N5exNaZuJZ4JfWdzQ7OUqFfJPJYmENgNwPsB8BvnS/QuuC+A72aAmGvMWmuBEvuAJa1b174nmGNezxjOekUERGBKAhIITElbZYlAXQISCPj5TmUErdvDyt0iEDp8695UCB1YlDossjYOrbGWhvvjm7j11/U0buyGyrq5P9UNjtDNGjY9JdTBnJsayxA2dBgea2g9DgAPunNFApZIZqw3Cuv3N/bvUxwujK3jmPdDAoF7Oy8SL2rCQFAkEJP+1bnzzo1THFNG7Nh9OYBDAPyxO/jaqZd56qEyX98EDwJsB/daT3cGqmcn3A71fWtSwrHE9HGJZ6zv4th5LKWOseFdcm7rhtYOqfNYSptqPRu60TzkWjj0fKmbhiXnd2tOnNtAZdVv6XN26DvdjtlcgQDfDxlc2/FJkdyRbu009DvJvYVplc+/p7RtZwDvaG6q7+f5MZcUq1iC3G0SCFAcwv2WLzH8wEsLfGA577zWCQCHsotdA1n5MO9SdR6qp7UOj21Hm3fIQx6fmcqLXW4Xz2Vsza1v6nshcVWKh6XUcqd8fkkCgdhLA/dw35McTnONWevbUWofsKR165r3BCXX2jnjVO+IgAgskIAEAgvsFFVJBDIJ+AQCvNUXcl1NAwAPLropZgNo3azIbEaV1yQQqIJ1cZnysI4HcL7EG9o0xr/TuQIeeq7kwUvIKN4e/PKAmEryvkGNdStxo8gSKrCcMQeoMYPAcvGZKlKYc1NjGcJ8B8aXdzdVr2wAe6Xrj9wYziFvFCw619VuTD+PfWaqw4Wx9cx933do83p3S+ShCRkz/AC9DEwR7/zSLlYmb8IPJd7EZogMiqvkQSChE41HJRBIZxkrDjgDwF4ZMactY9PQrfv0Vkz3hnVLuyvcI1t6+qEQqJ9K3jQsPb+HhKNsRylhQ26vrXnOZputeTvFiN5n+IfO9Ts9cg0ljs+PNy7ieeuee9l+Ghs/29rnprTNupldSpxMBpYgd5sEAiEWJfZY7Ziz+jfmXKXNyxp3NQ23IXfzrF9KO/j8tdxvmJ4RhtJHAew/Qhid+92NfW8uY2ts/cY8Z+3Nl7xfTGn3UgQCseKAHPFql8dcY9ZaC5QSCCxp3brmPUHptXbKb1LPioAILJSABAIL7RhVSwQyCFju+FKyjNkAWhvYlPJqPyuBQG3Cy8jfOkzkTQUaYD/YxImk0aufYsZ9SktDm6X25ho3Orx1MpRK3SgK3RBguWNc2cXwuKGLD7uj5+FU1/dzbmpyBQJs+vVdzOuLGtDa29g5cWit2zoUx9CYmytAiOnv3GemOlzIrd/Y90IeBOiinwYC3+3CtmyOCXob4I1JfkOmSpdpDnrfPuDphOKAhzgjG+sjgUC5Hnk4gGcNZCcPAsOMGVaAoXsONbqA45QH32/K6CrLJfz3m7nupm5Ozch+lldiPSqFwiaVNFiVnt8t4ejcfbbmOZsD1pq3U4zo/R9ASJTCZzlncj1/hOeXM1b8Ye1zU9pm7dFTjfa+j4Vl9ON7qWWV/k3GfOhK8Srh9j+mvqFbrXw/ZX8ZCoPHvEoKsrptswxvqe3g85aXlNRQPzF9UfKZuYytJdvgyyu0N/+8W8ucOUVFKpexBIGAJbRuEXzF7QNjwpD5sM01Zq21QCmBANu9lHXrmvcEc8zrlX/qyl4ERGAsAQkExhLU+yKwHALWZjqlpjEbWd+mO+XApFsnX/2XeBiewlLPTkfAui3Pw0QejPm8DNBl9y0ag9ePClXZOhiht4JruBvjQ0XylvA9CxgCLeEEy/4bjzFqLAr2CWOU3yuQUeothTk3NWMEAkRwIwDvAmCJBGgYfHSCO/IWr9XXPFjk4eMpYzu2wvtTHi5UqL6ZZUggcBAAy8tESvx6szIZDwzVj+uAwzvfKAkEMsB6XvGtsXiAyO/Ikg5ure9iyYPBIVy8Pcx55o4R+McIsKz4pyz+KQCeUGDejmhKkUdCRoKui/uQob2k56XS83uM0YvCUbaBN4qnTmues8nKmrdz94RtP4TGJ/eq9KJziYFOK2FEXaNAwBLkEpUEAmcPmJizjpjvQcy8kFLWXN8sa7znMrO8Eoy9MR3TR7nPzGVsza1v7HuW+OpJTUbst01IcwsEGPLlDY2w+0oGzK43tjHc5xqz1lqg5D5gKevWmG//UvcEpdfaY8as3hUBEVgIAQkEFtIRqoYIFCAggUABiMpi9QRC7iTpSYKuSHnLcCjViIUYcm/7jwAuF7g13HXvO6ZjONcz9jVv+vrSj52bx1PHFDTw7s0BHAdgB0++Od4L5tzUWIawmMNwhrp4c4BJi6pvfI3pmpjNKsUBbMdPYjKc8JkpDxcmbNZvi7IEAnzwBo3r8xN7IUfoNeBxzr333J4fdnPxfBkq4zFNPZ8B4NcdmBIIlBtZvsP6JXpEsr6LJQ8Gu4Q5t1HwxDAddPFsJc5F9Kgz5ttneeShIWhfAHSdvIZk3TjmOoR8XwXg4IEGjXXj3s+yxvxuGahKHczn9Pea52y215q3Y9ZEIW70DPK6SPFPN58S4T4sg2lK26w9OvcmtwLws5xB5N7hb5lrywONPCQQOAcQ1+NvG8Gcr1r7HD6TIhCwjLfMj9+s2wI4emTd29f/xK09LfFySjvavC3RyhivPoWa781mLmNr7XaFhGk8D2BIsc/UrsRE+c8lEOD3+JEAKLaISbyoQW84Y73DzTVmrbVAyX3Aktata90T1Fhrx4xzPSMCIrBgAhIILLhzVDURSCRgHT6kZBezAZQHgRSienYqAqENCr1RfBXA3gOVaV3+v7dwRUO37ngjmDefaHTrpx8C2BPA6YXqQ08FJxtGlC+5g66vFyrTuhHNYu4RCLHgq8acmxrLEBZzYBwbJ5vtzxEJxBxWjrlFaw2PqzQGJf6P4QxS0pSHCyn1KvVsjECgPzbe54xy3yxViQL5XNcdTNPo1g+DIYFAAcAuCwow6EaznyQQAM7nxDTPaTyy8HZWTOJvicagMeIAlnNJZ0jhnOpLpefSbjk7u98fQ37w9nSJ9EAnQBrKi56MeHBNcQV/+/001o17P78a8zvXWO8HwH2SL9USScb0z1rnbLbNmrdj1kQWI8t9e/99rudpbOeYHZNKCgQsj2JjjXIp68ptEghYITzGfr9i9jkcgzHnKt2xahnV+WypeYYeeI4CsE/EjyW1HcwyRrhS8/tLkRG9CzEUzg8i2th9ZC5ja2I1kx8PzfklxFXJFar4wtQCAa7RaDSmsf/Cke3K2ev7sp5rzFprgZICAbZ9KevWte4Jaqy1I4e7HhMBEVgqAQkEltozqpcIpBPwCQR4gE83ob7EjSEXs90UswGUQCC9j/RGfQKhQzi6HP2px0hOo/iNAfA2XMkUik/G3yZvjw3NxaWNQCzjye4mcqh9DLPAg5Qx8e+Yvy9mebfsEwDcrjE+/DwR+JybmhICATY3Nl42bwkxPAM3/LG3CmIO41gH3mqgAbJv5E3sjt8+znIf5FxsP745FDwsMaOpDxcSqzf68RiBQDs2nu5uIDMsSveG/uhKVM5AAoFygH3jpfTcUKLG1nex1MEgXS/zRvsDIty1dttVwnNANz+6o3+xAY6eWu5krL9T2HMOpwHnZQAoGOIt4dS501de6Dbh5xxvChK4X+imEm7c+3WqNb9bxl7Wg0Yqrn9KCEU5H/6VC+fzaaOj1zpns1nWvF1CIHARZ9yjh52YRO8d+xcQA1ljJqVtVgg0totinPtmrsliPVOxnG0SCFBofZLbaw2NnTEeXzguuUbbL2JQxpyrdLOJ/SaMnWdSxAGsX2o72jbFiKAYPonzWilhPMu+uvtdce2wB4AzIvqq+8hcxtbEaiY9HppjS4mrkipU+eEpBAIUrXKsHQLgL50oJrZZpTwHtOXNNWattUCpfUDbziWtW9e4J6i11o4d93pOBERggQQkEFhgp6hKIpBJwCcQsA4Chg5AYjaAEghkdpReq06ARk/evkxJPOSh4rt0DNoLuAMk3mZKSTXCHeza3Lo8NuLG5fcB3M0dkscapdu2tUYMHnReNtDgMbdF5tzUWIawlANjigR4e+k+xsDIcX885Kp+qBi6J2VYjpCIzBq3PBjhod6zOka7nIOAqQ8XrHaV/nusQKB0uVPmJ4FAOdq+8cKb8LcpeHu8RI2t72Lq94DfFM5XvJnDb9kBAHiLuC9mjan7SxtD4cMabywlw3PQMHSMc8MbqsM3nJccijrGpKu6cB6cX5hKi0RCbu7p8vxwJzDst6F0PZh/rfk9ts843zIM1XMzx0xXyMF92V5NSJ+PRXT+GudsNsuat1PWRCFModuC/fcoVHxBBHPrkZICAZZl5dc+w99b7Nqb30qy4W1VXyivfjutc4H+87V+kyH+llfE2Db8QeMZ7YMAeNPfl3Ju4l8BwFs8XlWGyok5V+m/RzfvFCvtaAzUzzdG9Ts3gutPWQO69/c/BvAmALv3/jvHnu+MOKcdzJ77HYrbhsLUdItn/hRFs16xv4GhZnP8PKHZ29Bwx0QPghIInM0i5J2ilLgqcShWfby0QIDnOryMwnXZ9Z1nKnpXiv3+to2lOJ8eTui9Y8xY78PbFoHAktatsevLJe0J5pjXq/7QlbkIiMB4AhIIjGeoHERgKQQkEFhKT6gecxNgTOLjAwccQ/XjIQINCTVSzKFgt9xa4Q5YBjezdLNoxZnksx9p4qE+wt1ktm4xcz1xNQD/AKA1YoRY5oQWaPObc1NjGcJSD8NjbyDxIIEClthYqSnuZpn3U5xYIcX9JgUg7MeHulAZ3f5ONQjyXcvQkJNnjd9zbp4SCMQZylq+vvGQe9Db7zffb7mG0TN1zIRum8YaRlLLHPO89V0ck3fuu/yu8WYWRVjW/JVTRspcSiHWo93NyNiDYIohKCxkDNt+GIUaYzTkxp0Gbv4e+6mUIbabb835PaXPvuf6jIf3MWEpaDTgrXWGXrm2a1CKMW2Nc3bMvJ26JvL9FrneONETkqv7zpebcBL7NkZGHsSPTdbaPbVt13QeJaz1N7/x/G3R45kvcbz8UeOt6xUD3wcaivn9uJLn5dQ5pOZv0te+UgIBcnq+u9kbGg+xwmhyZd/QIxuN3m2isIgC7Ft7Ckn5FrRZsO7PBvCQiIHM+Y6iJnqfstbx/C1RRN8az7vZf7bxpkfvblzXD6WcdrT5xIZj4POnuTrQYB07f7M/6GWHgkDOZ92Uu26cy9ga0eVZj1i/h7Xvs4aghPowC2KBl/4NwF3dOC+Q3bmymGvMzrGHX8q6lR2Qsr5cwp5gjnm99FhXfiIgAoUJSCBQGKiyE4EZCUggMCN8Fb0oAjE3RroVHnPgEdNwa9PUz6NWuIO2nBRXpHyHB0/vBvChxnUeXUB2E2943gIARRmxtzvHxtqbc1NjGcJSD4zJMiYcA59LdX8cKz7o9ucXnMcLHs7xoLB1Yd26T2Qs571dn4cOuXMOmazfSU6eMb/PqZ6RQEACgdixFvrGpRp3Yssc85z1XRyTd867n3A3s+gev1ZKMei2deA3/B3OAMNbq10jJo02V27EjTdyLqt5O82XaggE6IL55IHbpL46MBwTb7h+tTDg2vN76vqHzeO8SM8dXAP9d6e9FPLwUJhroGsMcEhdW65tzmaTrXk7Z03kG1IUXxxqjDeGTuJzJVJpgUDoxmO/vjQ4U5zC0B4U6LRrMX4X6K6dN8aHBAD8xtyhMaoyzBPXakMpdQ6p/ZscqmMpgQDzDt2Y7pdNw92r3G+dv3smtp/fZY7lP/fcFH65E1+zz4ZS6regzSPnm8BQcdyzdUObtN8qis58cwvHHA1u13FCg5LtaPNK/f5y/0ljGsUX7Ju2T5gfvQxRdMP6UhjAW9y+JIHA2WRCbtn57eCc/pkSH88F5bE0gQDDU3E/GxKAjcG3TQKBpaxb2V9r2xPMMa+PGdd6VwREYAICEghMAFlFiMBEBCQQmAi0ilk8gZhYn91G8DCFB7w/qtQyuqKjR4PQ4UW36FrhDtoyOPczNvLrM1zijUVEN/S8STkm7v2cmxrLEJZ7GB57syY1NMOlm7iIb45whT22X/vv5xjzLUNDTp6l2zUmPwkEJBCIHT8Xcgf8jJ/cT6nGndgyxzxnfRfH5J3yLsMI0IBI9+IlQwr46sAbi3RHbxktU9oQ82wNgQDLjTHAtvWjZwbepI31iBDTLj4zxfyeaqSKrXv/uRyj4JrmbLbXmrdz10RDzK0b+KUNXKUFAmwThSQU4lw8d1AZ79FrCr2hvVMCgd+SSrmJn9MtdPFP0cafOGP2UB4534I2HwpzafCngKxmasXbj6ooEGBfHNSEoHvlxPtPCQTOHjmhUC1vdF7hSodarDlmY/JeikCA34lDmu/ySRXWTV0O2yQQWMq6teW/pj3BFGvtmN+nnhEBEVgQAQkEFtQZqooIjCQggcBIgHp9owgwrvpLIltE95MPjnw297HnucP0mPdrhjvolk9XmDQe7xRTqZHP8GbKw53hJtZdpK/IOTc1liFszGF4rHs6ukJlTG4KW2LSHAaHHGO+ZWjIyTOGz1TPSCBQRiBAIxAPsMcKuui2nfn0Uy3ja8o4o1cRhnihN5x+okH6aSmZTfCs9V2sXYXWvfLfV7yV5WvDHAeCtcZo7E3bmmGQpprfp1j/5BoF1zJn8zdhzdtj1kT935x1A7+0gauGQIBtqiVQofeEpzahvv6vBALn+Vzn3MSPmbfoVe1AFz4mNA/mfgvaOjBsCW/S09NMjdT17BYa92PbwbrPIRKQQADgb4AhBm8wMIA4p9O7xHE1BtfMec4tEODYY6goXv4Ye/4Rg3LbBAJLWLd2+2Ute4Kp1toxY1bPiIAILISABAIL6QhVQwQKEJBAoABEZbExBK7WuL3/AICLRbToNoFbHxGvRz3CQ1K6FrbSDwHw1ujp1oOF/n4F50mAG6xaqXSsvTk3NZYhbOxheKzRgu6peZjDeLsxieEfngHgr2MeHvkMb+/SiJnqPtEyNEggMLJjJnjd14c5h8rWeKjVnFrG15T6cg7gLSMaxPppib8D67uY0vaUZzm3PKW5lfuW5gD2P1JeLPws99N0+c1bkbUFdwz/cnDjBahG+IQLOpfm+xt8GBeaz/ykMEdmN+X8Xnv9k/Pda5GuYc5mXa3v9Ng1UX+I0QX2exuR1I69P9QwcNUSCPB7wZukjBm/Q6HfUCsOoFjK+g2leqGx8qsxZ5YMMdAijg3nFdslXXEA36kpEGD+/F5xrov1RhfTDo6XezfhKo7s3GquLRBo68UQt8K2EQAAIABJREFUGCy3luihLYfrhPtm3tyey9ga03epz4Titdec01PrWfr5uQQCFFtQtEq2UwgDWm5zjVlrLVBr77KEdWt/zK5hTzDHvF76t638REAEChOQQKAwUGUnAjMSYCxwqlPpqrqbGA+PN3dLJ98GMvcwyHcYkKv6Lt1e5bcuAtbCt23Nd5p4wDcGwIOemumKjQvKDzZeDXgzLJRqHLRZ7WJ8eYYc4GHlJayHE/5ey92z1bc1GVqGsNzvXxdr7O0yigTo1vTrkX3CNR/jdNI19O6R76Q8xli5DB/RjRGa8v5chwspdRzzrDwIlPEgMKYPYt6t+f2IKZ/PhFy9371xNfy62Iwmes76LpasxmcB0MD1BgDfKJlxgbxogDoCwB0L5NXPgu5pecBK1+E1D5tDLojbOjG0AIVgNdLU83u7/qHHqQsXbBAFchTk0UtTbkilpc/ZxGXN2yXWRN1u8RkDeDP2toVDi9QSCLA97NubOYHumHADHGd/AeBdHQOv9RvaVoEAufM3Tq9xfznyt05DPb29UdTdptoCAZbD8f9kAAwlMTb5xGZTCQTa/qDIj4KZUmKZlsv33JzJtUJuyKG5jK1j+7b/vuV9peacXrotqflNJRDgPH+iE4oyJMhcotW5xqy1FqglEOB4mHvd6huTS94TWOuEJeyFU3/rel4ERGAkAQkERgLU6yKwxQQkENjizl9J0+lq8zFGXbmJo0H2rMptuoAT8PDWdyjRdTRvX8+R6BaNNwzIbI8RFaCB+OkVb3XOuamxDGElDsO5NqM7wsMi+oBhBngo/s2IZ9tHaBDhzR3+Psb0M/NjX7+8udn06iaExg8S6jD06JyHCyOrHvX6NggEaPA43hk/ulBybtJa4yEKesZDcx+KMN7w+5s40hRN9lNN1+4ZqH77ivVdTM2b4SN+DuCL7qb8h5rbmR9rbs5/bYSxNbUOY57/QzePMtYy59XcxHAab2o8ITFEEb0Ksf9rJ9b9FE94C5b9LQC8xf3VShWZa35nP9GbFNdfdOedmxgahOs43h7MFQb0y17qnM16Wt/pEmuiPo+7OIFQ97/ftRE+MsRAyVRTINDWkwZrhjjjupvG39hEgycN3VzH9b01Wb+hbRYIkC/X2Azp9ZyMNTCN6jTO8xvZ/x5PIRBoxwcNT/QaQW8yqYZ1toHv8hs1JDYLjftaovpdXcgn3vS/aOyPYOA5fnPf5ubMEje35zK2jkAw+Oo13ZgdYlt7Ti/dltT8SgsEznCCE+6/Kdzk5Y9PNCIXClKmWKNZ7Z9rzFprgZoCgbnXrVafLHFPYK0T5t4LW0z1dxEQgQoEJBCoAFVZisCWELAOTpaIoebidIntVZ1EIJcABQ10c32LRhG/F4DLeQxW3BB/26nmT2iepyGnhtvh3HbovTCBtp8pXNkXwO97vEjwJgRvSn28ESR80rnq5OEIjXhKcQS2QSDgu/kugUDcGGGMWI4TGiqHUq3D+bja6alUAjTsXsW5nuZcSs8tFH70DTq/AcBDZwq9TnUH+Tx05n9bwoFzarvX/jx/h1z3UDBJD1Nc/+wy0Cj2D72c8fY6Q4JQHDCF2JRrM83Zax9l564/BSo0sFDowPAdNAAzzESbaPikpzOONYYro4G6lABls0imteZSAA503K8+sM/hHudTTvBMQfnSvNa0a3iKE4bGDWnwO8V55RjngeZMA9FcBkZWi2fT9ITJthzQhP+7jvO8NyS0Y7u+61y4c+/JsIIUEdb0sJM2upbzdMgrFb3K0YOA1hrL6S/VZDMJaE+wmf2qVonAxhCQQGBjulINEYHJCUggMDlyFSgCIiACIrBSApsuEOCNPBovhm4o5Ri2rdsotYZByq0J3vhkPXko/f2RxkHeMKE3jv0CDZvK400ttspXBERABERABERgmQQsb3c0wlOc9LNlVl+1GiBAEczJntByv2j+dtNGkPFhkRMBERABERABEdhuAhIIbHf/q/UiMIaABAJj6OldERABERCBbSKwdIHAPs3NrX90rjJ5K+tXzq176xGErjSHwkjQTeHdATw64E6d3iZ4g5qu42OTTyDAA82jCsT3vELjGvTmA5VJEQgMuWjkjUMenrPNZMdbbp/ulcNbx0y8mXxJAH/V3Oy7bgSYGm60I4rVIyIgAiIgAiIgAhtO4OIAuAaiN4Wh9NbGrTpDfHB9qLQOAkMhWdqaU9TLMHUMWaIkAiIgAiIgAiKwxQQkENjizlfTRWAkAQkERgLU6yIgAiIgAltDYOkCgas5F60Xq9AjjJXMOMspyScQoHF9D2d4T8mv/6wvXnCKQIB5Mj483bPWTowbTJe7QyKN2mUrfxEQAREQAREQgc0mcC0XvuJCnmY+rQlt8djNRrBRraOXq7e7kA1DDZPodKO6W40RAREQAREQgXwCEgjks9ObIrDtBCQQ2PYRoPaLgAiIgAjEEli6QIAxto+PvMke22Y+l+vCdC0Cgb8A8NoUIBnPMkY9b3kdnfGuXhEBERABERABERABi4C1nrk9gLdZmejviyFwQxdeYMeBGtErGMMLnLmY2qoiIiACIiACIiACsxGQQGA29CpYBFZPwCcQOAjACQttHd3+/nyhdVO1REAEREAENpfA0gUC3BPQ0H23wl3wagD3bW6d/TIx37UIBPYEcBKA30lsX8rjXG8dDuB/Ul7SsyIgAiIgAiIgAiIQQeACABhC4FaeZ38IgOud0yPy0iPzE+Cant67DvFU5UnNf3/i/NVUDURABERABERABJZAQAKBJfSC6iAC6yTgEwj8GYBj1tkk1VoEREAEREAEqhBYukCAjX4MgKcWbP1nAdwawNcz8lyLQOCKAD4I4NIZbbReoajioQBeLHGAhUp/FwEREAEREAERyCTgW3O12aWGX8qshl4rROAPXbiIPxjI78cAbgLgM4XKUjYiIAIiIAIiIAIrJyCBwMo7UNUXgRkJSCAwI3wVLQIiIAIisCoCaxAI3M7dICsB9i0A7g+At85y0loEAhcHwIPzq+c0MvAO48Y+GsAXCuer7ERABERABERABESgJXB+AC8DcHAAyd8BOEzIVkMgFC7ijQDuAeBXq2mNKioCIiACIiACIlCVgAQCVfEqcxHYaAISCGx096pxIiACIiACBQmsQSBwMwDHA8jdH3zbeRB6nnNDO8Ylfm2BwLUB/PVA/37JuWU9K7Lv6Zb3QQCuDIDeBK7SeY9hB34vMp/vAfiQ4/fPTZ4/iHxPj4mACIiACIiACIhALoHbNyLHNwPYwZOBbpznkp3nvQsCoMh0/4HiuS5nGInj5qmaShUBERABERABEVgigdwDwCW2RXUSARGYloAEAtPyVmkiIAIiIALrJXBE487zDgPVPwrAw1fWLBrFd+nU+UcAYg3qsU3ljbaLDRxY/9oZz/lPJREQAREQAREQAREQgTwC1wfwHgAXDbyuG+d5bOd664YATgaw40AFPgdgbwDfn6tyKlcEREAEREAERGB5BCQQWF6fqEYisBYCvwvgQgOVrWEoWAsT1VMEREAEREAEREAEREAEREAEREAEREAEcgj8CYCHAXhqxVBD9KR0NIDLBir4nwD2AvCxnEboHREQAREQAREQAREQgeUTkEBg+X2kGoqACIiACIiACIiACIiACIiACIiACIiACIiACGw2gW6YpRMAPL5xDX8qgDGhm1pi5wNwEICXNAIEemsKpec6oUKJcje7x9Q6ERABERABERABEVgpAQkEVtpxqrYIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiMDGEOgKBNpGfbsJ70SD/T8BODOjpRQD3BrAPwDYPeL90wAc4MI6RTyuR0RABERABERABERABNZIQAKBNfaa6iwCIiACIiACIiACIiACIiACIiACIiACIiACIrBJBIYEAt32fRfAsQCOc+7/fwiA/2tv+tNLwK4ALulCBNzBxZ7fIRLSjwHs77wWRL6ix0RABERABERABERABNZIQAKBNfaa6iwCIiACIiACIiACIiACIiACIiACIiACIiACIrBJBCyBQM22UhxATwMfqlmI8hYBERABERABERABEVgGAQkEltEPqoUIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiMD2EphLIPANALdvBAIML6AkAiIgAiIgAiIgAiKwBQQkENiCTlYTRUAEREAEREAEREAEREAEREAEREAEREAEREAEFk1gDoHA2wH8NYDvLJqMKicCIiACIiACIiACIlCUgAQCRXEqMxEQAREQAREQAREQAREQAREQAREQAREQAREQARFIJnAJAE8HcM/kN9Nf+DyAQwCcBOB/0l/XGyIgAiIgAiIgAiIgAmsmIIHAmntPdRcBERABERABERABERABERABERABERABERABEdgkArsCOBjAAwBcqXDDjgPw9wA+CuDXhfNWdiIgAiIgAiIgAiIgAishIIHASjpK1RQBERABERABERABERABERABERABERABERABEdgqAhQL7AvgzwHsCeByCa3/DYCvAHg3gGMAfADAWQnv61EREAEREAEREAEREIENJSCBwIZ2rJolAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiKwcQQuCuCCACge2L3Tul8B+CyAnwP4mfvnxjVeDRIBERABERABERABERhPQAKB8QyVgwiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAgsnoAEAovvIlVQBERABERABERABERABERABERABERABERABERABERABERABERABERABERABMYTkEBgPEPlIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAKLJyCBwOK7SBUUAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQgfEEJBAYz1A5iIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiMDiCUggsPguUgVFQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREQAREYDwBCQTGM1QOIiACIiACIiACIiACIiACIiACIiACIiACIiACIiACIiACIiACIiACIiACIrB4AhIILL6LVEEREAEREAEREAEREAEREAEREAEREIECBC4MYGcAZxTIS1mIgAiIgAiIgAiIgAiIgAiIgAiIwCoJSCCwym5TpUVABERABERABERABADQ0HMogFMA/LOIiIAIVCFwQQA3AvAZAGdWKcGf6e8C2AvAJ5xB938mLl/FbQ4BjuMHAngSgK8DuDmAb25O89QSERABERABERABERABERABERABEYgnIIFAPCs9KQIiIAIiIAIiIAIisAwCXUMP//3HAPYHcOoyqjdZLf4WwNMHSnsNgIMmq4UK2nQCewI4CcDvAPg2gNcCeAuATwL4ZeXG/ymA9wPYyZXFf38DgGMlGIgmT5HFO5s+3Lv3xr8D2GMLbtKfD8CBAJ4F4EodBi8HcMgEYzi6o/SgCIjA4gnsB+DOgVp+DcBzAPzn4ltydgU5rzP9aiX1VTVFQAREQAREQAREQAQKEpBAoCBMZSUCIiACIiACIiACIlCVwPkB3AnAi5z3gG5hX3I3QnkzdFuSBALb0tPztvOpAB4zUIXfAPi7xl374RWr5xvjLPJpjXH3sRXL3pSst1kgcEUAbwRwPc/45Xzy1k3paLVDBESgKoFrADgZwMU9pXBOvCWAE6rWolzmF3OCO4qobg/gJ+WyVk4iIAIiIAIiIAIiIAJrICCBwBp6SXUUAREQAREQAREQARHYEcA/AbhLAMX7tuyQUwIB/S5qE9ilCS9wfHMD/boDBf2iMZbctPHe8eFKlaB3kLc77yD9ImqXbTWJdXsigO82YqUjmlAnuaEPuB/fAcCvrQJH/H2bBQKXbEJUnNh4vKBhbyhto7BsxFDSqyKwtQQu4sRE9CDgS5wLbw3gRyugtJsLzdV+G49z6+tNFAlQXEwxBP95dffv1wGwa7PGuFYjjHiYC1W2gm5TFUVABERABERABESgLAEJBMryVG4iIAIiIAIiIALrIcDDopu4A6P11LpeTekq/BQAP6xXxOicL+9uZl05kNM2uY2WQOCcgbAzgFc2xuwbjR5l682AN+pfUrj63fAC/azf04QZuC2A/ypcZpvd1QB8wB3m94v4qBMOzGHMuAKA1wO4oasUf4f0opAqEuBe/JEAbgfgno13lM9V4rjNAgEi/TMnNKEQYyi9ugmdcV+FGqg0+pStCKyfAA3LLwRwn4imPNcZnFPng4isiz3CuevoAU8IRwG49wo8CXBOuxAAej6gwf/CACjgYEii/+v+yT0en6PI0Ur0hHSY9ZD+LgIiIAIiIAIiIAKbSEACgU3sVbVJBERABERABEQghkA3tnXM85v+DOOl7gXgYwtv6M2buNm86eQz9rD6uQa7hTf9PNWTQOAcJD4j6Nr6dEx9axxyPw/AgzyVuqtz3z6mzqF37xcQPDypeZE3+KdM3Dsz9jSFKDv1Cs755tzA3W5v8zrUCQ1KCy62XSDAGNvPB3B/z2ChW3CFGpjyl7SOsmh85A1jCoIu52K189bxRV31z2g8Fn3a/fv3AXwBwM8A/HwdzVMtIwm0Qq5YA/LSvyf0cPDmgTmsxcH5jXN+6Xmozb/9XfGfTJyf6MWA32mmPwLwe+7fGSLmKu7fafCnELRGerfzPnZWjcyVpwiIgAiIgAiIgAgsmYAEAkvuHdVNBERABERABESgJgEJBM5Ndy0CgZjD2qUf0JYa1xIInENSAgGgtEDgUi7e8u4DA/bzLrzAmaUGcy+fCzh3zrcayH+ubxVvKh7rjIX9avGbczdneIm5OerzhvJvAO4F4F8Kct12gQBR0sjLEDQ0OA2lbQ81cIDzBlJw2FXJikbLZwP4WoXc+c2hx5T/B+A2APgbzUn0xkRvIO9ynis+memdgvWhoTbkMSm2fl8G8BX3ML/dFDfQW1TMtyq2jE197vbuux4Spfbb/mPn4ebUBUK5tvMecNlA3VI9cfH7Sjf9DL3TNeqzCBr+W4P/AnH8b5W+3ngnu3HjIeJbS62g6iUCIiACIiACIiACtQhIIFCLrPIVAREQAREQARFYOgEJBM7dQ3MZ3XLGCQ8heQPqwMDLSz6gzWnz0DuxAoE1GM9pEGV/5t6+XEMbS/W7L5/SAgG6Zn+Hp7DaN/hD4QVqhzYI9dP1m9ACLL+9Rdx9NlaYZLmrfkDhUBESCJzdS3cHcGSgcxmegwbZX9X+oS4wf99csrSqll6n8BbzPs3N/0cAuGWlxvK7QK9HTwXA0Ci/jiyn9pzGev2rW0u91RlJJRg4d+eEvvd8kgx9woEli46sdrFtKSKBiztRG0V0a0wc97doBELvXWPlVWcREAEREAEREAERGENAAoEx9PSuCIiACIiACIjAmglIIHDu3it98F57bFg3QhlX+vFNPNVv1q7IiPzpYnzoFtdnG1fmp0fkK4HAOZB8xhTe5vxOBMs1PUKDBG/k9Q0TJQUCvPVHY+pdBsDQnfZNAXCc1koPdG7hh/Knq/iX1io4It+QccUSJlkeUFKMMhFV/d9HJBA4mxQ5vA0Aw9QMJRr7aCQ+IRbsBj23bQIBigwZIuXpTWz5S0zUj//eCAX2cLf3Y4qsLRDo14HeSx7nPLdw3tz2tBsAup73eXDgt57fCwobyW0ocY6kS3/eUF9aupHzcjEkdmvr+iwAj47wgMF57bXOi87S2hlbn5Lrp9gy9ZwIiIAIiIAIiIAIzE5AAoHZu0AVEAEREAEREAERmImABALnBr82gQBrP+T69WgAj3LxgGcaWtHF/lPj9vcvB56OPaiUQOAceD5jymsAHBTdI+t40NfW2HET08prAjjFc1P+he6mda3bpjTevd25aO7XlS6Ab9L06VdjGlHxmZDb6dDN0dB7NCbtC+C7hestgcA5QCnKOjEQf/u05pY33e3/oHAfLD27bREI0GPAnQA8d0JhQNv3SxcItPWkUOC+AE7a4hAEvhAwLSOKA+7obpxfxIkq9vP8yBnahN/9nyzwIxATPuExzffyGRGeL+5X2PNNCVw/cl6pGE7jY43Y4b/dP9kXDLXB7/zPRniuKlFH5SECIiACIiACIiACsxKQQGBW/CpcBERABERABERgRgI+gcBHANwDwH/MWLfaRT8PwB16haQKBBinl8Z4pXMIpLrJl0Agn11/3EkgAJQUCPhu8P/CeQ/4cMUf/g2bMk4GsONAGW903+e53cDneALgjdT3e+IxW54HxuCWQOAceuw3xrB/SAAoDWK8WV5LADOmL2u9uw0Cgcs0ogCKmxg6ZY60FoFAy+ZFTmy5yWvhoXFwaRd2gUK0oTQUSsbyaMUQE/TGs1aRAL8PhxvfxOu5MAMU+NVO9GL0TgD8TX3aFdYa/LlGoSBgm77ftXkrfxEQAREQAREQgQ0mIIHABneumiYCIiACIiACIhAk4BMIpBp514h5yDAtgcD4nkwdOxIInMM8lV2/tyQQKCcQ4I3I9wDgbet+4n+/LYD/Gv9z8ebwxOZw/9CBv/LA/1YunnfF4qOzPr8zON7H88bfAKCLZqbQLdMhg1N0JSIelEDg3JAsYx7jsd8TwE8j2G7KI5ssEOCZF928vw7AhWfssLUJBIiKXmTocWHTwvT4hsHFABzVGLr3CYwTn7Hcuo3PfO+9QJGAJXZrUXA+OyJgeL8UgA8BuGKPHee3MwDwn0xfbDxnfcX9O4V+vNnfCido+P+C+9uvATAMAr0J9dPY9eKMnwEVLQIiIAIiIAIiIALLIiCBwLL6Q7URAREQAREQARGYjsCcAgHG/ORtXx5GdhNdUz+/+dtZlTFIIFAHcOqh5VQCgQs4l/C+WLp1aAznSuPcUAzwVHb93CUQKCcQYFxlxl7u7xVpoKfnEcZxr5VoZKD3gN0HCvioCzuwpFuYIcN/6xWAoQNeAuDuHmgxtzPH8JZA4Lz07g/gxb3/vM2u1TdVIMCQAo8AcNiIH9D3AHyqY9TsZ/XHzih6CaOMNQoE2KQlu8gf0a3neTVGHBBytx9jaF+qSMASuxEWDfx3c94Vhm7ns/1kyN8cXffTwD82+TyVjV0vjq2X3hcBERABERABERCBjSEggcDGdKUaIgIiIAIiIAIikEhgToHA7wFgKIPL9eo81aGXBAKJgyXy8dT+m0ogEFn9SR6rdeArgUC8QIAx1ukFwJf2AnDVgT/SdS8NHLkup3kT8FhjlPnECXztlxPcZOUNyHsltvFPXFx7Cr/6iTdweXuSt3CH0ssBHOLaVusHKIHAecnu6sYi3WJzXD3OifNqesao1b8l8r0agGuMzOhKAJ7S/O93PPnwZjD/PkYAyb7ib4ouxK1Eo+c/OIGA9Wz379924hF+r3jbmWXGJBpGKYC7mbspft3eS6UFAhQgPaoJl8E461aikOn6jWcYhm9hP+9gvdD7+xTfqcQqFX3cCivAwijyerAxHmIM7cc3t+TvGjmGizbSyCwkdmtfre3tpl/FWuvFKbmqLBEQAREQAREQARFYNAEJBBbdPaqcCIiACIiACIhARQISCJwbrkIMjB9sEgjYDGsd+PqMoDRo81B/k9LOAI5sXO3v0WsUvZLE3JSd67awVT8aFtkuxmqeK9FzAl1Fpxox6R2AdU9JU93MlUBguFco2mBf84b5N1M6Ts8OEvCtqdqHU+fHMZhpqH1eIyiip4jYREEAhSKnF4pfzu/0HV2eFE+UFgik5tdyoJDh6gDoMp7frRixAG+M06j9pliYK3ruMs6NfV/Q0W1CikCC/R7yGMN8lxq6IUYkQEEKQzB8coI+rrVenKDqKkIEREAEREAEREAE1kFAAoF19JNqKQIiIAIiIAIiUJ6ABALnZlpKINCPN1q+5+bPkQa3XQaqkWoAkQeBcyCmsuvj9xlB5x8t09XAMsC3NVmqQOCaznAydBN/KoqvAXBQRmE0SDLGOQ2CMYnhZBhq4+uBhymY2BPAxWMyDDzDECM0fPa9QqTcQA5VgR4lGBYi5vb9ksKdjMRa5XXejH86APbN2tJSBAIxrt67bE8DcHDj5eNzlYCzPry9T4M8xWr0KBKTrDktVyDQLZvGcQopQh5l2ucZKmVfAN+NqfxKntkNwD8b3jNe6UI0xXzf2mbHGNq/AuBAJ0hZEi56waB47YoDleL6/iEAXlhIRGO1WwIBi5D+LgIiIAIiIAIiIAIjCUggMBKgXhcBERABERABEVgtAQkEzt11pQQCYw29axhQpQ4tJRA4p7fHjhvLmLKGcTW2jmsXCDyxMTocOhbCyPdzBQIslq67aSi3DPo0/u4P4FSjrmsZ0ymGyrW0aeQwyn49hWV2IZVeXIpAgF4h3hxxM56hA2i0p7GzRLz00lit30qpsUKPAg8EcEQEswe42/Gl2zpHftcGcDSAywYKzxEHtNnFhC3gXEBR2XvnABAoc+g3NEddS621F4ZX1REBERABERABERCB5RCQQGA5faGaiIAIiIAIiIAITEtAAoFz85ZAIH78lTq0lEDgHOYSCMSPP9+TaxYI0EhzIgDe6JwzjREIsN6Wd4aUGM6WgXBOTt2yUwyVa2nTXGxTWM5VR1+5SxAI8Kb+ewBYXki+4cJL0HvAUpP1Wyk5VmK9LpAtvQ2k3KZfIt9bOxHJToHKjREHtNnGhC/gnPDwRlj2ggUJVfrjYS5vB6XW2kscg6qTCIiACIiACIiACCyCgAQCi+gGVUIEREAEREAERGAGAhIInBu6BALxg7DUoaUEAucwl0Agfvz5nlyzQIA3WJ8/HsHoHMYIBLi3vicAxqse2mfTEHQ3Z5hiTG8rWQZC6/2p/p5iqFxLm6Zi1y8nheVcdfSVO7dAYFcAxwK4ngFmLmNnan9Zv5XSY4Xlvc25YXG8AAAgAElEQVSFPvHVlSEwGPbk9NTGLOT5WG8JJcQBbZNjRAJ89i0A7t+EoSDjJSSGzaF3DYYauHtTt+/MUKlSa+0Zqq4iRUAEREAEREAERGAdBCQQWEc/qZYiIAIiIAIiIALlCUggcG6mEgjEj7FSh5YSCJzDvJZA4CgX9zm+d5f/5M4AjgSwR6+qYwUCpVgxpvUdBjD66hcy7NWIe/17AD4C4HIDdcwVCHBffQiA5wbcdNNF800aNp+JHGKWgTAym+qPpRgq19Km6tA8BaSwnKuOvnLnFAjw98fvy9MMKGsRB7AZ1m+lxli5JYB3ewROLVoai1+3tMEXUR/Om/+/vTMBvqYoz/1TqMSlVBQVE9wjxi2GskRcgqIQUWJpcEGIolbUqwbBGJeKmrglooiaqJBgormW+xL1ugQBEbnBfUlMXBMixHLFNS5cjBHvnefaR85/mJ7pnuk5M3P+v66iPr7v9PL2r3vmzJn36ff1Kf2Hd9R9kaSnSnIKilIlJd2Ax/qipKMlzSWyxeUDgJ+WApHZT6ln7cxhqQ4BCEAAAhCAAAR2DwEEArtnrZkpBCAAAQhAAAI7CSAQ2MkDgUD6FVLqpSUCgUuZjyUQ6OvwTd8Nm69pR4dPON6pNrSdY6cmmBMLg1+KVe6+PkrSGyJ2HxecOgnTSq5SWiDgU6lPlHRiggXPruo8K6Geq3Q5CBO7Gb1ajqNyKXMaHVpkgByWU9kYG3dKgcCtJJ1T3Suu1QLFAp3DJH1sbuAi9nRdK2PslWtU3ytnSrpdCyNHejl+IQxXZt4onNBvm5fr+v783MLigJUN1wzfc/dIYPdMSSdtQSqHhKm2Vin1rD3UDtpDAAIQgAAEIACBrSWAQGBrl5aJQQACEIAABCDQQSBHIPCIKnTtgQWJ2sHnE7Z71vr8dvVi9t2FX06+PYTdXR+qyYGHQCB9gUu9tMx1pNYtHNvRm04kvWYpdvURY86UUk7v9BnOv+bY+yZnX1895Axvur/+u6S7S3K+8JKlTSBgkcXTMwZzGObnBYFASrMvVI7MgyVdmFA5tqdzHYOl+rHJTWubY49PpDpEeZsjNwHN1la5KDi6l5jjfSqBgPeUhVF+TmsrT5Lk0+FLKVMIBMzGEWAszIoVRxi4fxWx4ccLAOn3nb8dIh5crcVep395fAipn5L+pe/U/ezvveooDF3lU5IeLOlzXRW3+POxnhe3GBlTgwAEIAABCEAAAnkEEAjk8aI2BCAAAQhAAALbQyBHIBBzeC2BRlNYbwQCw1au1EvLHEdqk8VjO3qHUWpuXYpdvfdtFQhcsQpb71Odq2JR0W0qp/QvhX+wg92nZ50r2OGJU8rY+yZnX7dFD8g5bZ8y71WdNoFAapoG92X2r4ikU2izxyGk35hgcCnHfql+bPJQgUDCtKmyUAJTCQRuLelcSXu1cLPw8siFncieSiDw6I5INEOj/Wxqe1+pSvfyHEkWhrQVpxKwI94pdsYUB6xssKjMIjRHCUgpjtjglAcWD+22Mtbz4m7jyHwhAAEIQAACEIBAlAACATYHBCAAAQhAAAK7lQACgZ0rTwSB9Cuh1EvLHEdqk3VjO3rTiaTXLMWuPuImBAJ2QNnp0FR+LXIq2k5k32tWuXxXba8j6ba1jiwGuHY6yh01HyPp5Yltx943qft67xDd5IAGu78q6SBJFyTOKadaCYFASshqR0C4aYNhb5VkYURXXudSjv1S/XgqCARydtruqjuFQMDvs+xAPbYFde6zzVxWbSqBQOw7esXl/JDeJiUKylQsbybpTZL27zDAUbvuU6We+PCGDfW+PSYIzCwY6CoW/zmNjYUul3RV3qLPx3pe3CJETAUCEIAABCAAAQgMI4BAYBg/WkMAAhCAAAQgsFwCCAR2rl3uS3S/eP39huU/L7ywX0L42b6791BJf9vQ+EMhzHHqSa9UR2rMzrEdvX35tLUb64VvikDAIajbTu25j/XT+mPMf6w+U53OHn/sfZO6rx1m+TURIGNFD/BwQwUCTntg51NbmPynhZzXzou+b22O35B0Z0l2tLWVUo79Uv3YVgQC7WvmPOMW+nxtrAt9xv1OIRDYJ6RkuHkLl1dKsoCqS5AzN7RTCQScAuT9DaK2FZ+clCKbZnq5IBZ5oaQux/tnJf1OFe7fQq6pisVx/u6+fqIBH5f08JmkHYg9RyROZdbVcn8PzXoyGAcBCEAAAhCAAATaCCAQYH9AAAIQgAAEILBbCSAQ2LnyvBDb/JWQ6kiNWTa2o3cMIlMKBLocH2PMd1N9fik4nX3yvquMvW9S9rUjKJwd0iPU7bXDxk74L3dNpOfnfQUCdj49TtKLq9DVe0TGXs9l7Sqx0833rSJIvLPD/lKO/VL92NwpBQLO321H8D/P2Nm7Cs/u/OHOd//2XRQafAqBQFuKEu/Xn1QCgoMnOCHe89a0o9lUAoGuCAJzFQg4asBrJTVFpKmvx9skPUrSd0ss1MA+rhvsPiSjH99XHFFgjAg7qWYgEEglRT0IQAACEIAABCAwYwIIBGa8OJgGAQhAAAIQgMCoBHIEAnYIPaCgNQ43bidVvdi59HVJ/rNUOaEhn2yTkweBQCni6f2kOFLbehvb0Zs+k/SaUwoEfJL7g5JumG7uYmo6d/I9JJ2VYPHY+6ZrX/s36B9J8r2pqfizExPm0bdKH4GAT4afKumBLYM25bK+p6TTJNV/d1s4cHzHBEo59kv1Y3M3LRAwt1uEqBeOOPGDkHriM30Xf8R2jhzg08CH18Y4XdKfh1PZ3iPbWjYtEPDecCQfn6iOlTMqQckR1f65eIHQ5yoQ+EDY4z+cCVOn/TmuinjwZwlRA2zyn4Tvlzldi4524O/lP81k+pbQbgqhAAKBzMWiOgQgAAEIQAACEJgjAQQCc1wVbIIABCAAAQhAYBMEcgQCpe2JOaj+t6R7S/pR6QFr/SEQGBlwYvddjtSubsZ29HaN3+fzKQUCMQden3kMbfO9huv832ph5x0S+5OSvr82mE9vrp+st5Mm934x9r7p2te3CmHBm0L0O+yzowd8cyjglvZ9BAI3DY7+/SL9Opf1g0JUhPUqsRDonwiCDu+DWCnl2C/Vj+3clEDA0QIsxvjjKg3Fr9YAjZl+Ysi2s5DBzlOLSZrKmcFZbTHeNpZNCwR8//Az0y1bYDq1wMsXCnsqgcAqCkYM2/skOQJKaiqlsfD7XebdJP11wz2iaUxfd0dLeleVasiCujmWu4a0O6kpB1ZzsAjJ3+ufbpjbXkGQF7svdXGIpQ1DINBFjs8hAAEIQAACEIDAAgggEFjAImEiBCAAAQhAAAKjEEAgsBNrSgSBLgfAKAu1wE5TQ/B2OVK7pj62o7dr/D6fTykQsL3PrcJOOz+8ix0cTSGGfbLQDtx1x/xqro7w4Zfw9WIH8b+Gf3xpQ8SRsU/F56zF2PumbV87GosdOrFTv8eEcMs588mt2yYQuE9wIDX16cgT75VUFwm05bKOnXK2sOOgEC4/Zn8px36pfmznpgQCscgLtmHsFBS5+2lVv8ux6lPOJ/ftfAHtup4PSgsgu1LG+N7uOp9fALsmE6cSCPj7y3s1Vl4p6ZETM71eJcSxnY4OkVLOl/QXIUJXSv0p61w5CBl8D8wtTm3yDEkWDKwiJLR936X0H7tuEQik0KMOBCAAAQhAAAIQmDkBBAIzXyDMgwAEIAABCEBgNAIIBHaiRSBQbqshEIiznFogUG6V4z01OVERCPw8rcDrqxO/b64cGHdowFfagRhboTZHZptAwP3tL+mdklYnPFNyWcccx/eX5PaxUsqxX6of27kpgUCXc3RuznaHOXde8MMii7l0Z3XKfXPTAoEuQcam7icpbPrU6boGUp8zcsa+hiRHurhdS6MpozI4soiv/eckphPwNF4l6amS3lil+fAJ/bkXP4vbTq+Fvy+bIu10zcEpNf5K0vMCp49U6Thu0NUo8nnsOvI+WIkte3bd2czXgDnUyxjp2NbH+E9JD46IQTuNpgIEIAABCEAAAhBYEgEEAktaLWyFAAQgAAEIQKAkAQQCO2kiECi3u1Jf3BNB4FLmQ505MWfKqyU9rNzSJvWEQEB6aAOplUjCv0FvL+llkg4I9X5ShWc/VNK5SYSHVRoiEPDIB1YOtHdLOinklu/KZe05en/bibxeTqhOeT69ZSqlHPul+rGpmxIIeKyjJL0hwuejwRnfFOVj2O7o1/rWYe86nHdTsXPS0TGcNmRby6YFAq+o0q08ogWm7y/HLxj2FAKBO4b0L3tGuPk+fXB17X14w1yvIOlISX8p6WqJY/uZ1vvjTdW92sIC37OXIhC4S0gv5Lk66tHjEue8Xs2pICxCc0SCMQQCPUzKbjKWoDTbEBpAAAIQgAAEIACBbSWAQGBbV5Z5QQACEIAABCDQRQCBwE5CCAS6dkz65wgE4qzGeuGLQCB9f06ZYuDENTPXc0jbefOEWv7km1Un7G8j6a2Fc0YPFQjY7r0rp43TSqSUWIjn04ID58eRTko59kv1YzM3KRDYJzgrb97AxznEDw+htFPWYOw6duDZIR0rzn1ukcA2l00KBOzwfUclyjikBeiUJ91LrPOmBQJ2wr9O0gNbjJ9CmONULK/NPAFv57jT2HwlzKWLZYn1KtVH07P4LUMkhJWgrmssfzdZyOH0N2OlGOiyocTnYz0vlrCNPiAAAQhAAAIQgMBWEEAgsBXLyCQgAAEIQAACEOhBAIHATmgIBHpsokgTBAJxlmO98EUgkL5/5yIQWFnsE47+XXpR+Af//4OqMP7OdX3FcHLUIoFSZahAINeOmDPzc+FEa0xoUMqxX6ofz3uTAgGP96xKHPLMCPC5nMrvSi/wheCsuzB34yys/iYFAg677qgcdpw2FQtI7iHprIUxXDe3y6md+pyRisCnzZ3+ZY+WBs8O12RqnyXqXT2IxNrEIKtxHM3FUVn+ovpzPbJLF8sSdpbqI/YsfrnwXXhqQhSFx0pyPRcEAqVWhn4gAAEIQAACEIDAFhJAILCFi8qUIAABCEAAAhBIIoBAYCcmBAJJ2yapUuqL+02nGPALZp989p9Tld8KTsb6+FOlGHixpAcUhnHdhvzIdn47D3nJ8qEQQnnlWE/te24CgXW77Uw/OZz+XP278wE7t/vHUifYUW/TAgGb03Std+WlL+XYL9VPbB6p97s+y9e2Vt4XPl38mT4dF2zT5Rhfeqj7VFRdHIbe49ftuF4Im75vxLiU55nUeU1Vr8upXfK6c8qXMyrHeixFhhl8NVxvF0wA5IaS3ltFONivZeyPS3qIpH9rqNPFcoIpRYfs2rtOO/Ankh7f8JzhTh2Nx+kYLs6c1JS/iWKmjiUozURDdQhAAAIQgAAEILC9BBAIbO/aMjMIQAACEIAABNoJTPkyLHaip+QL9LbZNzmrul5KznE/xRydJV+cjznvTQsEhp4kG5PF0L3fN4JAbA3GnGupvvsym6tAwM6fd1ah2JtCyp8nyeKSLxWAF7v3Oz/83SR9oMAY611cR9LZkm5V67frlHMpx36pfmz+piMIdJ3On+JEc317tEU5mCpne+EtnNTdJgUCXWPZmX2HtRDzSROYWaUup3ap55y7S3pTJcxyVIa28keS1lPEbBqX7/+nN0Q4cKSAJ0k6pXKcXxIx6vJVNInfTJjjpufUNJ7nc26CoNAimT9tENN5Pf+px0Sm/E0UMxeBQI+FpAkEIAABCEAAAhDIIYBAIIcWdSEAAQhAAAIQ2CYCU74MQyBQZichEJCe34Dy1ZIe1vDvCAQuCwWBwKVMYvsm92rtK3zpCiXtvNIOg/39XINq9WP3/jFEUnZM+QS586E3FZ94dd7vplLKsV+qH9u4aYGAxzxK0hsijKYO3+8965PXB0bs6yviGbjFJ2ne5bQvyaJrrFLO80lAhkHHFgg4mpDFLY9LmKQd1nbWDr33JgwVreJ3l0+uiRTeXjnSj1+4EGQIE7e9cWDyQElPq9Ly+JnQ4rPcMuVvopitCARyV5H6EIAABCAAAQhAIJMAAoFMYFSHAAQgAAEIQGBrCJR6GdYnRLmdRnbW1svPJH1dkv/MKX8n6Q8zGhBBIAPWiFX7OlJXJuWeBEcgcNnFRCBwKZOpBQK25EZVGGsLAW4Sue7+RtKxtfzSuZfoJgUCXXm9nS/7hMgESjn2S/VjM6cQCOwj6ZxIZAnbdHT12RtzN0Gh+j6V/H5J/k5vKseFlBmFhpt1N11O+5ICgQOqaB/uzxEmmgoCgWYuV6yitNy2es58dAjHv0fCjiqd4iVhyGiVlYjM3xP/I1x7fZzhQ2yYa9trV5EUftQjtcBqPqV+E5Xkg0CgJE36ggAEIAABCEAAAg0EEAiwLSAAAQhAAAIQ2K0ESr0Mm4ODMdexh0BgHrsegcCl6zDUeVQyxcDrJflkYt/iE43Ojb5ehvZph9hTan32ZZYrLMnlMHRfdznVbf9JPU9Jei4x52LpCAJOKWDHdlvo7rZ7dynHfql+zG4KgYDHbQvj7xP8RwxwjOXu71V9v0txdAgLVprKlDnb+85pSLtNCgRijsOV/btBIOD0FRaHXpSwaBZc3aYKw28nck6xWNX57N+a02jkuleV5HQwF488zm7rvtRvopLcEAiUpElfEIAABCAAAQhAoIEAAgG2BQQgAAEIQAACu5VAqZdhCASm20GkGGhOMRA7lUwEgcvu1abrd2iu5TH6bHpRXlog4NzH3yhwOV9X0hUa+knl2hRKer27oU6rmNOhpECgK13Caj6OlnDfiJOvlGO/VD+2eSqBwK1DXu69GvaVHaUHS/pwgb2b00VXZINXSfq9AUKWHFvmUHeTAoF7STqtZdK7QSAw9pr7Pvu7kt68i/bw2Ezn3H+p30Ql54hAoCRN+oIABCAAAQhAAAINBBAIsC0gAAEIQAACENitBEq9DEMg0L6D7JS2I9PPnR+S9NHqRNrnwn/fkXTJgA242wUCL5XkENb1EnPEXq468eq8w/5zqvJbwclYH7+vs3vVT8kIAqmO7BjDpQoExt4TOVy7HOxDwl6PLRCwOOIUSY9KAPoBSYdL+mFD3VKO/VL92MSpBAIOje5TzGbVVMzb98JNhhs/StIbIvbYDtt6esIe2JYqmxQIdI2FQGDYrvq2pAdJOntYN7ReEIFSv4lKThmBQEma9AUBCEAAAhCAAAQaCCAQYFtAAAIQgAAEILBbCZR6GYZAoH0Htb3Iz3EYNo2y2wUCQ0O5T3Htj/XCF4FA+mrGrpv0HvrVzL3enWfaJ+wdHrupnCvJ++n7mebE9qCjJ9xZ0vmZ/a1X74p+UO+6zZEZ29NfC87nbybaeRVJr6mc1Xeo1c/tx80tSnpArZ9NOWPbHPKbDud/+cDUNjUVC+EO67E3E5d0ltW6nPZDRWDrk+4ay/vB+/0rsySVZlTs+k9r3b+WI3E4csB/9O+ClgskUOo3Ucmpj/W8WNJG+oIABCAAAQhAAAKLJoBAYNHLh/EQgAAEIAABCAwgUOplWJOT1qdbnS/8ewPsa2p6DUkvkFQPs9yWx7qpnyabS4bXXh/zUElnhggCdVuca/xtAxghEJAe2sDviZJePIDrmE3HeuEbc6bE0i2s5jjGaf8x+txEioEx19195woE3Mb3CIe43iNi3N+EHPBOj5BaYntwqKPbv62dj/4lEXvtcLPoYb20OTKnchCmclzVG8otdbyukP6OIHByamcD67WlPHDXm7Rl4FSKNe9y2pcUCPxGSDnhfPRNZaznmWKwEjra9PX/gyrFzGPC/XZIZKeEqVFlhgRK/SYqObWxnhdL2khfEIAABCAAAQhAYNEEEAgsevkwHgIQgAAEIACBAQRKvQzbZMjlWA75OQsEHizptQ3r9NMq9cDdJDnEdt+ymwUCbSG37yPpXX2hjtxurBe+MWdKl1N6DGf+GH3uVoGAT2q/LDiuYlvT94GTMsLLjyUQaBMzWMhgR/qf1ibR5sjctIOw76W/KYGA7YulVfFnmzy1/7iwL5uYbTqaQd91K91ukwKB2LPQ+pyc4uE9pSe5wf42df1/S9JTJb1R0kUbnB9DzYtAqd9EnpXfM19T0p4DpxhLSfURSccU2K9O7fOjgTbSHAIQgAAEIAABCCyaAAKBRS8fxkMAAhCAAAQgMIBAqZdhCATaF+Fpkp7bUKVEOO/dLBBocx7sRoGATxd/qCEcfR+BgJ0k3x1wb7luteedh369DO3T6+0IIuul74ncpaQYWM117+DoOyCyJo7Y4nDuH0tcszEEAvcLDrb6utskp0mweOAQSW+t2YhAIHHRQrU7Sjon4nj6vyH1wul5XWbXvrqkM6o9eWCk5SkhgoDt2U1lkwIB3wsdmeh2LYDnHEknZV+MKRD4rKR3SPLz63kZ4qoUu6mzTAKlfhN59mPu3ZJ0u54PS45FXxCAAAQgAAEIQGCWBBAIzHJZMAoCEIAABCAAgQ0QKPUyDIFAfLH8rOnoAc5nWy+fqBy69xiYhmE3CwSuVUVgsIP4ljWwcw+tPFYEgdiJ0q4XwE3X7wZuP0WGKC0QyI1EEptEjGnXWrRBsTP27CrFypUjlezk8mnDLyWQjUU16XsSvk0csG5XbO/HBD1LcbL05ZawVJepciVJbw+CkKb2PgXtk6WOUDNWuaek0yJpczYlUhhrbkP63aRAoC2CzmoOr5f0kAU7v7uu/5xUVr4eLAqw8M3/LVW84uv/4CpizFWGbNQtbvvlEEmlzxRL/Sby2F17t499Y7QZ8kwyhj30CQEIQAACEIAABDZOAIHAxpEzIAQgAAEIQAACMyFQ6mUYAoH4grad8ivx8n43CwRiDnGHTD1I0j/P5DqrmzGWQOB6khx2dt/agF3RFBAIXApszgIB/259sqQTW/a1w/gfK+m/O/Z+qfuGbTpSku9lezSMWY9scK/gWK5XRSCQd7NqC+9v5r7/fSavy+TaXnOnvPA+ayqbTHOQbPSGKm5SIOApOTKRIxTFSgkR4obQNQ7T5WTdpDBnSg7rY6eklpiLrVPYMeQ7vNRvIs+7a+9OwaZpTAQCc1kJ7IAABCAAAQhAYDICCAQmQ8/AEIAABCAAAQhMTKDUyzAEAvGFvIWkD4RcpPVaJcL/xhx9OSfrhm5DOyPP7RmSfshJ69j+nbvTYCyBQIwHAoHL7vDYdTPEubA+ypB93XY9OrS7Q/Q7VH+sPFbSqR0XdWz+OREZ/DvaTuKXRMQBPwvigfWUArl7NOZk+VoIpf/NxJuXT9u+RtIdavVz+4kNd0kVUv87kvznJspNqmgRH6zW2ak8mspxkk4eyZAbh/t9XYi0Gm7MsUeaUrFuNy0QcOSOesqO9cn41PzdwjNIsUlusKMuJ+vcv+vHQIVAoJ3qkO/wUr+JbGHX3h1jb/TpE4FAH2q0gQAEIAABCEBgqwggENiq5WQyEIAABCAAAQhkECj1MgyBQBx67MSsw9s6vcBZGevVVHWqXOrrtgwJ6T/EkXpoyMFcf56f+6nJsQQCvynp/ZIuv7Y4F1f/dldJH2/ZZ01r4BPhDmPetxwfTjGvtx/a5wGSnlIzKMehvd50qQIBz+H2If/7XpHFqZ/az7lvpPK8QhWl4OlVmO5ntmwQMz6pFso79p3zGEkvb+gr5mTJdQyW6qfv9VC6na9xCx6OinQ85in+tugFXw3X/QWlJ7yQ/jYtEGgTIK6QPbv6n2cthF/dzC4na+59YKEYdpiNQKB9FREI5O1yBAJ5vKgNAQhAAAIQgMAWEkAgsIWLypQgAAEIQAACEEgigEBgJ6Yhju4YcIf/dRjgevmGpDtLOj9ppeKVdrNAIJZH/X2S7luFY79oINuxmo8lEGjqN2VPNwkEhr40HqPPpvmlOrTra7lkgUBKqgFfA/eX9P3IJh4SQcCn8R2hwLnN2+57L2g4UR/7zontt1KO/VL9jHVP6NPvPUO6hqb3GRagHV5FTDi9T8ctbRzB4gxJB0bqnFJFUnAEgaXmdx+Ka9MCgS4HuufzhZCz/sKhk5ugfdf8EAhMsCgzH3IJAoH3SvqPDXO8rSTfn+pl6LPehqfBcBCAAAQgAAEIQKA8AQQC5ZnSIwQgAAEIQAACyyCAQGDnOqU4U3NW9ooh/K8dNfXS17FZ72c3CwRi+ZeHvCDOWd++dccSCPyhpBfVjJrKgTKGQKAv76Z2SxYIeD521L6rIUqDP3PKjydJsrM2FvK+r0DgRpLeIul2LYvhPfjUYEe9Wq5AwPdQO5z3q3X0XUnPl+RoCSllGwUC+1SO33Mk3TwC4I2SjpHkMPOlSpso4SfBEf3hUoMtsJ9NCwSMyNEB2iJ5uM7R1T7xflhaQSBw2RUjgkD7Lh7y/FfqN5EtbNu7XWmfxrhOY9/5CATGoE2fEIAABCAAAQgsigACgUUtF8ZCAAIQgAAEIFCQQKmXYaQYaF6UtjzRJ4QQ3UOXc7cKBBxi2w4Pn5Kul7m/8BxLINAkmPhcSDHw7aEbLbM9AgHpoSPvTZ/iPlvSldfG+ZQkR9bwureVWGqPNuGS06X4mrtaS8dt4gA3i4VEH/ua3UaBgHm+NAgompbEIgqnHfl85rUbq96V1uDd1b47UpLTmuzWMoVA4I5BKLJnC3SnmPH1+52FLQwCgcsu2JWCEMeRXMYsN5Dk59RfigxiIZDvPyUFSCXm8+VqrzvFSp9S6jeRx0Yg0GcFaAMBCEAAAhCAAAQmIIBAYALoDAkBCEAAAhCAwCwIlHoZhkCgeTl9SugdkZV2VIH3FNgFu1UgcC1JdmbesoGhRQNvK8B2rC7GEAjEBBNTpVtAIDC+QMC/Y59TOWj+OGzUF0p6RqKDNiYQeH1IHdAUIt7OfTuBLXxqKs51bpGKIxjESuz065IEAperuO/RMc+x7h31frucw46+cHIhY24t6VxJezX0N1ZKg0Kmb6ybKQQCdhi/XdJhHbN0VJF6hJmNgek5EAKBnuAGNvOeerOke0f6OVhzCIMAACAASURBVE/Sb0n60sBx5ta81G8izwuBwNxWF3sgAAEIQAACEIBAhAACAbYGBCAAAQhAAAK7lUCpl2EIBC67g/yM+TJJxzZsrq+G0OAXFNh4MYGAQ28/RdL3CozR1YUdgnYc+cRqbok5Krschr8RxrxqbUCfXr2rJJ+YnGsZQyBgDqeFE8Pr824Kt7u/pN8fGY6dBw5Hv14+KekfRx7X3dt54Wvvxy1jLT3FwGpq15H0t5JOCoKZVLyx664rPHNMJGDn44sTcs8vWSBgp9kDgwjDof0fM4PTs041cUYlNnM0iabik7R2HH8/dWO01GsLZV9ynAKmTtbFFAIBT/YoSW/omLWfCe4u6Z8mo5M/MAKBfGZDW/jZ9cmSTox09DNJR0h659CBZti+1G8iTw2BwAwXGJMgAAEIQAACEIBAEwEEAuwLCEAAAhCAAAR2K4FSL8Nizqavj+BA8UlpO5nqpcuxVa/fZPP/qUJ230WSHZlDS1t+6PdK+p3Kge/xhpaYo3Oq3PO58+krELifpLc2DGbxxR0kfSXXkA3WH0MgcD1JH5G0b20eTUKL2PgbRDDqUG1h8lcDb4tAoC/IvgIBj3f74JT2SXKLg5zS4O8SxAFuu0SBwN5BbOXT+BYJuPwkhPl2mO2pS1sUmVIn+9u+zzz/kpEKpuY5ZPypBAJdQpHVnBxRxhF2SghGhnBKbYtAIJVUuXpNqWvWe/f9xoK0pigz5ayYpqdSv4lsPQKBadaQUSEAAQhAAAIQgEA2AQQC2choAAEIQAACEIDAlhAo9TIs5mzaJKa5CQTuGU50Nz1r2rl0aDgBP5TRbhUIxHJvTxVSP2cdxxAIONf4+yVZQLNemtItIBCQdrNAwLmrnfrkkIZNm3of9b56iX6eRuHsjM2/NIGAr6dTJT2iYY5vCeKItpQKGWh6V20L/e9OTwkO/CEOvYdIek3EwpIRcXpDmEnDqQQCnr5FcxbqdL3femXYD462M/eCQGCzK3RDSRaw7hcZ9m9CVKwh9zzfU3+62Wklj1bqN5EHRCCQjJ2KEIAABCAAAQhAYFoCXT+gprWO0SEAAQhAAAIQgMB4BEq9DEMgsHON/ALUzhSH/Y0V5/I+MjFfeNsO2I0CgWtIOrPKh367BjAOLX/8eJdMkZ7HEAg8Ojgy1w2MRcRAILC7BQJtjgs7Dx+ZsMv9G/oK4SR9QvVfVLlJlbv6g9VevW6tUVdKkZwxmurG5pwSaSX2PelQ2xaC2aE2ZenKQT/Ugd91Ot1CkSds6Yni3HWdUiDQlTd+fS5LEQkgEMjdgf3rm/Xbqvuz0wM1lRLRJ5yixpGfXiDJvxuGiJb6zzTestRvIo+AQGCMFaJPCEAAAhCAAAQgMAIBBAIjQKVLCEAAAhCAAAQWQaDUyzAEAjuXu+tEp2v7xegDwgvZIZtlNwoE2pwwPun6uiFAN9B2DIHAKxpOOZ9fCSnuJOnC2pyaxndUC58+vajQ/O1kuFGtL6fu+MdC/a+6ua0k74f1QoqBdshtjouxHfWxa3fscYcIBNoEX6WEXkMviyaB0HqfQ1IAtEXDcV77g6rvss8MncCWtJ9SIGCEt6pSX5wj6VoJPO0MflQlqPtuQt2pqiAQ2Ax5vxN9cpVC5cTIcOcF4cCXBphzR0nvXNubfnZ9kaRLBvRZummp30S2C4FA6dWhPwhAAAIQgAAEIDASAQQCI4GlWwhAAAIQgAAEZk+g1MswBAI7l/pZlQDgmQmr/1lJd5f0zYS6sSq7USAQc4bFTswPwDtK09ICgVhEhdNCvukf12bRNH7KSeocGE33hFQnsE+m36EKmf0vCbmym/Y/AoH2lbpqSH/itBT1krpGOXthve4SBQK2384tO173rE3cQq/Dq/16el8ghdrFIjOsuj9D0hE9ItZ0nUp/o6RjZhwyvBDe5G6mFgjYUKf/eLOkPRKs/qKkoyV9PKHu0CrXk/QkSc9rEK3F+kYgMJR6Wvu2PWMR0GHVfe5jaV011nJKLadk2av26bOrSDTPlTQkZcEAsy7TdOhvIj+7OLKMRQ8IBEquDH1BAAIQgAAEIACBEQkgEBgRLl1DAAIQgAAEIDBrAkNfhq0m1+QM9EvFp0j6XmECdoY6PGn9RWNq7uw2m0s4mPcJjqSbJ857aE7X3SYQaAun/QlJ9xhhzyUuZXK10gKB2HV8QvXi/ekNVs1VIHCVEN7+OZKuVjmRHtuQNqE+HQQCydvuFxV/uQqN/xFJN2hoikCgmWdbFIG+zvf8lYu3sH121tvR11QcIeTgytH34cxBY8IId+M+7fg7N7PPba4+B4GAnZSnhOgAqaxPripa2Pid1AYZ9W5cOU2fIenhknKFaAgEMkD3rHr7SgDle1j9mdrd2dntVFhOC9C3+HnD7b0vm8rLQ4qSi/sOULDdkN9Et5F0Uojk9BUEAgVXha4gAAEIQAACEIDAyAQQCIwMmO4hAAEIQAACEJgtgSEvw9Yn1SQQyH0RnAop5tyai0DgcZJeljqZAi9gly4QyED1/6u2pW8w9+NzO5ygfmmBQCyiwn1DSN/6FOcoELCT4uzqBbtFAqvy7yHCxpdb1giBQP4GbhMIPLESZ7w4v8vkFnYonymp/ht87HGHpBhYTc5pMxwpoH4yu1S6mGSIkYpHSXpDw2e22dfJpzNzfreJIjzMHIQRQ5mVbj8HgYDn1EckYGfwa0OY+c9n7pU6Rwsl7y3Jz0P7r32Y+1yIQKD0Dt3Z3w0lvbdKy7RfZBhHfPD3ge9xfcvVg0DgkJYOnN7okQkRg/rakNquz2+iy0l6WBAzOhLCXSQ5nRIRBFKpUw8CEIAABCAAAQhMTACBwMQLwPAQgAAEIAABCExGoM/LsCZjEQj8nMr1g5Pzpg2QfNryW5L2bfhsSAjX3SYQaEvfEHOIT3aBRQYuKRCInRz+RvXi/86Szm+wYY4CgVgoc4cg9prHCgKB/N3dFo7+PpLeld9lcosHBydkvcHY45YQCLRFL0lJa5EMqWdFn9T2aX5/x/i75oXVd9IrB5wKbxNjzUUU0RPVaM3mIhDwBO2YfYWkB/SYrZ9J3iHp70NoeUcW+FFDP3aO7i3pOpIODIIui4D896aCQKDHYozU5JqV4NKO+btF+vd3q0/EDxEHrLpOEQlYOOZ0F98dab4p3eb+JnKkIwtTHxo6X49ChkAghTh1IAABCEAAAhCAwAwIIBCYwSJgAgQgAAEIQAACkxDIfRkWM/IR4eXw+ud+yfd8SX7RXLI4DKrDYPvl5nr5aHCGpI7VJGoYkmLAz5QOjf7HEQOcf9Uh331a61oNdXxK2k6yT6VOINTbTQKBtvQNX5V0UHWS64JMflNULykQiDl72xyWcxQIeB2aTmh/PZzIczSBpoJAIH8Htzkxx3bUO9/002om2wHl1CBn5U8luUUJgYAHu6ek0xoiIMzBYW6xkNn69KqjBjgPdt/i7zM7vo6NdODvW+cl/37fAba03ZwEAkZsUcufS3KUmTkUBAJzWIWfi0cc9j92qn9o6qumWXaN6TYWODmlgQWOU5Sc30QHhIgtv1oz9PDq99B7iCAwxfIxJgQgAAEIQAACEOhHAIFAP260ggAEIAABCEBg+QRyXoYtf7Y7Z1BaIHCrKsfzORHnv51Hfmlop81jJP1VBGYfkcBuEgjEQmgbp/NvH1MJNH66gI1aUiAQO5HddvJ+rgKB2AntPws5rJtOMiIQyN/wdmxYQGLe9TKmQOCKwSnle+F6+WEQ9/xz/lSSW5QSCNjJ5dD6Pi1dL3OIIpAMpKNi2/eZm/pe63D0lJ0E5iYQsHU+5e9Q/w4VX0+Psen1QyCwaeKXHa8r/cT7qnQk9x9J/NMVtcDWflbSb0v60gSoUn4T+Xvz8VUaD4vdmq6n1XcoEQQmWECGhAAEIAABCEAAAn0IIBDoQ402EIAABCAAAQhsA4GUl2HbMM+mOZQUCMTCo6/GXc/V7Jezr6tegj4wAtZRDBxm1WG+U0K77haBQJtjzijNzCKBenG47TvObBPbQfuUBptyHYwxh7pFEg4b/IHIvMcSCPiF+FXDmC9tCG3tU3X/IcknnV1uI+lXwv/bcXCViL1tUQRKCwR8gtG2Dy3HB6d3vR9HPzlxaOcD298vOOrr3Vws6a6Vc+bjA/uPNY9Fu3AajDtJunCkcd3tEIHAKoz6npJuKelBkn6vwdY5RBEogdDvR3zq3E6wpmIH3t0lfbPEYFvWxxwFAivEvt++qfqevPmEzBEITAi/cmp3iQPeH763xwzznyISOC+IamORg8ai2PWbyM8rFkb5GS5WnhjEOAgExlol+oUABCAAAQhAAAKFCSAQKAyU7iAAAQhAAAIQWAyBrpdhTTlnFzO5DkNLCgTaogL8LISldmqBVblhSDWwX4uNDu/8VEkXdcxjtwgE2qIHfKGK3nBwxMEYO60/x32cKxCw8MFRK+y4XC+fCCHbvxeZZKpAwP365KkdSuvO/FW31w0Oh02wfEl1ovEJDaKZ0gKBsecyB4FAU5h/z3tIipUUbt5Lvq/Vi0P2+8Tqj1M66Vkn5qxxChyLdXyt/LqkX5ZkIcPNqhQ5jnhw7czx1sVgmU1nU70resBxVaSck2dj7bwMmbNAwKQsKvN16AgzTRFExqbp76sjMlJPtTlZbWuu4GDs+c25f4sDLH7z82pTsVPeaX42cXI/RSRg4di9K0HW5zcINXb9+pnK93Z/V5hjW7GwypwRCGxw4RgKAhCAAAQgAAEIDCGAQGAIPdpCAAIQgAAEILBkAggEdq5eHwfZ7cOLw70iG+EtkhwG/r9rn3e1c/UvSvJppHe35JPeDQKBvUNO19iprVMk2WnVFHFhWwUCbTnC29ILeF+lCgRc9xWSHjGDm9y3gwjEp5fXCwKBvMVpi8ThvM93lmTHTOlyHUlnS7LzuV5KiCbstLHTySGffy2kevGY+4cQ6753eOyxQ6yvp5MpzXAT/XVFD2gTY23CvrmPMXeBwIqfo7U8snoueXoPEUzuGlgk6fRKFjx+OjEy0moMBAK5tJvr+/74vPA82VRjihP7Fhi+ORJpZ2Vjn7RbQ4gdWkWzObMS0PR5R+xnlN+VdFbY4wgEhqwEbSEAAQhAAAIQgMAGCfR5+NugeQwFAQhAAAIQgAAERiOAQGAn2lyBgJ1tTgVwUGSFuvpLEQm4aztl/HL97xuEBtsuEPCzuh2IJ0QY+wSw+X8m8vm2CgRip3x/EhzpH265a+QIBB4t6dTR7kB5Hf+ZpGfUHEwIBPIYPkTSayJNPhdSDNjRUbK0hbWOpcOw4MonnO1k8V53Wgqf7L9p5ej6pUowdKCkKwdRQCw1Rck55PRlQdeRkpyyoV5s9/VzOttw3X0q1r7OYoI3pwn52w3Z5H3oNCneI0spSxEIrHg6fcbtwqlypz0qdS1ZEPk2Sa8KUW76RgdBIDB853tNHfHj4ZGufJ3dqzqt71PymyiOzHKNMJBFAo7m5egtsbJJkUDf551XB5HqD9Ym0bZ3HVHM6ZY2WW5b/V7x/aleSgj0NjkPxoIABCAAAQhAAALFCSAQKI6UDiEAAQhAAAIQWAiB2Mvsfw1Ogr4vdZcw/aYc4V0O/fV5deVydd0mh2adjcPEvzOceO3itv7S3Y4Tp4DYdoFAl4jijVWkhWNanEjbKBBoO+WbEuI8RyAw5ERdfT9/ay2M/D+u5TC3yMN/XzkC/yukNPD1s16+Xp1Cv4uk9bzECAS67hqXfm4HgZ3XDqPfVN5aiZGcyqPNIev7nh3z308c1k5+pzRweoim8lFJh63197RQP7H7WVazSMfXzbkN1jWltpnlJGZgVG7KlRmYvGgT/L3ilBp+LrxbuNc653oslYwjA/ie7OcQX8eO7vIxSZ/KSCGwaGALMN6pgd4U0gQ1mevvXt9/vW6xYhGJozj5TxenHnK/Fmq5WCjrPWMR1+rvFp2sQvH3SdVSt2UTIgHb7+dJp7tJLRYEOEKYxbv1CFZd4pbUMcauh0BgbML0DwEIQAACEIDA7AkgEJj9EmEgBCAAAQhAAAIjEeg67TbSsLPtNlUg0BWu1RP0y/K7rzlB2yZ9i3Dazrnec4rzZvtlbdOpv69VL30PTxw/Z8x6Xb84jtntE78XVQ7Jl/c8BeoXz3ZaHhIxsO9p+SHzHbNtqkPMp5Adrt2O2no5OrzkbrMzRyDgNfxgcBKt9+m9Z8eQ99m/hPX9ZHD0+kSiRUYurtdHaOSTzM5Xvb63HEnjYTVnxjYLBPaV5P980vA7LWlGuvakHTvOLe3IAddqqezc1L5W28r1JH0kiAyc/9uOpQuDg9DCjvXisP7u82otHT62FqHCJ1lP65rQxJ+v9r5zdd8pkrYgJlxCIJC+eKn3w/QeqQmB3UHAIjBH2/H9t6040pCd7+sOfTvKYyKyKemNLRK4dRB1xaKn1OduYe+xVaqOr0SgIBCYcrcwNgQgAAEIQAACEMgggEAgAxZVIQABCEAAAhDYKgIIBHYuZ4pAwM62p7SEvHePPll3RIgMkLph7ER7WZX/+6GpDRZSL8Vh3TSVlAgNrwwvwJcUgtpzjUU1SHGI+aWzQzfb4VsvHw+hgu1Mbis5AgGfALcT1Kf27ej/bkOai7G24rOqU3nPDA7pPwjO6PVTev4d99qQ93fdhhSOscgbdsY7/O/Q4vW5UUMnOaf16vfn1YldCzAsxrgknNb95to4vhYsznAYe99T7KR3WgGfBG4rXw2pOi7oqHfV4MD/zaGAIiKq3whOGo8zRfGJaPM0X19HjmzxjcD0h0EUs7LLjjSLLhx1oV5i4iUEAumrmnIdp/dGTQhsP4FfDd+Zjqq0jWUskYCfN/+6JQ3DOktH8npSFW3jlA7RHgKBbdyBzAkCEIAABCAAga0kgEBgK5eVSUEAAhCAAAQgkEAAgcBOSF0CgRRxgHt8SQipXQ852rUkfi51aF+/qPSL3qUXn7C9syQ7H3OKOTy5ykF+YksjO0kPDk7GnL7nULevQKCLS/00dmyuOQKBKXn5tLtfssdy9Tof/T80nHZMCZUfEwg4l7CjFAwtMUdwjkDA87eT9JZDjUlon5IOZdVNCSd3TEQ11pxX4gqf9nTECwtezq+c+45K4dQXfYUv9wyCiaZ3CnYgHVcLPV2CXcJybkUVBAJbsYxMYoMEDpJ0VogstcFhNzqU79v3lvT5gqM+sXrWeGFCf/6+eFD4DumqjkCgixCfQwACEIAABCAAgZkQQCAwk4XADAhAAAIQgAAENk4AgcBO5G0CgZS0Au7tfSGHaWqO7qZF96ntR1Y5Xe20awvPvfENkzlgk4MspQvngH1zJHT3qr1zlT+/Ie9rSv9T1+krELi9pDMkNYXATY0e4LnPUSCwynNs+7rC6fv3269LsrN1/4bFdCSO4zsWeQkCgT45kfvsbTs9HPEgFiq53qevvef2GWitjfmf1HD9Ol+1BR5Oj5Ja2pz/jgbQtZ9Sx2mq5zQoviad9qNemkRMCATSaSMQSGdFTQiYgL8zTq3SBjxi4Tgsrm17T3te+M6yCLVESXnmfJWkx4W0WSljIhBIoUQdCEAAAhCAAAQgMAMCCARmsAiYAAEIQAACEIDAJAQQCOzE3iYQ6Dq97Z7+U9JhtRzpQxbWogS/uHSo9V8b0tEEbf2C106+0zPH9gm4s8OL7ljTEiKMTLOKVu8jEHDud4e+v3nEEocUdrj9lDJHgUAsdP0q3/v6vK5ZOZev0jJRh9R/XQeIJQgEPAU74u2QH6v0uWc9OGOv1e22M//xITxzLMJKfc7rYf8tYvh0gZP/JXnaaWRRSlN5drh/rz6z465JTFDSnm3py05Ac3VqEwoEIJBGYA7P9evf207TskqDs4rc4plYQOV0OC5OyeIoLqvvhDYx5IpCSZGAhRW+1zymAbFTCliw63QyOVHB2gQC95H0rrTlLFYr9syTE9WomDF0BAEIQAACEIAABOZEAIHAnFYDWyAAAQhAAAIQ2CSB2ItEv7Tz6fVtfjHvE8Z2Rq+XrhQDdtjb8fjAhkWy4+vIcPp1jDXcJ4RVPbpyoN+lchzaljkXn0p2CoALM430vJ4e8ug2Ne3j0Mw0YfTqfQQC5uKIDI9qsO7dYe9dnGj5HAUCNv2lISR74jQaqzmdha/rCzo6WYpAYIgzvovjFyU9QNKnuirWPr9XCKuf2UwfCSdbP9fR0I4VC0bsZFrCd9CNJZ0rad+Gef2vKp2BBSsX5cKiPgQgAIEeBPx+88+DEKtH8180sWP8G+Fv/xZSsviv/r5YOfz9nOcILS6l79cpIoFzwnfYyoYh8927Em+9R9IBa514fvfrmc4AgcCQ1aAtBCAAAQhAAAIQ2CABBAIbhM1QEIAABCAAAQjMikBMILAbQvs2hXruEgh48W4YTnLvV1vJWMjssRbcYeZvVgkWbIdPpDo0t8ttJP1Ky6Cud+2xjFrr1+FYfy/zxNWquZ3hdhbXT3ONLcLYAJb/P4QdiXdsGMwn6j4g6acRQxzO3OHXD1n73Hv27pI+mmH8XAUCJZzhT6qcyy9KYLEUgcChks7sCLecMN0dVSwkOSFcYz/IbVy1cwSH35d0g7W2Tfcd780PSnp/uGfmioV6mDZJE79P8OnTY9dG92lTR0JYnZCdxDAGhQAEdiWBm1bPBf8g6Zdrs/+WpA9J+lqVauiTkpwK678qJ/i/hFP89ZP8U8NrC/1vAYOfGf6u53Nm09z8LO0IVleunqXfFgSZjmzQpyAQ6EONNhCAAAQgAAEIQGACAggEJoDOkBCAAAQgAAEIzIIAAoGdy5AiEHCLB1Uh/9+w5rTbtDhgFptnZCOaTszDWbpRdULeKRZuEvj3YTJXgYBP7lmcdKWee8vCgKdWESjsOOgqYwsEYqHk3x5OKXbZt/rc6/0ESXY2+H5t5/yq+N+ukdCRhTXnB8eHBSZ22KcwSuiaKoGABT92KL26ci69YO1ULYAgAAEITEHA33EWgtmB/j+riE4+bb+EiCx1Vk0iAUeSciSvswqD9bvhPwyCW9/Hh3xPIhAovDh0BwEIQAACEIAABMYigEBgLLL0CwEIQAACEIDA3AkgENi5QqkCATuv/1rSw8Np5VSn5Nz3w9zsWz8xf2qVo9ZpIYa8sJ3b/Pras3phbkev/9+nAHPKXAUCTqPh040r8UPqnE6vKj5L0scyThKuwtjXx/DpejsfKBDIIeB3CntIuiSnEXUhAAEIjETAz6m+LzkqwJKL5/DkSjh4YpjElyXdp0dqnE0zQCCwaeKMBwEIQAACEIAABHoSQCDQExzNIAABCEAAAhBYPIHV6dT6id3zQsjkJZ42Sl0UhxK9fq2ync/OJZ0SUvQW4SXli3FapyLvVc8pHezQfjmcf8Hv8pUT+w8kvUXSl3pQ3T+EiF9v6j3//Imd4/5d5hPyeybOyc5Y5x7GKZsIjGoQgAAEIACBhRFYRZS6UyUM+B1J/74A+53O67iQBqxu7l9OIHC4l6QjGrjlRjVaAHpMhAAEIAABCEAAAnkEEAjk8aI2BCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIGxCWxLRISxOdE/BCAAAQhAAAIQgEAmAQQCmcCoDgEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEFgiAQQCS1w1bIYABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhkEkAgkAmM6hCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIElEkAgsMRVw2YIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIBAJgEEApnAqA4BCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhBYIgEEAktcNWyGAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIZBJAIJAJjOoQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIACBJRJAILDEVcNmCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAQCYBBAKZwKgOAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQWCIBBAJLXDVshgAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCGQSQCCQCYzqEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgSUSQCCwxFXDZghAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgEAmAQQCmcCoDgEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEFgiAQQCS1w1bIYABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhkEkAgkAmM6hCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIElEkAgsMRVw2YIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIBAJgEEApnAqA4BCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhBYIgEEAktcNWyGAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIZBJAIJAJjOoQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIACBJRJAILDEVcNmCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAQCYBBAKZwKgOAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQWCIBBAJLXDVshgAEIAABCEAAAhCA3bjALAAAAIVJREFUAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCGQSQCCQCYzqEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgSUSQCCwxFXDZghAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgEAmgf8HL7QJ0hl4zpMAAAAASUVORK5CYII="/></switch></g></g></g><g data-cell-id="brokerio"><g><rect x="863" y="658" width="540" height="110" fill="#e8f4ef" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(232, 244, 239), rgb(21, 32, 27)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 514px; height: 1px; padding-top: 713px; margin-left: 876px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Broker 内的 DeviceManager / Driver<br />共享 PSU / CAN / RS485 / PLC</div></div></div></foreignObject><image x="876" y="689.5" width="514" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="e6"><g><path d="M 373 568 L 373 647.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 373 655.76 L 369 647.76 L 377 647.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="e7"><g><path d="M 1133 568 L 1133 647.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 1133 655.76 L 1129 647.76 L 1137 647.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="legend"><g><rect x="13" y="803" width="1480" height="55" fill="#ffffff" stroke="none" pointer-events="all" style="fill: light-dark(rgb(255, 255, 255), rgb(18, 18, 18));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1454px; height: 1px; padding-top: 831px; margin-left: 26px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 18px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">实线：调用 / I/O 路径　　灰色虚线：配置依赖　　TTL 到期 → 隔离核查；连接确认退出后才交接</div></div></div></foreignObject><image x="26" y="820.5" width="1454" height="26.5" xlink:href="data:image/png;base64,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"/></switch></g></g></g></g></g></g><switch><g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/><a transform="translate(0,-5)" xlink:href="https://www.drawio.com/doc/faq/svg-export-text-problems" target="_blank"><text text-anchor="middle" font-size="10px" x="50%" y="100%">Text is not SVG - cannot display</text></a></switch></svg>"><figcaption>图 1　统一入口下的两条 I/O è·¯å¾„；整图为 V3.0 ç›®æ ‡è®¾è®¡ã€‚</figcaption></figure><div class="table-wrap"><table><thead><tr><th>模块</th><th>职责</th><th>明确边界</th></tr></thead><tbody><tr><td>RunService / RecipeScheduler</td><td>创建 DUTExecution；异步等待；组织步骤、资源集合和恢复策略</td><td>不持有物理连接、不直接引用厂家 SDK</td></tr><tr><td>DeviceService / ResourceRouter</td><td>逻辑能力解析、权限与快照检查、路由、结构化错误</td><td>不根据网络故障自动切换 Local/Broker</td></tr><tr><td>Local ResourceManager / LocalExecutor</td><td>同机 arb.db é¢„约；命名 Mutex è¿žæŽ¥å®ˆå«ï¼›ä¼šè¯é˜Ÿåˆ—与直连驱动</td><td>只控制配置分配给本进程的会话；TTL è¿‡æœŸä¸å¼ºæŠ¢</td></tr><tr><td>BrokerClient / LeaseAuthorityClient</td><td>命名管道请求、响应关联、事件订阅、断线查询</td><td>无真实驱动，不把客户端 UI çŠ¶æ€å½“授权</td></tr><tr><td>DeviceBroker</td><td>本域授权、任务调度、会话串行、驱动生命周期、遥测分发</td><td>不替代 Recipe、MES æˆ–全平台全局锁服务</td></tr><tr><td>DeviceManager / Driver</td><td>依配置实例化、连接、自检、重连、协议解析和读回</td><td>不决定谁有生产/维护权限</td></tr><tr><td>ConfigurationService</td><td>草稿/发布/生效、拓扑冲突检查、版本分发</td><td>运行中的快照不可热覆盖</td></tr><tr><td>Supervisor / RecoveryCoordinator</td><td>宿主存活检查、隔离、设备核对、人工恢复许可</td><td>拉起进程不自动恢复输出</td></tr></tbody></table></div><p>ResourceManager ä¸Ž DeviceManager äº’不直接依赖，由应用协调器组合。Broker å†…也采用同样边界，所有物理写入只能从 Dispatcher ç» SessionGate åˆ° Driver。监控读取缓存快照，不额外建立同一设备连接。</p></section><section id="routing"><h2>04　Local / Broker é€‰æ‹©ã€èµ„源键与粒度</h2><div class="table-wrap"><table><thead><tr><th>设备/行为</th><th>推荐路径</th><th>授权资源粒度</th><th>物理串行粒度</th></tr></thead><tbody><tr><td>独立单通道 TCP ç”µæºï¼Œä»…单 Worker ä½¿ç”¨</td><td>Local；若要跨进程维护则经原宿主代理或停机交接</td><td>psu/PSU001/ch/1 + parent permit</td><td>PSU001/session/main</td></tr><tr><td>8 é€šé“电源，共同 SCPI/串口会话</td><td>Broker</td><td>每输出通道独占；整机 reset å– parent exclusive</td><td>整机 SessionKey</td></tr><tr><td>CAN/CAN-FD å¡ï¼Œå¤šä¸ª DUT å…±ç”¨æŽ¥æ”¶</td><td>Broker</td><td>bus permit + å‘送规则；UDS æŒ‰ bus/address/session æŽ’ä»–</td><td>SDK çº¿ç¨‹å®‰å…¨åŸŸï¼›UDS ä¼šè¯é˜Ÿåˆ—</td></tr><tr><td>RS485 å¤šåœ°å€æ€»çº¿</td><td>Broker</td><td>站地址/功能；广播命令取 bus exclusive</td><td>物理串口 SessionKey</td></tr><tr><td>温箱、PLC æ¸©åº¦/联锁</td><td>Broker å•ä¸€é…æ–¹æŽ§åˆ¶è€…</td><td>chamber æŽ§åˆ¶æƒæŒ‰ Run/group；各 DUT ä»…订阅</td><td>PLC/温箱真实连接</td></tr><tr><td>共享 DMM + ç»§ç”µå™¨çŸ©é˜µ</td><td>Broker åŽŸå­ä»»åŠ¡</td><td>DMM + Matrix è·¯ç”±ç»„合</td><td>切换→稳定→测量→释放片段</td></tr><tr><td>模拟设备</td><td>Local æˆ–仿真 Broker</td><td>沿用真实资源键与策略</td><td>仿真注入队列与故障</td></tr></tbody></table></div><h3>4.1 ä¸‰ç±»é”®</h3><p><b>ResourceKey</b> è¡¨ç¤ºä¸šåŠ¡å¯æŽˆäºˆçš„权利；<b>PhysicalSessionKey</b> è¡¨ç¤ºå¿…须串行化的真实连接；<b>AuthorityId</b> è¡¨ç¤ºç­¾å‘与校验租约的唯一主体。地址别名必须规范化为同一物理身份，例如串口号+设备序列号、IP/端口+仪器序列号、CAN é€‚配器序列号+通道；不能仅用工程师自定义 DeviceId é˜²é‡ã€‚</p>
<p>本版本 ResourceKey ç»Ÿä¸€å°å†™ã€å›ºå®šåˆ†éš”符并使用 Ordinal æŽ’序；配置保存时完成规范化。多通道 SessionGate å†…必须把“选择通道 + å†™å…¥/查询 + è¯»å–响应”视为不可拆分片段，避免两个穴位选错通道。</p>
<h3>4.2 çˆ¶å­èµ„源冲突</h3><p>每个通道持有独占通道令牌及父设备的共享 Permit。整机 reset、断连、改通信参数、维护接线需要父设备独占，必须等待所有 Permit å½’还。父 Permit ä¹Ÿè¿›å…¥ç§Ÿçº¦é›†åˆå’ŒæŒä¹…化表，不能仅锁一个字符串前缀。V3.0 çš„ DDL ç»™å‡ºæŽ’他叶资源基线；父共享 Permit ä½¿ç”¨åº”用层在同一 BEGIN IMMEDIATE å†…检查/更新的 <code>parent_permit</code> è¡¨å®žçŽ°ï¼Œä¸ä½¿ç”¨ SQLite çš„行级锁假设。</p>
<p>è·¨ Authority çš„多资源组采用协调式预留：Prepare（有期限、不可 I/O）→全部准备成功→Activate；任一步失败则 Abort。发生协调器崩溃时全部按预留期限失效进入检查。它不能宣称跨库原子事务；要求严格全有全无的动作必须将资源放入同一 Broker åŸŸï¼Œæˆ–将整组动作作为一个 Broker Task。禁止持有域 A çš„运行租约无限等待域 B。</p></section><section id="configuration"><h2>05　工程师配置与发布工作流</h2>
<p>沿用 DeviceConfigView、DeviceDebugView、DeviceMonitorView åˆ†å·¥ã€‚配置工程师编辑草稿，维护工程师申请维护会话，操作员启动生产。管理员发布权限不自动授予设备写权限。以下为配置工作台字段定义，不代表当前 UI å·²å®žçŽ°ã€‚</p>
<div class="table-wrap"><table><thead><tr><th>配置页</th><th>关键字段</th><th>校验与反馈</th></tr></thead><tbody><tr><td>设备注册</td><td>DeviceId、Kind、DriverType/Version/Hash、Transport、EndpointRef、PhysicalIdentity、HostId</td><td>驱动能力、位数、地址/物理身份去重；凭据只保存引用</td></tr><tr><td>执行位置</td><td>ExecutionMode=Local/Broker、AuthorityId、BrokerId/OwnerProcessId、PhysicalSessionKey</td><td>同一会话只能有一个宿主；BrokerId ä¸Žè®¾å¤‡åŸŸä¸€è‡´</td></tr><tr><td>通道与资源</td><td>ChannelId、Capabilities、ResourceKey、ParentKey、AccessPolicy、ConflictDomain</td><td>通道唯一；整机动作与通道动作冲突展开完整</td></tr><tr><td>穴位绑定</td><td>SlotId、Capability、DeviceId、ChannelId、GroupId、MappingVersion</td><td>120 ç©´ä½èƒ½åŠ›è¦†ç›–，无缺失/重复功率通道；共享映射须显式标注</td></tr><tr><td>Broker Task æ¨¡æ¿</td><td>TemplateId/Version、OpCode ç™½åå•ã€å‘¨æœŸã€deadline、SafeStateProfile、订阅规则</td><td>禁止任意 C# / è„šæœ¬æ‰§è¡Œï¼›å‘¨æœŸèƒ½åŠ›ä¸Žåè®®/看门狗匹配</td></tr><tr><td>仲裁与恢复</td><td>TTL、RenewInterval、WaitTimeout、MaxTaskTime、HandoverTimeout、RecoveryProfile</td><td>Renew â‰¤ TTL/3；运行超时不能直接触发新 owner；安全配置需审核</td></tr><tr><td>发布预览</td><td>变更差异、受影响穴位/Run、Hash、验证报告、审批人</td><td>运行中影响连接/输出/映射的变更禁止直接 Apply</td></tr></tbody></table></div><h3>5.1 æ‰¹é‡ç”Ÿæˆ 120 ç©´ä½</h3><ol><li>选择拓扑模板：“120×1 TCP”或“15×8 å¤šé€šé“”；设置地址规则、穴位范围和设备编号前缀。</li><li>生成草稿和映射预览，显示全部 120 æ¡æ˜ å°„；单点覆盖保留来源与差异。</li><li>离线校验身份冲突、能力、限值、Broker åŸŸå’Œé©±åŠ¨ä¾èµ–；通过后申请维护窗口执行连接探测、通道寻址和读回。</li><li>发布不可变 ConfigVersion；分发到各宿主 Prepare å¹¶ç¡®è®¤åŒä¸€ Hash。</li><li>停止受影响 Run，撤销写权限，安全断连；各宿主 Apply å¹¶è‡ªæ£€ã€‚全部成功后才更新 Effective æŒ‡é’ˆï¼›å¤±è´¥ä¿æŒåœç”¨å¹¶æŒ‰ä¸Šä¸€ç‰ˆé…ç½®æ¢å¤ã€‚</li><li>创建新 Run æ—¶å¤åˆ¶ç”Ÿæ•ˆå¿«ç…§ï¼›æ—¢æœ‰ Run ç»§ç»­å¼•ç”¨åŽŸ Hash，不允许静默切版。</li></ol>
<h3>5.2 é…ç½®çŠ¶æ€ä¸Žå¤±è´¥å¤„理</h3><p>Draft â†’ Validated â†’ Published â†’ Prepared â†’ Effective â†’ Retired。Published å†…容不可修改，回滚也建立新的生效记录。多 Broker ç”Ÿæ•ˆé‡‡ç”¨åœæœºçª—口中的两阶段分发和最终确认；它不是跨机器数据库事务。若部分宿主 Apply æˆåŠŸã€éƒ¨åˆ†å¤±è´¥ï¼Œæ•´ç»„标记 <code>ApplyFailed</code>，阻止 Run å¯åŠ¨ï¼Œç›´è‡³æ‰€æœ‰å®¿ä¸»ç»Ÿä¸€åˆ°æ—§ç‰ˆæˆ–新版并完成读回。</p></section><section id="config-example"><h2>06　配置契约与启动校验</h2><div class="codebar"><span>JSON / é…ç½®ç¤ºä¾‹</span><button class="copy">复制</button></div><pre><code>{
  &quot;schemaVersion&quot;: 3,
  &quot;configVersion&quot;: &quot;CFG-20261103-001&quot;,
  &quot;topology&quot;: &quot;15x8&quot;, &quot;slotCount&quot;: 120,
  &quot;authorities&quot;: [
    {&quot;id&quot;:&quot;broker-b01&quot;, &quot;host&quot;:&quot;IPC-01&quot;, &quot;pipe&quot;:&quot;aging.b01.v3&quot;},
    {&quot;id&quot;:&quot;local-ipc01&quot;, &quot;host&quot;:&quot;IPC-01&quot;, &quot;db&quot;:&quot;arb.db&quot;}
  ],
  &quot;devices&quot;: [{
    &quot;deviceId&quot;:&quot;PSU01&quot;, &quot;executionMode&quot;:&quot;Broker&quot;,
    &quot;authorityId&quot;:&quot;broker-b01&quot;, &quot;sessionKey&quot;:&quot;psu01/main&quot;,
    &quot;physicalIdentity&quot;:&quot;serial:TBD-PSU01&quot;,
    &quot;driver&quot;:{&quot;type&quot;:&quot;MultiChannelScpi&quot;, &quot;version&quot;:&quot;TBD&quot;, &quot;sha256&quot;:&quot;TBD&quot;},
    &quot;endpointRef&quot;:&quot;endpoint/psu01&quot;, &quot;channels&quot;:8,
    &quot;accessPolicy&quot;:&quot;ExclusiveChannelWithParentPermit&quot;,
    &quot;safeStateProfile&quot;:&quot;PSU-SAFE-001&quot;
  }],
  &quot;bindings&quot;: [{&quot;slotId&quot;:&quot;S001&quot;, &quot;capability&quot;:&quot;Power&quot;,
    &quot;deviceId&quot;:&quot;PSU01&quot;, &quot;channelId&quot;:1, &quot;resourceKey&quot;:&quot;psu/psu01/ch/1&quot;}],
  &quot;leasePolicy&quot;:{&quot;ttlMs&quot;:30000,&quot;renewMs&quot;:8000,&quot;handoverMs&quot;:30000},
  &quot;taskPolicy&quot;:{&quot;maxQueuedPerSession&quot;:128,&quot;defaultDeadlineMs&quot;:5000},
  &quot;note&quot;:&quot;字段示例，仅列一个设备和一个穴位；完整120映射见第17章。&quot;
}</code></pre><p>JSON é‡‡ç”¨å›ºå®šåºåˆ—化规则（UTF-8、稳定字段/数组排序、排除自身 Hash å­—段）计算 SHA256。Secrets、运行状态、当前租约不得进入可迁移明文配置。Schema æ ¡éªŒå’Œè¯­ä¹‰æ ¡éªŒåˆ†åˆ«è¾“出字段路径、错误码、影响穴位与建议处理。</p>
<p>启动顺序：读取有效版本 â†’ æ ¡éªŒ manifest/包 Hash ä¸Žé©±åŠ¨ä½æ•° â†’ æ£€æŸ¥ Authority å”¯ä¸€å®žä¾‹å’Œ epoch â†’ æ‰“开数据库并迁移 â†’ åŠ è½½è®¾å¤‡èº«ä»½ä¸Žè¿žæŽ¥å®ˆå« â†’ è¿›å…¥ Recovering â†’ æ‰§è¡Œæ— è¾“出连接探测/状态读回 â†’ æ ‡è®°è®¾å¤‡ Ready â†’ å‘布 HostReady。Run å¯åŠ¨æ—¶è¦æ±‚所有绑定资源 Ready，且宿主回报的配置 Hash ä¸Ž RunSnapshot å®Œå…¨ä¸€è‡´ã€‚示例中的 TBD ä¸å…è®¸é€šè¿‡ç”Ÿäº§å‘布门禁。</p></section><section id="database"><h2>07　数据库边界、实体与一致性</h2><div class="table-wrap"><table><thead><tr><th>库</th><th>唯一写入责任</th><th>主要内容</th><th>一致性边界</th></tr></thead><tbody><tr><td>aging_system.db / config.db</td><td>ConfigurationService / RunService</td><td>不可变配置、Run å¿«ç…§ã€ç‰ˆæœ¬ç´¢å¼•ã€ç”¨æˆ·/审计、结果归档索引</td><td>配置发布与 Run èµ·å§‹è®°å½•éœ€äº‹åŠ¡ï¼›é‡‡æ ·ä¸æ··å…¥é…ç½®åº“</td></tr><tr><td>arb.db（同机 Local）</td><td>受控 Local Lease Store；多进程短事务</td><td>排他资源状态、父 Permit、进程身份、租约历史</td><td>仅同一主机本地磁盘；PhysicalSessionKey Mutex å¦è¡Œå®ˆå«</td></tr><tr><td>broker-b01.db ç­‰</td><td>各 Broker å•ä¸€å†™å…¥å™¨</td><td>本域 fence、任务日志、事件、结果 Outbox、恢复检查点</td><td>每个 Broker ä¸€ä¸ª Authority；其他进程只走 IPC</td></tr><tr><td>每 Run aging_data.db</td><td>ResultWriter</td><td>样本、信号、步骤结果、质量和时间戳</td><td>批量写入，独立背压；通过 RunId / DUTExecutionId å…³è”</td></tr></tbody></table></div><p>SQLite ä½¿ç”¨æœ¬æœºç£ç›˜ï¼›ç¦æ­¢æ”¾åœ¨ SMB/NAS ä¸Šè®©å¤šæœºåŒæ—¶å†™ WAL。所有连接显式设置 foreign_keys、busy_timeout；WAL åªå…è®¸ä¸€ä¸ªåŒæ—¶å†™äº‹åŠ¡ï¼Œå¿…须缩短事务并避免在事务内执行 I/O。启用 WAL ä¸ç­‰äºŽä»»æ„å†™å¹¶å‘，也不等于无限吞吐。跨机扩展经 Broker æœåŠ¡é€šä¿¡ï¼Œä¸èƒ½å…±äº«åŒä¸€ä¸ª arb.db æ–‡ä»¶ã€‚[E1][E2]</p>
<p>关联关系：ConfigSnapshot 1:N Device / Resource / Binding / TaskTemplate；RunSnapshot å¼•ç”¨ Config Hash；ResourceState 1:N LeaseHistory；BrokerTask å¼•ç”¨ Config Hash å¹¶åœ¨è¯·æ±‚ JSON ä¸­æºå¸¦å®Œæ•´ grant é›†ï¼›Task 1:N Event，Task 1:1 ResultOutbox。历史日志保留资源名和快照 Hash，不能被修改后的当前配置反向解释。</p>
<p>UTC æ¯«ç§’用于审计，宿主的单调时钟用于活跃租约和 deadline åˆ¤å®šã€‚epoch + boot identity é˜²æ­¢é‡å¯åŽæ²¿ç”¨æ—§å•è°ƒæ—¶é’Ÿï¼›æœ¬åœ°ç³»ç»Ÿæ—¶é—´è·³å˜æ—¶åœæ­¢ç»­ç§Ÿ/交接并进入恢复检查。SQLite datetime('now') ä¸æ˜¯ç‹¬ç«‹å¯ä¿¡æ—¶é’Ÿã€‚</p></section><section id="ddl"><h2>08　SQLite DDL ä¸Žç§Ÿçº¦äº‹åŠ¡</h2><p>以下两段 DDL åˆ†åˆ«ç”¨äºŽé…ç½®åº“和每个仲裁域的运行库。它们是新增 V3 schema，不直接对现有 data.db æ‰§è¡Œ DROP/覆盖。迁移程序维护 schema_version、备份和回滚标记；生产迁移必须在停机窗口完成。</p><div class="codebar"><span>SQL Â· é…ç½®åº“</span><button class="copy">复制</button></div><pre><code>PRAGMA foreign_keys=ON;
PRAGMA journal_mode=WAL;
PRAGMA synchronous=FULL;
PRAGMA busy_timeout=3000;
CREATE TABLE config_snapshot (
  config_hash TEXT PRIMARY KEY, version_id TEXT NOT NULL UNIQUE,
  schema_version INTEGER NOT NULL CHECK(schema_version=3),
  content_json TEXT NOT NULL, author TEXT NOT NULL,
  published_utc_ms INTEGER NOT NULL
);
CREATE TABLE effective_config (
  scope_id TEXT PRIMARY KEY, config_hash TEXT NOT NULL
    REFERENCES config_snapshot(config_hash), revision INTEGER NOT NULL
);
CREATE TABLE resource_definition (
  config_hash TEXT NOT NULL REFERENCES config_snapshot(config_hash),
  resource_key TEXT NOT NULL, device_id TEXT NOT NULL, channel_id INTEGER NOT NULL,
  parent_key TEXT, session_key TEXT NOT NULL, physical_identity TEXT NOT NULL,
  execution_mode TEXT NOT NULL CHECK(execution_mode IN (&#x27;Local&#x27;,&#x27;Broker&#x27;)),
  authority_id TEXT NOT NULL, owner_process_id TEXT,
  access_policy TEXT NOT NULL, safe_profile TEXT NOT NULL,
  PRIMARY KEY(config_hash, resource_key)
);
CREATE TABLE slot_binding (
  config_hash TEXT NOT NULL, slot_id TEXT NOT NULL, capability TEXT NOT NULL,
  resource_key TEXT NOT NULL, group_id TEXT NOT NULL,
  PRIMARY KEY(config_hash, slot_id, capability),
  FOREIGN KEY(config_hash, resource_key)
    REFERENCES resource_definition(config_hash, resource_key)
);
CREATE INDEX ix_binding_resource ON slot_binding(config_hash, resource_key);
CREATE TABLE broker_task_template (
  config_hash TEXT NOT NULL REFERENCES config_snapshot(config_hash),
  template_id TEXT NOT NULL, template_version TEXT NOT NULL,
  operation_code TEXT NOT NULL, parameters_schema TEXT NOT NULL,
  required_resources_json TEXT NOT NULL, max_duration_ms INTEGER NOT NULL,
  safe_profile TEXT NOT NULL,
  PRIMARY KEY(config_hash,template_id,template_version)
);
CREATE TABLE run_snapshot (
  run_id TEXT PRIMARY KEY, config_hash TEXT NOT NULL
    REFERENCES config_snapshot(config_hash), recipe_hash TEXT NOT NULL,
  driver_manifest_hash TEXT NOT NULL, dbc_hash TEXT NOT NULL,
  uds_hash TEXT NOT NULL, slot_set_json TEXT NOT NULL, started_utc_ms INTEGER NOT NULL
);
CREATE TABLE config_apply_ack (
  apply_id TEXT NOT NULL, authority_id TEXT NOT NULL,
  config_hash TEXT NOT NULL REFERENCES config_snapshot(config_hash),
  phase TEXT NOT NULL, readback_json TEXT NOT NULL, utc_ms INTEGER NOT NULL,
  PRIMARY KEY(apply_id,authority_id)
);</code></pre><div class="codebar"><span>SQL Â· è¿è¡Œåº“</span><button class="copy">复制</button></div><pre><code>PRAGMA foreign_keys=ON;
PRAGMA journal_mode=WAL;
PRAGMA synchronous=FULL;
PRAGMA busy_timeout=3000;
CREATE TABLE authority_meta (
  authority_id TEXT PRIMARY KEY, epoch INTEGER NOT NULL,
  boot_id TEXT NOT NULL, schema_version INTEGER NOT NULL
);
CREATE TABLE resource_state (
  resource_key TEXT PRIMARY KEY, generation INTEGER NOT NULL DEFAULT 0,
  phase TEXT NOT NULL CHECK(phase IN (&#x27;Free&#x27;,&#x27;Active&#x27;,&#x27;Draining&#x27;,&#x27;RecoveryRequired&#x27;,&#x27;Disabled&#x27;)),
  lease_id TEXT UNIQUE, owner_id TEXT, owner_type TEXT, group_id TEXT,
  process_instance_id TEXT, epoch INTEGER NOT NULL,
  expires_utc_ms INTEGER, handover_utc_ms INTEGER, updated_utc_ms INTEGER NOT NULL,
  CHECK(phase &lt;&gt; &#x27;Free&#x27; OR lease_id IS NULL)
);
CREATE INDEX ix_resource_expiry ON resource_state(phase,expires_utc_ms);
CREATE TABLE parent_permit (
  parent_key TEXT NOT NULL, lease_id TEXT NOT NULL,
  mode TEXT NOT NULL CHECK(mode IN (&#x27;Shared&#x27;,&#x27;Exclusive&#x27;)),
  owner_id TEXT NOT NULL, epoch INTEGER NOT NULL,
  expires_utc_ms INTEGER NOT NULL,
  PRIMARY KEY(parent_key,lease_id)
);
CREATE TABLE lease_history (
  event_id INTEGER PRIMARY KEY AUTOINCREMENT, resource_key TEXT NOT NULL,
  generation INTEGER NOT NULL, epoch INTEGER NOT NULL, lease_id TEXT,
  owner_id TEXT, event_type TEXT NOT NULL, reason TEXT NOT NULL, utc_ms INTEGER NOT NULL
);
CREATE TABLE broker_task (
  task_id TEXT PRIMARY KEY, client_instance_id TEXT NOT NULL,
  idempotency_key TEXT NOT NULL, payload_sha256 TEXT NOT NULL,
  config_hash TEXT NOT NULL, epoch INTEGER NOT NULL,
  template_id TEXT NOT NULL, request_json TEXT NOT NULL,
  state TEXT NOT NULL CHECK(state IN (&#x27;Accepted&#x27;,&#x27;Queued&#x27;,&#x27;Running&#x27;,&#x27;Succeeded&#x27;,
    &#x27;Failed&#x27;,&#x27;Cancelled&#x27;,&#x27;Expired&#x27;,&#x27;Unknown&#x27;,&#x27;RecoveryRequired&#x27;)),
  priority INTEGER NOT NULL, submitted_utc_ms INTEGER NOT NULL,
  deadline_utc_ms INTEGER NOT NULL, started_utc_ms INTEGER, finished_utc_ms INTEGER,
  result_json TEXT, error_code TEXT,
  UNIQUE(client_instance_id,idempotency_key)
);
CREATE INDEX ix_task_queue ON broker_task(state,priority,submitted_utc_ms);
CREATE TABLE broker_event (
  cursor INTEGER PRIMARY KEY AUTOINCREMENT, task_id TEXT,
  event_type TEXT NOT NULL, payload_json TEXT NOT NULL, utc_ms INTEGER NOT NULL
);
CREATE TABLE result_outbox (
  result_id TEXT PRIMARY KEY, task_id TEXT NOT NULL UNIQUE REFERENCES broker_task(task_id),
  payload_json TEXT NOT NULL, state TEXT NOT NULL CHECK(state IN (&#x27;Pending&#x27;,&#x27;Acked&#x27;)),
  attempt INTEGER NOT NULL DEFAULT 0, created_utc_ms INTEGER NOT NULL
);
CREATE TABLE recovery_checkpoint (
  resource_key TEXT PRIMARY KEY, epoch INTEGER NOT NULL, status TEXT NOT NULL,
  physical_readback_json TEXT NOT NULL, approved_by TEXT,
  evidence_json TEXT NOT NULL, updated_utc_ms INTEGER NOT NULL
);
CREATE TABLE operation_audit (
  audit_id INTEGER PRIMARY KEY AUTOINCREMENT, correlation_id TEXT NOT NULL,
  principal_id TEXT NOT NULL, owner_id TEXT NOT NULL, task_id TEXT,
  resource_key TEXT NOT NULL, action TEXT NOT NULL, outcome TEXT NOT NULL,
  detail_json TEXT NOT NULL, utc_ms INTEGER NOT NULL
);</code></pre><div class="codebar"><span>SQL + äº‹åŠ¡ç¼–排说明</span><button class="copy">复制</button></div><pre><code>-- å‰æï¼šè¯·æ±‚资源已展开、规范化、去重、Ordinal排序，属于同一 Authority。
-- æ¯ä¸ªå¶èµ„源必须 Free；Expired ä¸å±žäºŽ Free。父 Permit å†²çªä¹Ÿåœ¨æœ¬äº‹åŠ¡æ£€æŸ¥ã€‚
BEGIN IMMEDIATE;
-- åº”用先 SELECT å¹¶æ£€æŸ¥å…¨éƒ¨å¶èŠ‚点 + parent_permit，无跨域/缺项/冲突才继续。
SELECT resource_key, generation, phase, epoch FROM resource_state
 WHERE resource_key IN (@r1, @r2);
-- å¯¹æ¯ä¸ªå¶èµ„源执行下列参数化 UPDATE，并检查 changes() = 1。
UPDATE resource_state
 SET generation=generation+1, phase=&#x27;Active&#x27;, lease_id=@lease_id,
     owner_id=@owner_id, owner_type=@owner_type, group_id=@group_id,
     process_instance_id=@process_id, epoch=@epoch,
     expires_utc_ms=@expires, updated_utc_ms=@now
 WHERE resource_key=@resource_key AND phase=&#x27;Free&#x27; AND epoch=@epoch;
-- çˆ¶Permit冲突检查后插入；只要任一条失败，整个事务 ROLLBACK。
INSERT INTO parent_permit(parent_key,lease_id,mode,owner_id,epoch,expires_utc_ms)
 VALUES(@parent,@permit_id,&#x27;Shared&#x27;,@owner_id,@epoch,@expires);
-- åŒäº‹åŠ¡æ’å…¥ lease_history，COMMIT æˆåŠŸåŽæ‰è¿”回 Grant。
COMMIT;

-- Renew：保持 Generation ä¸å˜ï¼›ç¦æ­¢è¿‡æœŸç§Ÿçº¦å¤æ´»ã€‚
UPDATE resource_state SET expires_utc_ms=@new_expires, updated_utc_ms=@now
 WHERE resource_key=@resource_key AND lease_id=@lease_id
   AND generation=@generation AND epoch=@epoch
   AND phase=&#x27;Active&#x27; AND expires_utc_ms &gt; @now;
-- çˆ¶Permit同事务续期；组内任一项失败 =&gt; å›žæ»šç»­æœŸã€ç»„整体失效并隔离。
-- Draining ç»­æœŸèµ°ä¸“门分支，上限不得超过 handover_utc_ms。

-- TTL过期：保留Generation和owner证据，进入恢复，不直接清空或删行。
UPDATE resource_state SET phase=&#x27;RecoveryRequired&#x27;, updated_utc_ms=@now
 WHERE phase IN (&#x27;Active&#x27;,&#x27;Draining&#x27;) AND expires_utc_ms &lt;= @now;
-- åªæœ‰æ¢å¤åè°ƒå™¨è¯»å›žåˆæ ¼ã€æ—§I/O已隔离、父Permit正确归还后可变为Free。
-- æ­£å¸¸Release亦须在SessionGate内完成排空及任务清理后再置Free。</code></pre><p>初始化时为已发布资源创建 Free è¡Œï¼Œgeneration=0；删除设备也保留 fence å¢“碑。生成号永不因释放、重启或清理历史回退。恢复旧数据库备份后必须更换 Authority identity/epoch，禁止旧 token å†æ¬¡æœ‰æ•ˆã€‚SELECT ç»“果的分支与 changes() æ£€æŸ¥ç”± C# åœ¨åŒä¸€è¿žæŽ¥äº‹åŠ¡å†…实现，不使用 SQLite ä¸æ”¯æŒçš„ SELECT INTO / FOR UPDATE。[E1]</p>
<p>持续数据、任务终态、Outbox ä¸Ž Event åœ¨åŒä¸€è¿è¡Œåº“事务提交；ACK ä»…在消费者持久化成功后发送。Outbox ä¿ç•™åˆ° ACK，消费者按 ResultId å”¯ä¸€çº¦æŸåŽ»é‡ã€‚日志清理不得删除尚未 ACK、Unknown、RecoveryRequired æˆ–被 Run å¼•ç”¨çš„证据。</p></section><section id="csharp"><h2>09　C# æŽ¥å£ä¸Žå…¼å®¹è¾¹ç•Œ</h2><p>以下为 V3.0 åˆçº¦åŸºçº¿ï¼Œå¯æŠ½å‡ºä¸ºç‹¬ç«‹ç±»åº“。使用 Task å’Œæ™®é€šç±»ä»¥é€‚配当前 net472，不依赖 TimeProvider、PeriodicTimer、record æˆ–原生 await using。序列化工具应显式映射只读 LeaseGrant æž„造器。Token æ˜¯æŽˆæƒå¼•ç”¨ï¼ŒæœåŠ¡ç«¯è¿˜å¿…须校验连接身份与 owner；不能把可见 token å½“作签名凭据。</p><div class="codebar"><span>C# Â· åˆçº¦</span><button class="copy">复制</button></div><pre><code>using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace Aging.ResourceContracts.V3
{
    public enum ExecutionMode { Local, Broker }
    public enum OwnerKind { Production, Maintenance, SystemSafety }
    public enum TaskState { Accepted, Queued, Running, Succeeded, Failed,
        Cancelled, Expired, Unknown, RecoveryRequired }

    // Broker/Store签发；必须按持久化字段还原，不能在反序列化时生成新LeaseId。
    public sealed class LeaseGrant
    {
        public string AuthorityId { get; }
        public string ResourceKey { get; }
        public string LeaseId { get; }
        public string OwnerId { get; }
        public long Epoch { get; }
        public long Generation { get; }
        public long ExpiresUtcMs { get; }
        public LeaseGrant(string authorityId, string resourceKey, string leaseId,
            string ownerId, long epoch, long generation, long expiresUtcMs)
        {
            AuthorityId=authorityId; ResourceKey=resourceKey; LeaseId=leaseId;
            OwnerId=ownerId; Epoch=epoch; Generation=generation;
            ExpiresUtcMs=expiresUtcMs;
        }
    }
    public sealed class AcquireRequest
    {
        public string OwnerId { get; set; } = &quot;&quot;;
        public OwnerKind OwnerKind { get; set; }
        public string ProcessInstanceId { get; set; } = &quot;&quot;;
        public string ConfigHash { get; set; } = &quot;&quot;;
        public string[] ResourceKeys { get; set; } = new string[0];
        public int WaitTimeoutMs { get; set; }
    }
    public interface ILeaseScope
    {
        IReadOnlyList&lt;LeaseGrant&gt; Grants { get; }
        CancellationToken LeaseLost { get; }
        Task ReleaseAsync(CancellationToken cancellationToken);
    }
    public interface IResourceCoordinator
    {
        Task&lt;ILeaseScope&gt; AcquireGroupAsync(AcquireRequest request, CancellationToken ct);
        Task&lt;IReadOnlyList&lt;LeaseGrant&gt;&gt; RenewGroupAsync(
            IReadOnlyList&lt;LeaseGrant&gt; grants, CancellationToken ct);
        Task RequestHandoverAsync(string resourceKey, string reason, CancellationToken ct);
    }
    public sealed class DeviceOperation
    {
        public string OperationCode { get; set; } = &quot;&quot;;
        public string ParametersJson { get; set; } = &quot;{}&quot;;
        public string IdempotencyKey { get; set; } = &quot;&quot;;
        public string ConfigHash { get; set; } = &quot;&quot;;
        public IReadOnlyList&lt;LeaseGrant&gt; Grants { get; set; } = new LeaseGrant[0];
        public long DeadlineUtcMs { get; set; }
    }
    public sealed class OperationResult
    {
        public string RequestId { get; set; } = &quot;&quot;;
        public TaskState State { get; set; }
        public string ErrorCode { get; set; } = &quot;&quot;;
        public string ReadbackJson { get; set; } = &quot;{}&quot;;
        public bool PhysicalStateKnown { get; set; }
    }
    public interface IDeviceExecutor
    {
        Task&lt;OperationResult&gt; ExecuteAsync(DeviceOperation op, CancellationToken ct);
    }
    public sealed class BrokerTaskRequest
    {
        public string ClientInstanceId { get; set; } = &quot;&quot;;
        public string TemplateId { get; set; } = &quot;&quot;;
        public string TemplateVersion { get; set; } = &quot;&quot;;
        public DeviceOperation Operation { get; set; } = new DeviceOperation();
    }
    public sealed class BrokerTaskTicket
    {
        public string TaskId { get; set; } = &quot;&quot;;
        public TaskState State { get; set; }
    }
    public interface IDeviceBrokerClient
    {
        Task&lt;BrokerTaskTicket&gt; SubmitAsync(BrokerTaskRequest request, CancellationToken ct);
        Task&lt;OperationResult&gt; QueryAsync(string taskId, CancellationToken ct);
        Task CancelAsync(string taskId, string reason, CancellationToken ct);
        Task AckResultAsync(string resultId, CancellationToken ct);
    }
}</code></pre><div class="table-wrap"><table><thead><tr><th>现有接口/ç±»</th><th>V3.0 è¿ç§»æ–¹å¼</th><th>影响</th></tr></thead><tbody><tr><td>IResourceManager</td><td>保留旧单资源方法为过渡 Adapter；新增 IResourceCoordinator</td><td>续期、组预约与异步状态查询为新接口，业务调用需适配</td></tr><tr><td>ResourceOwnerToken</td><td>仅保留业务 owner å…ƒæ•°æ®ï¼›I/O ä½¿ç”¨æ¯èµ„源独立 LeaseGrant</td><td>一个 owner å¯æŒæœ‰å¤šä¸ªä¸åŒ generation，禁止共用可变 Generation</td></tr><tr><td>IAutoDeviceFacade / IAutoDeviceLease</td><td>LeaseScope æ³¨å…¥å¿ƒè·³ä¸Ž LeaseLost；显式异步 Release</td><td>Dispose ä¸å¾—阻塞 UI；释放失败应可查询和进入恢复</td></tr><tr><td>DeviceService</td><td>通过 SnapshotResolver + ResourceRouter è°ƒç”¨ IDeviceExecutor</td><td>已有 raw command ä»…留受控维护入口，生产用类型化 OpCode</td></tr><tr><td>DriverFactory / DeviceManager</td><td>区分宿主驱动与 BrokerProxy；Proxy ä¸åŠ è½½è®¾å¤‡ SDK</td><td>位数冲突的 SDK ç‹¬ç«‹ Broker è¿›ç¨‹ï¼ŒIPC åˆçº¦ä¿æŒä¸€è‡´</td></tr><tr><td>DebugSessionManager</td><td>保存 session、grants、handover ä¸Žæ¢å¤ç»“æžœ</td><td>不能重新构造 owner token ä»£æ›¿æ¢å¤æŒä¹…化 token；监控与写权限分开</td></tr></tbody></table></div></section><section id="execution"><h2>10　执行入口、生命周期与取消语义</h2><h3>10.1 å•æ¬¡æ“ä½œ</h3><ol><li>步骤解析 Slot/Capability，得到冻结版本下的资源集合与宿主；检查 Run / DUTExecution çŠ¶æ€ã€‚</li><li>申请组预约（或复用已有 Scope），取得叶节点和父 Permit；启动独立续期任务。</li><li>DeviceService æ ¡éªŒåŠ¨ä½œã€å‚数、限值和软件联锁，构造 OperationCode ä¸Ž IdempotencyKey。</li><li>LocalExecutor æˆ– Broker åœ¨å…¥é˜Ÿæ—¶æ ¡éªŒï¼›å‡ºé˜Ÿå¹¶æŒæœ‰ SessionGate åŽå†æ¬¡æ ¡éªŒå®Œæ•´ grant、epoch、ConfigHash、deadline ä¸Žè¿žæŽ¥èº«ä»½ã€‚</li><li>执行不可拆分的选择通道/命令/响应片段；读回核对并记录质量。联锁故障打断可中断任务，已发动作按硬件能力处理。</li><li>提交 Task ç»ˆæ€ã€äº‹ä»¶å’Œ Outbox；结果回到步骤引擎，由引擎判定步骤/产品结果。</li><li>Scope é€€å‡ºå…ˆåœæ­¢ç»­æœŸå’ŒåŽå°ä»»åŠ¡ï¼ŒæŽ’空 I/O，再读回/安全交接并释放。失败进入 RecoveryRequired，绝不仅记录日志后假装可用。</li></ol>
<h3>10.2 ä¼ªä»£ç ï¼šSessionGate ä¸Žæœ‰æ•ˆæœŸæ£€æŸ¥</h3><div class="codebar"><span>C# Â· æ‰§è¡Œç®—法</span><button class="copy">复制</button></div><pre><code>// æ‰§è¡Œç®—法示意，依赖的Store/Driver不是本文已实现代码。
using (await sessionGate.EnterAsync(sessionKey, ct))
{
    await authority.ValidateAtDispatchAsync(op.Grants, principal, ct);
    ValidateConfigAndDeadline(op);
    await safety.CheckAsync(op, ct);
    // åˆ‡æ¢é€šé“ + å†™ + è¯»å“åº”保持在同一Gate，禁止中途释放。
    await journal.MarkRunningAsync(requestId, ct);  // I/O之前持久化
    var result = await driver.ExecuteAtomicAsync(op, ioToken);
    await journal.CommitResultAndOutboxAsync(requestId, result, persistToken);
}
// æ¯ä¸ªä¸å¯é€†å­åŠ¨ä½œå‰å†æ¬¡æ ¸å¯¹lease；续期不能抢同一被长任务占用的调度队列。
// äº¤æŽ¥å…ˆå…³é—­æ–°å…¥é˜Ÿã€å–消待执行任务、等待当前原子片段终止并读回；
// æœªèƒ½ç¡®è®¤ç»ˆæ­¢æ—¶ä¿æŒéš”离，禁止仅因Generation增加就启用新owner。</code></pre><p>取消分三类：排队取消可确定未发送；执行中取消需驱动确认安全停止；响应等待取消仅停止等待，不能证明物理操作撤销。调用方的 CancellationToken ä¸å¾—取消终态/审计持久化；终态保存使用有界的独立 token，失败则隔离。</p>
<p>不能在同一个非线程安全 SDK ä¼šè¯ä¸­å¹¶å‘发送 SafeShutdown ä¸Žæ­£å¸¸å‘½ä»¤ã€‚安全通道必须有经验证的独立能力（如 PLC ç¡¬çº¿ã€ç‹¬ç«‹æŽ§åˆ¶å£ï¼‰ï¼Œå¦åˆ™ç­‰å¾…会话退出，超时触发硬件策略并保持隔离。</p></section><section id="tasks"><h2>11　Broker Task æ¨¡åž‹ã€æ¨¡æ¿ä¸ŽçŠ¶æ€æœº</h2><p><b>Broker Task</b> æ˜¯å®¿ä¸»æ‰§è¡Œçš„有界设备动作或可续租设备任务；它不是 C# Task å¯¹è±¡çš„序列化，也不是整个 DUT Recipe。Recipe ä¸­çš„é•¿ Delay ç•™åœ¨æ‰§è¡Œå¼•æ“Žï¼›å‘¨æœŸ CAN å‘送、TesterPresent、采集订阅等可驻留 Broker，受 owner ç§Ÿçº¦å’Œå®¿ä¸»çœ‹é—¨ç‹—约束。</p>
<div class="table-wrap"><table><thead><tr><th>Task ç±»åž‹</th><th>输入/资源</th><th>完成条件</th><th>失效策略</th></tr></thead><tbody><tr><td>OneShot / AtomicSequence</td><td>类型化命令 + grant é›† + deadline</td><td>写入及必要读回完成</td><td>超时按发送边界区分 Expired / Unknown</td></tr><tr><td>PeriodicTx</td><td>CAN å¸§æ¨¡æ¿ã€bus、周期、持续期限、owner</td><td>Stop/到期/租约失效并确认停止</td><td>周期错失跳过过时帧；禁止重连后追补旧帧</td></tr><tr><td>ProtocolSession</td><td>UDS åœ°å€ã€ä¼šè¯å‚数、总期限、独占键</td><td>响应完成或显式退出</td><td>TesterPresent ä¸Žä¸šåŠ¡åŠ¨ä½œç»Ÿä¸€ä¼šè¯è°ƒåº¦ï¼›å¼‚常恢复协议状态</td></tr><tr><td>Acquisition</td><td>采样通道、周期、缓存策略、订阅 ID</td><td>取消并确认停采/解绑</td><td>允许数据 Gap，质量标记 Stale/Disconnected；不可伪造连续数据</td></tr><tr><td>SafeState</td><td>受审安全模板及恢复授权</td><td>物理读回符合模板</td><td>失败维持 RecoveryRequired å¹¶æŠ¥è­¦</td></tr></tbody></table></div><h3>11.1 ä»»åŠ¡å­—段与状态</h3><p>TaskId、ClientInstanceId、IdempotencyKey、TemplateId/Version、PayloadSHA256、ConfigHash、RunId、DUTExecutionId、StepExecutionId、OwnerId、GrantSet、Priority、SubmittedAt、StartDeadline、MaxDuration、Attempt、State、Readback、ErrorCode、ResultId、CorrelationId。超时分为排队起始期限和运行上限，不能混用。</p>
<p><code>Accepted â†’ Queued â†’ Running â†’ Succeeded / Failed / Cancelled / Unknown / RecoveryRequired</code>；未启动任务可转 Expired，取消待执行任务可转 Cancelled。Accepted å¿…须已持久化，但不代表设备已执行。Running è½ç›˜åŽæ‰å‘ I/O；若崩溃在落盘与发送之间，恢复时仍按可能已发送处理，不能推测为未发送。</p>
<h3>11.2 å¹‚等与不可逆动作</h3><p>同一 (ClientInstanceId, IdempotencyKey) ä¸”同一 PayloadHash è¿”回已有 Task；同键不同内容报 IDEMPOTENCY_CONFLICT。客户端重连保留原 ClientInstanceId æŸ¥è¯¢ï¼Œä¸ç”Ÿæˆæ–°é”®é‡å‘。跨重启保留 Journal ä¸Ž epoch；旧 epoch æœªå¼€å§‹ä»»åŠ¡å…¨éƒ¨å¤±æ•ˆï¼Œéœ€æ–°ç§Ÿçº¦å’Œæ–°ä»»åŠ¡ã€‚命令执行与数据库提交之间无硬件事务，因此不承诺 exactly-once。SetVoltage ç­‰åŠ¨ä½œèƒ½å¦é‡è¯•å¿…须按仪器行为和读回定义；触发、复位、烧写、计数动作默认禁止自动重放。</p>
<h3>11.3 ç¤ºä¾‹æ¨¡æ¿</h3><div class="codebar"><span>JSON Â· æ¨¡æ¿ç¤ºä¾‹</span><button class="copy">复制</button></div><pre><code>{
 &quot;templateId&quot;:&quot;psu.set-readback&quot;, &quot;version&quot;:&quot;1&quot;,
 &quot;allowedOperationCodes&quot;:[&quot;SelectChannel&quot;,&quot;SetVoltage&quot;,&quot;ReadVoltage&quot;],
 &quot;resources&quot;:[&quot;psu/{device}/ch/{channel}&quot;,&quot;parent-permit:{device}&quot;],
 &quot;atomicSession&quot;:&quot;{device}/main&quot;, &quot;maxDurationMs&quot;:3000,
 &quot;validation&quot;:{&quot;voltage&quot;:&quot;within channel and recipe limit&quot;},
 &quot;onUnknown&quot;:&quot;IsolateAndReadback&quot;, &quot;retryClass&quot;:&quot;ReconcileFirst&quot;
}</code></pre><p>模板允许参数替换，不能指定任意驱动类型、地址、脚本或文件路径。模板变更参与配置 Hash。PeriodicTx çš„周期/抖动验收必须由真实 SDK å’Œè®¾å¤‡æµ‹é‡ï¼ŒWindows æ™®é€š Task/Timer ä¸æž„成硬实时保证。</p></section><section id="broker-runtime"><h2>12　Broker è°ƒåº¦ã€é˜Ÿåˆ—与遥测</h2><div class="table-wrap"><table><thead><tr><th>运行单元</th><th>调度规则</th><th>背压与限制</th></tr></thead><tbody><tr><td>IPC Accept / Auth</td><td>协议握手、用户/进程身份验证、消息边界和长度限制</td><td>连接数、消息大小、调用频率限额；默认 1 MiB æ¶ˆæ¯ä¸Šé™ï¼Œå¾…压测</td></tr><tr><td>Control Worker</td><td>Acquire/Renew/Release/Cancel/Query；与设备耗时 I/O åˆ†ç¦»</td><td>保留控制带宽；限流防普通请求耗尽心跳处理</td></tr><tr><td>Session Actor</td><td>每真实连接单队列；每次仅一段原子 I/O</td><td>队列上限示例128；满返回 QUEUE_FULL；过期任务不发送</td></tr><tr><td>Task Scheduler</td><td>安全事件优先、维护让渡协调、生产按 owner è½®è½¬</td><td>同优先级公平；连续占用时间上限；不在任意命令中间抢占</td></tr><tr><td>Protocol Worker</td><td>CAN å•æŽ¥æ”¶å¾ªçŽ¯ + è§£ç /订阅；UDS åˆ†ä¼šè¯è°ƒåº¦</td><td>按 SDK çº¿ç¨‹å®‰å…¨èƒ½åŠ›åˆ†ç»„ï¼›bus reset å±žå…¨å±€åŠ¨ä½œ</td></tr><tr><td>Journal / Outbox Writer</td><td>单写入器批量提交；关键状态先持久化</td><td>不可丢写操作审计；磁盘满停止新增动作并隔离</td></tr><tr><td>Telemetry Fanout</td><td>单次采集多订阅；携带来源、质量、序列号、时间</td><td>UI æœ€æ–°å€¼å¯è¦†ç›–；生产样本使用有界队列，Gap å¿…须记录</td></tr><tr><td>Watchdog / Recovery</td><td>独立心跳检查、异常隔离、恢复门禁</td><td>不能因为忙而无限续租；不得循环快速重启</td></tr></tbody></table></div><p>Session Actor é‡Šæ”¾ä¼šè¯é”åŽç­‰å¾…稳定延时还是保持锁，取决于设备耦合：共享 DMM/矩阵须保持资源权利及路由不变；仪器可独立定时输出的电源任务可释放操作锁，但保留通道预约。队列串行化本身不意味着允许多个 Run åŒæ—¶æ”¹å˜åŒä¸€æ¸©ç®±è®¾å®šå€¼ï¼Œæ¸©ç®±æŽ§åˆ¶æƒå¿…须绑定兼容的 Run/group。</p>
<p>硬件 Safety ä¸Žæ™®é€šè°ƒåº¦ç‹¬ç«‹ã€‚示例公平策略为每 owner ä¸€æ¬¡åŽŸå­ç‰‡æ®µåŽè½®è½¬ï¼›ä¼˜å…ˆçº§åªå†³å®šä¸‹ä¸€ç‰‡æ®µï¼Œä¸ç»•è¿‡ç§Ÿçº¦æˆ–联锁。持续采集/周期发送占用逻辑权利但不永久占用普通调度线程。定时线程数量由会话/SDK èƒ½åŠ›ç¡®å®šï¼Œä¸èƒ½æŒ‰ 120 ç©´ä½åˆ›å»º 120 è½®è¯¢çº¿ç¨‹ã€‚</p></section><section id="ipc"><h2>13　IPC åè®®ã€èº«ä»½ä¸Žäº‹ä»¶æ¢å¤</h2><p>同机基线使用 Windows Named Pipe；服务名含 Station/Broker/协议主版本。现有 PipeClient å¿…须先修复响应不可达、serverName、取消和等待问题，再作为候选基础；不能直接宣称现有 SendMessage ä¸ºå¯é è¯·æ±‚-响应。[E3]</p><div class="codebar"><span>JSON Â· æ¶ˆæ¯å¤–壳</span><button class="copy">复制</button></div><pre><code>{
 &quot;protocolVersion&quot;:3, &quot;messageType&quot;:&quot;SubmitTask&quot;, &quot;requestId&quot;:&quot;req-...&quot;,
 &quot;correlationId&quot;:&quot;run-.../step-...&quot;, &quot;clientInstanceId&quot;:&quot;worker-01/boot-...&quot;,
 &quot;authorityId&quot;:&quot;broker-b01&quot;, &quot;expectedEpoch&quot;:42,
 &quot;configHash&quot;:&quot;sha256:...&quot;, &quot;deadlineUtcMs&quot;:1793673605000,
 &quot;body&quot;:{&quot;templateId&quot;:&quot;psu.set-readback&quot;, &quot;templateVersion&quot;:&quot;1&quot;,
         &quot;idempotencyKey&quot;:&quot;run/dut/step/attempt-1&quot;, &quot;grants&quot;:[], &quot;parameters&quot;:{}}
}</code></pre><p>Body è¿™é‡Œåªæ˜¯å¤–壳示例；真实设备 Submit å¿…须含完整 grant é›†ï¼Œç©ºæ•°ç»„被拒绝。应答回传 RequestId、TaskId、BrokerEpoch、State、ErrorCode、RetryAdvice、ServerUtcMs；对不兼容协议拒绝连接，不自动降级安全字段。</p>
<p>帧协议选择“4 å­—节长度 + UTF-8 JSON”并实现精确读取、最大帧限制、半包、粘包、响应关联与取消；即便使用 Message æ¨¡å¼ï¼Œä¹Ÿè¦å¤„理 IsMessageComplete å’Œå¤§æ¶ˆæ¯ã€‚每条连接单写入泵、单读取分发器，多个请求通过 RequestId å…³è”，禁止多个调用方同时直接读同一 stream。</p>
<p>管道 ACL é™åˆ¶æŒ‡å®šæœåŠ¡èº«ä»½å’Œå·¥ç¨‹è´¦æˆ·ï¼›æœåŠ¡ç«¯ä»Ž OS èº«ä»½æ˜ å°„ Principal，不相信 body ä¸­çš„角色或 OwnerKind。OwnerId å¿…须绑定已认证的 Run/DebugSession/进程实例。跨机扩展采用 TLS çš„独立服务端口、双向身份验证和网络白名单，Named Pipe å®žçŽ°ä¸ä¼šè‡ªåŠ¨å˜æˆå®‰å…¨çš„跨机网关。</p>
<p>事件带持久化单调 cursor。客户端断线后先 Query æœªç»ˆæ€ Task，再按最后 cursor ç»­è®¢ï¼›è‹¥ cursor å·²è¢«ä¿ç•™ç­–略清除，返回 CURSOR_GONE，客户端取全量任务/资源快照并重建订阅。进程 PID åŠ  ProcessStartTime/随机 ProcessInstanceId，避免 PID å¤ç”¨è¢«è¯¯è®¤ä¸ºåŽŸæŒæœ‰è€…。</p></section><section id="arbitration"><h2>14　资源仲裁与维护交接</h2><figure><button class="zoom" aria-label="放大图2">放大查看</button><img class="diagram-image" alt="图2 V3.0目标架构设计" src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<!-- Do not edit this file with editors other than draw.io -->
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" style="background: transparent; background-color: transparent; color-scheme: light dark;" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="1517px" height="878px" viewBox="-0.5 -0.5 1517 878" content="&lt;mxfile host=&quot;Electron&quot; agent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) draw.io/28.2.5 Chrome/138.0.7204.251 Electron/37.6.1 Safari/537.36&quot; version=&quot;28.2.5&quot; pages=&quot;3&quot;&gt;&#10;  &lt;diagram name=&quot;architecture&quot; id=&quot;architecture&quot;&gt;&#10;    &lt;mxGraphModel dx=&quot;-824&quot; dy=&quot;-248&quot; grid=&quot;0&quot; gridSize=&quot;10&quot; guides=&quot;1&quot; tooltips=&quot;1&quot; connect=&quot;1&quot; arrows=&quot;1&quot; fold=&quot;0&quot; page=&quot;0&quot; pageScale=&quot;1&quot; pageWidth=&quot;1600&quot; pageHeight=&quot;900&quot; background=&quot;#ffffff&quot; math=&quot;0&quot; shadow=&quot;0&quot;&gt;&#10;      &lt;root&gt;&#10;        &lt;mxCell id=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;1&quot; parent=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;title&quot; value=&quot;Local + DeviceBroker：统一业务入口与分域 I/O（目标设计）&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=28;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;fontStyle=1;strokeColor=none;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;60&quot; y=&quot;24&quot; width=&quot;1480&quot; height=&quot;60&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;config&quot; value=&quot;配置 / 发布服务&amp;lt;br&amp;gt;不可变快照 · Hash · 路由&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;60&quot; y=&quot;125&quot; width=&quot;400&quot; height=&quot;95&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;hmi&quot; value=&quot;HMI / 维护会话&amp;lt;br&amp;gt;权限 · 占用状态 · 审计&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;600&quot; y=&quot;125&quot; width=&quot;400&quot; height=&quot;95&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;run&quot; value=&quot;Run / Recipe / OpenTAP&amp;lt;br&amp;gt;120 DUTContext · 逻辑能力&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;1140&quot; y=&quot;125&quot; width=&quot;400&quot; height=&quot;95&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;facade&quot; value=&quot;DeviceService + ResourceRouter&amp;lt;br&amp;gt;按快照定位资源 / 宿主&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;600&quot; y=&quot;290&quot; width=&quot;400&quot; height=&quot;100&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#8796a5;dashed=1;exitX=0.5;exitY=1;entryX=0.2;entryY=0;&quot; parent=&quot;1&quot; source=&quot;config&quot; target=&quot;facade&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;Array as=&quot;points&quot;&gt;&#10;              &lt;mxPoint x=&quot;260&quot; y=&quot;255&quot; /&gt;&#10;              &lt;mxPoint x=&quot;680&quot; y=&quot;255&quot; /&gt;&#10;            &lt;/Array&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;exitX=0.5;exitY=1;entryX=0.5;entryY=0;&quot; parent=&quot;1&quot; source=&quot;hmi&quot; target=&quot;facade&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;Array as=&quot;points&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;exitX=0.5;exitY=1;entryX=0.8;entryY=0;&quot; parent=&quot;1&quot; source=&quot;run&quot; target=&quot;facade&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;Array as=&quot;points&quot;&gt;&#10;              &lt;mxPoint x=&quot;1340&quot; y=&quot;255&quot; /&gt;&#10;              &lt;mxPoint x=&quot;920&quot; y=&quot;255&quot; /&gt;&#10;            &lt;/Array&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;local&quot; value=&quot;LocalExecutor / LeaseStore&amp;lt;br&amp;gt;本机 arb.db · 连接守卫 · SessionGate&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;150&quot; y=&quot;470&quot; width=&quot;540&quot; height=&quot;110&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;broker&quot; value=&quot;BrokerClient → DeviceBroker&amp;lt;br&amp;gt;本域 Lease / Task / Queue / Outbox&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;910&quot; y=&quot;470&quot; width=&quot;540&quot; height=&quot;110&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e4&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot; parent=&quot;1&quot; source=&quot;facade&quot; target=&quot;local&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e5&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot; parent=&quot;1&quot; source=&quot;facade&quot; target=&quot;broker&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;localio&quot; value=&quot;唯一 Worker 内的 DeviceManager / Driver&amp;lt;br&amp;gt;固定归属的独立 TCP 会话&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;150&quot; y=&quot;670&quot; width=&quot;540&quot; height=&quot;110&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;brokerio&quot; value=&quot;Broker 内的 DeviceManager / Driver&amp;lt;br&amp;gt;共享 PSU / CAN / RS485 / PLC&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;910&quot; y=&quot;670&quot; width=&quot;540&quot; height=&quot;110&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e6&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot; parent=&quot;1&quot; source=&quot;local&quot; target=&quot;localio&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e7&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot; parent=&quot;1&quot; source=&quot;broker&quot; target=&quot;brokerio&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;legend&quot; value=&quot;实线：调用 / I/O 路径　　灰色虚线：配置依赖　　TTL 到期 → 隔离核查；连接确认退出后才交接&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=18;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;strokeColor=none;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;60&quot; y=&quot;815&quot; width=&quot;1480&quot; height=&quot;55&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;      &lt;/root&gt;&#10;    &lt;/mxGraphModel&gt;&#10;  &lt;/diagram&gt;&#10;  &lt;diagram name=&quot;handover&quot; id=&quot;handover&quot;&gt;&#10;    &lt;mxGraphModel dx=&quot;1600&quot; dy=&quot;900&quot; grid=&quot;1&quot; gridSize=&quot;10&quot; page=&quot;1&quot; pageScale=&quot;1&quot; pageWidth=&quot;1600&quot; pageHeight=&quot;900&quot; background=&quot;#ffffff&quot;&gt;&#10;      &lt;root&gt;&#10;        &lt;mxCell id=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;1&quot; parent=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;title&quot; value=&quot;资源交接：先排空、隔离与核查，再允许新 owner（目标设计）&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=28;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;fontStyle=1;strokeColor=none;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;24&quot; width=&quot;1480&quot; height=&quot;60&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;free&quot; value=&quot;Free / Ready&amp;lt;br&amp;gt;允许申请&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;80&quot; y=&quot;160&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;active&quot; value=&quot;Active&amp;lt;br&amp;gt;Grant + 周期续租&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;635&quot; y=&quot;160&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;drain&quot; value=&quot;Draining&amp;lt;br&amp;gt;停止新写 / 排空片段&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#fff2d9;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1190&quot; y=&quot;160&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1&quot; source=&quot;free&quot; target=&quot;active&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2&quot; source=&quot;active&quot; target=&quot;drain&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;expire&quot; value=&quot;租约 / 心跳异常&amp;lt;br&amp;gt;阻断后续写入&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#fff2d9;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;635&quot; y=&quot;385&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;verify&quot; value=&quot;安全交接检查&amp;lt;br&amp;gt;读回 · 连接隔离 · 联锁&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1190&quot; y=&quot;385&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3&quot; source=&quot;active&quot; target=&quot;expire&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e4&quot; source=&quot;drain&quot; target=&quot;verify&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;recovery&quot; value=&quot;RecoveryRequired&amp;lt;br&amp;gt;设备状态未知 / 禁止重授&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#fdeced;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;635&quot; y=&quot;610&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;new&quot; value=&quot;检查合格 → Free&amp;lt;br&amp;gt;重新申请新 Grant&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1190&quot; y=&quot;610&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e5&quot; source=&quot;expire&quot; target=&quot;recovery&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e6&quot; source=&quot;verify&quot; target=&quot;new&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e7&quot; source=&quot;recovery&quot; target=&quot;verify&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;exitX=1;exitY=0.5;entryX=0;entryY=0.5;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot;&gt;&#10;            &lt;Array as=&quot;points&quot;&gt;&#10;              &lt;mxPoint x=&quot;1080&quot; y=&quot;662.5&quot; /&gt;&#10;              &lt;mxPoint x=&quot;1080&quot; y=&quot;437.5&quot; /&gt;&#10;            &lt;/Array&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;limits&quot; value=&quot;异常路径说明&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;Draining 超时 / 检查失败&amp;lt;br&amp;gt;→ RecoveryRequired&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;Broker 重启：epoch + 1&amp;lt;br&amp;gt;旧 Grant 全部失效&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;Local 旧守卫未退出&amp;lt;br&amp;gt;→ 保持隔离，不按 TTL 抢占&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;80&quot; y=&quot;385&quot; width=&quot;330&quot; height=&quot;330&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;legend&quot; value=&quot;实线：正常申请或恢复推进　　异常到期不直接转 Free　　未确认的已发命令 → Unknown / 恢复检查&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=18;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;strokeColor=none;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;810&quot; width=&quot;1480&quot; height=&quot;55&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;      &lt;/root&gt;&#10;    &lt;/mxGraphModel&gt;&#10;  &lt;/diagram&gt;&#10;  &lt;diagram name=&quot;deployment120&quot; id=&quot;deployment120&quot;&gt;&#10;    &lt;mxGraphModel dx=&quot;1600&quot; dy=&quot;900&quot; grid=&quot;1&quot; gridSize=&quot;10&quot; page=&quot;1&quot; pageScale=&quot;1&quot; pageWidth=&quot;1600&quot; pageHeight=&quot;900&quot; background=&quot;#ffffff&quot;&gt;&#10;      &lt;root&gt;&#10;        &lt;mxCell id=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;1&quot; parent=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;title&quot; value=&quot;120 穴位：6 Worker + 3 Broker 域（15×8 PSU 基线 / 建议）&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=28;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;fontStyle=1;strokeColor=none;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;24&quot; width=&quot;1480&quot; height=&quot;60&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;hmi&quot; value=&quot;IPC-01：HMI / RunService / Supervisor&amp;lt;br&amp;gt;配置快照与结果索引；ResultWriter 独立落盘&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;500&quot; y=&quot;110&quot; width=&quot;600&quot; height=&quot;95&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;w1&quot; value=&quot;W01 + W02&amp;lt;br&amp;gt;S001–S040 · 2×20 DUTContext&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;315&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;b1&quot; value=&quot;Broker B01&amp;lt;br&amp;gt;唯一宿主 · 本域 DB / 队列&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;520&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;p1&quot; value=&quot;PSU01–PSU05&amp;lt;br&amp;gt;5 台 × 8 通道 = 40 穴位&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;725&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1a&quot; source=&quot;hmi&quot; target=&quot;w1&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1b&quot; source=&quot;w1&quot; target=&quot;b1&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1c&quot; source=&quot;b1&quot; target=&quot;p1&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;w2&quot; value=&quot;W03 + W04&amp;lt;br&amp;gt;S041–S080 · 2×20 DUTContext&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;600&quot; y=&quot;315&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;b2&quot; value=&quot;Broker B02&amp;lt;br&amp;gt;唯一宿主 · 本域 DB / 队列&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;600&quot; y=&quot;520&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;p2&quot; value=&quot;PSU06–PSU10&amp;lt;br&amp;gt;5 台 × 8 通道 = 40 穴位&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;600&quot; y=&quot;725&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2a&quot; source=&quot;hmi&quot; target=&quot;w2&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2b&quot; source=&quot;w2&quot; target=&quot;b2&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2c&quot; source=&quot;b2&quot; target=&quot;p2&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;w3&quot; value=&quot;W05 + W06&amp;lt;br&amp;gt;S081–S120 · 2×20 DUTContext&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1140&quot; y=&quot;315&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;b3&quot; value=&quot;Broker B03&amp;lt;br&amp;gt;唯一宿主 · 本域 DB / 队列&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1140&quot; y=&quot;520&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;p3&quot; value=&quot;PSU11–PSU15&amp;lt;br&amp;gt;5 台 × 8 通道 = 40 穴位&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1140&quot; y=&quot;725&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3a&quot; source=&quot;hmi&quot; target=&quot;w3&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3b&quot; source=&quot;w3&quot; target=&quot;b3&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3c&quot; source=&quot;b3&quot; target=&quot;p3&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;legend&quot; value=&quot;CAN / PLC / 温箱按真实物理与 SDK 域固定唯一宿主（TBD）；共享设备不因分 3 域而复制连接。&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=18;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;strokeColor=none;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;845&quot; width=&quot;1480&quot; height=&quot;45&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;      &lt;/root&gt;&#10;    &lt;/mxGraphModel&gt;&#10;  &lt;/diagram&gt;&#10;&lt;/mxfile&gt;&#10;"><defs/><g><g data-cell-id="0"><g data-cell-id="1"><g data-cell-id="title"><g><rect x="12" y="12" width="1480" height="60" fill="#ffffff" stroke="none" pointer-events="all" style="fill: light-dark(rgb(255, 255, 255), rgb(18, 18, 18));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1454px; height: 1px; padding-top: 42px; margin-left: 25px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 28px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; font-weight: bold; white-space: normal; word-wrap: normal; ">资源交接：先排空、隔离与核查，再允许新 owner（目标设计）</div></div></div></foreignObject><image x="25" y="25.5" width="1454" height="41" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="free"><g><rect x="32" y="148" width="330" height="105" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 304px; height: 1px; padding-top: 201px; margin-left: 45px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Free / Ready<br />允许申请</div></div></div></foreignObject><image x="45" y="177.5" width="304" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="active"><g><rect x="587" y="148" width="330" height="105" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 304px; height: 1px; padding-top: 201px; margin-left: 600px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Active<br />Grant + 周期续租</div></div></div></foreignObject><image x="600" y="177.5" width="304" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="drain"><g><rect x="1142" y="148" width="330" height="105" fill="#fff2d9" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(255, 242, 217), rgb(38, 27, 5)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 304px; height: 1px; padding-top: 201px; margin-left: 1155px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Draining<br />停止新写 / 排空片段</div></div></div></foreignObject><image x="1155" y="177.5" width="304" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="e1"><g><path d="M 362 200.5 L 576.76 200.5" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 584.76 200.5 L 576.76 204.5 L 576.76 196.5 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="e2"><g><path d="M 917 200.5 L 1131.76 200.5" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 1139.76 200.5 L 1131.76 204.5 L 1131.76 196.5 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="expire"><g><rect x="587" y="373" width="330" height="105" fill="#fff2d9" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(255, 242, 217), rgb(38, 27, 5)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 304px; height: 1px; padding-top: 426px; margin-left: 600px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">租约 / 心跳异常<br />阻断后续写入</div></div></div></foreignObject><image x="600" y="402.5" width="304" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="verify"><g><rect x="1142" y="373" width="330" height="105" fill="#e8f4ef" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(232, 244, 239), rgb(21, 32, 27)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 304px; height: 1px; padding-top: 426px; margin-left: 1155px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">安全交接检查<br />读回 · 连接隔离 · 联锁</div></div></div></foreignObject><image x="1155" y="402.5" width="304" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="e3"><g><path d="M 752 253 L 752 362.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 752 370.76 L 748 362.76 L 756 362.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="e4"><g><path d="M 1307 253 L 1307 362.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 1307 370.76 L 1303 362.76 L 1311 362.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="recovery"><g><rect x="587" y="598" width="330" height="105" fill="#fdeced" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(253, 236, 237), rgb(42, 28, 29)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 304px; height: 1px; padding-top: 651px; margin-left: 600px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">RecoveryRequired<br />设备状态未知 / 禁止重授</div></div></div></foreignObject><image x="600" y="627.5" width="304" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="new"><g><rect x="1142" y="598" width="330" height="105" fill="#e8f4ef" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(232, 244, 239), rgb(21, 32, 27)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 304px; height: 1px; padding-top: 651px; margin-left: 1155px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">检查合格 → Free<br />重新申请新 Grant</div></div></div></foreignObject><image x="1155" y="627.5" width="304" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="e5"><g><path d="M 752 478 L 752 587.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 752 595.76 L 748 587.76 L 756 587.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="e6"><g><path d="M 1307 478 L 1307 587.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 1307 595.76 L 1303 587.76 L 1311 587.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="e7"><g><path d="M 917 650.5 L 1032 650.5 L 1032 425.5 L 1131.76 425.5" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 1139.76 425.5 L 1131.76 429.5 L 1131.76 421.5 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="limits"><g><rect x="32" y="373" width="330" height="330" fill="#ffffff" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(255, 255, 255), rgb(18, 18, 18)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 304px; height: 1px; padding-top: 538px; margin-left: 45px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">异常路径说明<br /><br />Draining 超时 / 检查失败<br />→ RecoveryRequired<br /><br />Broker 重启：epoch + 1<br />旧 Grant 全部失效<br /><br />Local 旧守卫未退出<br />→ 保持隔离，不按 TTL 抢占</div></div></div></foreignObject><image x="45" y="418.5" width="304" height="245" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="legend"><g><rect x="12" y="798" width="1480" height="55" fill="#ffffff" stroke="none" pointer-events="all" style="fill: light-dark(rgb(255, 255, 255), rgb(18, 18, 18));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1454px; height: 1px; padding-top: 826px; margin-left: 25px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 18px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">实线：正常申请或恢复推进　　异常到期不直接转 Free　　未确认的已发命令 → Unknown / 恢复检查</div></div></div></foreignObject><image x="25" y="815.5" width="1454" height="26.5" xlink:href="data:image/png;base64,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"/></switch></g></g></g></g></g></g><switch><g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/><a transform="translate(0,-5)" xlink:href="https://www.drawio.com/doc/faq/svg-export-text-problems" target="_blank"><text text-anchor="middle" font-size="10px" x="50%" y="100%">Text is not SVG - cannot display</text></a></switch></svg>"><figcaption>图 2　租约交接与异常恢复；超时进入隔离，不直接转为可用。</figcaption></figure><div class="table-wrap"><table><thead><tr><th>当前状态</th><th>请求</th><th>决策与下一步</th></tr></thead><tbody><tr><td>Free ä¸” Ready</td><td>生产/维护申请</td><td>同域原子授予； generation+1；发放组 grant</td></tr><tr><td>Production Active</td><td>另一个生产请求同通道</td><td>有界排队或 RESOURCE_BUSY；不共享同一输出权</td></tr><tr><td>Production Active</td><td>维护申请</td><td>默认拒绝并显示 Run/穴位；授权让渡只在安全边界启动 Draining</td></tr><tr><td>Maintenance Active</td><td>生产启动</td><td>拒绝启动，显示维护会话及影响范围</td></tr><tr><td>共享读订阅</td><td>维护写请求</td><td>先停止相关写权；被动读可保留，必要时标记 Stale</td></tr><tr><td>Draining</td><td>现 owner ç»­æœŸ</td><td>仅续到 handover deadline；禁止新普通任务，允许收尾/安全动作</td></tr><tr><td>Draining/Active è¿‡æœŸ</td><td>新 owner è¯·æ±‚</td><td>RecoveryRequired；等待排空、连接守卫与物理读回</td></tr><tr><td>RecoveryRequired / Disabled</td><td>任何普通写请求</td><td>拒绝；只有受控恢复动作允许执行</td></tr><tr><td>所有状态</td><td>硬件急停/严重联锁</td><td>硬件执行停机；软件阻断、记录状态并核查，不等待租约到期</td></tr></tbody></table></div><h3>14.1 é¢„约、操作锁与读订阅</h3><p>生产预约可覆盖一个 Run/步骤组，而 SessionGate åªè¦†ç›–一次原子 I/O。只读监控优先使用缓存；带副作用的 query、读清零寄存器、切换通道读取仍是排他 I/O，不能归为无锁读取。共享写只允许经明确的组合策略，例如 CAN å‘¨æœŸå¸§æŒ‰ ID/周期规则分配，不能泛化为“同设备命令排队即可安全共享”。</p>
<h3>14.2 å®Œæ•´ç»´æŠ¤äº¤æŽ¥</h3><ol><li>显示资源的占用者、Run、DUT、任务、剩余租约和父子影响；维护工程师填写理由。</li><li>Run åè°ƒå™¨æ‰¹å‡†å—影响穴位安全暂停，资源变 Draining；拒绝新写任务并停止周期任务。</li><li>等待在途片段结束；执行适用的 SafeStateProfile å¹¶è¯»å›žã€‚超时转 RecoveryRequired，不自动给维护者。</li><li>原 owner æŽ’空并释放；Local è¿˜é¡»ç¡®è®¤æ—§å¥æŸ„关闭和命名 Mutex å¯èŽ·å–。</li><li>确认独立联锁/断能手续后授予维护 Scope；维护动作全量审计。</li><li>退出维护先读回/复核、恢复通信配置和报警基线，再释放并由 RunService æ˜Žç¡®æ¢å¤æˆ–新建 Run。</li></ol>
<p>“Force release” æŒ‰é’®ä¸èƒ½ç›´æŽ¥ UPDATE/DELETE ç§Ÿçº¦è¡Œï¼›å®ƒåªèƒ½è§¦å‘隔离及恢复流程。多人作业、拔线、接线和柜门操作的许可不由软件 token å•ç‹¬åˆ¤å®šã€‚</p></section><section id="fencing"><h2>15　Fencing、超时与 Local è¾¹ç•Œ</h2><p>完整校验集合为 <code>AuthorityId + Epoch + ResourceKey + LeaseId + Generation + OwnerId + ConfigHash + Principal</code>，并检查活跃期、parent permit、deadline ä¸Žè®¾å¤‡ Ready。generation å¯¹æ¯ä¸ªèµ„源单调增加；续期保持不变。Broker åœ¨ SessionGate å†…处理交接与最终发命令的序列，旧任务不能排队越过新 owner çš„授权边界。</p>
<h3>15.1 å·²å‘命令无法被 token æ’¤é”€</h3><p>进程暂停可能发生在最后一次校验之后、写入之前；因此只有查询数据库再直连设备，不能提供强物理 fencing。Broker åœ¨åŒä¸€ I/O åŸŸå†…以执行串行和交接排空避免旧/新 owner å¹¶è¡Œï¼›å¯¹å·²å‘出的命令，仍需等待完成、设备取消能力或独立断能。若驱动无法终止且状态未知，不授予新租约。</p>
<h3>15.2 Local çš„准入限制</h3><p>Local ä¼šè¯ç”±é…ç½®å›ºå®šåˆ°å”¯ä¸€ Worker，连接守卫使用规范化 PhysicalSessionKey çš„同机命名 Mutex。获取守卫的专用宿主线程持续持有至连接关闭（Windows Mutex ä¸ºçº¿ç¨‹æ‰€æœ‰ï¼Œä¸èƒ½ç®€å•è·¨ await çº¿ç¨‹é‡Šæ”¾ï¼‰ï¼›é©±åŠ¨æ“ä½œå¦ç”¨ SemaphoreSlim/SessionGate。线程异常与 AbandonedMutex ç»Ÿä¸€è½¬æ¢å¤æ£€æŸ¥ã€‚Mutex ä¸å›  TTL è¿‡æœŸé‡Šæ”¾ï¼Œæš‚停的旧进程仍持有它，因此新进程不得接管。</p>
<p>远程客户端、另一个软件或同设备的其他别名不受此同机 Mutex æŽ§åˆ¶ã€‚若设备不能限制外部直连，且需要跨进程自动切换/共享，必须 Broker åŒ–并配网络 ACL/访问凭据或硬件连接隔离；不能在文档中承诺绝对阻止所有外部命令。工程师维护 Local è®¾å¤‡æ—¶ä¼˜å…ˆç»çŽ°æœ‰å®¿ä¸»ä»£ç†ï¼›è‹¥å¿…须迁移连接，先停止旧 Worker å¹¶ç¡®è®¤æ— æ—§å¥æŸ„，再走恢复门禁。</p>
<h3>15.3 æ—¶é—´å‚æ•°</h3><p>建议初始 TTL=30 s、续期=8 s、让渡上限=30 s，均为设计默认值。权威宿主以单调时钟判定；UTC ä»…用于持久化/展示，外来 UTC deadline è½¬æ¢ä¸ºæœ‰ä¸Šé™çš„本地预算。心跳失败后立即阻断新操作；没有有效确认不能无限延长本地有效期。系统重启或宿主 epoch å˜åŒ–后全部旧 grant å¤±æ•ˆï¼Œå¾…核对后重新预约。</p></section><section id="recovery"><h2>16　异常恢复与重启编排</h2><div class="table-wrap"><table><thead><tr><th>故障</th><th>即时动作</th><th>恢复判据 / ç¦æ­¢äº‹é¡¹</th></tr></thead><tbody><tr><td>Worker å´©æºƒæˆ–断线</td><td>停其周期发送/订阅写任务；本域租约到期转 RecoveryRequired</td><td>核对在途任务与输出；进程死亡不等于设备输出关闭</td></tr><tr><td>Broker å´©æºƒ</td><td>受影响 DUT æ ‡è®°è®¾å¤‡ä¸å¯ç”¨ï¼›Supervisor é™é¢‘拉起</td><td>持久化 epoch+1；Running→Unknown；旧队列失效；读回后 Ready，禁止重放旧命令</td></tr><tr><td>宿主暂停/卡死</td><td>心跳超时、联锁策略介入；新 owner ä¸æŠ¢å </td><td>确认旧 I/O å®¿ä¸»é€€å‡ºæˆ–隔离、硬件状态已知</td></tr><tr><td>TCP/串口断线、USB重枚举</td><td>Session Faulted；不缓存并追发旧写命令</td><td>重新识别设备序列号、通道/配置、输出状态；更换设备需配置审批</td></tr><tr><td>超时/回包丢失</td><td>区分未发送与可能已执行；后者 Unknown</td><td>按模板读回；无法判定则人工恢复，不按 RetryAdvice ç›²å‘</td></tr><tr><td>DB busy / disk full / æŸå</td><td>限制短重试；停止接受新写动作；关键审计失败即隔离</td><td>DB å®Œæ•´æ€§æ£€æŸ¥ã€ç©ºé—´æ¢å¤ã€Outbox è¡¥æŠ•ï¼›ä¸èƒ½ç»•å¼€ Journal ç»§ç»­ç”Ÿäº§</td></tr><tr><td>系统断电/重启</td><td>由硬件保障断能策略；启动进入 Recovering</td><td>旧 epoch失效；核对SN/穴位、物理输出和温箱；创建恢复记录</td></tr><tr><td>配置Hash不一致</td><td>拒绝启动和操作</td><td>对齐宿主版本、驱动包与映射，重新 Prepare/Apply</td></tr><tr><td>CAN bus-off/UDS会话失效</td><td>隔离总线/会话；停止相关周期任务，标记数据质量</td><td>有界重连、地址/会话重新建立；不能把协议会话当成连续有效</td></tr><tr><td>安全联锁动作</td><td>硬件执行；软件停止新任务并记录原因/受影响资源</td><td>人工复位并读回，生产恢复必须显式批准</td></tr><tr><td>结果消费者断线</td><td>Outbox ä¿ç•™ï¼Œé™åˆ¶ç§¯åŽ‹å¹¶æŠ¥è­¦</td><td>按ResultId补投，消费者落盘再ACK；不能吞掉失败结果</td></tr></tbody></table></div><h3>16.1 Broker é‡å¯æ­¥éª¤</h3><ol><li>获取 BrokerId å•å®žä¾‹å®ˆå«ï¼›åŒä¸€ç‰©ç†ä¼šè¯ä¸å…è®¸åŒå®žä¾‹åŒæ—¶å¯åŠ¨ã€‚</li><li>数据库短事务增加 epoch å¹¶è®°å½• boot identity；旧 Active/Draining→RecoveryRequired，旧 Running→Unknown，未开始旧任务→Expired。</li><li>阻断普通写请求，加载有效配置，验证设备身份，建立连接；读取输出/通道/协议状态。</li><li>按设备安全模板执行经审核的恢复动作。安全状态不是统一“所有输出 Off”：温箱、冷却与被测件有各自安全要求。</li><li>恢复检查点和证据持久化；若需人工审批则等待。全部通过后资源 Free/Ready，再通知 RunService。</li><li>RunService å¯¹æ¯ä¸ª DUT è®°å½•ä¸­æ–­çª—口与数据 Gap，决定继续、重新执行可重入步骤或终止重测。168 h ç­‰é•¿æ—¶è€åŒ–如何计时须按产品策略冻结。</li></ol>
<p>Supervisor å»ºè®®é€€é¿ 1/2/5/10/30 s，5 åˆ†é’Ÿå†…重启超过 3 æ¬¡é”å®šæŠ¥è­¦ï¼Œæ•°å€¼ä¸ºå¾…验证默认。软件重启恢复仅表示通信和状态恢复，不表示测试结果自动合格。</p></section><section id="deployment"><h2>17　120 ç©´ä½éƒ¨ç½²æ–¹æ¡ˆä¸Žå®Œæ•´æ˜ å°„</h2><figure><button class="zoom" aria-label="放大图3">放大查看</button><img class="diagram-image" alt="图3 V3.0目标架构设计" src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<!-- Do not edit this file with editors other than draw.io -->
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" style="background: transparent; background-color: transparent; color-scheme: light dark;" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="1519px" height="903px" viewBox="-0.5 -0.5 1519 903" content="&lt;mxfile host=&quot;Electron&quot; agent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) draw.io/28.2.5 Chrome/138.0.7204.251 Electron/37.6.1 Safari/537.36&quot; version=&quot;28.2.5&quot; pages=&quot;3&quot;&gt;&#10;  &lt;diagram name=&quot;architecture&quot; id=&quot;architecture&quot;&gt;&#10;    &lt;mxGraphModel dx=&quot;-824&quot; dy=&quot;-248&quot; grid=&quot;0&quot; gridSize=&quot;10&quot; guides=&quot;1&quot; tooltips=&quot;1&quot; connect=&quot;1&quot; arrows=&quot;1&quot; fold=&quot;0&quot; page=&quot;0&quot; pageScale=&quot;1&quot; pageWidth=&quot;1600&quot; pageHeight=&quot;900&quot; background=&quot;#ffffff&quot; math=&quot;0&quot; shadow=&quot;0&quot;&gt;&#10;      &lt;root&gt;&#10;        &lt;mxCell id=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;1&quot; parent=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;title&quot; value=&quot;Local + DeviceBroker：统一业务入口与分域 I/O（目标设计）&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=28;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;fontStyle=1;strokeColor=none;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;60&quot; y=&quot;24&quot; width=&quot;1480&quot; height=&quot;60&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;config&quot; value=&quot;配置 / 发布服务&amp;lt;br&amp;gt;不可变快照 · Hash · 路由&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;60&quot; y=&quot;125&quot; width=&quot;400&quot; height=&quot;95&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;hmi&quot; value=&quot;HMI / 维护会话&amp;lt;br&amp;gt;权限 · 占用状态 · 审计&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;600&quot; y=&quot;125&quot; width=&quot;400&quot; height=&quot;95&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;run&quot; value=&quot;Run / Recipe / OpenTAP&amp;lt;br&amp;gt;120 DUTContext · 逻辑能力&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;1140&quot; y=&quot;125&quot; width=&quot;400&quot; height=&quot;95&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;facade&quot; value=&quot;DeviceService + ResourceRouter&amp;lt;br&amp;gt;按快照定位资源 / 宿主&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;600&quot; y=&quot;290&quot; width=&quot;400&quot; height=&quot;100&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#8796a5;dashed=1;exitX=0.5;exitY=1;entryX=0.2;entryY=0;&quot; parent=&quot;1&quot; source=&quot;config&quot; target=&quot;facade&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;Array as=&quot;points&quot;&gt;&#10;              &lt;mxPoint x=&quot;260&quot; y=&quot;255&quot; /&gt;&#10;              &lt;mxPoint x=&quot;680&quot; y=&quot;255&quot; /&gt;&#10;            &lt;/Array&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;exitX=0.5;exitY=1;entryX=0.5;entryY=0;&quot; parent=&quot;1&quot; source=&quot;hmi&quot; target=&quot;facade&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;Array as=&quot;points&quot; /&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;exitX=0.5;exitY=1;entryX=0.8;entryY=0;&quot; parent=&quot;1&quot; source=&quot;run&quot; target=&quot;facade&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot;&gt;&#10;            &lt;Array as=&quot;points&quot;&gt;&#10;              &lt;mxPoint x=&quot;1340&quot; y=&quot;255&quot; /&gt;&#10;              &lt;mxPoint x=&quot;920&quot; y=&quot;255&quot; /&gt;&#10;            &lt;/Array&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;local&quot; value=&quot;LocalExecutor / LeaseStore&amp;lt;br&amp;gt;本机 arb.db · 连接守卫 · SessionGate&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;150&quot; y=&quot;470&quot; width=&quot;540&quot; height=&quot;110&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;broker&quot; value=&quot;BrokerClient → DeviceBroker&amp;lt;br&amp;gt;本域 Lease / Task / Queue / Outbox&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;910&quot; y=&quot;470&quot; width=&quot;540&quot; height=&quot;110&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e4&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot; parent=&quot;1&quot; source=&quot;facade&quot; target=&quot;local&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e5&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot; parent=&quot;1&quot; source=&quot;facade&quot; target=&quot;broker&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;localio&quot; value=&quot;唯一 Worker 内的 DeviceManager / Driver&amp;lt;br&amp;gt;固定归属的独立 TCP 会话&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;150&quot; y=&quot;670&quot; width=&quot;540&quot; height=&quot;110&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;brokerio&quot; value=&quot;Broker 内的 DeviceManager / Driver&amp;lt;br&amp;gt;共享 PSU / CAN / RS485 / PLC&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;910&quot; y=&quot;670&quot; width=&quot;540&quot; height=&quot;110&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e6&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot; parent=&quot;1&quot; source=&quot;local&quot; target=&quot;localio&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e7&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot; parent=&quot;1&quot; source=&quot;broker&quot; target=&quot;brokerio&quot; edge=&quot;1&quot;&gt;&#10;          &lt;mxGeometry relative=&quot;1&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;legend&quot; value=&quot;实线：调用 / I/O 路径　　灰色虚线：配置依赖　　TTL 到期 → 隔离核查；连接确认退出后才交接&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=18;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;strokeColor=none;&quot; parent=&quot;1&quot; vertex=&quot;1&quot;&gt;&#10;          &lt;mxGeometry x=&quot;60&quot; y=&quot;815&quot; width=&quot;1480&quot; height=&quot;55&quot; as=&quot;geometry&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;      &lt;/root&gt;&#10;    &lt;/mxGraphModel&gt;&#10;  &lt;/diagram&gt;&#10;  &lt;diagram name=&quot;handover&quot; id=&quot;handover&quot;&gt;&#10;    &lt;mxGraphModel dx=&quot;1600&quot; dy=&quot;900&quot; grid=&quot;1&quot; gridSize=&quot;10&quot; page=&quot;1&quot; pageScale=&quot;1&quot; pageWidth=&quot;1600&quot; pageHeight=&quot;900&quot; background=&quot;#ffffff&quot;&gt;&#10;      &lt;root&gt;&#10;        &lt;mxCell id=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;1&quot; parent=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;title&quot; value=&quot;资源交接：先排空、隔离与核查，再允许新 owner（目标设计）&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=28;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;fontStyle=1;strokeColor=none;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;24&quot; width=&quot;1480&quot; height=&quot;60&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;free&quot; value=&quot;Free / Ready&amp;lt;br&amp;gt;允许申请&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;80&quot; y=&quot;160&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;active&quot; value=&quot;Active&amp;lt;br&amp;gt;Grant + 周期续租&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;635&quot; y=&quot;160&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;drain&quot; value=&quot;Draining&amp;lt;br&amp;gt;停止新写 / 排空片段&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#fff2d9;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1190&quot; y=&quot;160&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1&quot; source=&quot;free&quot; target=&quot;active&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2&quot; source=&quot;active&quot; target=&quot;drain&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;expire&quot; value=&quot;租约 / 心跳异常&amp;lt;br&amp;gt;阻断后续写入&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#fff2d9;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;635&quot; y=&quot;385&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;verify&quot; value=&quot;安全交接检查&amp;lt;br&amp;gt;读回 · 连接隔离 · 联锁&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1190&quot; y=&quot;385&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3&quot; source=&quot;active&quot; target=&quot;expire&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e4&quot; source=&quot;drain&quot; target=&quot;verify&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;recovery&quot; value=&quot;RecoveryRequired&amp;lt;br&amp;gt;设备状态未知 / 禁止重授&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#fdeced;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;635&quot; y=&quot;610&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;new&quot; value=&quot;检查合格 → Free&amp;lt;br&amp;gt;重新申请新 Grant&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1190&quot; y=&quot;610&quot; width=&quot;330&quot; height=&quot;105&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e5&quot; source=&quot;expire&quot; target=&quot;recovery&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e6&quot; source=&quot;verify&quot; target=&quot;new&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e7&quot; source=&quot;recovery&quot; target=&quot;verify&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;exitX=1;exitY=0.5;entryX=0;entryY=0.5;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot;&gt;&#10;            &lt;Array as=&quot;points&quot;&gt;&#10;              &lt;mxPoint x=&quot;1080&quot; y=&quot;662.5&quot; /&gt;&#10;              &lt;mxPoint x=&quot;1080&quot; y=&quot;437.5&quot; /&gt;&#10;            &lt;/Array&gt;&#10;          &lt;/mxGeometry&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;limits&quot; value=&quot;异常路径说明&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;Draining 超时 / 检查失败&amp;lt;br&amp;gt;→ RecoveryRequired&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;Broker 重启：epoch + 1&amp;lt;br&amp;gt;旧 Grant 全部失效&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;Local 旧守卫未退出&amp;lt;br&amp;gt;→ 保持隔离，不按 TTL 抢占&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;80&quot; y=&quot;385&quot; width=&quot;330&quot; height=&quot;330&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;legend&quot; value=&quot;实线：正常申请或恢复推进　　异常到期不直接转 Free　　未确认的已发命令 → Unknown / 恢复检查&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=18;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;strokeColor=none;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;810&quot; width=&quot;1480&quot; height=&quot;55&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;      &lt;/root&gt;&#10;    &lt;/mxGraphModel&gt;&#10;  &lt;/diagram&gt;&#10;  &lt;diagram name=&quot;deployment120&quot; id=&quot;deployment120&quot;&gt;&#10;    &lt;mxGraphModel dx=&quot;1600&quot; dy=&quot;900&quot; grid=&quot;1&quot; gridSize=&quot;10&quot; page=&quot;1&quot; pageScale=&quot;1&quot; pageWidth=&quot;1600&quot; pageHeight=&quot;900&quot; background=&quot;#ffffff&quot;&gt;&#10;      &lt;root&gt;&#10;        &lt;mxCell id=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;1&quot; parent=&quot;0&quot; /&gt;&#10;        &lt;mxCell id=&quot;title&quot; value=&quot;120 穴位：6 Worker + 3 Broker 域（15×8 PSU 基线 / 建议）&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=28;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;fontStyle=1;strokeColor=none;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;24&quot; width=&quot;1480&quot; height=&quot;60&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;hmi&quot; value=&quot;IPC-01：HMI / RunService / Supervisor&amp;lt;br&amp;gt;配置快照与结果索引；ResultWriter 独立落盘&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;500&quot; y=&quot;110&quot; width=&quot;600&quot; height=&quot;95&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;w1&quot; value=&quot;W01 + W02&amp;lt;br&amp;gt;S001–S040 · 2×20 DUTContext&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;315&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;b1&quot; value=&quot;Broker B01&amp;lt;br&amp;gt;唯一宿主 · 本域 DB / 队列&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;520&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;p1&quot; value=&quot;PSU01–PSU05&amp;lt;br&amp;gt;5 台 × 8 通道 = 40 穴位&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;725&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1a&quot; source=&quot;hmi&quot; target=&quot;w1&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1b&quot; source=&quot;w1&quot; target=&quot;b1&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e1c&quot; source=&quot;b1&quot; target=&quot;p1&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;w2&quot; value=&quot;W03 + W04&amp;lt;br&amp;gt;S041–S080 · 2×20 DUTContext&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;600&quot; y=&quot;315&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;b2&quot; value=&quot;Broker B02&amp;lt;br&amp;gt;唯一宿主 · 本域 DB / 队列&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;600&quot; y=&quot;520&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;p2&quot; value=&quot;PSU06–PSU10&amp;lt;br&amp;gt;5 台 × 8 通道 = 40 穴位&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;600&quot; y=&quot;725&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2a&quot; source=&quot;hmi&quot; target=&quot;w2&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2b&quot; source=&quot;w2&quot; target=&quot;b2&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e2c&quot; source=&quot;b2&quot; target=&quot;p2&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;w3&quot; value=&quot;W05 + W06&amp;lt;br&amp;gt;S081–S120 · 2×20 DUTContext&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1140&quot; y=&quot;315&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;b3&quot; value=&quot;Broker B03&amp;lt;br&amp;gt;唯一宿主 · 本域 DB / 队列&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1140&quot; y=&quot;520&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;p3&quot; value=&quot;PSU11–PSU15&amp;lt;br&amp;gt;5 台 × 8 通道 = 40 穴位&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;1140&quot; y=&quot;725&quot; width=&quot;400&quot; height=&quot;100&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3a&quot; source=&quot;hmi&quot; target=&quot;w3&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3b&quot; source=&quot;w3&quot; target=&quot;b3&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;e3c&quot; source=&quot;b3&quot; target=&quot;p3&quot; edge=&quot;1&quot; parent=&quot;1&quot; style=&quot;edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; relative=&quot;1&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;        &lt;mxCell id=&quot;legend&quot; value=&quot;CAN / PLC / 温箱按真实物理与 SDK 域固定唯一宿主（TBD）；共享设备不因分 3 域而复制连接。&quot; style=&quot;rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=18;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;strokeColor=none;&quot; vertex=&quot;1&quot; parent=&quot;1&quot;&gt;&#10;          &lt;mxGeometry as=&quot;geometry&quot; x=&quot;60&quot; y=&quot;845&quot; width=&quot;1480&quot; height=&quot;45&quot; /&gt;&#10;        &lt;/mxCell&gt;&#10;      &lt;/root&gt;&#10;    &lt;/mxGraphModel&gt;&#10;  &lt;/diagram&gt;&#10;&lt;/mxfile&gt;&#10;"><defs/><g><g data-cell-id="0"><g data-cell-id="1"><g data-cell-id="title"><g><rect x="13" y="12" width="1480" height="60" fill="#ffffff" stroke="none" pointer-events="all" style="fill: light-dark(rgb(255, 255, 255), rgb(18, 18, 18));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1454px; height: 1px; padding-top: 42px; margin-left: 26px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 28px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; font-weight: bold; white-space: normal; word-wrap: normal; ">120 穴位：6 Worker + 3 Broker 域（15×8 PSU 基线 / 建议）</div></div></div></foreignObject><image x="26" y="25.5" width="1454" height="41" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="hmi"><g><rect x="453" y="98" width="600" height="95" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 574px; height: 1px; padding-top: 146px; margin-left: 466px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">IPC-01：HMI / RunService / Supervisor<br />配置快照与结果索引；ResultWriter 独立落盘</div></div></div></foreignObject><image x="466" y="122.5" width="574" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="w1"><g><rect x="13" y="303" width="400" height="100" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 374px; height: 1px; padding-top: 353px; margin-left: 26px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">W01 + W02<br />S001–S040 · 2×20 DUTContext</div></div></div></foreignObject><image x="26" y="329.5" width="374" height="53" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABdgAAADUCAYAAACPtUHUAAAAAXNSR0IArs4c6QAAIABJREFUeF7tvQn8Rd9Y7/+5TddwlaFCGSLK0C3/GzIlU2S6LlFo4IVSSULqGq6MZQgRMqSbzENkKGPITLpxGzQgogyRiMvVde9/f9gn53d+e69nrb3XOmfvc97r9fr54bv22s96r7XX2fuznvU8/04UCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEign8u+IruAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEhsDMJIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAITCCCwT4DGJRCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABBHbmAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEBgAgEE9gnQuAQCEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQggMDOHIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEITCCAwD4BGpdAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABBDYmQMQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgQkEENgnQOMSCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAACO3MAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIDCBAAL7BGhcAgEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhBAYGcOQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQmEEBgnwCNSyAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACCOzMAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIDABAII7BOgcQkEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAIGdOQABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQmEAAgX0CNC6BAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCCCwMwcgAAEIQAACEIDA8gmcRdIFJV1a0nkkfaekr5D0dkkfkfSXkt4l6bPL78q/WXhWSfeW9EP9//NcSXdZkf2YCoFjI7DGdeacki4g6RKSvmZrbfygpD/t1pRP9v/2Ovn5Yxsw+gMBCEAAAhCAwDIIILAvYxywAgIQgAAEILA0AleWdKuEURZyHynp3Xsy/D9Iuqukbxy533t6ez6zB3v+s6QbJO7zN50I/msVxG4L6beW9GOSvjWzX3/VMXqipN+S9LHMaw5RzYKYbbzm1s1/O5hzh7CTe7YlcDNJ35u4xcclPWSPc/n8kn5O0jlGbHpb/3z9v7ZY5G80P/eXTdznLd2m25Mq2LG2deYrJV1d0m0k3USS/3du8fg9TtLv7nFO5dpGPQhAAAIQgAAEVkwAgX3Fg4fpEIAABCAAgYYE7CH92k7cOlviHj8h6fENbdhuOrLnnyRdRdI7G9tjD8/fkXS9xH0srv/MDDss8tmz23ynlv8r6TGS7tV7cE5tp/Z1fvf8AUlPkPTVO40jsNemvfz2vFn1goSZFrKv3T3br9xTVyJ7/kLS90j6aGN7vrYTkf9Q0qUarr9rW2fOLul2ku43sHZMGY7nS7q7JG9KUiAAAQhAAAIQgMAsAgjss/BxMQQgAAEIQOBoCdhj/MW9mDTWSQvNN+9E3P+zBwq37z0PU7f6fknPa2yLPa/fnPCk9+1vJOmFE+z48t6D2x6WJV6ZqVtZCPxBSa+aYE/tS8zuUZJuPNIwAntt4stvzydS3iDpwglTf0nSPffUFc/POybu5RMyFtj/qLE9l+sFdodRGir/q3umryrpjyfYsbZ1JrUpN6H7Z7rEG6IW2j9dozHagAAEIAABCEDgNAkgsJ/muNNrCEAAAhCAQA6BB0q6R6Li+yQ5lMzf5zQ2o45jjT+zi6NrAT1V5nqO55h4LUkvl74QwmGofKhn4pA1JcVC2iMkeSOhdrE3+516j/bWoS2GbHffLFo+INg4QGCvPfLLby/n2bYnt0Myfapxd87VP9upsCw2YR8nd6INRYc6sWe/Q+iUlLWtM+fuN1YdSqhlMU/f470tb0LbEIAABCAAAQgcLwEE9uMdW3oGAQhAAAIQmEsgEpP3Fb4hx8vVfZ0qOpVwijYdfr/fCChJNurQB/Za/+ESQybUdWzph0val8huT1mHg3HfdsPBDJmPwD5hUI/gkkhM3lf4pygM1QZ165M7OZsOUzYT17bOXKyPle7Ezvso75fkEEFOHE2BAAQgAAEIQAACRQQQ2ItwURkCEIAABCBwUgRyhO19hG+I4iJvBmVO2IScgc2Jv/5fJT04p7G+jkPBOFa6ExrmFocysOjoMD72us0t9mS34G2BsGWxsO7TBg+VdKGCGyGwF8A6oqo5wrY3n57WuM+/IOlBGfdofXInJ/56aRiqta0zF5f0UkkXzRiP7SqbtfF8E8NsOUG1k+56jCkQgAAEIAABCEAgmwACezYqKkIAAhCAAAROjoA9KZ/Sx1kf6/w+wjdEcZG3bWsZvsFij+NFW7wZKo5Ff3VJry+YKXfthPJfyaj/Ckn372M/b3vHWzhzIkS38yMZ7Th0zTUbhUKwh6xj8v9yt2nwdRm27FZBYJ8A7Qgu+RpJL5P0XYm+/Jak2zQ8fZGzebYxr/XJHSdrfnUXUsnr71CZEoZqbevMDTPyWHjD8LmSnirpLZL+cWd++DvX65Bj5v94ty77RFZOce4Rb0Q63j4FAhCAAAQgAAEIZBFAYM/CRCUIQAACEIDAyRL4oV7AGAMwRewpgZkbF3nTZsvwDZEn/V/0Yo4Ti+aUy/fC4jkTlR224Na94BaFdvl2Sc/q4tVfIrj5k/o40jWS0/pd0t6mP9WLWGNJGXN4ILDnUDrOOlHopdbhn6LNs13qLU/uRJ70pWGo1rjOpAR2C+lOSuq8HCWJSS8i6WGJJMvbY+zNSgv3FAhAAAIQgAAEIJBFAIE9CxOVIAABCEAAAidL4JK9R7aTzY2V0nAFJTBzwkdst9cyfEMkApZ42VqIfnafvHGMh0XFG0v6QAGwC0h6vqRUosbP9d6crytod7uq3x8vLOmWndfoHSR9w8R2di9DYK8EcoXNRPkeWod/ijbPdpG2OrmTE3+9JAzVWteZIYH9XyXdS5Ljz0/1Lnf4qp/uc1F8WeI5+XNJ1+g2Dj+ywmcJkyEAAQhAAAIQOAABBPYDQOeWEIAABCAAgRURcJxvH5n3MfuxMiXhXi6CKAHibjutwjfkcCiJE32TPrzB2LvYnFjATg74WknnT0B+jiSfTrBoVVpyWAy1+ebOg/QcksaSFiKwl47E8dTPyffQMvxTSRgqU2+VeDXiUBqGaq3rzK7A/gf9SZ6Szcaxp8Nr7t0ycmW03Dg+nieXnkAAAhCAAAQg8AUCCOxMBAhAAAIQgAAEIgKR53ar8A053pxDtrcI3xB58pcIbpFAXSMZqcV+x88fK/Ziv5qkN0WDP/D3yP6hJh1n/iGduG5hf2yzBoF9wmAcySU5z3qr8E+lYag2yEs21HKHKfLkLwlDFT2nS15ntgX2+3YJS/0bNGUzcIy7c1c8oRftx+qUnEjKHV/qQQACEIAABCBwpAQQ2I90YOkWBCAAAQhAoCKBKOleq/ANjpnrMCb26twt7+zijVv0HiqlMYpzUEUhJJyk0eFcckIXfJ8k2zj2HjbHu3zTl0hcc72pGxE5bW/seLek23bJXx1SI7oOgT1nJh5vnSjfQ6vwT1fsNpte0z0PX1W4zrQ4uRPFX3+MpDtmJntd8zpjgf13+7XjyZn9LX0yvq3/fRnLgVGymVF6b+pDAAIQgAAEIHBkBBDYj2xA6Q4EIAABCECgAYGv7QXSSyXabhG+ISVqW2hy+Bh7vu6WFolXoxASuXGRba89y28+wnKOZ/luk77HMxJjNlVAioRy3/KTfbzk39jadIiuQ2Bv8PCuqMnolEir8E9jorY3yyzuem0bKrVP7pxFkr30r5cYs9ywJWtfZ64jycK381REyZ2nTvGI979I+u5u4/QdU2/AdRCAAAQgAAEInA4BBPbTGWt6CgEIQAACEJhKwO8Lvxkcp28RvmFM1LbgcvcuZMA9+5jeQ/3KFaJymEQhJEriIqe88m1LiSd8ZPt5e8/cS4xUnCpYpoRyh3F4QCeO/Wovsm/fGoE9GrHT/ns0P0xn6qmLMbIpkdVhnxzW6EEjF9c+uXNRSW+QdL6R+5VsHK59nXEyUoewaSWubxDfpfsNeVjisfNmx0tO+7Gk9xCAAAQgAAEI5BBAYM+hRB0IQAACEIAABKLwDe+RdCVJH66EKiVqW/i6WRc65omSLEoNlZrhGyLP2hJP8Ihj7bjOUfz8KYLlkBD6j32cZHusf3pkTCIBFQ/2Sg/PipuJ5quTXXrzbGyOlXY9JWr7ub5zn4zYyXmHSs2TO1H89ZLQV8ewzpSO5ZT61+3DdY1d61NUL5rSMNdAAAIQgAAEIHBaBBDYT2u86S0EIAABCEBgKoFIZC7x4s6x4TslvbbzID3bQGWHZnC8cyehu+ZIYzXDN0RiVW4yvOgkQImHag5D16kp2m3uuRHKHT7hpb2w/hZJnw+MQmDPHbXTrRfN19rPSCoMlU/l/GwfHmtsI6/myZ1ocyE3DNWxrDP7eApSvzO+PwL7PkaBe0AAAhCAAASOgAAC+xEMIl2AAAQgAAEI7IFAFK/WJuQKQDnmOr7640YqbgRthyK5x0idmuEb7JXtRJ1jJdfrPIplX+KhmsPQdZwg1mEnLjxywd93IvkVJH0gt8E+7v2FOibv78L0OCRMbkFgzyU1nhD27/rx+mB+U6uqGT0j7kzN8E+p3Apezxw+5JmSvn+EYq3Eq2eX9ILEhmHJBmbEcC3rzD4mLgL7PihzDwhAAAIQgMAJEEBgP4FBposQgAAEIACBSgTGkgFumq8l3DhBX0rU2gjaKe9T21QjfEMUf93haq4i6Z0ZjC/Xe8OedaTulHAt0W2jjZES4S66V/R3BPaI0Jf+Psbq2AX2yPvahGqFf0o929vPRWrdm5rHYHcmRPHXS8JQnfo6k/+USQjsJbSoCwEIQAACEIDAKAEEdiYHBCAAAQhAAAK5BCwkv7r3YB66plb4hpTYtC1oR6JUjfANkQDzh5JuIOlTGRCjUDOtEupFoSdyPfAzupisgsCeT/BUBXYTip6TWuGfUuvZtqAdrXs1NsaizcLcMFQ5/I59ncl/yqQbSnrhyAW1Nk9K7KEuBCAAAQhAAAIrJYDAvtKBw2wIQAACEIDAAQhEoQdsUo3wDSmxaVvQjryzayReTYWqcX9LxLVUOIp/keSY5u9oMK43keTNhrFS0oc55iGw59M7ZYE9yvdQK/xTyjN9W9CO1r0aiVdTa4NnTckm2KmvM/lPmXSXPgzQ0DUt1+QSG6kLAQhAAAIQgMAKCCCwr2CQMBECEIAABCCwEAJ+b3B4hjsk7KkRviElEN23u/d9tu6fEsnmhj+JwlWUeDjuYzNgbFgiD9yn9wKe+9OyILDn0z1lgd0hlJ4v6ToJXHPDP0XP4y36MFU2IVoH5p7ciZ6LkjBUUb9qbDoufZ3JfcqiUGQtWeXaSD0IQAACEIAABFZCAIF9JQOFmRCAAAQgAIGFEIhCGcwN35AbF3mDIxKP5yRejTxXSxIcRm2VhJopnQqRR3DLe2/bGgmJvy3pVqWdO9L6pyywe0ijfA9zwz+lwksNCeZR2Jo5J3dqPp+sM/kLwkW6pLKv6xNBD11VK6dIvkXUhAAEIAABCEBgtQQQ2Fc7dBgOAQhAAAIQOAiBKO55ibflUAdSMc+HEv1FgtIckSRKFlgi8kXcWorL55f0ZkkXGpkx+/LURGDPf2RPXWCPNs5Kkn4OUU9tFA6tGZEIPufkTs0QTqwz+c+Yw+48JVF9zuZsvhXUhAAEIAABCEDgKAggsB/FMNIJCEAAAhCAwN4IRCEIbEhJvOBdw3+6D0Mz1KGhRH8twzdE8ddLwlREyVJbxkGPhO2/k3QFSR9sPIsiO1puMjTuWvXmT11gjzbO5oR/ikJdDQmr0dydc3InFRKrJAyVJyHrTN6jeB5JL5HkTdShUivOf5411IIABCAAAQhAYPUEENhXP4R0AAIQgAAEILB3AlH4hiEhPMfISLwfE+6jsDVTwjdE8XlLBZjrSrJn7Fhp6S0ZiYOlfckZy6E6kR0I7F+iduoCe7RxZlJTn5mUeJ8S7lPr3tRnKBUSy30sCUPl+qwz8erkuXU3SQ9OVH1Zl3D6xl2oos/EzVEDAhCAAAQgAAEIfDFpDwUCEIAABCAAAQiUEIi8JKeGb0iFN0iFnonCIkwJ33BeSW+U5LaHSqnH6g0lvTABeY7Xf87YPVnSj45UnCoO5tx3uw4Cez6xUxfYTSraOJsa/ikVfia1dkVha0pOtGxmwnf0ccDPMTI1SsJQuQnWmfgZu7wkC+jnHKnqUwM3lfS8uClqQAACEIAABCAAgS8SQGBnJkAAAhCAAAQgUEog8rqcGr4hJailEnFGnu+lYrh5RGJaqWh/F0kPS4B2319UOhAF9RHYC2AtoCoC+xc3t94g6Xwj4zGUjDRn6FKe6KnTN1HYmlIx3LZGyVNLRXvWmfQMuLCkV0i6eKLavpI+58xV6kAAAhCAAAQgsBICCOwrGSjMhAAEIAABCCyMQCpusE2dEr4h1WYUo7x2+IYoDE5p2JmovUMK7B6v1vf3PfBgz3+IEdilaOPMNEufw6jN1EmSKGxNaTiXqL0pJ0tYZ8afsQtIer6kyyYew89JulZ/qiD/aaUmBCAAAQhAAAInTwCB/eSnAAAgAAEIQAACkwjUDt+Q8orPSfQXeZyXhGCJ4q9P8ZxNCV85/Zs0SFsX3UPSAxONILDPJVz3egT2L/KMBOPSkyRTw1BtRjflcV56cic6CTTl5A3rzPBzaM/135N06eAxNb+HSvKaTIEABCAAAQhAAALZBBDYs1FREQIQgAAEIACBLQIX6b38vnGESqk3Zyque05bUfiGksSr7pNDU1iUGSpTYj/X9rAvnYyRUInAXkq0bX0E9i/yvaKk10j6qhHcpeE8poah2tz+kp2H8+slnXvEnpKTO1Eui9LNA5vEOnPmgfGYvTiRT2NzhUPH3ETSp9o+2rQOAQhAAAIQgMAxEkBgP8ZRpU8QgAAEIACB9gQiL+9Sr+yUMJQT2zgKt1CSeNUhAl6eyFVTIqJtRuLQMdAR2Ns/EzXvgMD+RZqRl3cq+fHueERrRBSGyu1FYY5KNt9u38WXf1xi0pSGv3FTrDNnBHp9Sc+WdLbg4Xx1n9jU84kCAQhAAAIQgAAEigkgsBcj4wIIQAACEIAABHoCkUCUI1i5qSgucm6iv1rhG1LhVErDQGwmC8JXLE7+tqRb8XR9gQAC+5cmQpTvITf8U+qUS8mGoEMteY0YKrnho/wN9lRJt5zZzu7lrDNfJPKVvTf//TPWkz+XZCHeJ6UoEIAABCAAAQhAYBIBBPZJ2LgIAhCAAAQgAAFJUYiD3PANqbjIJYn+aoRviMT+Ek/47UmC8HU6Arvfrx1CZCysSc7icXZJT5F0hZ3K/yDpepI+ktPISJ3PS/qYJP97DSXK95Ab/imVpyEnDNWGVXTCJcfzPAppVeIJzzpzxll8PkmP7xM3R/Pbce5vLOkDUUX+DgEIQAACEIAABFIEENiZHxCAAAQgAAEITCVQK3xDSkArSfRXI3xDSuw3p1wxb5fpb0i67Qjokk2EqWMVhYixaPuSqY1nXheNz7F4sEf9zMTVrNrf9cL9B5vdoW7D0TOZu+k1NwzVpldRjoac2OlRUuYpYahs3ymvM/6u9ebH0yV5AyMqDgN2C0mEhYlI8XcIQAACEIAABEICCOwhIipAAAIQgAAEIJAgkAqX4MtywjekQkDkiFXb5s0N3xB5p1qQeeaEGZES90rCU0y49RcuObQHvW2IhGcE9qmjW3bd2gT2KN9DTtim6GRKbhgqk47sydkUTIXX+lyX2PVqkt5UNqxfqH2q64xPfPxydzLjjpnMHiHpnh2vz2TWpxoEIAABCEAAAhBIEkBgZ4JAAAIQgAAEIDCHQCRIRx7fKS94C8/2rH5pgYGRPVH4hrkC/ZipkQe5vfhfVNDP0qoI7KXEptePNhKmt1znyrUJ7O51lO8h8vhOecH/s6Tv7pJc/lkB3pQ90YmUGgI968yXCDg02PO6jc9LZIzfv3bhYG7Xh1/y7wsFAhCAAAQgAAEIVCGAwF4FI41AAAIQgAAETpZAFC4h8ua8Yuet+ZqReNUlcZE3AxDZk/KIj4TRqXGRbduSBXaHSHDIinc2nsURXzzYGw9A3/waBfYo38PvSLq5JHuzDxX/7Rkjf8vNFbF9eWRPyiN+zhoVzZBTWmf8HfsjfVgcJzWNytu7Ne4Hu8Syfx1V5O8QgAAEIAABCECglAACeykx6kMAAhCAAAQgsE0g8saMvDlrxUXe2BTZkxLToljPkZdsamb8kKSnJiqUhKgonYEOn/ACSdccuXBfgisCe+nItam/r/GuaX2U7yG1Gefvnd+UdOsRg36pDxdSYm9kT+rkThR/PTplwzojnVWSTxvdOXPQfkXSvQkJk0mLahCAAAQgAAEIFBNAYC9GxgUQgAAEIAABCOwQiMI3jInHNeMib5uUsiflrZ1KtpoT5zk1MW4o6YWJCnPE+2hCRsL26/tQPP8SNTTz75Edx+LB7g2NJ0m60gxeXybp/JL8793i5KRjnto5t7QY/f2SPpJTeUF1UrkaUnkMnPDSG2uXGujLnPwHKXtSiVdTm4ofknRlSe+ZyP0U1pnz9ZuVYxuG2+je33u5e/wpEIAABCAAAQhAoBkBBPZmaGkYAhCAAAQgcDIEvq3zjn6dpHOO9HgsfEPKYzzyfE/BjcI3jCVenSqY5Qz05XqRz56XQ8WCrGMDtygWat/cefFeaKTxOaFvSuw9FYG9hMlY3TFWa/Q+r8HDbXyfJM/Vse+XMU/0lMf4lDBUm/5M2ZCLNhXnPovHvs5cpt+ovGDGpPKGnZOefjKjLlUgAAEIQAACEIDALAII7LPwcTEEIAABCEAAApIi4XRMxEoJVFHs9hT4KeEboj5EyVqjieBEfPYUP/dIxSiGdNR+6u/RvVuK+9t2RYyPxYN9zlhtrkVgPzPFKHb5WPin2mGoNpZNCSkV9WHuSZboWV/zOuME1s9JbORuxsWbs7eV9CxJJDKtsRrRBgQgAAEIQAACIQEE9hARFSAAAQhAAAIQyCDgeLj3GKk3FoYh5TGeSkaaYY5KvdEjYWrM6z3HFtc5r6Q3SrIoN1RahmmJYj7fVdLDczsyox4Cez48BPYzs4ryKwyFf4o8xufkPojaHvJGt0j88hEv/LlhqI55nckV19/UJTG9ZRdv/735jxo1IQABCEAAAhCAwHwCCOzzGdICBCAAAQhAAAJSSjgyn93wDZGX+ZxEf75fafiGVBLSVNz23LGPEo3+vaQrdGFiPpDbYEG9VN/mxKAuMOELVRHY84khsA+zivI97G6EtQpDtbGuNJ56aiMyFbc9d+Yc4zpzeUkvy/Bcf0SfrPYzubCoBwEIQAACEIAABGoRQGCvRZJ2IAABCEAAAqdNIAp98AeSLJp/useU8qqem+jPtygN35DyeB8LPVE64r/Rhy4Yuq6G9+qYPam+1WCdywGBPZfU+GbEKcdgN70ov8JuuKPU5tKcMFSbkYxOh2xvFEYe73PDUG1sOqZ15sJd0tdXSLp44tFxSJhbdHPjRYSEyV9gqAkBCEAAAhCAQF0CCOx1edIaBCAAAQhA4FQJ+J3iN7uj+bceAbAr5KY8P+cm+rMJkZi1fY/Im34seWLpWEfet3PCVYzZEnm0tgxNs2sTAnv+jMGDfZhVNIe2RfNoTZobhsoWfm2fvPhSI0O7fY9o029uGKqNCceyznyNJMeMv2bisXl/f1rp7fmPFjUhAAEIQAACEIBAfQII7PWZ0iIEIAABCEDgVAmkvEXNZOPNGYnfcxP9bfinRPztkCzf0Yk4r5N0joGBqxlC5XK9GHfWkQnSIgFhJOrVEBlz53skjpLk9EskEdjHZ1UqzIq9ma8q6Y8zxO+5YahsYSTib29gXVeSN/aGSo0wVJt2j2GdMVf/Dnhzc6z8uaTrS3ISbQoEIAABCEAAAhA4KAEE9oPi5+YQgAAEIACBoyIQJQrdiLkp0bdmqJRU+IZt4Ty1MWDx5sqSLMjPLZG3a817bWxNxaI3g+t1sd9fOrdjmdcjsGeCSsSrP/UQMSYY5XvYnARpHYZqM5q5+RtSGwO1wlDZpmNYZ6JQQH8j6XsR1/MXFGpCAAIQgAAEINCWAAJ7W760DgEIQAACEDglApGAuvHmvLqkF4yAqZHob9N0JDTZO/JeQWibml7lkber7a7hVbvp/1dIeoqkm4+wbiHop+Z7ND/wYP8SPTzYx2dSlO/h6ZIcbuXnu1BRDxpppkYYqk3T0caibfF692JJ3zNiT60wVG5+7etMtG79s6TrdJuDbz2lH1f6CgEIQAACEIDAsgkgsC97fLAOAhCAAAQgsDYC9+kSzf3iiNGbOOy3lXSPkTq1Ev3lCE0W2W4n6YWd+HXZEXtqx0VPeZTbhGdK+pFO+Lcn/9xykT70jQXJofIYSXfcY2JABPb8EUVgH2cVCbCOw+6TGb8u6ftHmqkVhsrNR/PaJ3d+tfO4foOk8w3YUzMM1ab5Na8zV5T0mi48zFeNjJ1/O7xxYm4UCEAAAhCAAAQgsAgCCOyLGAaMgAAEIAABCBwNgVRYBovGN5T0c4nEdbUS/W2ApsI32Fv+JyU9X9K5B0ZgO55zrQE6by8eXWKkwZr3TG12fK6z42qdJ+ibanUso51IiMSD/UsQEdjTEyr1XHsjz8K6T284HNVuqRmGatN2KvyLN/Is9nsjb+jbq8VJkjWvMymWf9mvWx/OWG+oAgEIQAACEIAABPZGAIEpCNX/AAAgAElEQVR9b6i5EQQgAAEIQOAkCERhWSxo370Ly3KhARobD/f3VCSVCt/gxIIPSYSRsCfstSV9vKI9biolfPvvz5FkAfFfZ9z3YpJeK+n8I228TNKNJX1mxj1KL0VgzyeGwJ5mlXquvUl11y5p8cO65/tsA820eK5TceG9kefwMA5ZM1RqhqHabn+N68y5JL08caJon0mZ859WakIAAhCAAAQgcPIEENhPfgoAAAIQgAAEIFCVQBT/17GInZxuSPiqGRd506mUqGtP1t+VdNMRAq3EnG/rQ7ecc+S+Dn1wC0nPmjgyXynJ4V9+LNG++/y8ie1PvQyBPZ8cAnuaVc5c+tE9PtepuPDeOPzTft0bMql2GKrNPda4zkTJTX0yYd/rVv5TS00IQAACEIAABE6WAAL7yQ49HYcABCAAAQg0I5AK3/APvVf10DtIzbjI251LhRz4tKSzj5ComXB0+xbu+yM6z/g7JUZgaiI/t303SQ9OtG1v2h/Ys/e6zckRRW/VbFauq2EE9ni8Us/1eyV90x6fa8eFd/6EoZjv3jDzZp43vnZLzZBQu22vcZ25iSR79A8Vn7Zxktg/iqcGNSAAAQhAAAIQgMB+CSCw75c3d4MABCAAAQicAgHHPR5L6DfW/xZxkTf3SoVvGLOnRbia7XtFIVxc96OSnKwwN076l3fX/LSkh0v6spGOTRXua8xbBPZ8igjsMatUvodDPNe375KYPi42+ww1WoSrWfM64wSm3jgZKi03IwqHjeoQgAAEIAABCEDgjAQQ2JkREIAABCAAAQjUJnCW3gvxegUNO06xvRMtKtcuqfANY/dqEa5m914ODeHkh1F5dFfB8ZQ/lqh4kT7mtOOqp8ovdB77D5Vkr9p9FwT2fOII7DGrKN/DUAstn+sovMmQPa3CUG3fa03rzJMljYX2cZ/+UdJn46lRtYY3JX0qy2F+KBCAAAQgAAEIQGCQAAI7EwMCEIAABCAAgRYELOQ+qKDh35J0m0bCbxQXfsjMVuFqtu8VxUrftesPJT1b0ke2/uDTAo7XfpkM1k/sBKo7zEyemnGb0SoI7Pn0HLboSV3CxyvtXPK+PgzJ9hzIb/W4ai7tuY7m9xD9VmGo1rjOTNmY3ceMxnN+H5S5BwQgAAEIQGDlBBDYVz6AmA8BCEAAAhBYKIHS8A0/LOlpDfuSigu/e9uW4Wp273W+XjT/7oZ9d9N/0Auzn2h8n1TzkQD525KIwX7AAVrhrZf2XKfiwu/ibR2Gavt+a1hnovXhUNMTgf1Q5LkvBCAAAQhAYEUEENhXNFiYCgEIQAACEFgRgZLwDf8kyYL8Oxv275KSXi/p3Bn3aBmuZuj2F5b0e5IunWHblCqv65OaWtA7ZIkENAT2Q47OOu+9tOe6JN9Dy3A1a1xnovXhUDMUgf1Q5LkvBCAAAQhAYEUEENhXNFiYCgEIQAACEFgZgUd1ccPvmGGzQ5/cQNKnMupOrVIi3uwjLvJuP+xh+lRJ15zawZHrHHrHiU8/XbndKc1FY4DAPoXqaV9TElakZRiqzSiU5HtwbPTH73n4lrzOROvDnlH92+0Q2A9FnvtCAAIQgAAEVkQAgX1Fg4WpEIAABCAAgZUR+M+SXpBh8y91ccHvmVFvbpXc8A37iIs81BfHZP9ZSbbT/31OcTJAx7S3Z/whEpoO2R4JaAjsc0b8dK/NzffQOgyVR+ArJD2zD8eUGpFDirZLXWei9eFQM/yQY3WoPnNfCEAAAhCAAAQKCSCwFwKjOgQgAAEIQAAC2QScgPMNkuw1OVYs/l67CxHzyuxWp1fMCd+wz7jIYz05j6Sf773/z1rY3XdLul8XbuY5kj5TeG3r6pGAhsDeegSOs/2cfA/7CEO1oXv7bs17XID6bf269/EDDsnS1plofTgUKgT2Q5HnvhCAAAQgAIEVEUBgX9FgYSoEIAABCEAAAidFwJ6m39nHT79GF0LmYpLOvkPgg5LeKuklkl4m6X0L8lg/qcGisxBYKQHWmZUOHGZDAAIQgAAEILAcAgjsyxkLLIEABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIEVEUBgX9FgYSoEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQgshwAC+3LGAksgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEBgRQQQ2Fc0WJgKAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACyyGAwL6cscASCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQWBEBBPYVDRamQgACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAwHIIILAvZyywBAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABFZEAIF9RYOFqRCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEILAcAgjsyxkLLIEABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIEVEUBgX9FgYSoEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQgshwAC+3LGAksgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEBgRQQQ2Fc0WJgKAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACyyGAwL6cscASCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQWBEBBPYVDRamQgACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAwHIIILAvZyywBAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABFZEAIF9RYOFqRCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEILAcAgjsyxkLLIEABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIEVEUBgX9FgYSoEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQgshwAC+3LGAksgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEBgRQQQ2Fc0WJgKAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACyyGAwL6cscASCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQWBEBBPYVDRamQgACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAwHIIILAvZyywBAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABFZEAIF9RYOFqRCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEILAcAgjsyxkLLIEABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIEVEUBgX9FgYSoEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQgshwAC+3LGAksgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEBgRQQQ2Fc0WJgKAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACyyGAwL6cscASCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQWBEBBPYVDRamQgACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAwHIIILAvZyywBAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABFZEAIF9RYOFqRCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEILAcAgjsyxkLLIEABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIEVEUBgX9FgYeokAl8p6eslXVrSV/f//TJbLb1d0kf6//13kt4v6eOSPjvpbnUuOoukC/Y2n0fSd0r6CkkbW/9S0rsObONYT9ds+1ifzirp3pJ+qK/wXEl3qTPUJ9vKGp9L23x+Sd/RryXfJcnz3c/ieyR5/fgLSZ862VFt0/FjXFPakFpeq37HPLekb5Z0oZ3f381z81FJfyrpnyT9v+V14WQsOqekC0i6hKSv2Xrv+GA/Pp/s/+33pc8vlIr78C39XLuopIv170lv6X6zbf+fSHJ/lmr/QrFiFgT2SuDLJfnb55v6Z9nfP/9Jkp9vl82a5P/u34+/kvQvvHvtdYy4GQQgAAEIjBBAYGdqHBsBizFXk3RzSdftP+in9PHTkt4s6RmSXizpw1MaKbjGL5O3lvRj3T2/NfM6v1Q+sXsJ/S1JH8u8pkW1Ndse8bDgYL7X3Kr425JuFV3I389AYK3P5dkl3bjbdLtTtw5cNnNM/0HSf+/E+Mf3G3aZlx20mt8FvPak+vjYfpNvH4Ye85qyD36HvIefmetJup2ka0n6skxj/q+kV3Yi729I+n1J/g2mtCPgDcOrdxuDt5F0E0n+37nlbZIeJ+l3D/zu4XXrkt3mzM9I+sEtAS7Vj808e7Skl0r619xOL6iehcc7S/Lm/9yy62Tyvn6za0lcLKz+136zbqi/f9MJsr92AKeTaBy8sfOkYID8neJ3jKWXz3Qbb4/ovlPe28BQvx9eRdINu02wG3XvTxeeeA/PWTs5/F7nCPH8jus7Vvp8T+w+l0EAAhCAwBIIILAvYRSwoQYBi9L36LxJf7jgg77kvn/UfUjesRPt/cJcs9gj1t7RPzGjUX8wPkbSvXovrRlNFV26Ztujjnpt/AFJT+i9lbfrI7BH9L7097U+lz7t8rP9M1UiPO2SeU5/2uED+cgOUtMnfF4j6WsTd//PnVfrixpbd8xrSmN0B2/emyIWwbwZNeeZcUf8m2YB9wG9t+LBO3dEBngDxJsf9xv4bZvSTQtZd++9SKdcP+Ua/z5fvhdVLzelgf6af+zn67NX5tXuU42vlXS2GX2PLvVJTt/Da/5L+ufwUCdM/LtghxefghkqfyjpBgfwYI7GIedd8Re6k3APigZjAX//X5Ku2ongf1zJFnupe4Pvrt3Yfl+lNneb8e+IN9Ee2H+7cXKlEWiahQAEIACBLxFAYGc2rJ2APYwftScPEIsHD64EzC+X9oK2iDBXjNiY5KOS9uJ6VSUbx5pZs+05aKI5lfPRlHOfY64TMazZ95rPpX8T7XX79EBsLrHfXlUWtJ6y0BAY7rO9/+4QdKqlwH7sa0rJfFlbXf9+eTPKIkat37INAz879+w8k38VT8TZ0yK1aTy78X4NsdDe+uSBNz+9Xv1oDaP7Nv6gd874UMU2WzYVCbst7v3Pkp7cnQr1SSZ7jO9TbEdgbzGiZW3WEth96uIW/abC15WZMLm2w/ddgc3ayfy4EAIQgAAECgggsBfAouqiCPglzR7l9nCr/VE/1tFaQp5t91HL2zcgao8NexDao73FB9CabY9w584pBPZxkrkMo7Eo+Xut59Iir72pam2i7fbhYb2n55KO3tvGXLGmlcB+zGtKyTxeY12HSPBm1BUbG/+8PoSR47RTygk4Dr43829WfmnRFQ4d43u0CCNhQxxT3WFpfOKmdnH+Ha9xDpmy9JK7Zrfqh/MA+XfX4RP34RWMwN5qJPPbnSuw+/3Kp0If2X2f7EtY3/QOgT1/nKkJAQhAAAIzCSCwzwTI5QchcL7uQ+upO3Gx92FIDSHPx7P9oetQNi3Lz3XHvx9eWWRfs+0p1psXf4+LveOigsA+TGjNz6U36ewp+4vR4M/8u+eY4wUvRWR3v5+WKby1ENiPdU2ZOU1WcblF9RdWPOkRddrirWMVLz3cUtSPff+9pSg91JdWQrVjrVvQdfLSVsWnAB0T23NtyeXQAvuGzbv7TenWQjsC++Fn4xyB3Sca7fTjd4hDFAT2Q1DnnhCAAAROlAAC+4kO/Iq77eQ3TmDTwoMpwjJXYLeY5ZdMJxPMLT5uba+9/9B5fpwr96I+hq29RX6n4JpU1TXbPtYvC+vfL+mhidieQ9cisJ+ZypqfS/8O3q3Qc90CucMJODlXqTeWY656zrU4YVL6uH9vH6M0JxFlbYH9GNeUUv5rrf89vSexkw+WFMd1tlBjwSxnzu227VAeXrM/UXLTE6578f75LhWlN+8d3jSdckLQIUS8tjhhZo3i35dXdJuB7k9ucXz1z3YODaV9qG17rr0l9ZYisG9sdo4iO438dUknCuoisBfAalR1isDud6vr95v4Oc4rjUwXAnsrsodv92v65Lg+uW0HGSdIp6yTAGO5znHD6gECCOxMizUR8OJrwfiaBUY7ZMqfdy95/gBwcp6P7Fz7HyXZu8IfLJcKPibnCuwOP/ErGbb7Q/L+vc3+QNwUf+jaRrfzIxntvKdnVeO49ppt30Vlr9mbS/rlCeKo20JgPyPRtT+XFo6dqC8S/Bw64D6SLPJ9aguBN2ocKsMxzH86Q5Dyh+o1GiRMzlgSzlDFm3b2PLRYmlNqC+zHtKbk8DumOjmJ+T7Tr5XP7T2CHcN5u/i5sXB2nf65uUwmIIcYuPNCNqgyTT5YtRv2pwxSBvgdyWPkU4FO4m5henvzz98J3kT0OvHjfY6KnA55bfEmv+fBnOJ1yiGCLNinijc9H907MfidZzt0idvwe6PX75x59lt9X5dy0mi330sT2G2fWfnkpJ1IaoeNQWCf8wTVubZUYK8Rcs9r0f/s8i34W2aofHt/oiVyckBgrzMHltLKefsNPTurfeuWUbXfUZfS32O2g7E85tE94b4hsJ/w4K+s66Xejs4c7/jsby0Mx3CeXvwa+pCcI7BfvotT+7IuWVvK489Hq2/dfci+OkM88IvlsyRdIhjHJ3Wetj8h6f/MGO81277pttc6e7/9VP/h7LjPUwsC+5fIrf25zPGM9IelX+T9vEXCgTfrLM5Em4B/2ImON9gR6qfOx6nXeV349YKLa368HMOaUoDu6KqmBHbHZ3ayS580yxUovT57s/s3uusuF9D6XC/yvu7oqNbvUEpgt3jlcXpmYWLSi0hyPgmH64mKHQEs3E8tuaeLHKrIG5xR+KDcZMreYLhpL+xPtb3ldZHA7mfjUZkG/HtJ39WdqrLjgdt1SCH/96mlRb6EYxbYHfpo7oncb+6/d75iZND+qv/7tsNO6fh6Lfe8ysmD4fdCO7B4E72k/EP/TmKHB5+GyP392Dg5OEG9E8pfduemCOwlo7Dcul6nvL58w4iJNd9Rl0vhOCxjLI9jHOnFCAEEdqbGWgjkhjKwd6nFsL+t0DGL7T8p6R5d+AgLslMFdl/77F5QGzNrSnxZi3l+Ed19mdy+x1wxYs22e32zgHrL/uN77KWsdKogsH+J2JqfS88PJxv20dKxMiWesD36LRRaoEmVueJT6bzdrn9BSa/qxZTcdmp9vKx5Tclldez1hgT2T/abuf6tizaixvh4bjyw91BPMazlHX3s4zQksFu0upekX5vhXW5By6d1nOcldfLHpwd9Wmf35GAudwuPrwni/E9JHu2wFZ6nZ0sY4lOPjsf+sVxj91gvEtjnvqM49JmdOByOyaFfSt+dprzPpvAds8BeY9pE82GfG/oW17254w383OLvGK9J78xwLspp0xtETrbsNr35gMCeQ235daITWbXeUZdPYv0WMpbrH0N6kCCAwM70WAMBf3T7BcxHyVPlvv3Hea7XQ27fHTvQH/0+duyPudJyk/4I9tjzNifmp72NXtsftR+z6zmSfqjAG2S7nTXbXhoCY9PvN3fjfI6EV9Hcj9fS+bPU+mt/LqOPUoe08JrjUzClxZtzLwm8cQ8l4ORsLAz1t9bHy5rXlNJ5cKz1dwV2r4l3lGSRfW7JORVTGq5grk1rvX73I9YOCD4lF3l65/Q317v8RhlhaobuZ29cJ4W+bcKYJ/ab51Pe+SwcPyXo6CE3QVOmRb9dNd9RNo4KTs6dEwJtY7ffa6/XCfTvyplMQR0E9jSgaD7sS2DPXRM2vfE7kNejv6gwR4aasD0+LefQRZ6/H2x0H5rdDwFE2f1w3sddGMt9UOYeByOAwH4w9Ny4gMAVey+mr2r0oZVrij/4SkOtRCKv45/OTUYafSjai/1qnVj4ptyO9vXWbLu7ENk/hMMx8h/SievelBiLTV3z47VwSBZVfc3PZY54MzcZ6XdLeqWk1Lp1iz5Ewz4H1kcz7b2e8t4csqeGwB49k0teD/c5Rku/10Zg93hZAH1yJc/DTb99CuRFXb4DP0NjZeqJsqWzrWnf9kdsCwcEb4Y8oRfJxux2yKzbTJgfkWg4xzHBttr2p/WermO2Oya9N1mXllQ3YtPqHcXOJv+tP/WVk/x27hhtxgWBPb0qRPNhXwK7Tzz4ZEiUz6ZlvP6a6ydtLYsAouyyxmOONYzlHHpcu3gCCOyLHyIM7L3HHaZlrDjmqwXkDy+Q1vf1Wc3HnrU53uWb7kailev9UufBfs9CPmu23V3N4bJB8u5eKPKHSHRdq4/XwuE5eHWf6ljrc/ltfTzRsZwINbzLc0R8J212wt3Sjbupg5+bMHCo/RoC+9rXlKncj+06C+wWuH0M35tILUo0V36/D2ExJ65wC7uX1KY/Yn+30SbIpp/RWmrvVG9Wf7QAjN+XHMLGcdXHSg3v8kiY9Lp89S7m/+sLbN9H1cju1u8oTur99C6vkDfZo+JTExZe52xSILCnKUfzYR8Ce05eFffCYfc8H/yORYFACQFE2RJay67LWC57fLBuJgEE9pkAubw5AcfSe0GQNNCeWfdpbkn5DSyw+QiyBbShMtWzfKgt3+MZCRNLP3LXbPsGQySUu55DGjhOo2Nmf6a/MLqu9cdr+Uzb/xVrfi5Ny+vFLyaw1fIsj7z8nTDsKn3s0X2MYiqx6WN7T9Qxz/a5AvsxrCn7GKM13MN5Thxf+40Njf3aTty0MHSpkXu8R9KVFrqx3hBLUdP2vvYmor1KnbizRXG8bm8UOhzIUPmX/iTCOwpu7kSqTqj4jSPX1PIsj9Yk395Cv8NLLKlEguo+3lHswe6NtvtngJkTysfNI7CnIUfzobXAnhMSzz3wmu3k7o61ToFAKQFE2VJiy63PWC53bLCsAgEE9goQaaIpgfP2H/EXHbnLUj2MbG70kfgySTeekWhsG4k5ORnYJUY4+eP62gXehmu2fYMgJZT7iOoDOvHhVwfiBiOwx4/0mp9Lh5/ws+dQKUOl5omYnDj1Fr0fHyOfXSOVr8Ef4N50+L1E6Ji5AvsxrCmzB+FIGpgSLm1K173xORaDe4pwO8WGNV/jZKQO49NKXN+wuUuQn8biu3NS5JbIYcDx/h+d21hQLzopUeqcUMmsZDORoLoPgd0G+hvSIQ7tzR6FBZlz4gCBPT2rovnQUmD3HPBpJp+STRXE9X2sDMd9D0TZ4xlfxvJ4xpKeDBBAYGdaLJ2AhfU3dMmuzjdi6JKTnTmx6FMTgB073TFAa5UoZEdJmJg1277hOSSU/2MfcsjCzadHwCOwxzNyzc+lPcZf3W2wWCQcKiXPSUzqiwmGU+vAPsLEpGIlW4CzyGRveidMbuXBHnFY8nqYM87UqU8gJdwu+be/Pollt3jdPhTemJUlm3Nel5/Zh5EYau9Dkq7ce8PWoHKu7iTEyyVddqSxJTpxRILqvgT2DbKc2NtOMHnViUlPEdjTMz2aDy0F9kv3zj0+cTRW5iSMr/GM08ZxEECUPY5xdC8Yy+MZS3oyQACBnWmxdALRi+NSP7L9bP1mIvlX7Y9Ej+O1+g/Fsec6N2btmm3fns8bodyJ8l7aC+s+Wv75YNIjsMerwlqfS/dsk6BxqJctxJRL9jF8zz2CdR8ekikBxEkIf1zStzcU2I9lTYmfDGrUJJD6CFvqb3/N/q+lrej3oERgd1gYO1VceKTzLTYkHyXJXvFjZV+njHLHO+K9b4Hd6/vdJD046MAju1jsd55wogKBPQ02mg+tBPacPDO2/OeCEy658556p00AUfZ4xp+xPJ6xpCcI7MyBFRKIXhyX+pEdxY/NFbtLhiz6MP37Tmi+gqQPBI2u2fbtrvnl/0J9UiWHhMktCOwxqbU+l1G84BZidzSfHPvfSQBbJf26QOfx+YqR8FFOPOgE0Y6nHY1piUi2O4OOZU2Jnwxq1CSAwF6TZru2aq4dkaNAC7Hba5tz/YwVh0DxCZvWoXZyRyjivW+B3Xb7lJRPZDrx8ViZ+r6OwJ6eGdF8aCWwRwmObfWL+zBCmxxHuXN8zfX8numTMdvFJwV9SrDkW2RpDHb7ZWelj2U4LdXqx1pEWec9cXjITdk3p1q8W7azlrFsyYC2j5gAHuxHPLhH0rXoxdrdtHfm8xbW38v1Cdq2f2S3TawdhsJtR+Jhrnfumm2vMQ0iQfQQH681+lWzjbU+lxab35xIntfCO9LcIw/J2uFRNmPtTSYn6bMoNVQcO3XjdRh9pM8R2E99Tan57J1SW/sW2P1O/L1dIr639WLIPlg7J4Sfjz9YkIBb2u+aa8c9+tNmQzbkvsOU2h+dMvJ8cA6bj5c23Kh+xPtQ7yg54UIe058WKNmsiN43WgnI0fAtZRwiO1rw8Vrpd4s7JCBN3VCJuC/p716/HfrI36FX7516UvZZYLcjh/PdPL/Lw+Xkz61Ed296+eTkWH4E5zH5VMJY982/wbfu++j2hspH+hwbT5CUc0o4xWdXnN6u69/mJycuvlXvTBLNj5qCt5n4+buFpBslTl7ZJoclfb2kJ/WnzT8RGZr4ezS2vtSbWg7PVKs4p4sTGvvfY2V7Tq1tLGtxoh0IfCFBDQUCSyYQxce07Y7X6QRK/vhaSoniDZcm/crtVxSHPUfIW7PtuZxS9RDYY4prfS6j+Ot3lfTwuPvFNaJnqsWGm420KO6PuKEPLHvMO3ayPZBcoo/0OQJ71P8lr4fFg80F1QikwjnZG9DP8zsr3c3vwxaLHMbCgtRN9yCyW8BwPhDfy3196EpF9tRGSEmC9Sj+uhMlXknShyuN+aaZ6PesRUi/OV2I1upDCex+hu7XvYvfK9E5n6R02L6/LQCAwJ6GFc2HFgK7E92/ZuRk3MZaC4ne3F/St1nBtButaoHReWs8z30qeE6xCPrrkn5FkvMU1CzRvNh2sNi+rx1R7p8IcZqy8e/6cFF2VonCcQ61YwH9R2tCGGjLNnrc5vD+6u794GckeUN4zJEu6obfze/eifN/FVUc+LvfHV7Ur6Vjl7+rC/t4jf4U94RbnOkSb8yjU/QAACAASURBVHA43OrYhs1uno21jGUNNrQBgTMQQGBnQiydgOeoEwTeMmGovST8I+Kd86WUlMeqd3j9gWHPhdrlJpL8YjNWcoS8NdtegycCe0xxrc/l7buEyY9LdK+V0Bt5cLfwnE+FhtkkNnXomE2JPsbmCOynvqbETxQ1hghYfL7tCJqaYuu2uL75eHQi5JYi+7a4vuniWkX2VDLakvedKJSUvfztJTiWoHzqUxT9nrXynJ9qb7RWH0pgd39ywoaUhvlBYE/PlGg+tBDYby7pGQmzPteHn3vT1Em+wOu8TthL3Z7a39zAvkd33uz3lPTJSm1H82JXYPfGgTeZLfaPeavnmvacfnPFG+ElZemirBn9pKSHzBDWd3n4JIiF9tLfNesIr5T0VQnAD5B07wob9zmCvh0drddsytLHsmReUhcCRQQQ2ItwUflABCJRzGa1/hgu6XoUqqWmMLBrV+ShG8USXbPtJWOUqovAnkdybc+le3UoofeifeK+842g9bFRi/sWo2oUfxz5KP6PjTTmTQYn9dv2LIs+xqYK7KwpNUb09NqIvIpria1D4vqGtu/ho/9zjnIPjdyQuL6p54SAPkVTEkLjkLOjptd5FKrFHrG3a9TZ6PTfkkIRRmv1IQV2z4enSLIAO1ZKcxAhsKcnfTQfagvsUdJyW/uyzonoxn2YikaP7F6b9bvbY/s+tbyx8+L8YBeS5VUVbhLNi22B/eySLPA7HEyt8ro+/r5PAOWWJYuyngMWkK+Z25mCes6D9F+6XB/2Os8tfg4f0YUuu1Pigu08S7ntDtXzpqhPWowVb6j4pOp2uKMlj+UcFlwLgZAAAnuIiAoLIHCR7gfNP9RO4pkqU37MW3Qv8sKq/bK73YfoAzW695ptrzWWCOx5JNf2XEZCb41jo2Pkoueq9r0tBj175CinN/j8gfDeHWOjj7GpAnvU92hNypuNw7Xmrodz7s218whcsQ9BMOadZa8vH9GeW3zU30etLQwOldoiu8V1h7XzfYeKhXULU6mkm3P7XPP66HegREyNEpyOhTSo0Z9ow7jlvUvtj9bqQwrs7kuUNLY05A4Ce3qGRPOh9m9s9Jtua0tPKZQ+A/us7xOIPmV4wT3d1CcMLZraSWLORms0LzZrWmrDd26XS38/lyrK+l3SCXvtLNOqvL9fO99ecIOv7zdjnP9irMwN1XSxLkrAayV5HR4qu6FhNnWWOpYFeKkKgWkEENinceOq/RLI2aXdWOTdWoeT8bGpOS8mc3oYeau2/PiJPkQi7/k12z5nzLavRWDPI7m25zLyiK39EVoyp0rCKESj8019wsShDwGviU7G9KyBRqKPsakCO2tKNGL8fZdATixnhwp5YQV0PvL9890xa4dPGyulIsFYO5G47use1h8Xb5X4rgKyMzThvC72WB4rJcJ0lKth6hqU0+dUHHlf39J7Pse+7TrRWt3yHTPH1mjNL4nL7/tF77Utf7tT/V3KOER21OYTnZStnR8jZ861qnP93lnhbK1ukGh3bsiwaF54bfZpqdRpxxrd9qks/67llCWKspftk7h6Y6l1+Zs+0fr7Cm6UyrXkZhyuyZvXdkIsLTnfebuhYTb3WOJYlvaf+hCYRACBfRI2LjoAgWgHddckH2Xyy0OtWHYlXY5eanLioJfcb7tuJA5HnrJrtn0qs93rIoaH/nit1c8a7azpuYw+0lvEQd9mnHrZdB6Jq0r645mD4tAwT5N0s5F2ho5xbqpGz/5UcStqd8nr4czh4PKJBKJ1xR+fV+5CIDlhYo2yD5H9GMX18/TCgz08h0rpupZKats6Dnq0Ti3pd3/ptjrchE9gpEIplCQUj367awvIuWvKUsYhsqM2n+i0R+375Y5H7XqX70PdnDOz4bdJ+u+S/G97I28Xr5V+x3Nej+9JJIrcvsae7D8Q5NVKmRbNC38j+zd0aIPU935uHxLlT7YSlvq38v/rQpl4Y9V9GUt4uW3XmIfzkO1LE2Uv3L1rOFfRxTPmgHl5I9YhHz+1Vd/zxyK9hWhzi5jZU97j7gS4OcXv/c4LkArvU9rm5r5RnPfUN8XSxjKHJXUgUIUAAnsVjDSyJwKOS+ekOrnz1uL6nftrcn+oanTlupJ8LHqslHh0ldoTicPRB++abS9lNVY/YrikD+1afZ7Tzlqey+/oPTjOMdLZ1uMavWxOFbC3u2PRwgmqhkr0kRN9jE21jzVlztN1etdG+QNMxB53ziFQ85RaS5H9GMV1v4fdrUv09uDEFC2Nw5xKahu9u8x9UqL1b0miYWRr69+yHNapfCe+vsRGBPY08Wg+1J67qefUltYK35Uzz1rVyRVWfdLokZIe1P0mfSzTGG9A+ffrfhnJRP9Z0nW6HD1vzWx7u1o0L36rb3s79IeFddvl2N6Rg9pX92P9oxm23berc5+MehajzzpS73sl+T16rNyqF8Oj23y+Hyv/O1X8u23Hmyjm+vP7cHUfiG4s6QJ9LiiHgUsVJ1J1rqTckjq56jb8ruQNkeflNth9S/hb2PXNfahE3xRLGsuCblMVAvMJ5AqV8+9ECxCYT8Af3r/cJQK0iFRS3t1f4x3c6Ae1pN2xutFRY+9g28u0VZnjKbtm22vxRGAvI7mW5zL62GjpSW2iKe9M/32qgL0ZrcjbauwY5+b6iM9U+1hTyp6nU6+dyh9gNi2F1hYi+zGK6x6HaL2Z8kGfencpjdtd+hwtVcQd6ke0VpeI16WccuvX9HJe6tgsZRwiO2oK7DmnE9Yefz0SFjfPgGNl28Hkr3Mfip16FlstckcCrj2ob7LjFZ1zy2he7LZhr3v//v5RTuN9nZzfTFf9yy6nytUkfbig7d2q0bvk1HfUIZNywtR5M+IufXLYEm0hh5mTnV5j4CRECl8Urs3jaoeX3I2gqL3omyJl6z7HcsaU41IITCOAwD6NG1cdjsBUMc8W+2XI4rxfNkt+DEt76x/cVLy5mi8BQ7bNEdjXbHvpOI3VR2AvJ7mG5/KQntQm2lJgt4jnRI0+zjlU/BH345JScZ2jj7Gp6xZrSvnzdKpXRKKtucxN2BWxzfn4zY3Jfqzieo53Z6moFwl3UXi7aFyjvy9VxB2yO1qrlyCwRwKKw2hcu0vm+PFoYIjBHhKK5kPps5i6YZTgtDS+fti5A1TwBoHDjKbKSzvR+ObdKelPzLTP6549lS1mpkqpR7PbiubF9v2cn+sG3YbBOyf0J+fUmefF9SSZ29QSrSlT31GH7IlCo1hcd763Z088SZfDzKccHl0Ay57/tsfjOFZy55E3f7yxc4mRhlKhYXJM3udY5thDHQhUJYDAXhUnje2JgD+Af7pPzhLFMhsyqbXQ3lJIy0E8JxTFmm3PYZNTB4E9h9KZ6yz9uYxe6FqGbjKt6Nmaev+v6I/p+qNwqOQmTYo+xqZ+vET9ntpu7iydsx7m3oN68wlcpk9aesFEU9GR5PlWfLGFHJE9EliOVVz3h7ePxDum7FiZklQt+t09tMDe+v4lczdaq5cgsDsuv4XdsXAPJTyXuvmxlHGI7KgpsPv5f7OkbxyZsC1PGJU8I1Pr+vfnVV3scecBGSu5G6y5NuSEIvnz3qP5I7mNFgjsHjN7S7+loO3dqjnc5p4Sjd7ha71L5gjVcxPQmt/X93Pt0iPcPR4OD1SyieP4+J6/Y3kDcjzjI+/9j/anETwnp5Z9jeVU+7gOArMIILDPwsfFBybgRDFOzpL6IE+ZaKH9Tn1c5pqxXFOC0j68O+7RxfV7YKLjqZeQNdteazpGH/pL+Hit1dcW7Sz1uYxe6Fofa/YRX8dzHCtTBfZUSI2SJFnRR/rUjxfWlBZP2XG1abH2JZ23lr0jx0rJXK5BZ47Ifqziuj3Xf0/SmCCw4T5FfIh+d/+iTw7oj/sWxbk5nDvnKiONlwjCLezbbjNaq5fwjhLZWMITgT09oyLWNQX26F5OmnkFSTnxqFs/J1PajxwCWm3y5pzeukXnUfzMgk5FY7Vpyt+MjiE/9zvYMdZ/MWGfNyZu1OXu+HRBH7arRu/wU99Rd835vv63YEwjm5owdKjbqTAsUxN7p3Ix2YYHSLp3YrwjkT7XCz41zPsay4lTjcsgMI8AAvs8flx9eAJOsuIXAy/4U4vjkjn7tj/gapTUC9o+vDuiF8SpAvvSba8xdm4j+tBfwsdrrb62ameJz+WhX+ii+08R2KMXYSffcqLnnA+n6GNs6sfLmtfDVs/HWLsWZr+rO53l58feQY7t2jKc2b77N3S/a3WCrY8bj3lcba7xMXofmfZH577KFJH9WMX1S3Ze6xYWLhrAnxovOPrdrSkSDnUhun+JINx6fkZr9RLeUSIbS3gisKdnVMS65rMT3atkXFs/J6XtR+Fv3F4NcXHIrshr2NfYQcNhaXJ/A6Oxcps1YqNv+hPdb+7ciN6hp76jbo+HT4Tacc+ch0rt72CfBHmDJG9eD5UpXv9RyMiUB7pD1zhH3M1G7Km1ubCPsSx9/qkPgWoEENiroaShAxLwPL66pCd0P4zfPMMOxzq7Z0bm9OgWc2KgR23n/H2OwL5m23PY5NSJPrSX8PGa049D11nacznnuajBMnqhLBXYo2PFr5Pke+YeL40+jqZ+vLCmxLPHcVidwNsC8nZxgm57rZUkHYvvtowaXh/uIMmbQFGoN8ddN5vPHMB023m3LtTFgxP33oSLcRV7GNoDbqw4P8vdg3wIB+hm8pbX72O7ni0w7NWSbirpnyZ04NAiavS7P1ccmoBk9JJorV7CO0pkYwnPQ8+NsYGI+rivcYjsqCmw1wz9U/OZqNFW5LlcmiSy1KZv609Uj202e131CZvcOOnRvLB99+3+w57nNcq5JL08ET7sX/o8Qe+YeLPoHXrqO+q2Od5Ifr2kc4/YWDsHjAV9vzP4JOpQmer1H8WQH8vL5JO2z+3mxZA+WCM0zKaP+xjLidOMyyAwnwAC+3yGtLAcAt55/YEurtljew/AKZZ9UtIP9cegc7w+h+6xZkFpzbZPGe+ha6IP7X19NNXqz6HbWcpzeUwCe5Qg6Z/72I1vLRj86GNs6scLa0p6ELzeODGVk/AOlSljWTDsB6nqDQVvaPvkWFSiWOfR9TX+niOyv6m/0RUTN1ybuO51xuvm/TMg+sSFhfj3ZdQdqnJoETX63S8RhCciyL4sWquX8I4S2VjC89BzY2xgoj7uaxwiO2oK7JEwVjKu2RN+TxUfNbDJvX3r0qSTpWZHYqvbc0gRexjnlGhe1PbGtk2p9z1vkDuE5FSHgWjuTX1H3WZ5+z7p7BDfViFe7yLJ7wZDZWrIpehEhEPueUPJJ8425Tx9qD5vog2Vmqc39jGWOc8IdSDQhAACexOsNHpgAv54t2ecd+XHEixFJnp314lUp8SKW7OgtGbbozHN/Xv0ob2vj6Zce9dS79DP5TEJ7Km4jZ4PU16Eo4+xqR8vrCnpJ9RHkZ8RPMQvk3TjA3lw115fvkXSsyQ5qWlU7El1u4JTGFF7c/6eI7Kn2l+buH4+SY+X5Oc+Km/r5+ecuMuHFlGj3/0lCYfRWr2Ed5TIxhKeh54bY/M/6uO+xiGyo6bA7o1g5yoYKyXjGq0r+/x75H1d6j0+1XY7eD01cfGvdSeEfiaz8WheeN2+dpeL7OOZ7eVUa/me3VqUjTY4WvAy01S/5myCRElUd9eF1NjVCg2zmUOtxzJnrlIHAs0IILA3Q0vDCyDgOLZ+EXEClylCu39MHYfsvYV9+Q1Jtx25Zs6PZa4Z0QvO9fpd6qH21mx7Lp+oXvShva+PpsjOtf79UM9lykvELKcKyLnjEL1QOjHRwzMai5JhPbHfYPzXjLa2q0QfY1P5sKaMD0T0Qbe5cu7R6sKp0KS645nfqvcOs2d0VCzuOn/AIcLCjNk2VWRfk7juPjou/tODpLMbRg4J4DBGU8LCbHM+byf2vDER472mSDg0vtHv/nu68AdX6jYvPxxN3D38PVqrl/COEgmxJUlrEdjTkyqaDzWfneheaxXYo9AgNRmmRvM7+jAxTro8VEpChkRjVRrTPWdpc4gRtztWpr5Hur3oHXpO224/isHv8DDe8K9donGa0y9f+/yRMHz2yHdIt+f1ictfM/KbXzM0zIZd67GsPUa0B4EiAgjsRbiovFICFvR+tksMcy9JOR/22918fy+8vb2g7ymBu9URs23z5niMrtn2giFKVo0+tGt8vEabILX6UqOdGv0dsmPfz2X0QvcTvcdmDWZDbURjnvMS7URIPtJ58REjHabhGpI+MqETrV7yWVPGByNaa7avTG2MThjuvV5ib2iHbrMXflR8dNmbYQ4hs8QEr6Ui+5rE9bFcAGNj9og+b02NTZDoWSgRZKM5NvT3pYq4Q7ZGa3Wr3+wSrpHQViJYLnVsljIOkR0lrKMxju41NaRFdN/Wf482hEo8x+fYGm00lmz0RWPVok/Re3bOe+4Yv5Zt+57R5karb4RonErCAu2yi8JJvqUP7eYcM2OOgVNOxEbPQOuxjO7P3yHQlAACe1O8NL4wAhb0/lt3HO5OhUL730iyuPGuzP7UENIybzVYrZXA7pvNeTnK6dMc23Paz6kTfejX+HiN5kiOnfuqU6O/KVv39VxGL3SlSUZL+UdjHj1bUVLTubG6o5f8yL4xHnP7Xcp5t/4S1pSxPpyl9/by70uq7OPk01zOY9d7w8chYewdFhV7Sv2gpFdFFQ/891yRfU3iuj047cl2iQy2Ph1jT76nSJqaq2b3NtHvbmvP2KWKuEPDEa3VrX+zM6bIF06OPjBR0SckLBzlzJ+ljs1SxiGyo6bAHomQa/2tik44zhE5c56XTZ1oHfxQ52RxZUkW2qMSzYsW77zRe/bU90j3tWXbbj/aZHEonU9F0Cf83e+BX5e4bu44fVOXXNYnHy46co8X9GyHks3XDg2zMaH1WE4YBi6BQD0CCOz1WNLSeghcoE/alZNgbdMr/zg5y/cnMrq5ZEEpiiO4ZtszhiarSvSCW+PjNeKcZeieKtXob46prZ/L6IVu7kts1Mc5ntyRF4q9fp3gOXU0N7Iv+hib+mEUzfWp7Ub92fw9JbBH62HuPebUc64Pe5Klir2MrpP5+zPHlprXliTI9H1fKMkJxiwgLL3Y0/txvUCYsrXkveFQffZ3wI9IciinnBN+Ps3nTZC/rmxw9Lt7aIHdcaf9DvjZyv2e0ly0Vu/rN3vMds8px5G+ZaJz95T0S5mdR2BPg4rmQ02BPRoLW7rG01apDaF9nDzeHuFaTgHRvGjxzhu9Z89532vZtvlH8e8zl6vq1WqMU5S3acjoFqFhNvdpPZbVB4EGIVBCAIG9hBZ1j43ApSQ5melYxuzd/j6yjwkbedxEP9KtjpnZXn/4ezf6miODFX2krtn2WvMz+tCv8fEaiY61+lKjnRr9LbGj1XN5FUmvluS410OlxXHZ7ftMjUWe4y07Ne76tn3Rx9jUDyPWlPTsjxJR1dg8KXn+atQ9tyTPSYeJiIq9oX+u8+B6zEJDwuza75MkfpYduzSnLFlkd24aexk71n1O+RVJ924UFz/KR9B6MyzyzN3372BqPKK1+tC2RrGM3TdvVvjERE6JRN2aAnKOPZs6SxmHyI6afKJkoGaTm0+mhHXrurVE7Rp21rIlmhc1hNvd/rYUTlu27X4s9busxjj5t/7Zkm5QMEFbhIbZ3L71WBZ0k6oQqE8Agb0+U1pcF4ESL7vP9cm/Xhd0MfrhqPFjOWZCJA6/vvcucdK8obJm22vNvIhhjY/Xpb7IDTGs0d/SsWnxXEYfG637mfpoSsUttRDhF+Oh45vmWkvAi/hMFdhZU+LZ7yO8z5F02Z2qLUJxxNbMq1ESaqSVN/S8HoxfXSqub1qq9YzW7Jfj4tvLeGwzfvtezkVjL3cLdS1LLWFpio3R+lficT3l/iXXRLa2/i2LbI3sK90sid7J3tYlyL12F/7RIRz2WaJ+7mscIjtqCuw5Yc1Kwv/sc7xS9zrk2rNrV/R9kHtCIJoXLb5Fo/e9qe+RZtSybbcfcT/UXK01TpeWNJbIdLdvrULDbO7TeiwPNVbcFwJfIIDAzkSAwBefA3ujPS3jiPQz+w/N/5MAZ494v9B6x3iotMpE7ntFnj7RMec1215rLkcfczU+mpb6IjfEsEZ/p4xN7efSIWje3HnWfuOIMRbBbiTp01OMDa6J5tRYAr/LS3qZpHOOtO/8EN8r6X0VbI4+xqZ+GLGm5A2ON5W+u5uj3yfJ8+WNkl4i6WN5ly+i1vX7zaCzZVjzi92Jq4c28obOuH1xlani+uZGPj3j9wyLi4cul+lD8lwwwxCv/3fsEs9+MqPu3CpR3O5cYWmKHdEHf8uTh6X2Rmv1oX6zN/2I3m9KBfHo9zM6mVnKN7d+NA772pSJ7KgpsJuNT734WR0rpeOby7tlvTUJ7LnvYtG8qCXcbo9LtI7m2j401i3b9v2idavl/Eu1XXOccvpoZ8KrdWEJ39Sww63HsqHpNA2BmAACe8yIGqdDIPIUNQknErQI8mcJLPbgs6e4j8kPFcdJvrmklEg/lXp070jcj65fsu1Tme1eF33MHfrjtVY/19JOrecyOrbe8qMwuveQuH/hLpnVK7qNv4snBsofzrViITvJkjcYxt4LbMt7g0nzWEn2St4urClredKm2+k5cytJ/n0ZO2mxaX1f3tDTe3PmK3PEdYtpLqnEjksQ2a/Vn5YY27Tb9N7JCm/bJ6iNwuLVYu0Y/I5tP1ZaJhqM7t1S3C/lFwlnh3xHid6f3FfHXt88Lzl9j9pMnQDLaX9qnSgpYk1hLGVjNB9qC+wO/ZXK9+Jvm6v330FT2e77uiUJ7KmNxpIkstG8aDE/WwqnLdv2fMsRn/c9L32/WuPkddRhueyUExWHz/3xbp32KcoWpfVYtrCZNiGQTQCBPRsVFU+AgJ+H+3XC972CvkaeTOftvQ/HMnZHYVrmoI7iTEexEdds+xxu29dGH3OH/Hit1cc1tVPruYzyE7T8SPda8IZOPHJYhqEytPEVvYAucQyHvJNYU5Y4UvVsKhHXHQbHv59L8OLOJWBx3SfXfLJgrPjD3N743lz4+SB54yFF9lxx3Z5rTlAZbajlMsytFwmWLT2CU165Dqlnx4p35Hakcb1IODvkO4o5vbJ7Br5qhMEU8TWKz18iOtYcmkhoLokzP8euaD7UFtijTXP35b7df9xnTqf2fO2SBPZatkTzopZwuz1U0Xvrmj3YHyLpj/Y8L327P+8Si79z5n1zcjlt38Kb6rfoN9hn3nrw8pbzpIW9tAmBIgII7EW4qHwCBHxk+lVdbNKLJfoaeXEfUshLJRT0D6bjVPrjZ6ys2fZa0xOBvRbJeu3UeC5tTSrR6Ge6JKjf0+gFOtr4Gtq0i15A69Gt19LQxxNrSj2+S2wp54SJE7XeRdKjV5LIdMO5RFzfeHl/+UJF9ijc1KbPj+i9i70e7rtEiUZbxXaOBNyxEF775rO5XyScHUpgd5grh1q8WQLMW7rQA9fpEut+ohBeSnR0U3OEu0JT/q16yuM153176n13r4vmQ22BPXpHtn1/2YeZ+HCtTjZuJ/VuuM+xdDdTc70kf0E0LxDYzzip/I7ysMQ8O8QaU2va5/7+b9/vPX2OlhYb7dH3zZpZ1xoz2lkxAQT2FQ8epjcj8Kg+5ujYDXI80FMva1M8eHI7m7L9Q13IiStL8o9mqqzZ9lxOqXrRx8OhPl5r9G3NbdR4LqMX6FYhCFLhB8bWg+gFdIljOfZSfOpryhLHqoZNOR9tDgljEf4Qnl9z+pgjrvsov73aPr9zo6WJ7DnhpuwFbI+1F0naV0iY3fGJTru0CuMVhfCKnCrmzLMp10bC2aHeURx64KVBmCjH8/dGW2mJwje0PN0wZKu/n50k2Cc9hso+Tz1E86G2wO7+2jvdeTRSxeuJT/+soUTzq9W74S6b6PujJN9ANC8Q2M9IP3rnjk6AL3We+13Gv+s+XTRU/Hs/pge2ChUTsUZgX+pswq4sAgjsWZiodGIEomOfOS84UTzPKMzMFOSRp2jOxoDvu2bbp3ArfcE91Mdrjb6tuY0az6VDJLw88TL5a134ip9pACklMI+FpoleQBuYObvJsZfiU19TZoNdYAM5oq0F0RtL+sAC7U+ZNEdc37S7FJHdfbFAfM1Eh70J4md3N3/CvoftLL2tjnc+VEq8N0tsjzzn9y3eRrZHwtkh3lEiEcd9muPVHP3+73sT5Fz9u8RlRwZrn6ceovnQQmC/Yueh/ppEKCBj8aaqwz6tIVF3NL9K8wZEz/DY36NNxqF8PWNtRfMCgf2M5KKTpq2+D6bOlZzrohCbXhv+e//PkCbYKlRM9H2DwJ4zutRZLAEE9sUODYYdkED0UpIjsF+uS/LjH66zjvSjxcdAFOc59+VgzbbXmDaRB8khPl5r9GvtbdR4Li/QxVJ+s6RvHIHRwkMy+hD//d7D97M7NkUvoEscz7GX4lNfU5Y4VnNsciiIJ3Qxum+daMSerE7mXRoKYo5dNa6tIa5v7Di0yO53fIsoFofGiuO7Xl/S+2rAq9BGKsGfm2/hSTo3tF6Fbhc1Ef0W7vsdJRJxNp37ySCJbQpC1GdvVNtD82+LSE6vHNnT4h1/zNrIlhYCu79tnt+H+0lR/Lkg7Mb0Eah7ZfSO0oLhUA8iO3K/49x2NC8Q2M84AtE39Ni7et2ZWLe11Kkih+5zbhnnXHlxHyJz6O4tQsVE3zcI7HXnAa3tmQAC+56Bc7tVEIheSnIE9ujIsT9mHa7FHwW1in+QXjDSmHeh7RVm0SMqa7Y96lvO3xHYcyjtv06N5zLykGyRLC2ye+zIvL3tf3OPmM3m6xL3+7ikTwX23GYkx8Opryl7HMa93Mrefs9NnASxl53DwqxRXI+8vcfCwoyBP6TIHq09f9MlX/YH+FLEdTOMThn5yLrXmVphbPwd5HV2bLNojtd1q4cxP43ZRQAAGFlJREFUGtd9C+w5eRjmejNHvyFmvc+QJFFIkRbi5dh8iuZDK3HYG6jPCCb5P0u6hqQ/afUwVGo38hxvdXpm1/zotF/JBmM0L1rM0ZbCacu2PQ6RM0xumNVKU3J2M3YoekUXpukSIy09qU867zCVUXiv2qFiWo/lbHg0AIE5BBDY59Dj2mMlEH3g5Rz9jD7azO5Gkl5YCaKTdD2l9xgcarJE0F+z7TVwIrDXoFi/jRrPpa3a94dxKlZpC0F/KvnoY2yOR8mprylTx2SJ19nD+2WSvmvEuCWKtjkcc0KplIrrm/vmiOyvk/QD3QevP+JrlOidwMKXk02+tcbNKrbh00Vv6I6sOwTR3HeZHLMu0oXPMfuxU021Bf0cm6I60Vq9T4E9R1z/XL9xYs5TS85viNclh6RqnaD3PN369xJJ9jYeKi3zLA3dL5oPrQT26LdgY+saNlyjRMfuy9T8AblzPjoVUCryR/MCgf3MI5MK5+ja+9zEy503Q/U8n33aweFoh8oHJV21OxH2rv6Prv84SbcdqV87VAwC+5zR5drFE0BgX/wQYeABCEQeBLkx8FIe5e6Wk//8iCS/jM8t0UfiY/qXw1yvrzXbPpclAvtcgm2ur/VcRh8db+mFpxret9EH6L4EgZwRibjMEdh9/1NeU3L4r6VOymux9kfYvpjkiOv3lfRASf860ah9i+xRjGRvFjyooif4RCxnuixHSK0pckTzOffkX63+57QTrdX7ENg9TreSZC/ILwuMrjXXUqF8bILXn5tKel4OxBl17EVsh5ax0iLUXMrcaD60EthtU3SaaWO354kF6tabHzOG9QshzVIe+Q6nZW/8j8y5SeLaaM0uDVESzQsE9jMPRrTGOJSKN8KXPI/dq2jjcyhc18W6+f1aSecfmaM1Q8UgsDdaRGh2GQQQ2JcxDlgxTuBskj4v6X/vCVKOF0NuDDwfOXQSoLHjWTW9V1NesvYeulofZy0X45ptz+3jWD0E9pjgmp/LyEuo5kd69MFWUyiKRy1dI/oYmyuwn/KaMndslnJ99Pu4pA2jXGbn7sPdXD1xwVxxfdP0PkV2bwZY2BwqSwx7sm2n48JaTBr7RqklGEYboDU3W3PnY069aK1uLbD7N/R+Xcgwx9eOSk3v5ciRxLa0FkGjsAu2weuF38n3VaL5UOt5GeqP58KzJd0go7NLF9lz5lermPKRB7Hxlr4vRvPi2AT2kvA5Y9M1mgM1TuNkPCqzqkQJ6FPrgT3efz1x91qhYiKBvcZYzoLIxRCYQwCBfQ49rt0HAb8g3L/zGPipLkbme/dwQx97f5UkC4hjpSS0S0r4dvvPkeQd86lecW4j2nWeKnqs2fY5UwWBPaa39ucyEr7nxos1wegY+dJEruhjbK7AbianuqbET9Q6akRJwPxx9vh1dOXfrLxsH+7BMZ6HSi1xfdN2JLLXCN0SxZLNdRI41FBGwrft8um/p840MPJEbh0SYqr50VrdUmD/dknPSjiObPepdgJdf7N67t4hAPfEvs6c9+qhWzi5s0+D/lji/n5+nWz1z6YO7oTrovnQUmC3uZfunYnG1tDtLvl0gfk53MnSiufXIyTdKRjfFqG1ohjYUzaOonmxNoH9Kl0izldL8mbEULlnkNA7Z75FodXchkNdWSCucco1x6aSOlEC+miDwL+9L+rXsKH71jqluI+xLOFGXQhUJYDAXhUnjTUgsHlB8I/GvfqX61ZHs3KOiTspqV+e/zazr9/W/xifc6T+3B+r6IV/jjfumm3PHJ7BagjsMb21P5eRN7UJzDnW7t/Wu0l6cAJli4+beOTGa0QfYzUE9lNdU+aMy5KuTYX58e/y90jy5tTaypjIXltc33AZE9lriOu+R/Qs+/h46zAac+fAT/fve2PtzD2uHnn5OTatw0G8f25HGlwfjW9tgd2/Z5eU9Mt9qK+cLrXKxRCF0djY9rDu5OvdZzqvbPfT79ru/12DzpeGY8xhGdWJ5kNrgd32RSEptvvw7t4bex+/FT5xYK9zj92HI5CZmwW153a0FtnsKRuK0bxo8Q4aeSbPeY+M+uME5XaemRt2Ndrs8Hi02sRz29/S/+NwNKUl2jR+ZLcxcOcgNFzU/7m/vTnvKLXGspQf9SFQhQACexWMNNKQwO4P6icl3VuSE5F8uuJ9fUzcsfeuHbSZ8+O03URLj4gcEW9OvLg12z5naiCwx/TW/ly6h9FRyP/bx1r0i15piT42p3gjldpQWj/6eJnzYbSx5VTXlNKxWGp9bzo59MhQ8ebzFSR9YKnGB3btiuytxPWNGbsiey1x3e07LvLYurWWjZCv708T2jt2rEwNP5LjTDEUo3YpUztaq2sJ7OZkwcyi8mUKOl/bc3371jkeppv6L+w92eeuSf4+sKDm5ypVPtqHY3T/91mi+bAPgT1y9hni8eju//Spto81gOVQH/5WvLWkv+t/m5zYMSp+R3H4Izt0pYrj7N+swslqbwA8X5J/f8bKK/q596nI+J2/R/NibQK7Wb05kZC61AFuDGdu2KPa7wi+r09NPaALjfvfAgedIdujkyS5m8Y54YrmhorZ11gWPjJUh0AdAgjsdTjSSjsCYy8IFr+eK+lRkt46w0vFL4VOWPJYSV8ddGPqy3MUwsW3ddsWsN6UidIf5/bwengiwVSND/Y1256J8kzVENhjcsfwXEYhXEzBR8wdwslrTU6CYP+mWpDwZt1YmKk5wn08MtNrRB9jNQR2W3eKa8r0UVnOlZ7bDslxyxGTSkSM5fTqjJZY5HDsb78PzElomtu/jcju0y6OO+53mRoltRFSM/dLDVtTbUTeeL725b03bG7IiRyxdKpw35rHpv1orS4V2P1sm4v/cduei9ftngNvcpSW0vEobd/1IyFpu03/hluw+lVJdtApKWfvPWL9nh19H7jdVvG5I5uj+bAPgd02ThHZ/T7k3xWf9ntn5nvWGA+fTHQseH8bbW8Ilf425bwb2gZ/t/n38JUT7PYz57wfFiovmBjgOd9x0bxYm8B+jv732eFFxoqfdW+s5Lyvp56rnHCxvt6beLfvHHY+FD2kib/7PcDz1qduvrmvVzo2/m71qTR7n4+VklMQ0Xv63NP3+xzLGUPDpRCYRgCBfRo3rtofgegFwZb4Bc3eBE/uM2A7VvvYTr/n/Nd1MVf942kvU4vr3jXOKXNeniNv2c39czw67JnhH+IbB0b/gqSHVnjRWLPtOeO6WweBPaZ2LM9ldBRyQ8IeRvbiS4WG8keZvbH8cZcqLY+WxiM3XiMa01oCuy04tTVlzrgs5dpoXbSd9hCcezy7tL/v63/LP1J64Uh9h3Pz6bja8ZvHzPPH9b+XZOG7VvG70I8mGvtHSZ+tdbPMdiwUebPyTzPru1quJ6GFU+fpcbLFsXEzZ4d8cQK3jYgxZMocQauga7OqRmv1rMZnXPwrvbjVKozjtmm5vyHb11gItZj7xj70z+4zYIH4/P33wU27OOr+58syecw5LZp5i9Fq0XzYl8BuA33qwSeMza60+Nl7gaTf6zcb7dk+9C3nZ9nvW94A8recn+trJTaESgV22315Sc5fNRbec7tv9qr2+6GTIn8+6HRpuKUSUXT31tG8KBVxc8azZYgY399OdfbyTpVf7L99h9Yhzx2HsvsfkjzfxkrOCfHNtZtNPIeHKjmN4Y0Vj+/P9rrEti0lY5Nj65T1KVpj54aK2ddY5sxb6kCgKgEE9qo4aawBgegFIXXLj++8nJ2v97CYYuZcUazUs8MvxP5Y3BYNnGDOWeRzjurOtXeb0ZptnzLWkZBU6h02xYalX3Msz2XOi+n2WLy99073i+Wm+CPPG3V+aY/Kkj0jozGtKbCf2poSzYs1/N0J7Py7dKmFGTtFPFlYF6qac5Y+PMz1qrY6v7GpnvM58Yk31llQ8XuTQyr87/7/9HF3x+32u5OdK1JlqaeLdm2O1ur5o1XWguPUOxSHExDO9RzNvXPpb0huu1Pq2cHHDi9zQ9FMubeviebDPgV22+ONMScLtWfvEsrU34go1N9u3yy0+gSUN3C23xFdz++JDkHqjQCfjMgpc52konlRIuLm2Os6rQV2n64x40i/8iayT5L6VLg3/bd/B/w74XB2UcignFBiu1z+qv/9dX4Bh4rabBBZ2Pe7kz3D/a3guZDavCkZm2gzaOpvb5Tw1H2fEypmn2OZO3+pB4EqBKIFqspNaAQCMwhELwgzms6+1B4v3smdG/PdAr8//pwktWVpIeKt2fZS1gjsMbFjei79sfM4SQ5H0LLUToxV29ZoTGsK7Lb9lNaU2mN1iPbs2WlPvQsd4uaJe04VTxbWjWrmRL9f1W5U2NDUj3zfxqLUczK9SQvNOkP1uYLWnHuXXBut1SVtzanrDQl7bTpedWn4lTn33VxrIffXOm/029ZobGIbhxbXbXY0H/YtsNumnDCWE5EXXzb1N8IaiZ0nnl5wkqHYuJELaiTpjeZFiYib26/WArtFX58s8MmFqaVkPuzrPXW3L7ljkyOCzwmbE53ynRMqZt9jOXW+cB0EigkgsBcj44I9E4heEFqbs0k0Uuu4uL2xfPwxlbhrTp9e178QzokHN3b/NdtewjQSKPBgjz/oSnhPqVv7ufSL3jP72LNT7ImusTeTYyw6xuhSS7TW1hbYzeFU1pSljnmJXQjsJbQOVzf6/TqUZXMEdtvsBJNeo+253KLUTljXwsZNm9Fa3fLem7btuejf4UN5bW/s8Hz45T5Exz76vX0Pxzz+MUm58f9b2RfNh0MI7Ju+frukZ3XP7iVadT6j3RJBdai56/fOUWN5dTJMyK7iTau7SHK40CjcTNRoNC9yRdzoPtt/by2w+15+F3XYxtzwTbv2l86HQ4jsOWOTk5DXXvQOoTQ1hF5OwtM5oWL2PZYlc5m6EJhMAIF9Mjou3BMBx8p8UfeCdsk93W9zm3f3XjF+Ma1d/GNtr/hrVm7YHzyO/zzX0z5l1pptz8UdCRQI7F+MYXtsz6U92f1R46PuNYtPlNg7vsWmV007o4+xFgK77T+FNaXmOB2qLQT2Q5Evu2/0+1XWWr3acwV2W2KhwGKdwxXVKnaeuF0Xl/0pewxvMtf2aK2e2/7Y9Q674DjrTyqMNdzKnk27/pa1CPq0zGSkc+3xnPGpVuc6mCuCzrXF10fz4ZACu+3zSQN/m3gTKzfnVQ0umzZe04fwScXcju73Tb0nu8NNtSr+7nQoK4cXqVGieZEj4pbasQ+BvTS0424fSgV2X+/vg4f0uT5KmZTW93fIPTNOBeV4lzsXgjcC55Qo4anbnhqW9hBjOYcF10IgiwACexYmKh2YgF/IbtYnT0olp6phpn94fUz4dxonObPXjRObPLCCR5Y/em7Te8bvI/7lmm3PmSORQIHA/kWKx/hcbo4EP6HCh7rjPP58n1RvCR/h0dyPPsZaCey269jXlIj9Gv6OwL6GUZKi369D9aKGwG7bvSH32Iwk7zn99Ik/J4N9b07lBdWJ1uqapjqJsDc1LKo7zNk+3jGn2v/VvVf9nSq8Vw/ZsAmJY6G4JJnh1P7kXhfNh0ML7Jt+WKT0ZpbFwygfQm7fx+p5rF7a5WK4e59Yuca8ddgbh4x5ZGX7/a7oxJwWVmsmCI7mxVoF9s07o7/V7z9hokwR2H0bfx9cvQ+L1eJEhr3yPV8dxz0qF+hzjaTscFg1JxavcQI/Sng6J3+J3//3PZYRX/4OgVkEENhn4ePiAxA4bx9qwbv8V630Em2vBn9AOJbkX+zZI+U8vQjnrOilnh32drhfH5u05ktZ7rCu2fZUHyOBAoH9zPSO7bmc8yG48fJzXPdDxKXNfX5360UfYy0F9o0tx7qmTB2TJV2HwL6k0Ri3Jfr9OlQvagnsG6HjP3bvTA+eGNbLwtt9JL114YLx2FhFa3XpGPvUo8Oc/EMXfuF/dIkK/1jSW7qTV++S9NnSxhZQ37/fTjp6V0mXqWCPk5s7JrYFsJYnRKeaGs2HpQjsm/5ZqL5sfwrAzlO5ST8jPhYS7a3r07z2Wm81dy0IOkHjPfpkmZFdY3+3kPqg/huuxbyK5sWaBfbN78AUwduJT+1pP3WTzPPXiUrtIOdkqXOK54C9vz1nc+1x2BbnnrDoPVY+2j0DV+sTrc6xb3NtTqz3OXmmpm5ezB3LGmxoAwJnIoDAzqRYMwHP33N33ub+0PKPrHdy/dJ2rv6f3b5tPiL+uv+IeHX/IWFBrIZ3wxyWfmHzy5C9I3wM2keydl86nfHcH4Qv6ZO82LPo0Ha7z2u2fc6Yce0wgWN6Lv0i/S2Sbi7pOv1/9/qyXbx+/E9JL+/D5nh9WYPH+pLnL2vKkkcH2yCwHAL+8L+2pP/SrcFX6pPwbsfmtejmGLEWGV/cvV+9VtInlmM+ljQmcJZOdHUccIeQ+Q5J/6k/BTEUy//jkvyPE5d6k8EirX/bWwm1jbu+iub9vmhvdn//+DvOjlPfkBgje8r6W+hT/SaQY0z7u8ibIHNCwEyF5fl1lX4Nsu1OAu7N6N3i90RvYL2q9zx+I+vQVOSDWtbF+98A5+qwd7fHwL8DXv8dntHv5X5H/93KJ3E243+9/tvdc3fodMZGf/AG5js6gd76g9cZz2PKlwh4PTjUWDIOEKhGAIG9GkoaggAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgVMigMB+SqNNXyEAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQKAaAQT2aihpCAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABE6JAAL7KY02fYUABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFqBBDYq6GkIQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEDglAgjspzTa9BUCEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAASqEUBgr4aShiAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQOCUCCCwn9Jo01cIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCoRgCBvRpKGoIABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFTIoDAfkqjTV8hAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCECgGgEE9mooaQgCEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAROiQAC+ymNNn2FAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIACBagQQ2KuhpCEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhA4JQII7Kc02vQVAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEqhFAYK+GkoYgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEDglAggsJ/SaNNXCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQqEYAgb0aShqCAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIACBUyKAwH5Ko01fIQABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAoBoBBPZqKGkIAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAETokAAvspjTZ9hQAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgWoEENiroaQhCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQOCUCCOynNNr0FQIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABKoRQGCvhpKGIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhA4JQIILCf0mjTVwhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEKhGAIG9GkoaggAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgVMigMB+SqNNXyEAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQKAaAQT2aihpCAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABE6JAAL7KY02fYUABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFqBBDYq6GkIQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEDglAgjspzTa9BUCEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAASqEUBgr4aShiAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQOCUCCCwn9Jo01cIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCoRgCBvRpKGoIABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFTIoDAfkqjTV8hAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCECgGgEE9mooaQgCEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAROicD/D3yzX4jqUAPQAAAAAElFTkSuQmCC"/></switch></g></g></g><g data-cell-id="b1"><g><rect x="13" y="508" width="400" height="100" fill="#e8f4ef" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(232, 244, 239), rgb(21, 32, 27)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 374px; height: 1px; padding-top: 558px; margin-left: 26px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Broker B01<br />唯一宿主 · 本域 DB / 队列</div></div></div></foreignObject><image x="26" y="534.5" width="374" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="p1"><g><rect x="13" y="713" width="400" height="100" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 374px; height: 1px; padding-top: 763px; margin-left: 26px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">PSU01–PSU05<br />5 台 × 8 通道 = 40 穴位</div></div></div></foreignObject><image x="26" y="739.5" width="374" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="e1a"><g><path d="M 453 145.5 L 213 145.5 L 213 292.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 213 300.76 L 209 292.76 L 217 292.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="e1b"><g><path d="M 213 403 L 213 497.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 213 505.76 L 209 497.76 L 217 497.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="e1c"><g><path d="M 213 608 L 213 702.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 213 710.76 L 209 702.76 L 217 702.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="w2"><g><rect x="553" y="303" width="400" height="100" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 374px; height: 1px; padding-top: 353px; margin-left: 566px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">W03 + W04<br />S041–S080 · 2×20 DUTContext</div></div></div></foreignObject><image x="566" y="329.5" width="374" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="b2"><g><rect x="553" y="508" width="400" height="100" fill="#e8f4ef" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(232, 244, 239), rgb(21, 32, 27)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 374px; height: 1px; padding-top: 558px; margin-left: 566px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Broker B02<br />唯一宿主 · 本域 DB / 队列</div></div></div></foreignObject><image x="566" y="534.5" width="374" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="p2"><g><rect x="553" y="713" width="400" height="100" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 374px; height: 1px; padding-top: 763px; margin-left: 566px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">PSU06–PSU10<br />5 台 × 8 通道 = 40 穴位</div></div></div></foreignObject><image x="566" y="739.5" width="374" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="e2a"><g><path d="M 753 193 L 753 292.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 753 300.76 L 749 292.76 L 757 292.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="e2b"><g><path d="M 753 403 L 753 497.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 753 505.76 L 749 497.76 L 757 497.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="e2c"><g><path d="M 753 608 L 753 702.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 753 710.76 L 749 702.76 L 757 702.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="w3"><g><rect x="1093" y="303" width="400" height="100" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 374px; height: 1px; padding-top: 353px; margin-left: 1106px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">W05 + W06<br />S081–S120 · 2×20 DUTContext</div></div></div></foreignObject><image x="1106" y="329.5" width="374" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="b3"><g><rect x="1093" y="508" width="400" height="100" fill="#e8f4ef" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(232, 244, 239), rgb(21, 32, 27)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 374px; height: 1px; padding-top: 558px; margin-left: 1106px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Broker B03<br />唯一宿主 · 本域 DB / 队列</div></div></div></foreignObject><image x="1106" y="534.5" width="374" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="p3"><g><rect x="1093" y="713" width="400" height="100" fill="#eaf2f8" stroke="#33556f" stroke-width="2" pointer-events="all" style="fill: light-dark(rgb(234, 242, 248), rgb(24, 31, 36)); stroke: light-dark(rgb(51, 85, 111), rgb(144, 173, 195));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 374px; height: 1px; padding-top: 763px; margin-left: 1106px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 20px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">PSU11–PSU15<br />5 台 × 8 通道 = 40 穴位</div></div></div></foreignObject><image x="1106" y="739.5" width="374" height="53" xlink:href="data:image/png;base64,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"/></switch></g></g></g><g data-cell-id="e3a"><g><path d="M 1053 145.5 L 1293 145.5 L 1293 292.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 1293 300.76 L 1289 292.76 L 1297 292.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="e3b"><g><path d="M 1293 403 L 1293 497.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 1293 505.76 L 1289 497.76 L 1297 497.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="e3c"><g><path d="M 1293 608 L 1293 702.76" fill="none" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/><path d="M 1293 710.76 L 1289 702.76 L 1297 702.76 Z" fill="#286494" stroke="#286494" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: light-dark(rgb(40, 100, 148), rgb(115, 167, 208)); stroke: light-dark(rgb(40, 100, 148), rgb(115, 167, 208));"/></g></g><g data-cell-id="legend"><g><rect x="13" y="833" width="1480" height="45" fill="#ffffff" stroke="none" pointer-events="all" style="fill: light-dark(rgb(255, 255, 255), rgb(18, 18, 18));"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1454px; height: 1px; padding-top: 856px; margin-left: 26px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 18px; font-family: &quot;Microsoft YaHei&quot;; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">CAN / PLC / 温箱按真实物理与 SDK 域固定唯一宿主（TBD）；共享设备不因分 3 域而复制连接。</div></div></div></foreignObject><image x="26" y="845.5" width="1454" height="26.5" xlink:href="data:image/png;base64,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"/></switch></g></g></g></g></g></g><switch><g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/><a transform="translate(0,-5)" xlink:href="https://www.drawio.com/doc/faq/svg-export-text-problems" target="_blank"><text text-anchor="middle" font-size="10px" x="50%" y="100%">Text is not SVG - cannot display</text></a></switch></svg>"><figcaption>图 3　单 IPC çš„ 120 ç©´ä½åŸºçº¿éƒ¨ç½²ï¼š6 ä¸ªæ‰§è¡Œ Worker、3 ä¸ª Broker åŸŸï¼›æ•°é‡ä¸ºè®¾è®¡å»ºè®®ã€‚</figcaption></figure><p>基线选择单 IPC、15 å° 8 é€šé“ PSU、120 ä¸ªè¾“出通道。建议划分 3 ä¸ªè®¾å¤‡åŸŸï¼Œæ¯åŸŸ 40 ç©´ä½ã€5 å° PSU；6 ä¸ª Worker，每 Worker 20 ä¸ª DUTContext。一个 HMI、一个 ResultWriter å’Œä¸€ä¸ª Supervisor æž„成运维基线。Worker ä¸Ž Broker æ•°é‡ç”±è¿›ç¨‹éš”离和压测决定，不是硬件既定事实；CAN å¡/PLC/温箱按物理 SDK ä¸ŽæŽ§åˆ¶åŸŸåˆ†é…ï¼Œä¸èƒ½ä»…å›  PSU åˆ†æˆ 3 åŸŸå°±å¤åˆ¶è¿žæŽ¥ã€‚</p>
<div class="table-wrap"><table><thead><tr><th>域</th><th>Worker / ç©´ä½</th><th>PSU</th><th>Broker职责</th></tr></thead><tbody><tr><td>B01</td><td>W01:S001–S020；W02:S021–S040</td><td>PSU01–PSU05；各8通道</td><td>PSU共享会话；本域资源与任务</td></tr><tr><td>B02</td><td>W03:S041–S060；W04:S061–S080</td><td>PSU06–PSU10；各8通道</td><td>同上，独立数据库和故障域</td></tr><tr><td>B03</td><td>W05:S081–S100；W06:S101–S120</td><td>PSU11–PSU15；各8通道</td><td>同上，独立数据库和故障域</td></tr><tr><td>全局共享</td><td>所有涉及同一温箱/PLC的Run</td><td>温箱01/PLC01/共用CAN（实际TBD）</td><td>固定唯一宿主；必要时增加B00；控制权按Run/group分配</td></tr></tbody></table></div><h3>17.1 æ˜ å°„公式与边界</h3><p>对穴位 s∈[1,120]：<code>PSU=⌊(s−1)/8⌋+1</code>；<code>CH=((s−1) mod 8)+1</code>；<code>Broker=⌊(PSU−1)/5⌋+1</code>；<code>Worker=⌊(s−1)/20⌋+1</code>。例如 S001→PSU01/CH1，S008→PSU01/CH8，S009→PSU02/CH1，S120→PSU15/CH8。</p>
<p>W01/W02 ç­‰çš„ 20 ç©´ä½è¾¹ç•Œä¼šåˆ‡åˆ†ä¸€å°å¤šé€šé“ PSU（如 PSU03）；这是选择 Broker çš„实际原因之一。通道预约独立，整机命令等待父 Permit，SessionGate ä¿è¯é€‰é€šé“和响应不串线。以下展开全部 120 æ¡è¾“出映射，通信地址、序列号和通道额定值须由工程师填充后才可发布。</p><details open><summary>120 ç©´ä½æ˜ å°„表（完整）</summary><div class="table-wrap"><table><thead><tr><th>穴位</th><th>Worker</th><th>Broker</th><th>设备</th><th>通道</th><th>ResourceKey</th></tr></thead><tbody><tr><td>S001</td><td>W01</td><td>B01</td><td>PSU01</td><td>1</td><td><code>psu/psu01/ch/1</code></td></tr><tr><td>S002</td><td>W01</td><td>B01</td><td>PSU01</td><td>2</td><td><code>psu/psu01/ch/2</code></td></tr><tr><td>S003</td><td>W01</td><td>B01</td><td>PSU01</td><td>3</td><td><code>psu/psu01/ch/3</code></td></tr><tr><td>S004</td><td>W01</td><td>B01</td><td>PSU01</td><td>4</td><td><code>psu/psu01/ch/4</code></td></tr><tr><td>S005</td><td>W01</td><td>B01</td><td>PSU01</td><td>5</td><td><code>psu/psu01/ch/5</code></td></tr><tr><td>S006</td><td>W01</td><td>B01</td><td>PSU01</td><td>6</td><td><code>psu/psu01/ch/6</code></td></tr><tr><td>S007</td><td>W01</td><td>B01</td><td>PSU01</td><td>7</td><td><code>psu/psu01/ch/7</code></td></tr><tr><td>S008</td><td>W01</td><td>B01</td><td>PSU01</td><td>8</td><td><code>psu/psu01/ch/8</code></td></tr><tr><td>S009</td><td>W01</td><td>B01</td><td>PSU02</td><td>1</td><td><code>psu/psu02/ch/1</code></td></tr><tr><td>S010</td><td>W01</td><td>B01</td><td>PSU02</td><td>2</td><td><code>psu/psu02/ch/2</code></td></tr><tr><td>S011</td><td>W01</td><td>B01</td><td>PSU02</td><td>3</td><td><code>psu/psu02/ch/3</code></td></tr><tr><td>S012</td><td>W01</td><td>B01</td><td>PSU02</td><td>4</td><td><code>psu/psu02/ch/4</code></td></tr><tr><td>S013</td><td>W01</td><td>B01</td><td>PSU02</td><td>5</td><td><code>psu/psu02/ch/5</code></td></tr><tr><td>S014</td><td>W01</td><td>B01</td><td>PSU02</td><td>6</td><td><code>psu/psu02/ch/6</code></td></tr><tr><td>S015</td><td>W01</td><td>B01</td><td>PSU02</td><td>7</td><td><code>psu/psu02/ch/7</code></td></tr><tr><td>S016</td><td>W01</td><td>B01</td><td>PSU02</td><td>8</td><td><code>psu/psu02/ch/8</code></td></tr><tr><td>S017</td><td>W01</td><td>B01</td><td>PSU03</td><td>1</td><td><code>psu/psu03/ch/1</code></td></tr><tr><td>S018</td><td>W01</td><td>B01</td><td>PSU03</td><td>2</td><td><code>psu/psu03/ch/2</code></td></tr><tr><td>S019</td><td>W01</td><td>B01</td><td>PSU03</td><td>3</td><td><code>psu/psu03/ch/3</code></td></tr><tr><td>S020</td><td>W01</td><td>B01</td><td>PSU03</td><td>4</td><td><code>psu/psu03/ch/4</code></td></tr><tr><td>S021</td><td>W02</td><td>B01</td><td>PSU03</td><td>5</td><td><code>psu/psu03/ch/5</code></td></tr><tr><td>S022</td><td>W02</td><td>B01</td><td>PSU03</td><td>6</td><td><code>psu/psu03/ch/6</code></td></tr><tr><td>S023</td><td>W02</td><td>B01</td><td>PSU03</td><td>7</td><td><code>psu/psu03/ch/7</code></td></tr><tr><td>S024</td><td>W02</td><td>B01</td><td>PSU03</td><td>8</td><td><code>psu/psu03/ch/8</code></td></tr><tr><td>S025</td><td>W02</td><td>B01</td><td>PSU04</td><td>1</td><td><code>psu/psu04/ch/1</code></td></tr><tr><td>S026</td><td>W02</td><td>B01</td><td>PSU04</td><td>2</td><td><code>psu/psu04/ch/2</code></td></tr><tr><td>S027</td><td>W02</td><td>B01</td><td>PSU04</td><td>3</td><td><code>psu/psu04/ch/3</code></td></tr><tr><td>S028</td><td>W02</td><td>B01</td><td>PSU04</td><td>4</td><td><code>psu/psu04/ch/4</code></td></tr><tr><td>S029</td><td>W02</td><td>B01</td><td>PSU04</td><td>5</td><td><code>psu/psu04/ch/5</code></td></tr><tr><td>S030</td><td>W02</td><td>B01</td><td>PSU04</td><td>6</td><td><code>psu/psu04/ch/6</code></td></tr><tr><td>S031</td><td>W02</td><td>B01</td><td>PSU04</td><td>7</td><td><code>psu/psu04/ch/7</code></td></tr><tr><td>S032</td><td>W02</td><td>B01</td><td>PSU04</td><td>8</td><td><code>psu/psu04/ch/8</code></td></tr><tr><td>S033</td><td>W02</td><td>B01</td><td>PSU05</td><td>1</td><td><code>psu/psu05/ch/1</code></td></tr><tr><td>S034</td><td>W02</td><td>B01</td><td>PSU05</td><td>2</td><td><code>psu/psu05/ch/2</code></td></tr><tr><td>S035</td><td>W02</td><td>B01</td><td>PSU05</td><td>3</td><td><code>psu/psu05/ch/3</code></td></tr><tr><td>S036</td><td>W02</td><td>B01</td><td>PSU05</td><td>4</td><td><code>psu/psu05/ch/4</code></td></tr><tr><td>S037</td><td>W02</td><td>B01</td><td>PSU05</td><td>5</td><td><code>psu/psu05/ch/5</code></td></tr><tr><td>S038</td><td>W02</td><td>B01</td><td>PSU05</td><td>6</td><td><code>psu/psu05/ch/6</code></td></tr><tr><td>S039</td><td>W02</td><td>B01</td><td>PSU05</td><td>7</td><td><code>psu/psu05/ch/7</code></td></tr><tr><td>S040</td><td>W02</td><td>B01</td><td>PSU05</td><td>8</td><td><code>psu/psu05/ch/8</code></td></tr><tr><td>S041</td><td>W03</td><td>B02</td><td>PSU06</td><td>1</td><td><code>psu/psu06/ch/1</code></td></tr><tr><td>S042</td><td>W03</td><td>B02</td><td>PSU06</td><td>2</td><td><code>psu/psu06/ch/2</code></td></tr><tr><td>S043</td><td>W03</td><td>B02</td><td>PSU06</td><td>3</td><td><code>psu/psu06/ch/3</code></td></tr><tr><td>S044</td><td>W03</td><td>B02</td><td>PSU06</td><td>4</td><td><code>psu/psu06/ch/4</code></td></tr><tr><td>S045</td><td>W03</td><td>B02</td><td>PSU06</td><td>5</td><td><code>psu/psu06/ch/5</code></td></tr><tr><td>S046</td><td>W03</td><td>B02</td><td>PSU06</td><td>6</td><td><code>psu/psu06/ch/6</code></td></tr><tr><td>S047</td><td>W03</td><td>B02</td><td>PSU06</td><td>7</td><td><code>psu/psu06/ch/7</code></td></tr><tr><td>S048</td><td>W03</td><td>B02</td><td>PSU06</td><td>8</td><td><code>psu/psu06/ch/8</code></td></tr><tr><td>S049</td><td>W03</td><td>B02</td><td>PSU07</td><td>1</td><td><code>psu/psu07/ch/1</code></td></tr><tr><td>S050</td><td>W03</td><td>B02</td><td>PSU07</td><td>2</td><td><code>psu/psu07/ch/2</code></td></tr><tr><td>S051</td><td>W03</td><td>B02</td><td>PSU07</td><td>3</td><td><code>psu/psu07/ch/3</code></td></tr><tr><td>S052</td><td>W03</td><td>B02</td><td>PSU07</td><td>4</td><td><code>psu/psu07/ch/4</code></td></tr><tr><td>S053</td><td>W03</td><td>B02</td><td>PSU07</td><td>5</td><td><code>psu/psu07/ch/5</code></td></tr><tr><td>S054</td><td>W03</td><td>B02</td><td>PSU07</td><td>6</td><td><code>psu/psu07/ch/6</code></td></tr><tr><td>S055</td><td>W03</td><td>B02</td><td>PSU07</td><td>7</td><td><code>psu/psu07/ch/7</code></td></tr><tr><td>S056</td><td>W03</td><td>B02</td><td>PSU07</td><td>8</td><td><code>psu/psu07/ch/8</code></td></tr><tr><td>S057</td><td>W03</td><td>B02</td><td>PSU08</td><td>1</td><td><code>psu/psu08/ch/1</code></td></tr><tr><td>S058</td><td>W03</td><td>B02</td><td>PSU08</td><td>2</td><td><code>psu/psu08/ch/2</code></td></tr><tr><td>S059</td><td>W03</td><td>B02</td><td>PSU08</td><td>3</td><td><code>psu/psu08/ch/3</code></td></tr><tr><td>S060</td><td>W03</td><td>B02</td><td>PSU08</td><td>4</td><td><code>psu/psu08/ch/4</code></td></tr><tr><td>S061</td><td>W04</td><td>B02</td><td>PSU08</td><td>5</td><td><code>psu/psu08/ch/5</code></td></tr><tr><td>S062</td><td>W04</td><td>B02</td><td>PSU08</td><td>6</td><td><code>psu/psu08/ch/6</code></td></tr><tr><td>S063</td><td>W04</td><td>B02</td><td>PSU08</td><td>7</td><td><code>psu/psu08/ch/7</code></td></tr><tr><td>S064</td><td>W04</td><td>B02</td><td>PSU08</td><td>8</td><td><code>psu/psu08/ch/8</code></td></tr><tr><td>S065</td><td>W04</td><td>B02</td><td>PSU09</td><td>1</td><td><code>psu/psu09/ch/1</code></td></tr><tr><td>S066</td><td>W04</td><td>B02</td><td>PSU09</td><td>2</td><td><code>psu/psu09/ch/2</code></td></tr><tr><td>S067</td><td>W04</td><td>B02</td><td>PSU09</td><td>3</td><td><code>psu/psu09/ch/3</code></td></tr><tr><td>S068</td><td>W04</td><td>B02</td><td>PSU09</td><td>4</td><td><code>psu/psu09/ch/4</code></td></tr><tr><td>S069</td><td>W04</td><td>B02</td><td>PSU09</td><td>5</td><td><code>psu/psu09/ch/5</code></td></tr><tr><td>S070</td><td>W04</td><td>B02</td><td>PSU09</td><td>6</td><td><code>psu/psu09/ch/6</code></td></tr><tr><td>S071</td><td>W04</td><td>B02</td><td>PSU09</td><td>7</td><td><code>psu/psu09/ch/7</code></td></tr><tr><td>S072</td><td>W04</td><td>B02</td><td>PSU09</td><td>8</td><td><code>psu/psu09/ch/8</code></td></tr><tr><td>S073</td><td>W04</td><td>B02</td><td>PSU10</td><td>1</td><td><code>psu/psu10/ch/1</code></td></tr><tr><td>S074</td><td>W04</td><td>B02</td><td>PSU10</td><td>2</td><td><code>psu/psu10/ch/2</code></td></tr><tr><td>S075</td><td>W04</td><td>B02</td><td>PSU10</td><td>3</td><td><code>psu/psu10/ch/3</code></td></tr><tr><td>S076</td><td>W04</td><td>B02</td><td>PSU10</td><td>4</td><td><code>psu/psu10/ch/4</code></td></tr><tr><td>S077</td><td>W04</td><td>B02</td><td>PSU10</td><td>5</td><td><code>psu/psu10/ch/5</code></td></tr><tr><td>S078</td><td>W04</td><td>B02</td><td>PSU10</td><td>6</td><td><code>psu/psu10/ch/6</code></td></tr><tr><td>S079</td><td>W04</td><td>B02</td><td>PSU10</td><td>7</td><td><code>psu/psu10/ch/7</code></td></tr><tr><td>S080</td><td>W04</td><td>B02</td><td>PSU10</td><td>8</td><td><code>psu/psu10/ch/8</code></td></tr><tr><td>S081</td><td>W05</td><td>B03</td><td>PSU11</td><td>1</td><td><code>psu/psu11/ch/1</code></td></tr><tr><td>S082</td><td>W05</td><td>B03</td><td>PSU11</td><td>2</td><td><code>psu/psu11/ch/2</code></td></tr><tr><td>S083</td><td>W05</td><td>B03</td><td>PSU11</td><td>3</td><td><code>psu/psu11/ch/3</code></td></tr><tr><td>S084</td><td>W05</td><td>B03</td><td>PSU11</td><td>4</td><td><code>psu/psu11/ch/4</code></td></tr><tr><td>S085</td><td>W05</td><td>B03</td><td>PSU11</td><td>5</td><td><code>psu/psu11/ch/5</code></td></tr><tr><td>S086</td><td>W05</td><td>B03</td><td>PSU11</td><td>6</td><td><code>psu/psu11/ch/6</code></td></tr><tr><td>S087</td><td>W05</td><td>B03</td><td>PSU11</td><td>7</td><td><code>psu/psu11/ch/7</code></td></tr><tr><td>S088</td><td>W05</td><td>B03</td><td>PSU11</td><td>8</td><td><code>psu/psu11/ch/8</code></td></tr><tr><td>S089</td><td>W05</td><td>B03</td><td>PSU12</td><td>1</td><td><code>psu/psu12/ch/1</code></td></tr><tr><td>S090</td><td>W05</td><td>B03</td><td>PSU12</td><td>2</td><td><code>psu/psu12/ch/2</code></td></tr><tr><td>S091</td><td>W05</td><td>B03</td><td>PSU12</td><td>3</td><td><code>psu/psu12/ch/3</code></td></tr><tr><td>S092</td><td>W05</td><td>B03</td><td>PSU12</td><td>4</td><td><code>psu/psu12/ch/4</code></td></tr><tr><td>S093</td><td>W05</td><td>B03</td><td>PSU12</td><td>5</td><td><code>psu/psu12/ch/5</code></td></tr><tr><td>S094</td><td>W05</td><td>B03</td><td>PSU12</td><td>6</td><td><code>psu/psu12/ch/6</code></td></tr><tr><td>S095</td><td>W05</td><td>B03</td><td>PSU12</td><td>7</td><td><code>psu/psu12/ch/7</code></td></tr><tr><td>S096</td><td>W05</td><td>B03</td><td>PSU12</td><td>8</td><td><code>psu/psu12/ch/8</code></td></tr><tr><td>S097</td><td>W05</td><td>B03</td><td>PSU13</td><td>1</td><td><code>psu/psu13/ch/1</code></td></tr><tr><td>S098</td><td>W05</td><td>B03</td><td>PSU13</td><td>2</td><td><code>psu/psu13/ch/2</code></td></tr><tr><td>S099</td><td>W05</td><td>B03</td><td>PSU13</td><td>3</td><td><code>psu/psu13/ch/3</code></td></tr><tr><td>S100</td><td>W05</td><td>B03</td><td>PSU13</td><td>4</td><td><code>psu/psu13/ch/4</code></td></tr><tr><td>S101</td><td>W06</td><td>B03</td><td>PSU13</td><td>5</td><td><code>psu/psu13/ch/5</code></td></tr><tr><td>S102</td><td>W06</td><td>B03</td><td>PSU13</td><td>6</td><td><code>psu/psu13/ch/6</code></td></tr><tr><td>S103</td><td>W06</td><td>B03</td><td>PSU13</td><td>7</td><td><code>psu/psu13/ch/7</code></td></tr><tr><td>S104</td><td>W06</td><td>B03</td><td>PSU13</td><td>8</td><td><code>psu/psu13/ch/8</code></td></tr><tr><td>S105</td><td>W06</td><td>B03</td><td>PSU14</td><td>1</td><td><code>psu/psu14/ch/1</code></td></tr><tr><td>S106</td><td>W06</td><td>B03</td><td>PSU14</td><td>2</td><td><code>psu/psu14/ch/2</code></td></tr><tr><td>S107</td><td>W06</td><td>B03</td><td>PSU14</td><td>3</td><td><code>psu/psu14/ch/3</code></td></tr><tr><td>S108</td><td>W06</td><td>B03</td><td>PSU14</td><td>4</td><td><code>psu/psu14/ch/4</code></td></tr><tr><td>S109</td><td>W06</td><td>B03</td><td>PSU14</td><td>5</td><td><code>psu/psu14/ch/5</code></td></tr><tr><td>S110</td><td>W06</td><td>B03</td><td>PSU14</td><td>6</td><td><code>psu/psu14/ch/6</code></td></tr><tr><td>S111</td><td>W06</td><td>B03</td><td>PSU14</td><td>7</td><td><code>psu/psu14/ch/7</code></td></tr><tr><td>S112</td><td>W06</td><td>B03</td><td>PSU14</td><td>8</td><td><code>psu/psu14/ch/8</code></td></tr><tr><td>S113</td><td>W06</td><td>B03</td><td>PSU15</td><td>1</td><td><code>psu/psu15/ch/1</code></td></tr><tr><td>S114</td><td>W06</td><td>B03</td><td>PSU15</td><td>2</td><td><code>psu/psu15/ch/2</code></td></tr><tr><td>S115</td><td>W06</td><td>B03</td><td>PSU15</td><td>3</td><td><code>psu/psu15/ch/3</code></td></tr><tr><td>S116</td><td>W06</td><td>B03</td><td>PSU15</td><td>4</td><td><code>psu/psu15/ch/4</code></td></tr><tr><td>S117</td><td>W06</td><td>B03</td><td>PSU15</td><td>5</td><td><code>psu/psu15/ch/5</code></td></tr><tr><td>S118</td><td>W06</td><td>B03</td><td>PSU15</td><td>6</td><td><code>psu/psu15/ch/6</code></td></tr><tr><td>S119</td><td>W06</td><td>B03</td><td>PSU15</td><td>7</td><td><code>psu/psu15/ch/7</code></td></tr><tr><td>S120</td><td>W06</td><td>B03</td><td>PSU15</td><td>8</td><td><code>psu/psu15/ch/8</code></td></tr></tbody></table></div></details>
<h3>17.2 120×1 Local æ›¿ä»£æ–¹æ¡ˆ</h3><p>若实物为 120 å°ç‹¬ç«‹ TCP PSU，按 6 Worker×20 ä¼šè¯å›ºå®šå½’属；每 Worker æŒ 20 ä¸ªè®¾å¤‡è¿žæŽ¥ï¼Œä½†ä½¿ç”¨å¼‚步收发与有界并发，不建 20 æ¡ä¸“用轮询线程。共享 CAN/PLC/温箱仍经 Broker；Local PSU ç»´æŠ¤ç»æ‰€å±ž Worker ä»£ç†æˆ–停机交接。若仪器全局命令跨穴位、SDK ä¸å…è®¸å¤šå®žä¾‹æˆ–需自动宿主切换，应转 Broker。两种拓扑由 ConfigVersion æ˜Žç¡®é€‰æ‹©ï¼Œä¸èƒ½æ··ç”¨æ˜ å°„公式。</p>
<h3>17.3 å¤šæœºæ‰©å±•</h3><p>可将每 40 ç©´ä½åŸŸè¿ç§»åˆ°ç‹¬ç«‹ IPC，通过 TLS Broker API è¿žæŽ¥ï¼›æ•°æ®åº“仍保存在各自主机。共享温箱只设一个控制宿主，断网策略由独立联锁执行。域迁移需停用、隔离旧宿主、更新 Authority/epoch、应用新配置并核对输出，不做在线双主切换。</p></section><section id="capacity"><h2>18　容量估算、数据与性能预算</h2><p>以下数字用于建立压测负载，均非现有软件或硬件实测。独立电压/电流样本与 CAN ä¿¡å·æ•°æ®éœ€åˆ†åˆ«é¢„算，不能把 UI åˆ·æ–°é¢‘率当作采样频率。</p>
<div class="table-wrap"><table><thead><tr><th>项目</th><th>计算/建议起点</th><th>验证方式</th></tr></thead><tbody><tr><td>PSU采样，10 Hz/穴位</td><td>120×10=1200 æ¡ç»„合V/I记录/s；拆两条则2400条/s</td><td>驱动支持的批量读、单机/整柜测量；协议能力未确认</td></tr><tr><td>10 Hz持续168 h</td><td>1200×604800=725,760,000 æ¡è®°å½•</td><td>先确认是否必须全量长期存储；按原始与汇总分层</td></tr><tr><td>存储模型，100 B/组合样本</td><td>约120,000 B/s、10.368 GB/天、72.576 GB/168 h（十进制）</td><td>未计索引/WAL/文件系统；预留系数≥2的起点，实测后定盘</td></tr><tr><td>单Broker，40穴位</td><td>示例400组合样本/s；共享协议会话可能低于此能力</td><td>对每台8通道PSU测全通道读回耗时</td></tr><tr><td>单PSU利用率</td><td>ρ=Σ(命令到达率×服务时间)；建议持续ρ≤0.6–0.7起测</td><td>80次通道读/s×10 ms=0.8，已超建议余量；需批量或降采样</td></tr><tr><td>Broker排队预算</td><td>start deadline示例5 s；AtomicSequence示例3 s</td><td>分别统计Queue/Driver/DB/IPC延迟，不能将TTL作为排队预算</td></tr><tr><td>UI刷新</td><td>聚合2–5 Hz，采样独立；只呈现最新值与质量</td><td>120穴位、报警风暴、窗口切换，观察帧阻塞和内存</td></tr><tr><td>续期负载</td><td>120个通道若每8s续一次≈15行/s；应按组事务聚合</td><td>与Task Journal及采样库隔离；父Permit和事件另计</td></tr><tr><td>CAN预算</td><td>Σ帧率×实际位数/有效总线速率，含仲裁、填充、重发和UDS</td><td>型号、位速率、FD数据段与总线数TBD；不能凭120穴位直接承诺</td></tr></tbody></table></div><p>建议按小时/日分片或批量列式文件归档，不让单个 7 äº¿è¡Œ SQLite è¡¨æ— é™å¢žé•¿ï¼›ä¿æŒ Run ç´¢å¼•ä¸Žåˆ†ç‰‡ Hash å¯è¿½æº¯ã€‚原始 CAN å¸§ä¸Žè§£ç ä¿¡å·æŒ‰è¿½æº¯ç­‰çº§é€‰æ‹©ä¿ç•™ï¼Œè´¨é‡äº‹ä»¶ä¸Žæ•…障前后窗口优先。采样写入背压达到上限时按 Recipe ç­–略暂停/报警；不得静默丢样后仍判定数据完整。</p>
<p>性能门禁建议：控制心跳处理 p99&lt;1 s、普通 IPC æœ¬æœºç©ºè½½å¾€è¿” p95&lt;20 ms、120穴位 UI æ— é•¿æ—¶é—´å†»ç»“；这些均为目标起点，必须列出 CPU/内存/磁盘/驱动/负载条件实测。周期帧和 UDS æ—¶åºç”¨ç¡¬ä»¶æ—¶é—´æˆ³éªŒè¯ã€‚</p></section><section id="ops"><h2>19　安装、观测与运维</h2><h3>19.1 æ‰“包与目录</h3><div class="codebar"><span>部署目录示例</span><button class="copy">复制</button></div><pre><code>C:\Program Files\AgingPlatform\        # åªè¯»åº”用/签名驱动包
  Hmi\  Worker\  Broker\  Supervisor\
C:\ProgramData\AgingPlatform\Station01\
  config\{hash}\manifest.json         # ä¸å¯å˜å‘布快照
  system\aging_system.db
  local\arb.db
  broker\B01\broker-b01.db
  broker\B02\broker-b02.db
  broker\B03\broker-b03.db
  runs\{RunId}\...                    # æ•°æ®åˆ†ç‰‡/报告索引
  logs\  recovery\  backups\</code></pre><p>生产数据使用服务账户可写的 ProgramData æˆ–独立数据盘，不把原型的 %LOCALAPPDATA%\PluginIntegrationTest ä½œä¸ºæ­£å¼å¤šè´¦æˆ·å…±äº«è·¯å¾„。所有插件从统一配置服务取得路径；禁止各插件自行拼接不同 BaseFolder。</p>
<p>上线前冻结 x86/x64、SDK版本、.NET依赖和包 Hash。Broker å¯é‡‡ç”¨ Windows Service；若 SDK éœ€è¦äº¤äº’桌面，则使用受控用户进程并验证服务会话差异。驱动隔离范围由 SDK å…¨å±€çŠ¶æ€å†³å®šï¼Œä¸èƒ½å°†ä¸€å¼ å¡çš„全局句柄分到多个 Broker。</p>
<h3>19.2 è§‚测与告警</h3><p>统一 CorrelationId=Run/DUT/Step/Task；日志记录 BrokerId、epoch、ResourceKey、SessionKey、LeaseId æ‘˜è¦ã€generation、ConfigHash、QueueWait、IoLatency、RetryCount、ReadbackQuality。运行指标包括活跃/隔离资源数、心跳余量、队列深度、Unknown任务、Outbox积压、数据Gap、DB busy时间、磁盘剩余、重启次数与CAN bus-off。</p>
<p>告警必须带影响穴位和处理入口，区分硬件联锁、通信故障、仲裁冲突和维护中；不能将维护占用持续刷成设备故障。诊断导出包含版本、匿名化日志、任务状态和恢复证据，排除凭据。备份使用 SQLite ä¸€è‡´æ€§å¤‡ä»½æ–¹å¼ï¼Œä¸èƒ½ä»…复制主 .db è€Œå¿½ç•¥æ´»åŠ¨ WAL。</p>
<h3>19.3 å‡çº§ä¸Žå›žé€€</h3><p>停止新Run â†’ æŽ’空任务/撤销写权 â†’ ç¡®è®¤å®‰å…¨æ€ â†’ ä¸€è‡´æ€§å¤‡ä»½ â†’ æ•°æ®è¿ç§» â†’ å‡çº§å®¿ä¸»åŠå®¢æˆ·ç«¯ â†’ åè®®æ¡æ‰‹/自检 â†’ é…ç½®Hash一致 â†’ æ¢å¤ç”Ÿäº§ã€‚è‹¥ schema ä¸å‘后兼容，不能直接回退旧二进制；使用验证过的备份恢复并提升 epoch，保留升级期间日志及结果。</p></section><section id="verification"><h2>20　典型运行场景与方案原理</h2><p>以下用实际调用过程说明各层为什么存在。场景中的编号、时间和电压均为解释示例，不是设备的已确认工艺参数。</p>
<h3>20.1 ä¸¤ä¸ª Worker æ“ä½œåŒä¸€å°å¤šé€šé“电源</h3><p>W01 çš„ S020 ä¸Ž W02 çš„ S021 åˆ†åˆ«æ˜ å°„到 PSU03/CH4、PSU03/CH5。两者各持有本通道的排他租约和 PSU03 çš„父共享 Permit，因此可同时处于“有权使用”状态。两条操作均交给 B01；B01 çš„ PSU03 SessionGate å…ˆå®Œæ•´æ‰§è¡Œ CH4 çš„“选择通道→设定→读回”，再执行 CH5。通道授权并行、物理会话串行，因此无需反复打开连接，也不会把 CH4 çš„设定写到 CH5。</p>
<p>若有人要执行 PSU03 æ•´æœº Reset，它要求父独占；CH4 æˆ– CH5 ä»»ä¸€ Permit ä»åœ¨ä½¿ç”¨æ—¶éƒ½ä¸èƒ½æ‰§è¡Œã€‚这样既保留通道独立性，又覆盖整机命令的影响范围。</p>
<h3>20.2 ç‹¬ç«‹ TCP ç”µæºèµ° Local</h3><p>PSU024 å›ºå®šå½’属于 W02。Recipe é€šè¿‡ S024/Power æ‰¾åˆ° LocalExecutor；W02 æŒæœ‰è¿žæŽ¥å®ˆå«ã€é€šé“租约和会话队列，直接调用驱动。HMI ç›‘控只读取 W02 å‘布的状态缓存。维护请求经 W02 çš„受控入口完成；若要换宿主，必须先停止 W02 çš„旧连接并通过恢复检查。Local çš„价值是减少代理跳转和独立进程数量，代价是不能仅凭租约过期进行跨进程自动接管。</p>
<h3>20.3 ç»´æŠ¤å·¥ç¨‹å¸ˆè¦æ“ä½œæ­£åœ¨ç”Ÿäº§çš„通道</h3><p>HMI æ˜¾ç¤ºè¯¥é€šé“ç”± Run-A/S024 ä½¿ç”¨ã€‚申请维护不会立即得到写权限：RunService å…ˆè®©å—影响 DUT åˆ°è¾¾å®‰å…¨è¾¹ç•Œï¼Œèµ„源转为 Draining；宿主停止接收新普通写操作，排空当前片段，执行适用安全动作并读回。确认旧连接/任务已隔离后，旧租约释放，新的维护 Grant æ‰èƒ½ç­¾å‘。交接超时会停在 RecoveryRequired；“等了30秒”本身不能成为接管依据。</p>
<h3>20.4 Broker å·²å‘命令，但客户端没收到结果</h3><p>客户端使用同一 IdempotencyKey æŸ¥è¯¢æˆ–重提。若 Journal å·²æœ‰ç»ˆæ€ï¼Œè¿”回原结果；若只记录 Running，且无法判断硬件是否执行，则返回 Unknown å¹¶æ ¸å¯¹è¯»å›žï¼Œä¸èƒ½ç”Ÿæˆæ–°è¯·æ±‚再触发一次。这说明 Task Journal è§£å†³â€œè¯·æ±‚是否见过、结果是否保存”，而不是替硬件实现数据库事务。</p>
<h3>20.5 Broker é‡å¯åŽå¦‚何恢复</h3><p>B01 é‡å¯å…ˆæå‡ epoch，旧 Grant å’Œæ—§æŽ’队任务失效，PSU01–05 æš‚时不可写。宿主重新识别设备、读取输出和协议状态；检查合格后资源回到 Free/Ready。W01/W02 å¿…须重新申请租约，RunService æ ¹æ®ä¸­æ–­çª—口决定继续还是重测。B02/B03 çš„独立 PSU åŸŸå¯ç»§ç»­è¿è¡Œï¼›è‹¥æ•…障涉及共用温箱/PLC，则按真实共享影响范围处理，不能假设只有40穴位受影响。</p>
<h3>20.6 120 ä¸ª DUT ç­‰å¾…与单次总线采集</h3><p>120 ä¸ª DUTContext å„自保存步骤、SN、计时和结果，但等待使用异步计时，不对应120条轮询线程。同一 CAN æ€»çº¿åªç”±ä¸€ä¸ªæŽ¥æ”¶å™¨è¯»å–，再解码并向多个 DUT åˆ†å‘。Broker çš„物理采集负责“数据从哪里来、是否新鲜”，Recipe å¼•æ“Žè´Ÿè´£â€œè¿™ä¸ª DUT æ˜¯å¦è¾¾åˆ°å·¥è‰ºæ¡ä»¶â€ï¼Œä»Žè€Œé¿å…120次读取同一总线。</p>
</section><section id="tbd"><h2>21　方案适用条件与限制</h2><p>方案是否成立取决于物理拓扑和设备协议。以下条件直接决定 Local/Broker è·¯ç”±ã€èµ„源粒度及恢复行为；它们是方案边界，不是研发排期。</p><div class="table-wrap"><table><thead><tr><th>条件</th><th>对方案的影响</th><th>未明确时的处理</th></tr></thead><tbody><tr><td>PSU ä¸º120×1还是15×8</td><td>前者可固定Local归属；后者跨Worker共享会话宜Broker</td><td>保留两种拓扑，禁止混用映射公式</td></tr><tr><td>设备是否允许多个会话、全局命令影响哪些通道</td><td>决定PhysicalSessionKey、父子资源和SessionGate范围</td><td>按更大的冲突域保守隔离</td></tr><tr><td>CAN/SDK是否单实例、线程安全域与UDS地址</td><td>决定一个Broker能持有什么、哪些任务可并行</td><td>不拆分同一全局SDK句柄；地址冲突拒绝发布</td></tr><tr><td>温箱/PLC安全态与人员作业许可</td><td>决定谁可控制设定、交接读回与独立断能动作</td><td>不以软件TTL或令牌代替硬件安全条件</td></tr><tr><td>动作能否取消、是否幂等、能否可靠读回</td><td>决定超时是可重试还是Unknown/恢复检查</td><td>不可逆动作默认不自动重放</td></tr><tr><td>采样率、保留周期和总线实际能力</td><td>决定队列、批量采集、数据分片与磁盘容量</td><td>将容量数字视作负载假设，实测后配置</td></tr><tr><td>Recipe允许的暂停、恢复与计时规则</td><td>决定掉线后续跑、步骤重入还是整件重测</td><td>保持中断证据，不自动判定合格</td></tr><tr><td>多机共享与第三方直连</td><td>决定是否必须Broker、TLS和网络访问控制</td><td>禁止共享SMB上的arb.db，禁止绕过唯一宿主</td></tr><tr><td>6Worker/3Broker是否符合真实SDK故障域</td><td>决定进程分组能否达到预期隔离效果</td><td>进程数作为建议；共享硬件按真实影响范围处理</td></tr></tbody></table></div><p>本文可以说明仲裁和恢复规则，但不能单独证明设备已达到节拍、硬实时、物理安全或168 h长稳要求。默认时间、队列容量和采样率均是可配置的初始假设；工程师发布配置时应填入实际设备参数。</p></section><section id="sources"><h2>22　来源、交付范围与阅读说明</h2><p>本 HTML æ‰€æœ‰æ ·å¼ã€è„šæœ¬ä¸Žæž¶æž„图均内置，打开与打印不依赖网络。全文含 22 ç« ã€3 å¼ å¯æ”¾å¤§æž¶æž„/状态/部署图、完整 120 ç©´ä½æ˜ å°„、C# åˆçº¦ã€SQLite DDL、故障恢复矩阵和典型运行场景。附带原生 Draw.io æ–‡ä»¶ä¾›å·¥ç¨‹ç¼–辑；HTML å†…也可下载同一原生图及 SQL / C# åˆçº¦ã€‚</p>
<p>绘图规则：<code>C:\Users\xcw11.HOMEAI\.codex\skills\drawio-default-style\SKILL.md</code>，版本 <b>1.0.0</b>；同时遵循 Draw.io æ’件原生格式/导出规则。图示内容为目标设计，静态实现事实以第 2 ç« ä¸ºå‡†ã€‚图 2 çš„安全确认包括在途命令终止、连接隔离、设备读回与必要的硬件作业许可。</p>
<p>参考技术资料（2026-11-03核对）：[E1] <a href="https://www.sqlite.org/lang_transaction.html">SQLite Transaction</a>：写事务与 BEGIN IMMEDIATE；[E2] <a href="https://www.sqlite.org/wal.html">SQLite WAL</a>：单机约束与读写并发边界；[E3] <a href="https://learn.microsoft.com/en-us/dotnet/standard/io/how-to-use-named-pipes-for-network-interprocess-communication">Microsoft Named Pipes</a>：进程间管道与身份能力。本文 IPC å¸§ã€ä»²è£ã€é˜Ÿåˆ—、恢复流程是本项目设计选择，并非这些文档提供的完整方案。</p>
<div class="table-wrap"><table><thead><tr><th>来源</th><th>路径</th><th>用途</th><th>SHA256（本次读取）</th></tr></thead><tbody><tr><td>S1</td><td><code>D:\TestPlatform\Aging_Software_Design_V2.1 (11).docx</code></td><td>V2.1设计基线：Run/DUT、120穴位、仪器管理与数据分层</td><td><code>36306c77933800fa0a9bd9719a77178021b44162d5034d244c8e3405d78238db</code></td></tr><tr><td>S2</td><td><code>D:\TestPlatform\TapProject\docs\MultiProcess_Instrument_Resource_Solution.html</code></td><td>旧多进程方案；本次对安全/IPC结论作修订</td><td><code>b8e1ec02155baca47e61fcdeaf4e36c0086c73fa658a7954ee92801037bb12ac</code></td></tr><tr><td>S3</td><td><code>D:\TestPlatform\TapProject\docs\DeviceConfig_DeviceDebug_Architecture.html</code></td><td>配置、维护会话与调试审计设计</td><td><code>c64f342e88828913b75c8813b69051028b5670e27e028ebb78e6bc732cdb80c4</code></td></tr><tr><td>S4</td><td><code>D:\TestPlatform\TapProject\Aging.Infrastructure\Core\ResourceManager.cs</code></td><td>当前进程内预约/代号/操作租约实现</td><td><code>61e75bb59c690e8bd5ff1d2b6672bdaa72693dbf27c324adad03d23ed03f8319</code></td></tr><tr><td>S5</td><td><code>D:\TestPlatform\TapProject\Aging.Infrastructure\Contracts\ResourceOwnerToken.cs</code></td><td>OwnerToken当前字段和构造行为</td><td><code>c45b12b4843019b6ddca7c267d8fec962971fd9fdd35903ff5f1b8a08e6ad09d</code></td></tr><tr><td>S6</td><td><code>D:\TestPlatform\TapProject\Aging.Infrastructure\Services\DeviceService.cs</code></td><td>命令校验及驱动调用路径</td><td><code>72a95fe5ddd07e5336b5a9b0e00c34d7ecf9abf104edd511956218bae69a1357</code></td></tr><tr><td>S7</td><td><code>D:\TestPlatform\TapProject\Aging.Infrastructure\Services\AutoDeviceFacade.cs</code></td><td>预约作用域及释放错误处理</td><td><code>67b7521a593b5961bf70bf998c72806e8e62d63afb41969d2058c7ec522e8e19</code></td></tr><tr><td>S8</td><td><code>D:\TestPlatform\TapProject\ConnectionUtil\PipeClient.cs</code></td><td>IPC响应不可达、serverName行为</td><td><code>b17451398fdffd7216c7b4c4db55f541cee76175b66ae93d822964bf59311870</code></td></tr><tr><td>S9</td><td><code>D:\TestPlatform\TapProject\ConnectionUtil\PipeServer.cs</code></td><td>现有命名管道服务端基础</td><td><code>58a3fc4f6f6ef8fe69a2781e429a557f0d529104717eb90ee10c7fdbb6d0b94e</code></td></tr><tr><td>S10</td><td><code>D:\TestPlatform\TapProject\Plugin.DeviceConfig\Model\DeviceConfigModel.cs</code></td><td>现有表与映射、版本模型</td><td><code>4b0022da848a9c0033ae20595e7c93123b952b15096035151f2d3b824f20d980</code></td></tr><tr><td>S11</td><td><code>D:\TestPlatform\TapProject\Aging.Infrastructure\Aging.Infrastructure.csproj</code></td><td>net472与依赖配置</td><td><code>f39ad8e25368431e2d2d77c2488c03c027dae5b0812e9dd50ec75de36269cace</code></td></tr><tr><td>S12</td><td><code>D:\06-产品开发\18-舱驾控制器老化设备\老化软件详细开发说明书_V1.0.docx</code></td><td>本工作区既有详细开发说明参考</td><td><code>9c0053ef959a55a15adcf06a7e27ba7cde46ae6f78ecb24291157c49b2d9cef7</code></td></tr></tbody></table></div>
<div class="downloads"><button data-download="drawio">下载原生架构图 .drawio</button><button data-download="configsql">下载配置库 DDL</button><button data-download="runtimesql">下载运行库 DDL</button><button data-download="contracts">下载 C# åˆçº¦</button></div>
<p class="muted">本文不包含已完成的生产代码、真实设备配置或现场验收结论。方案适用条件和未确认的设备参数在第 21 ç« åˆ—出。</p></section><footer>Local + DeviceBroker V3.0 Â· è®¾è®¡é»˜è®¤å€¼ä¸Žå®žé™…实现证据分别标注 Â· æœ¬åœ°å•æ–‡ä»¶äº¤ä»˜</footer></main><dialog id="diagram-dialog"><button id="close-dialog">关闭放大图</button><div class="dialog-body"></div></dialog><script>const assets={"drawio": {"name": "local-devicebroker-v3.drawio", "type": "application/xml", "content": "<?xml version='1.0' encoding='utf-8'?>\n<mxfile host=\"app.diagrams.net\" version=\"V3.0\"><diagram name=\"architecture\" id=\"architecture\"><mxGraphModel dx=\"1600\" dy=\"900\" grid=\"1\" gridSize=\"10\" page=\"1\" pageScale=\"1\" pageWidth=\"1600\" pageHeight=\"900\" background=\"#ffffff\"><root><mxCell id=\"0\" /><mxCell id=\"1\" parent=\"0\" /><mxCell id=\"title\" value=\"Local + DeviceBroker：统一业务入口与分域 I/O（目标设计）\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=28;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;fontStyle=1;strokeColor=none;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"60\" y=\"24\" width=\"1480\" height=\"60\" /><\/mxCell><mxCell id=\"config\" value=\"配置 / å‘布服务&lt;br&gt;不可变快照 Â· Hash Â· è·¯ç”±\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"60\" y=\"125\" width=\"400\" height=\"95\" /><\/mxCell><mxCell id=\"hmi\" value=\"HMI / ç»´æŠ¤ä¼šè¯&lt;br&gt;权限 Â· å ç”¨çŠ¶æ€ Â· å®¡è®¡\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"600\" y=\"125\" width=\"400\" height=\"95\" /><\/mxCell><mxCell id=\"run\" value=\"Run / Recipe / OpenTAP&lt;br&gt;120 DUTContext Â· é€»è¾‘能力\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"1140\" y=\"125\" width=\"400\" height=\"95\" /><\/mxCell><mxCell id=\"facade\" value=\"DeviceService + ResourceRouter&lt;br&gt;按快照定位资源 / å®¿ä¸»\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"600\" y=\"290\" width=\"400\" height=\"100\" /><\/mxCell><mxCell id=\"e1\" source=\"config\" target=\"facade\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#8796a5;dashed=1;exitX=0.5;exitY=1;entryX=0.2;entryY=0;\"><mxGeometry as=\"geometry\" relative=\"1\"><Array as=\"points\"><mxPoint x=\"260\" y=\"255\" /><mxPoint x=\"680\" y=\"255\" /><\/Array><\/mxGeometry><\/mxCell><mxCell id=\"e2\" source=\"hmi\" target=\"facade\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;exitX=0.5;exitY=1;entryX=0.5;entryY=0;\"><mxGeometry as=\"geometry\" relative=\"1\"><Array as=\"points\" /><\/mxGeometry><\/mxCell><mxCell id=\"e3\" source=\"run\" target=\"facade\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;exitX=0.5;exitY=1;entryX=0.8;entryY=0;\"><mxGeometry as=\"geometry\" relative=\"1\"><Array as=\"points\"><mxPoint x=\"1340\" y=\"255\" /><mxPoint x=\"920\" y=\"255\" /><\/Array><\/mxGeometry><\/mxCell><mxCell id=\"local\" value=\"LocalExecutor / LeaseStore&lt;br&gt;本机 arb.db Â· è¿žæŽ¥å®ˆå« Â· SessionGate\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"150\" y=\"470\" width=\"540\" height=\"110\" /><\/mxCell><mxCell id=\"broker\" value=\"BrokerClient â†’ DeviceBroker&lt;br&gt;本域 Lease / Task / Queue / Outbox\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"910\" y=\"470\" width=\"540\" height=\"110\" /><\/mxCell><mxCell id=\"e4\" source=\"facade\" target=\"local\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"e5\" source=\"facade\" target=\"broker\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"localio\" value=\"唯一 Worker å†…çš„ DeviceManager / Driver&lt;br&gt;固定归属的独立 TCP ä¼šè¯\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"150\" y=\"670\" width=\"540\" height=\"110\" /><\/mxCell><mxCell id=\"brokerio\" value=\"Broker å†…çš„ DeviceManager / Driver&lt;br&gt;共享 PSU / CAN / RS485 / PLC\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"910\" y=\"670\" width=\"540\" height=\"110\" /><\/mxCell><mxCell id=\"e6\" source=\"local\" target=\"localio\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"e7\" source=\"broker\" target=\"brokerio\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"legend\" value=\"实线：调用 / I/O è·¯å¾„　　灰色虚线：配置依赖　　TTL åˆ°æœŸ â†’ éš”离核查；连接确认退出后才交接\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=18;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;strokeColor=none;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"60\" y=\"815\" width=\"1480\" height=\"55\" /><\/mxCell><\/root><\/mxGraphModel><\/diagram><diagram name=\"handover\" id=\"handover\"><mxGraphModel dx=\"1600\" dy=\"900\" grid=\"1\" gridSize=\"10\" page=\"1\" pageScale=\"1\" pageWidth=\"1600\" pageHeight=\"900\" background=\"#ffffff\"><root><mxCell id=\"0\" /><mxCell id=\"1\" parent=\"0\" /><mxCell id=\"title\" value=\"资源交接：先排空、隔离与核查，再允许新 owner（目标设计）\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=28;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;fontStyle=1;strokeColor=none;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"60\" y=\"24\" width=\"1480\" height=\"60\" /><\/mxCell><mxCell id=\"free\" value=\"Free / Ready&lt;br&gt;允许申请\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"80\" y=\"160\" width=\"330\" height=\"105\" /><\/mxCell><mxCell id=\"active\" value=\"Active&lt;br&gt;Grant + å‘¨æœŸç»­ç§Ÿ\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"635\" y=\"160\" width=\"330\" height=\"105\" /><\/mxCell><mxCell id=\"drain\" value=\"Draining&lt;br&gt;停止新写 / æŽ’空片段\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#fff2d9;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"1190\" y=\"160\" width=\"330\" height=\"105\" /><\/mxCell><mxCell id=\"e1\" source=\"free\" target=\"active\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"e2\" source=\"active\" target=\"drain\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"expire\" value=\"租约 / å¿ƒè·³å¼‚常&lt;br&gt;阻断后续写入\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#fff2d9;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"635\" y=\"385\" width=\"330\" height=\"105\" /><\/mxCell><mxCell id=\"verify\" value=\"安全交接检查&lt;br&gt;读回 Â· è¿žæŽ¥éš”离 Â· è”锁\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"1190\" y=\"385\" width=\"330\" height=\"105\" /><\/mxCell><mxCell id=\"e3\" source=\"active\" target=\"expire\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"e4\" source=\"drain\" target=\"verify\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"recovery\" value=\"RecoveryRequired&lt;br&gt;设备状态未知 / ç¦æ­¢é‡æŽˆ\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#fdeced;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"635\" y=\"610\" width=\"330\" height=\"105\" /><\/mxCell><mxCell id=\"new\" value=\"检查合格 â†’ Free&lt;br&gt;重新申请新 Grant\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"1190\" y=\"610\" width=\"330\" height=\"105\" /><\/mxCell><mxCell id=\"e5\" source=\"expire\" target=\"recovery\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"e6\" source=\"verify\" target=\"new\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"e7\" source=\"recovery\" target=\"verify\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;exitX=1;exitY=0.5;entryX=0;entryY=0.5;\"><mxGeometry as=\"geometry\" relative=\"1\"><Array as=\"points\"><mxPoint x=\"1080\" y=\"662.5\" /><mxPoint x=\"1080\" y=\"437.5\" /><\/Array><\/mxGeometry><\/mxCell><mxCell id=\"limits\" value=\"异常路径说明&lt;br&gt;&lt;br&gt;Draining è¶…æ—¶ / æ£€æŸ¥å¤±è´¥&lt;br&gt;→ RecoveryRequired&lt;br&gt;&lt;br&gt;Broker é‡å¯ï¼šepoch + 1&lt;br&gt;旧 Grant å…¨éƒ¨å¤±æ•ˆ&lt;br&gt;&lt;br&gt;Local æ—§å®ˆå«æœªé€€å‡º&lt;br&gt;→ ä¿æŒéš”离，不按 TTL æŠ¢å \" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"80\" y=\"385\" width=\"330\" height=\"330\" /><\/mxCell><mxCell id=\"legend\" value=\"实线：正常申请或恢复推进　　异常到期不直接转 Free　　未确认的已发命令 â†’ Unknown / æ¢å¤æ£€æŸ¥\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=18;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;strokeColor=none;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"60\" y=\"810\" width=\"1480\" height=\"55\" /><\/mxCell><\/root><\/mxGraphModel><\/diagram><diagram name=\"deployment120\" id=\"deployment120\"><mxGraphModel dx=\"1600\" dy=\"900\" grid=\"1\" gridSize=\"10\" page=\"1\" pageScale=\"1\" pageWidth=\"1600\" pageHeight=\"900\" background=\"#ffffff\"><root><mxCell id=\"0\" /><mxCell id=\"1\" parent=\"0\" /><mxCell id=\"title\" value=\"120 ç©´ä½ï¼š6 Worker + 3 Broker åŸŸï¼ˆ15×8 PSU åŸºçº¿ / å»ºè®®ï¼‰\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=28;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;fontStyle=1;strokeColor=none;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"60\" y=\"24\" width=\"1480\" height=\"60\" /><\/mxCell><mxCell id=\"hmi\" value=\"IPC-01：HMI / RunService / Supervisor&lt;br&gt;配置快照与结果索引；ResultWriter ç‹¬ç«‹è½ç›˜\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"500\" y=\"110\" width=\"600\" height=\"95\" /><\/mxCell><mxCell id=\"w1\" value=\"W01 + W02&lt;br&gt;S001–S040 Â· 2×20 DUTContext\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"60\" y=\"315\" width=\"400\" height=\"100\" /><\/mxCell><mxCell id=\"b1\" value=\"Broker B01&lt;br&gt;唯一宿主 Â· æœ¬åŸŸ DB / é˜Ÿåˆ—\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"60\" y=\"520\" width=\"400\" height=\"100\" /><\/mxCell><mxCell id=\"p1\" value=\"PSU01–PSU05&lt;br&gt;5 å° Ã— 8 é€šé“ = 40 ç©´ä½\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"60\" y=\"725\" width=\"400\" height=\"100\" /><\/mxCell><mxCell id=\"e1a\" source=\"hmi\" target=\"w1\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"e1b\" source=\"w1\" target=\"b1\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"e1c\" source=\"b1\" target=\"p1\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"w2\" value=\"W03 + W04&lt;br&gt;S041–S080 Â· 2×20 DUTContext\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"600\" y=\"315\" width=\"400\" height=\"100\" /><\/mxCell><mxCell id=\"b2\" value=\"Broker B02&lt;br&gt;唯一宿主 Â· æœ¬åŸŸ DB / é˜Ÿåˆ—\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"600\" y=\"520\" width=\"400\" height=\"100\" /><\/mxCell><mxCell id=\"p2\" value=\"PSU06–PSU10&lt;br&gt;5 å° Ã— 8 é€šé“ = 40 ç©´ä½\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"600\" y=\"725\" width=\"400\" height=\"100\" /><\/mxCell><mxCell id=\"e2a\" source=\"hmi\" target=\"w2\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"e2b\" source=\"w2\" target=\"b2\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"e2c\" source=\"b2\" target=\"p2\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"w3\" value=\"W05 + W06&lt;br&gt;S081–S120 Â· 2×20 DUTContext\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"1140\" y=\"315\" width=\"400\" height=\"100\" /><\/mxCell><mxCell id=\"b3\" value=\"Broker B03&lt;br&gt;唯一宿主 Â· æœ¬åŸŸ DB / é˜Ÿåˆ—\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#e8f4ef;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"1140\" y=\"520\" width=\"400\" height=\"100\" /><\/mxCell><mxCell id=\"p3\" value=\"PSU11–PSU15&lt;br&gt;5 å° Ã— 8 é€šé“ = 40 ç©´ä½\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=20;spacing=14;fillColor=#eaf2f8;strokeColor=#33556f;strokeWidth=2;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"1140\" y=\"725\" width=\"400\" height=\"100\" /><\/mxCell><mxCell id=\"e3a\" source=\"hmi\" target=\"w3\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"e3b\" source=\"w3\" target=\"b3\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"e3c\" source=\"b3\" target=\"p3\" edge=\"1\" parent=\"1\" style=\"edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;endArrow=block;strokeWidth=2;strokeColor=#286494;\"><mxGeometry as=\"geometry\" relative=\"1\" /><\/mxCell><mxCell id=\"legend\" value=\"CAN / PLC / æ¸©ç®±æŒ‰çœŸå®žç‰©ç†ä¸Ž SDK åŸŸå›ºå®šå”¯ä¸€å®¿ä¸»ï¼ˆTBD）；共享设备不因分 3 åŸŸè€Œå¤åˆ¶è¿žæŽ¥ã€‚\" style=\"rounded=0;whiteSpace=wrap;html=1;align=center;verticalAlign=middle;fontFamily=Microsoft YaHei;fontSize=18;spacing=14;fillColor=#ffffff;strokeColor=#33556f;strokeWidth=2;strokeColor=none;\" vertex=\"1\" parent=\"1\"><mxGeometry as=\"geometry\" x=\"60\" y=\"845\" width=\"1480\" height=\"45\" /><\/mxCell><\/root><\/mxGraphModel><\/diagram><\/mxfile>"}, "configsql": {"name": "v3-config-schema.sql", "type": "text/plain", "content": "PRAGMA foreign_keys=ON;\nPRAGMA journal_mode=WAL;\nPRAGMA synchronous=FULL;\nPRAGMA busy_timeout=3000;\nCREATE TABLE config_snapshot (\n  config_hash TEXT PRIMARY KEY, version_id TEXT NOT NULL UNIQUE,\n  schema_version INTEGER NOT NULL CHECK(schema_version=3),\n  content_json TEXT NOT NULL, author TEXT NOT NULL,\n  published_utc_ms INTEGER NOT NULL\n);\nCREATE TABLE effective_config (\n  scope_id TEXT PRIMARY KEY, config_hash TEXT NOT NULL\n    REFERENCES config_snapshot(config_hash), revision INTEGER NOT NULL\n);\nCREATE TABLE resource_definition (\n  config_hash TEXT NOT NULL REFERENCES config_snapshot(config_hash),\n  resource_key TEXT NOT NULL, device_id TEXT NOT NULL, channel_id INTEGER NOT NULL,\n  parent_key TEXT, session_key TEXT NOT NULL, physical_identity TEXT NOT NULL,\n  execution_mode TEXT NOT NULL CHECK(execution_mode IN ('Local','Broker')),\n  authority_id TEXT NOT NULL, owner_process_id TEXT,\n  access_policy TEXT NOT NULL, safe_profile TEXT NOT NULL,\n  PRIMARY KEY(config_hash, resource_key)\n);\nCREATE TABLE slot_binding (\n  config_hash TEXT NOT NULL, slot_id TEXT NOT NULL, capability TEXT NOT NULL,\n  resource_key TEXT NOT NULL, group_id TEXT NOT NULL,\n  PRIMARY KEY(config_hash, slot_id, capability),\n  FOREIGN KEY(config_hash, resource_key)\n    REFERENCES resource_definition(config_hash, resource_key)\n);\nCREATE INDEX ix_binding_resource ON slot_binding(config_hash, resource_key);\nCREATE TABLE broker_task_template (\n  config_hash TEXT NOT NULL REFERENCES config_snapshot(config_hash),\n  template_id TEXT NOT NULL, template_version TEXT NOT NULL,\n  operation_code TEXT NOT NULL, parameters_schema TEXT NOT NULL,\n  required_resources_json TEXT NOT NULL, max_duration_ms INTEGER NOT NULL,\n  safe_profile TEXT NOT NULL,\n  PRIMARY KEY(config_hash,template_id,template_version)\n);\nCREATE TABLE run_snapshot (\n  run_id TEXT PRIMARY KEY, config_hash TEXT NOT NULL\n    REFERENCES config_snapshot(config_hash), recipe_hash TEXT NOT NULL,\n  driver_manifest_hash TEXT NOT NULL, dbc_hash TEXT NOT NULL,\n  uds_hash TEXT NOT NULL, slot_set_json TEXT NOT NULL, started_utc_ms INTEGER NOT NULL\n);\nCREATE TABLE config_apply_ack (\n  apply_id TEXT NOT NULL, authority_id TEXT NOT NULL,\n  config_hash TEXT NOT NULL REFERENCES config_snapshot(config_hash),\n  phase TEXT NOT NULL, readback_json TEXT NOT NULL, utc_ms INTEGER NOT NULL,\n  PRIMARY KEY(apply_id,authority_id)\n);"}, "runtimesql": {"name": "v3-runtime-schema.sql", "type": "text/plain", "content": "PRAGMA foreign_keys=ON;\nPRAGMA journal_mode=WAL;\nPRAGMA synchronous=FULL;\nPRAGMA busy_timeout=3000;\nCREATE TABLE authority_meta (\n  authority_id TEXT PRIMARY KEY, epoch INTEGER NOT NULL,\n  boot_id TEXT NOT NULL, schema_version INTEGER NOT NULL\n);\nCREATE TABLE resource_state (\n  resource_key TEXT PRIMARY KEY, generation INTEGER NOT NULL DEFAULT 0,\n  phase TEXT NOT NULL CHECK(phase IN ('Free','Active','Draining','RecoveryRequired','Disabled')),\n  lease_id TEXT UNIQUE, owner_id TEXT, owner_type TEXT, group_id TEXT,\n  process_instance_id TEXT, epoch INTEGER NOT NULL,\n  expires_utc_ms INTEGER, handover_utc_ms INTEGER, updated_utc_ms INTEGER NOT NULL,\n  CHECK(phase <> 'Free' OR lease_id IS NULL)\n);\nCREATE INDEX ix_resource_expiry ON resource_state(phase,expires_utc_ms);\nCREATE TABLE parent_permit (\n  parent_key TEXT NOT NULL, lease_id TEXT NOT NULL,\n  mode TEXT NOT NULL CHECK(mode IN ('Shared','Exclusive')),\n  owner_id TEXT NOT NULL, epoch INTEGER NOT NULL,\n  expires_utc_ms INTEGER NOT NULL,\n  PRIMARY KEY(parent_key,lease_id)\n);\nCREATE TABLE lease_history (\n  event_id INTEGER PRIMARY KEY AUTOINCREMENT, resource_key TEXT NOT NULL,\n  generation INTEGER NOT NULL, epoch INTEGER NOT NULL, lease_id TEXT,\n  owner_id TEXT, event_type TEXT NOT NULL, reason TEXT NOT NULL, utc_ms INTEGER NOT NULL\n);\nCREATE TABLE broker_task (\n  task_id TEXT PRIMARY KEY, client_instance_id TEXT NOT NULL,\n  idempotency_key TEXT NOT NULL, payload_sha256 TEXT NOT NULL,\n  config_hash TEXT NOT NULL, epoch INTEGER NOT NULL,\n  template_id TEXT NOT NULL, request_json TEXT NOT NULL,\n  state TEXT NOT NULL CHECK(state IN ('Accepted','Queued','Running','Succeeded',\n    'Failed','Cancelled','Expired','Unknown','RecoveryRequired')),\n  priority INTEGER NOT NULL, submitted_utc_ms INTEGER NOT NULL,\n  deadline_utc_ms INTEGER NOT NULL, started_utc_ms INTEGER, finished_utc_ms INTEGER,\n  result_json TEXT, error_code TEXT,\n  UNIQUE(client_instance_id,idempotency_key)\n);\nCREATE INDEX ix_task_queue ON broker_task(state,priority,submitted_utc_ms);\nCREATE TABLE broker_event (\n  cursor INTEGER PRIMARY KEY AUTOINCREMENT, task_id TEXT,\n  event_type TEXT NOT NULL, payload_json TEXT NOT NULL, utc_ms INTEGER NOT NULL\n);\nCREATE TABLE result_outbox (\n  result_id TEXT PRIMARY KEY, task_id TEXT NOT NULL UNIQUE REFERENCES broker_task(task_id),\n  payload_json TEXT NOT NULL, state TEXT NOT NULL CHECK(state IN ('Pending','Acked')),\n  attempt INTEGER NOT NULL DEFAULT 0, created_utc_ms INTEGER NOT NULL\n);\nCREATE TABLE recovery_checkpoint (\n  resource_key TEXT PRIMARY KEY, epoch INTEGER NOT NULL, status TEXT NOT NULL,\n  physical_readback_json TEXT NOT NULL, approved_by TEXT,\n  evidence_json TEXT NOT NULL, updated_utc_ms INTEGER NOT NULL\n);\nCREATE TABLE operation_audit (\n  audit_id INTEGER PRIMARY KEY AUTOINCREMENT, correlation_id TEXT NOT NULL,\n  principal_id TEXT NOT NULL, owner_id TEXT NOT NULL, task_id TEXT,\n  resource_key TEXT NOT NULL, action TEXT NOT NULL, outcome TEXT NOT NULL,\n  detail_json TEXT NOT NULL, utc_ms INTEGER NOT NULL\n);"}, "contracts": {"name": "ResourceContracts.V3.cs", "type": "text/plain", "content": "using System;\nusing System.Collections.Generic;\nusing System.Threading;\nusing System.Threading.Tasks;\n\nnamespace Aging.ResourceContracts.V3\n{\n    public enum ExecutionMode { Local, Broker }\n    public enum OwnerKind { Production, Maintenance, SystemSafety }\n    public enum TaskState { Accepted, Queued, Running, Succeeded, Failed,\n        Cancelled, Expired, Unknown, RecoveryRequired }\n\n    // Broker/Store签发；必须按持久化字段还原，不能在反序列化时生成新LeaseId。\n    public sealed class LeaseGrant\n    {\n        public string AuthorityId { get; }\n        public string ResourceKey { get; }\n        public string LeaseId { get; }\n        public string OwnerId { get; }\n        public long Epoch { get; }\n        public long Generation { get; }\n        public long ExpiresUtcMs { get; }\n        public LeaseGrant(string authorityId, string resourceKey, string leaseId,\n            string ownerId, long epoch, long generation, long expiresUtcMs)\n        {\n            AuthorityId=authorityId; ResourceKey=resourceKey; LeaseId=leaseId;\n            OwnerId=ownerId; Epoch=epoch; Generation=generation;\n            ExpiresUtcMs=expiresUtcMs;\n        }\n    }\n    public sealed class AcquireRequest\n    {\n        public string OwnerId { get; set; } = \"\";\n        public OwnerKind OwnerKind { get; set; }\n        public string ProcessInstanceId { get; set; } = \"\";\n        public string ConfigHash { get; set; } = \"\";\n        public string[] ResourceKeys { get; set; } = new string[0];\n        public int WaitTimeoutMs { get; set; }\n    }\n    public interface ILeaseScope\n    {\n        IReadOnlyList<LeaseGrant> Grants { get; }\n        CancellationToken LeaseLost { get; }\n        Task ReleaseAsync(CancellationToken cancellationToken);\n    }\n    public interface IResourceCoordinator\n    {\n        Task<ILeaseScope> AcquireGroupAsync(AcquireRequest request, CancellationToken ct);\n        Task<IReadOnlyList<LeaseGrant>> RenewGroupAsync(\n            IReadOnlyList<LeaseGrant> grants, CancellationToken ct);\n        Task RequestHandoverAsync(string resourceKey, string reason, CancellationToken ct);\n    }\n    public sealed class DeviceOperation\n    {\n        public string OperationCode { get; set; } = \"\";\n        public string ParametersJson { get; set; } = \"{}\";\n        public string IdempotencyKey { get; set; } = \"\";\n        public string ConfigHash { get; set; } = \"\";\n        public IReadOnlyList<LeaseGrant> Grants { get; set; } = new LeaseGrant[0];\n        public long DeadlineUtcMs { get; set; }\n    }\n    public sealed class OperationResult\n    {\n        public string RequestId { get; set; } = \"\";\n        public TaskState State { get; set; }\n        public string ErrorCode { get; set; } = \"\";\n        public string ReadbackJson { get; set; } = \"{}\";\n        public bool PhysicalStateKnown { get; set; }\n    }\n    public interface IDeviceExecutor\n    {\n        Task<OperationResult> ExecuteAsync(DeviceOperation op, CancellationToken ct);\n    }\n    public sealed class BrokerTaskRequest\n    {\n        public string ClientInstanceId { get; set; } = \"\";\n        public string TemplateId { get; set; } = \"\";\n        public string TemplateVersion { get; set; } = \"\";\n        public DeviceOperation Operation { get; set; } = new DeviceOperation();\n    }\n    public sealed class BrokerTaskTicket\n    {\n        public string TaskId { get; set; } = \"\";\n        public TaskState State { get; set; }\n    }\n    public interface IDeviceBrokerClient\n    {\n        Task<BrokerTaskTicket> SubmitAsync(BrokerTaskRequest request, CancellationToken ct);\n        Task<OperationResult> QueryAsync(string taskId, CancellationToken ct);\n        Task CancelAsync(string taskId, string reason, CancellationToken ct);\n        Task AckResultAsync(string resultId, CancellationToken ct);\n    }\n}"}};
const $=s=>document.querySelector(s); const $$=s=>[...document.querySelectorAll(s)];
const search=$('#search');function filter(){let q=search.value.trim().toLowerCase(),n=0;document.body.dataset.filtered=!!q;$$('main section').forEach(s=>{let hit=!q||s.innerText.toLowerCase().includes(q);s.classList.toggle('hidden',!hit);let a=$('nav a[href="#'+s.id+'"]');a.style.display=hit?'block':'none';if(hit)n++});$('#count').textContent=n+' / 22 ç« ';$('.no-results').style.display=n?'none':'block'}search.addEventListener('input',filter);
$('#clear').onclick=()=>{search.value='';filter()};$('#print').onclick=()=>{search.value='';filter();$$('details').forEach(x=>x.open=true);window.print()};
$$('.copy').forEach(b=>b.onclick=async()=>{let t=b.parentElement.nextElementSibling.innerText;try{await navigator.clipboard.writeText(t);b.textContent='已复制';setTimeout(()=>b.textContent='复制',1200)}catch(e){const r=document.createRange();r.selectNodeContents(b.parentElement.nextElementSibling);const sel=window.getSelection();sel.removeAllRanges();sel.addRange(r);b.textContent='已选中，请 Ctrl+C'}});
const dlg=$('#diagram-dialog');$$('.zoom').forEach(b=>b.onclick=()=>{$('.dialog-body').replaceChildren(b.parentElement.querySelector('img').cloneNode(true));dlg.showModal()});$('#close-dialog').onclick=()=>dlg.close();
$$('[data-download]').forEach(b=>b.onclick=()=>{let x=assets[b.dataset.download];let a=document.createElement('a');let u=URL.createObjectURL(new Blob([x.content],{type:x.type}));a.href=u;a.download=x.name;a.click();setTimeout(()=>URL.revokeObjectURL(u),1000)});
if('IntersectionObserver' in window){let obs=new IntersectionObserver(es=>es.forEach(e=>{if(e.isIntersecting){$$('nav a').forEach(a=>a.classList.toggle('active',a.hash==='#'+e.target.id))}}),{rootMargin:'-5% 0px -75% 0px'});$$('main section').forEach(s=>obs.observe(s))}
</script></body></html>

 docs/MultiProcess_Instrument_Resource_Solution.html

New file
@@ -0,0 +1,799 @@
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>多进程/多线程场景下的仪器资源独占与共享方案</title>
<script src="https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js"></script>
<style>
    * { box-sizing: border-box; }
    body {
        font-family: -apple-system, "Segoe UI", "Microsoft YaHei", "PingFang SC", sans-serif;
        max-width: 1240px; margin: 0 auto; padding: 32px 24px 80px;
        background: #FAFAFA; color: #212121; line-height: 1.75;
    }
    h1 { font-size: 29px; color: #1565C0; border-bottom: 3px solid #1976D2; padding-bottom: 12px; }
    h2 { font-size: 23px; color: #0D47A1; margin-top: 42px; padding-left: 12px; border-left: 4px solid #FF9800; }
    h3 { font-size: 17px; color: #37474F; margin-top: 26px; }
    h4 { font-size: 15px; color: #455A64; margin-top: 18px; }
    .subtitle { color: #757575; font-size: 14px; margin-bottom: 24px; }
    .card { background: white; border-radius: 8px; padding: 18px 22px; margin: 16px 0; box-shadow: 0 2px 8px rgba(0,0,0,0.06); }
    .highlight { background: #FFF8E1; border-left: 4px solid #FFC107; padding: 12px 16px; margin: 12px 0; border-radius: 4px; }
    .info { background: #E3F2FD; border-left: 4px solid #2196F3; padding: 12px 16px; margin: 12px 0; border-radius: 4px; }
    .success { background: #E8F5E9; border-left: 4px solid #4CAF50; padding: 12px 16px; margin: 12px 0; border-radius: 4px; }
    .warn { background: #FBE9E7; border-left: 4px solid #FF5722; padding: 12px 16px; margin: 12px 0; border-radius: 4px; }
    table { width: 100%; border-collapse: collapse; margin: 16px 0; background: white; border-radius: 6px; overflow: hidden; box-shadow: 0 1px 4px rgba(0,0,0,0.06); font-size: 13.5px; }
    th { background: #1976D2; color: white; padding: 9px 12px; text-align: left; font-weight: 600; }
    td { padding: 8px 12px; border-bottom: 1px solid #EEEEEE; vertical-align: top; }
    tr:nth-child(even) td { background: #FAFAFA; }
    tr:hover td { background: #E3F2FD; }
    code { font-family: "Consolas", "Monaco", monospace; background: #F5F5F5; color: #C62828; padding: 2px 6px; border-radius: 3px; font-size: 13px; }
    pre { background: #263238; color: #ECEFF1; padding: 16px 20px; border-radius: 6px; overflow-x: auto; font-family: "Consolas", monospace; font-size: 13px; line-height: 1.55; }
    pre code { background: transparent; color: inherit; padding: 0; font-size: 13px; }
    .mermaid { background: white; padding: 20px; border-radius: 8px; margin: 20px 0; text-align: center; box-shadow: 0 2px 8px rgba(0,0,0,0.06); overflow-x: auto; }
    ul { padding-left: 22px; } li { margin: 4px 0; }
    .toc { background: #F5F5F5; padding: 16px 24px; border-radius: 6px; margin: 20px 0; }
    .toc a { color: #1976D2; text-decoration: none; display: block; padding: 3px 0; }
    .toc a:hover { text-decoration: underline; }
    .kwd { color: #FFCC80; } .str { color: #C5E1A5; } .cmt { color: #546E7A; } .fn { color: #82AAFF; }
    .good { color: #2E7D32; font-weight: 600; } .bad { color: #C62828; font-weight: 600; } .mid { color: #EF6C00; font-weight: 600; }
    footer { margin-top: 60px; padding-top: 20px; border-top: 1px solid #E0E0E0; color: #757575; font-size: 12px; text-align: center; }
    .path { font-family: Consolas, monospace; font-size: 12.5px; background: #ECEFF1; color: #37474F; padding: 1px 6px; border-radius: 3px; }
</style>
</head>
<body>

<h1>多进程 / å¤šçº¿ç¨‹åœºæ™¯ä¸‹çš„仪器资源独占与共享方案</h1>
<div class="subtitle">TestPlatform Aging Software Â· SQLite è®¾å¤‡æ³¨å†Œ + Aging.Infrastructure ç§Ÿçº¦ + OpenTAP åºåˆ—执行器 ä¸‰æ ˆèžåˆè®¾è®¡ Â· 2026-11-03</div>

<div class="toc">
    <strong>目录</strong>
    <a href="#s1">1. çŽ°çŠ¶ç›˜ç‚¹ä¸Žé—®é¢˜å®šä¹‰</a>
    <a href="#s2">2. ä¸¤ç±»å¹¶å‘场景的严格区分</a>
    <a href="#s3">3. äº”个候选方案逐一评估与横向对比</a>
    <a href="#s4">4. æŽ¨èç›®æ ‡æž¶æž„：分层混合（租约表 + ä»²è£è§„则 + æŒ‰éœ€ Broker）</a>
    <a href="#s5">5. ç§Ÿçº¦å®Œæ•´ç”Ÿå‘½å‘¨æœŸï¼šç”³è¯· / ç»­æœŸ / é‡Šæ”¾ / è¶…时抢占</a>
    <a href="#s6">6. å…¨è‡ªåŠ¨ vs æ‰‹åŠ¨ç»´æŠ¤çš„互斥仲裁规则</a>
    <a href="#s7">7. å¼‚常场景处理：死锁 / å­¤å„¿é” / æ—¶é’Ÿ / å¹‚ç­‰</a>
    <a href="#s8">8. ç‹¬å  or åˆ†æ—¶å¤ç”¨ï¼šè®¾å¤‡åˆ†ç»„与 Slot ç»‘定策略</a>
    <a href="#s9">9. æœ¬ä»“库改造清单（具体文件路径 + æŽ¥å£ç­¾å + DDL）</a>
    <a href="#s10">10. æµ‹è¯•è¦ç‚¹ï¼šå•å…ƒ / å¤šè¿›ç¨‹é›†æˆ / å´©æºƒæ¼”练</a>
    <a href="#s11">11. åˆ†é˜¶æ®µå®žæ–½è®¡åˆ’与工作量估算</a>
    <a href="#s12">12. é£Žé™©ã€åæ¨¡å¼ä¸Žä¸æŽ¨èåšæ³•</a>
    <a href="#s13">13. ç»“论</a>
</div>

<!-- ================================================================= -->
<h2 id="s1">1. çŽ°çŠ¶ç›˜ç‚¹ä¸Žé—®é¢˜å®šä¹‰</h2>

<div class="card">
<strong>先说结论：你们的架构已经"半只脚"踩在正确方案上。</strong>
<code>ResourceOwnerToken</code>（含 Generation ä¸–代号）、<code>reservation_ref</code> å­—段、<code>IAutoDeviceLease</code> ä½œç”¨åŸŸâ€”—这些概念与工业界标准的"租约（Lease）+ æ …栏令牌（Fencing Token）"模型一一对应。唯一的问题是：<strong>整套机制活在内存里</strong>。
</div>

<h3>1.1 çŽ°çŠ¶ä»£ç äº‹å®žæ ¸æŸ¥</h3>
<table>
    <tr><th>组件</th><th>文件</th><th>现状</th><th>跨进程能力</th></tr>
    <tr>
        <td>ResourceManager</td>
        <td><span class="path">Aging.Infrastructure/Core/ResourceManager.cs</span></td>
        <td><code>ConcurrentDictionary</code> å­˜é¢„约 + <code>SemaphoreSlim(1,1)</code> æ¯èµ„源细锁；Generation å…¨å±€è‡ªå¢ž</td>
        <td class="bad">❌ çº¯è¿›ç¨‹å†…存，其他进程完全不可见</td>
    </tr>
    <tr>
        <td>ResourceOwnerToken</td>
        <td><span class="path">Contracts/ResourceOwnerToken.cs</span></td>
        <td>TokenId + OwnerType(Production/Maintenance) + Generation + IssuedAt/ExpiresAt</td>
        <td class="mid">⚠️ ç»“构可序列化，但目前没有跨进程校验路径</td>
    </tr>
    <tr>
        <td>AutoDeviceFacade / Lease</td>
        <td><span class="path">Services/AutoDeviceFacade.cs</span></td>
        <td>Reserve â†’ DeviceService åˆ†æ´¾ â†’ finally Release；Lease ä½œç”¨åŸŸå¤ç”¨</td>
        <td class="bad">❌ ä¾èµ–内存版 ResourceManager</td>
    </tr>
    <tr>
        <td>DeviceService</td>
        <td><span class="path">Services/DeviceService.cs</span></td>
        <td>执行前 <code>ValidateOwner</code>（内存查表）→ <code>AcquireOperationAsync</code> â†’ driver ä¸‹å‘</td>
        <td class="bad">❌ æ ¡éªŒä»…本进程有效</td>
    </tr>
    <tr>
        <td>DebugSessionManager</td>
        <td><span class="path">Plugin.DeviceDebug/Model/DebugSessionManager.cs</span></td>
        <td>RequestMaintenance å·²æ•èŽ· <code>ResourceConflictException</code>，并把 <code>reservation.ReservationId</code> å†™å…¥ <code>session.ReservationRef</code> æŒä¹…化</td>
        <td class="mid">⚠️ å·²é¢„留挂接点，差一个"活的"仲裁源</td>
    </tr>
    <tr>
        <td>debug_session è¡¨</td>
        <td><span class="path">Plugin.DeviceDebug/Model/DeviceDebugModel.cs</span></td>
        <td>有 <code>reservation_ref TEXT</code>、<code>state</code>、<code>closed_at</code>，无心跳/过期列</td>
        <td class="mid">⚠️ å¯æ‰©å±•</td>
    </tr>
    <tr>
        <td>IPC è®¾æ–½</td>
        <td><span class="path">ConnectionUtil/PipeServer.cs Â· PipeClient.cs</span></td>
        <td>命名管道（Message æ¨¡å¼ï¼‰å·²å®žçŽ°ï¼šå¤šå®žä¾‹æœåŠ¡ç«¯ã€è¿žæŽ¥äº‹ä»¶ã€è¯·æ±‚-响应 SendMessage（带超时）</td>
        <td class="good">✅ å¯ç›´æŽ¥ä½œä¸º Device Broker çš„传输层，无需新造轮子</td>
    </tr>
    <tr>
        <td>OpenTAP SynchronizationManager</td>
        <td>OpenTAP 9.31 å¼•æ“Ž</td>
        <td>进程内 <code>RequestLock(resource, timeout)</code> æŒ‰ä»ªå™¨äº’æ–¥</td>
        <td class="bad">❌ å®˜æ–¹æ–‡æ¡£æ˜Žç¡®ï¼šä»…进程内</td>
    </tr>
</table>

<h3>1.2 é—®é¢˜æœ¬è´¨æ‹†è§£</h3>
<div class="highlight">
"多工位共用一台仪器"其实包含 <strong>三个不同层面</strong>的问题，必须分开解决，混在一起谈必然方案走形：
<ol>
<li><strong>仲裁（Arbitration）</strong>：谁<em>有权</em>在这台仪器上发命令？→ éœ€è¦è·¨è¿›ç¨‹å¯è§ã€å¯æŒä¹…化、崩溃可回收的<strong>租约状态</strong>。</li>
<li><strong>连接独占（Connection）</strong>：物理句柄（COM å£ã€USB、CAN å¡ï¼‰åŒä¸€æ—¶åˆ»åªèƒ½è¢«ä¸€ä¸ªè¿›ç¨‹ <code>open</code>；网口仪器则允许同机多连接但需要"逻辑独占"语义。→ éœ€è¦æŠŠ<strong>连接持有者与租约持有者绑定</strong>，必要时引入代理进程。</li>
<li><strong>命令串行化（Serialization）</strong>：分时复用型设备（如共享温箱），允许多工位排队下发原子命令片段。→ éœ€è¦<strong>队列/栅栏令牌</strong>，而非独占租约。</li>
</ol>
</div>

<!-- ================================================================= -->
<h2 id="s2">2. ä¸¤ç±»å¹¶å‘场景的严格区分</h2>

<div class="mermaid">
graph TB
    subgraph åœºæ™¯A["场景 A：同进程多线程（单 HMI ä¸»ç¨‹åºå†…）"]
        A1["OpenTAP å¹¶è¡Œæ­¥éª¤ / MultiSite è°ƒåº¦çº¿ç¨‹"] --- A2["WPF UI çº¿ç¨‹ï¼ˆæ‰‹åŠ¨è°ƒè¯•ï¼‰"]
        A3["ResultProxy è½åº“线程"]
    end
    subgraph åœºæ™¯B["场景 B：跨进程 / è·¨æœºå™¨"]
        B1["工位进程1 tap.exe/Station1.exe"]
        B2["工位进程2 Station2.exe"]
        B3["HMI ä¸»ç¨‹åºï¼ˆç»´æŠ¤å·¥ç¨‹å¸ˆï¼‰"]
        B4["其他机器上的执行节点<br/>（多机共测一台仪器）"]
    end
    subgraph è§£å†³æ‰‹æ®µ["分别对应的手段"]
        S1["OpenTAP SynchronizationManager<br/>+ çŽ°æœ‰å†…存版 ResourceManager<br/>（保持不变 âœ…）"]
        S2["持久化租约表（DB Lease）<br/>+ Fencing Generation<br/>+ å¿ƒè·³ TTL + ä»²è£ç­–ç•¥<br/>（本次新建 â­ï¼‰"]
    end
    åœºæ™¯A --> S1
    åœºæ™¯B --> S2
</div>

<table>
    <tr><th>维度</th><th>场景 A：进程内多线程</th><th>场景 B：跨进程/跨机器</th></tr>
    <tr><td>典型触发</td><td>TestPlan ä¸­ Parallel æ­¥éª¤ / MultiSite åŒæ—¶è·‘不同分支</td><td>多工位独立进程、HMI ä¸Žè‡ªåŠ¨æµ‹è¯•å¹¶è¡Œã€CI èŠ‚点</td></tr>
    <tr><td>互斥原语</td><td>SemaphoreSlim / lock / SynchronizationManager.RequestLock</td><td>OS å‘½åå†…核对象 / DB ç§Ÿçº¦ / Broker é˜Ÿåˆ—</td></tr>
    <tr><td>崩溃表现</td><td>进程死 â†’ é”éšè¿›ç¨‹æ¶ˆå¤±ï¼ˆå†…核回收）</td><td class="bad">持有者死亡后锁<strong>残留</strong>，必须靠 TTL/看门狗回收</td></tr>
    <tr><td>可见性</td><td>天然可见（同一堆）</td><td>必须外部化状态（DB / Broker / å…±äº«å†…存）</td></tr>
    <tr><td>你们的现状</td><td class="good">已解决（ResourceManager å†…存版即是干这个的）</td><td class="bad">完全未解决——本次方案的主战场</td></tr>
</table>

<div class="info"><strong>设计原则：场景 A ç”¨è½»é‡å†…存锁（快），场景 B ç”¨æŒä¹…化租约（可靠），两层复合成一个 <code>LayeredResourceManager</code>，对上层 <code>IAutoDeviceFacade</code> å®Œå…¨é€æ˜Žã€‚</strong></div>

<!-- ================================================================= -->
<h2 id="s3">3. äº”个候选方案逐一评估与横向对比</h2>

<h3>方案 â‘ ï¼šå…¨éƒ¨æ”¶æ•›åˆ°å•è¿›ç¨‹ + OpenTAP å†…置同步</h3>
<div class="card">
把所有工位执行体都塞进一个主进程（一个 TestPlan è·‘多分支），完全依赖 <code>SynchronizationManager</code>。
<br><br>
<span class="mid">评估：</span>物理上最省事，<strong>但违反老化测试的独立故障域原则</strong>——一个工位 <code>StackOverflow</code>/原生驱动崩溃拖死全部 N ä¸ªå·¥ä½ï¼›è€åŒ–工龄动辄几十小时，进程级隔离是刚需。内存泄漏在多进程下可以按工位轮换回收，单进程无解。
<br><strong>结论：仅作为兜底简化形态（单工位小型机台可用），不作为多工位目标架构。</strong>
</div>

<h3>方案 â‘¡ï¼šå‘½åå†…核对象（Named Mutex / Named Semaphore）</h3>
<div class="card">
<code>new Mutex(false, "Global\\Lease_CAN-001")</code>，跨进程抢内核对象。
<br><br>
<strong>优点：</strong>实现成本≈0；进程死亡时内核自动释放 Abandoned（同机可靠）。
<br><strong>致命缺陷：</strong>
<ul>
<li><strong>无语义状态</strong>：Mutex åªçŸ¥é“"谁拿着"，不知道"拿去干什么、什么时候该还"——<code>AbandonedMutexException</code> æ—¶ä¸Šä¸€ä¸ªæŒæœ‰è€…<em>操作到哪一步了</em>完全不可知，对"人在接线/输出已打开"这类安全状态是盲区；</li>
<li><strong>无优先级仲裁</strong>：维护模式抢占生产、优雅交接（handover）都表达不了；</li>
<li><strong>无审计</strong>：谁在什么时间持有了多久，内核对象不记录，与你们 <code>debug_operation</code> å®¡è®¡ä½“系脱节；</li>
<li><strong>不跨机器</strong>；<code>Global\</code> å‘½ååœ¨ Windows æœåŠ¡/会话隔离下还有权限坑。</li>
</ul>
<strong>结论：不能单独成立；可以作为方案③的"同机加速信号"做混合（见 Â§4 åˆ†å±‚设计）。不推荐用 NamedEvent è½®è¯¢æ¨¡æ‹Ÿç§Ÿçº¦ï¼ˆç«žæ€å¤šã€è°ƒè¯•åœ°ç‹±ï¼‰ã€‚</strong>
</div>

<h3>方案 â‘¢ï¼šæ•°æ®åº“租约表（Lease + TTL + å¿ƒè·³ + å´©æºƒå›žæ”¶ï¼‰â­ æŽ¨èä¸»ä½“</h3>
<div class="card">
把租约状态持久化到 <code>data.db</code> æ–°è¡¨ <code>device_lease</code>，用 <code>BEGIN IMMEDIATE</code> äº‹åŠ¡å®žçŽ°è·¨è¿›ç¨‹åŽŸå­çš„"比较并换入"（CAS），TTL è¿‡æœŸå³è¢«è§†ä¸ºå´©æºƒå¯å›žæ”¶ï¼ŒGeneration ä½œæ …栏令牌防"僵尸持有者"。
<br><br>
<strong>与现有 IResourceManager çš„衔接：</strong>接口签名<strong>一个都不改</strong>。新增 <code>DbLeaseStore</code> å†…部类，<code>ResourceManager</code> å‡çº§ä¸ºç»„合模式：内存字典继续做本进程快速路径与信号量互斥，预约/校验同时读写 DB è¡¨ã€‚上层 <code>AutoDeviceFacade / DeviceService / DebugSessionManager / IAutoDeviceLease</code> é›¶æ”¹åŠ¨ï¼Œåªæ¢ Bootstrapper é‡Œçš„注册实例。
<br><strong>限制：</strong>SQLite æ˜¯å•æœºæ–‡ä»¶åº“——多机共享需把该表迁到服务端数据库（或走方案④ Broker ä»£ç†ï¼‰ï¼Œä¸” SQLite å†™å¹¶å‘要靠 WAL + çŸ­äº‹åŠ¡ï¼Œç§Ÿçº¦æ“ä½œè®¾è®¡æˆæ¯«ç§’级点查/点写，实测支撑每工位秒级命令流毫无压力。
<strong>结论：跨进程仲裁的最佳性价比，作为主体方案。</strong>
</div>

<h3>方案 â‘£ï¼šç‹¬ç«‹è®¾å¤‡ä»£ç†è¿›ç¨‹ï¼ˆDevice Broker + IPC）</h3>
<div class="card">
一台机器上跑一个 <code>DeviceBroker.exe</code>，<strong>所有物理连接（COM/USB/CAN å¡å¥æŸ„、SCPI TCP socket）只由它持有</strong>；各工位进程通过命名管道把命令转发给 Broker æŽ’队执行。仓库现成的 <span class="path">ConnectionUtil/PipeServer·PipeClient</span> å³å¯åšä¼ è¾“层。
<br><br>
<strong>解决的核心痛点（租约表解决不了的）：</strong>
<ul>
<li><strong>句柄独占</strong>：串口/USB ä¸å…è®¸ç¬¬äºŒä¸ªè¿›ç¨‹ <code>CreateFile</code>。若仅靠租约，每次租约易手都要 close→open ä¸€æ¬¡ï¼ŒUSB é‡æžšä¸¾å¯è¾¾ç§’级且丢缓冲；Broker è®©è¿žæŽ¥<strong>永不换手</strong>，切换的只是"逻辑所有权"；</li>
<li><strong>多机共享</strong>：A æœºæ’着 CAN å¡ï¼ŒB/C æœºçš„测试也能经 TCP/管道让 Broker ä»£å‘——Broker å¤©ç„¶æ˜¯è·¨æœºç½‘关；</li>
<li><strong>命令级串行化</strong>：分时复用设备（共享温箱）在 Broker å†…是单队列，比租约抢占高效得多。</li>
</ul>
<strong>代价</strong>：多一个常驻进程要运维（看门狗、升级、日志）；所有 I/O å¤šä¸€è·³ IPC（~毫秒级，老化场景可忽略）；开发量最大。
<strong>结论：串口/USB/CAN å¡è¿™ç±»"单机物理独占"设备的<strong>终局方案</strong>；但建议 Phase 3 å†ä¸Šï¼ŒPhase 1 ç”¨ç§Ÿçº¦è¡¨ + "租约持有期内保持连接"即可满足大部分场景。</strong>
</div>

<h3>方案 â‘¤ï¼šç›´æŽ¥å¤ç”¨ OpenTAP ç”Ÿæ€èƒ½åŠ›</h3>
<div class="card">
逐项核查 OpenTAP çŽ°æˆèƒ½åŠ›èƒ½å¦è¦†ç›–跨进程需求（详细分析见姊妹篇 <a href="./OpenTAP_Instrument_Package_Analysis.html">《OpenTAP Instrument + æ’件包机制分析》§9</a>）：
<table>
    <tr><th>OpenTAP èƒ½åŠ›</th><th>是什么</th><th>能否解决跨进程仲裁</th></tr>
    <tr><td><code>Instrument : Resource</code> èµ„源模型</td><td>仪器生命周期托管 + ç¼–辑器绑定</td><td class="bad">❌ å®žä¾‹ç”Ÿå‘½å‘¨æœŸä»…进程内；不感知其他进程</td></tr>
    <tr><td><code>SynchronizationManager</code></td><td>进程内按仪器互斥锁</td><td class="bad">❌ è®¾è®¡ç›®æ ‡å°±æ˜¯å•è¿›ç¨‹</td></tr>
    <tr><td>ResultProxy / è¿œç¨‹æ‰§è¡Œï¼ˆ<code>tap run --remote</code>、Session.Local）</td><td>把一个 TestPlan åˆ‡åˆ†åˆ°è¿œç«¯æ‰§è¡ŒèŠ‚点，结果回流</td><td class="mid">⚠️ è§£å†³"执行分布"，不解决"两台机抢一台仪器"——每个远端 session å„自还是单进程视野</td></tr>
    <tr><td>BenchStore / ResourceSettings（9.23+）</td><td>台架资源配置持久化（XML）</td><td class="mid">⚠️ é…ç½®å¯ä»¥å…±äº«ï¼Œ<strong>仲裁状态不行</strong>（无 TTL/心跳概念）</td></tr>
    <tr><td>私有包仓库分发</td><td>驱动以 <code>.opentap</code> åŒ…安装</td><td class="good">✅ è§£å†³é©±åŠ¨åˆ†å‘（与并发仲裁正交，值得并行推进）</td></tr>
    <tr><td><code>IResourcePlan</code>/ResourceConflicts（9.20+）</td><td>资源规划/冲突<strong>静态检查</strong>（编辑器里提示"两个序列用了同一仪器"）</td><td class="mid">⚠️ åªèƒ½æå‰å‘现冲突，运行时多进程并发仍不仲裁</td></tr>
</table>
<strong>结论：OpenTAP ç”Ÿæ€æ²¡æœ‰ä»»ä½•ä¸€å—能直接替代跨进程运行时仲裁——这是开源测试框架的普遍空白，也正是你们 IResourceManager ä½“系的战略价值。能复用的是：分发（包机制）、配置模型（BenchStore æ€è·¯ï¼‰ã€ä»¥åŠæŠŠæœ€ç»ˆé©±åŠ¨åšæˆ Instrument æ’件的长期形态。</strong>
</div>

<h3>横向对比总表</h3>
<table>
    <tr><th>维度</th><th>①单进程收敛</th><th>②Named Mutex</th><th>③DB ç§Ÿçº¦è¡¨ â­</th><th>④Device Broker</th><th>⑤OpenTAP çŽ°æˆ</th></tr>
    <tr><td>并发安全（跨进程）</td><td class="bad">伪命题（无多进程）</td><td class="mid">互斥可以，但无状态语义</td><td class="good">强一致（DB äº‹åŠ¡ CAS）</td><td class="good">单点串行化，最强</td><td class="bad">不支持</td></tr>
    <tr><td>崩溃残留处理</td><td class="good">进程死=锁消失</td><td class="mid">Abandoned å¯æ„ŸçŸ¥ä½†ç›²æŽ¥</td><td class="good">TTL è‡ªåŠ¨è¿‡æœŸ + å›žæ”¶</td><td class="mid">Broker æ­»=全停（需看门狗）</td><td>—</td></tr>
    <tr><td>优先级/抢占/优雅交接</td><td class="mid">代码可实现</td><td class="bad">表达不了</td><td class="good">状态列+grace å­—段原生支持</td><td class="good">队列策略任意定制</td><td class="bad">无</td></tr>
    <tr><td>审计可追溯</td><td class="bad">无</td><td class="bad">无</td><td class="good">表即历史（可挂 debug_operation）</td><td class="good">Broker å…¨æƒæ—¥å¿—</td><td class="mid">ResultProxy æœ‰ç»“果无仲裁</td></tr>
    <tr><td>性能开销</td><td class="good">纳秒级</td><td class="good">微秒级</td><td class="mid">毫秒级（WAL ç‚¹å†™ï¼‰</td><td class="mid">毫秒级（IPC ä¸€è·³ï¼‰</td><td>—</td></tr>
    <tr><td>实现成本</td><td class="good">0（重构架构为负）</td><td class="good">0.5 äººæ—¥</td><td class="good">3~4 äººæ—¥</td><td class="mid">5~8 äººæ—¥</td><td class="good">已内建/不适用</td></tr>
    <tr><td>可扩展到多机</td><td class="bad">否</td><td class="bad">否</td><td class="mid">需换服务端 DB</td><td class="good">是（Broker=网关）</td><td class="mid">部分</td></tr>
    <tr><td>物理句柄独占问题</td><td class="good">天然规避</td><td class="bad">不解决（close/open æŠ–动）</td><td class="mid">租约期内保连接可缓解</td><td class="good">根治（唯一持有者）</td><td class="bad">不解决</td></tr>
    <tr><td>调试难度</td><td class="good">低</td><td class="mid">内核对象黑盒</td><td class="good">低（一张表全透明，SELECT å³çŽ°åœºï¼‰</td><td class="mid">需双进程联调</td><td>—</td></tr>
    <tr><td>与现有代码衔接</td><td class="mid">大改</td><td class="mid">需新增旁路</td><td class="good">IResourceManager å®žçŽ°å±‚替换，上层零改</td><td class="mid">Driver å±‚拆分转发端/宿主端</td><td class="good">正交复用</td></tr>
</table>

<!-- ================================================================= -->
<h2 id="s4">4. æŽ¨èç›®æ ‡æž¶æž„：分层混合（租约表 + ä»²è£è§„则 + æŒ‰éœ€ Broker）</h2>

<div class="mermaid">
graph TB
    subgraph L4["上层调用（保持不变）"]
        TS["OpenTAP TestStep<br/>（全自动 Â· IAutoDeviceLease ä½œç”¨åŸŸï¼‰"]
        DBG["DeviceDebug UI<br/>（手动维护 Â· DebugSessionManager）"]
    end
    subgraph L3["门面层 Aging.Infrastructure/Services"]
        FAC["AutoDeviceFacade<br/>（租约申请/心跳/栅栏校验）"]
        SVC["DeviceService<br/>（命令分派 + owner æ ¡éªŒå‡çº§ä¸ºè·¨è¿›ç¨‹ï¼‰"]
    end
    subgraph L2["仲裁层（本次核心改造）"]
        LRM["LayeredResourceManager : IResourceManager"]
        MEM["进程内层：SemaphoreSlim + å†…存缓存<br/>（复用现有 ResourceManager é€»è¾‘）"]
        DBL["跨进程层：DbLeaseStore<br/>device_lease è¡¨ Â· BEGIN IMMEDIATE CAS"]
        POL["仲裁策略引擎：优先级/抢占/grace"]
        LRM --> MEM & DBL & POL
    end
    subgraph L1["物理连接层（Phase 3 æŒ‰éœ€ï¼‰"]
        OWN["本进程直连：网口仪器（SCPI/TCP/CAN总线模拟）<br/>租约=逻辑独占，句柄随租约开关"]
        BRK["DeviceBroker.exe：串口/USB/CAN卡唯一持有者<br/>复用 ConnectionUtil.PipeServer/PipeClient"]
    end
    TS & DBG --> FAC --> SVC --> LRM
    DBL --> SQLITE[("data.db<br/>device_lease è¡¨<br/>WAL æ¨¡å¼")]
    SVC --> OWN & BRK
</div>

<h3>4.1 åˆ†å±‚职责与决策规则</h3>
<table>
    <tr><th>层</th><th>解决什么</th><th>何时启用</th></tr>
    <tr><td>内存层（已有）</td><td>同进程多线程细锁、快速失败</td><td class="good">始终（零成本）</td></tr>
    <tr><td>DB ç§Ÿçº¦å±‚（新增）</td><td>跨进程运行时仲裁、优先级抢占、审计、崩溃回收</td><td class="good">Phase 1 â€”— ä¸»ä½“投入</td></tr>
    <tr><td>Broker å±‚（新增）</td><td>物理句柄独占、多机共享、命令队列</td><td class="mid">Phase 3 â€”— ä»…当出现：① ä¸²å£/USB é‡å¼€æˆæœ¬ä¸å¯æŽ¥å— â‘¡ å¤šæœºå…±æµ‹ä¸€å°æœºä¸Šçš„设备 â‘¢ åˆ†æ—¶å¤ç”¨è®¾å¤‡è¦æŽ’队</td></tr>
    <tr><td>OpenTAP ç”Ÿæ€</td><td>驱动分发（包）、配置共享（Bench æ€è·¯ï¼‰</td><td class="mid">与 Phase 1/3 æ­£äº¤å¹¶è¡ŒæŽ¨è¿›</td></tr>
</table>

<!-- ================================================================= -->
<h2 id="s5">5. ç§Ÿçº¦å®Œæ•´ç”Ÿå‘½å‘¨æœŸï¼šç”³è¯· / ç»­æœŸ / é‡Šæ”¾ / è¶…时抢占</h2>

<h3>5.1 ç§Ÿçº¦çŠ¶æ€æœº</h3>
<div class="mermaid">
stateDiagram-v2
    [*] --> Free: device_lease æ— è¡Œ/已回收
    Free --> Active: Acquire（事务CAS成功<br/>generation++ å†™å…¥ owner）
    Active --> Active: Heartbeat ç»­æœŸ<br/>（extends expires_at）
    Active --> PendingHandover: æ›´é«˜ä¼˜å…ˆçº§ç”³è¯·åˆ°è¾¾<br/>（Maintenance è¯·æ±‚，写 grace æˆªæ­¢ï¼‰
    PendingHandover --> Released: æŒæœ‰è€…优雅让渡<br/>（完成当前 TestStep åŽ Release）
    PendingHandover --> ForceReleased: grace è¶…æ—¶<br/>（请求者可抢占 generation++）
    Active --> Expired: å¿ƒè·³æ–­ï¼ˆè¿›ç¨‹å´©æºƒ/断网）<br/>expires_at &lt; DB now
    Expired --> Free: å›žæ”¶ï¼ˆä»»ä½• Acquire é¡ºå¸¦ DELETE<br/>+ åŽå° Sweep å…œåº•ï¼‰
    Active --> Released: æ­£å¸¸ Dispose/ReleaseReservation
    Released --> Free
</div>

<h3>5.2 ç”³è¯· + æŠ¢å  + æ …栏拒绝时序</h3>
<div class="mermaid">
sequenceDiagram
    autonumber
    participant P1 as å·¥ä½è¿›ç¨‹1<br/>(Production ç§Ÿçº¦æŒæœ‰è€…)
    participant DB as device_lease è¡¨<br/>(SQLite WAL)
    participant HMI as å·¥ä½è¿›ç¨‹2<br/>(Maintenance è¯·æ±‚者)
    participant DRV as DeviceService/驱动

    Note over P1,DB: â€”— æ­£å¸¸æŒç§Ÿ + å¿ƒè·³ â€”—
    P1->>DB: Acquire CAN-001（BEGIN IMMEDIATE→无冲突→INSERT gen=41）
    DB-->>P1: lease(tokenA, gen41, expires=now+30s)
    loop æ¯ 10s（TTL/3）
        P1->>DB: Renew WHERE token=tokenA AND gen=41
        DB-->>P1: å½±å“è¡Œæ•°=1 âœ… expires é¡ºå»¶
    end
    P1->>DRV: ExecuteCommandAsync("OUTP ON") [携带 gen41]
    DRV->>DB: FenceCheck(gen41) â†’ é€šè¿‡ âœ…
    DRV-->>P1: OK

    Note over HMI,DB: â€”— ç»´æŠ¤æ¨¡å¼æŠ¢å  â€”—
    HMI->>DB: RequestMaintenance(CAN-001)
    DB-->>HMI: å·²å ç”¨ â†’ å†™ state=PendingHandover,<br/>grace_until=now+30s, è¿”回"等待让渡"
    P1->>DB: ï¼ˆä¸‹ä¸€æ¬¡å¿ƒè·³å‘现 state=PendingHandover）
    P1->>P1: å®Œæˆå½“前 TestStep â†’ ä¸»åŠ¨ Release
    P1->>DB: Release(tokenA) â†’ DELETE è¡Œ
    HMI->>DB: è½®è¯¢/通知后重试 Acquire â†’ æˆåŠŸï¼ˆgen=42, Maintenance）
    HMI->>HMI: DebugSessionManager è¿›å…¥ MaintenanceActive

    Note over P1,DRV: â€”— åƒµå°¸æŒæœ‰è€…被栅栏拦截 â€”—
    P1->>P1: ï¼ˆå´©æºƒå¤æ´»/网络分区后仍以为自己持有 gen41）
    P1->>DRV: ExecuteCommandAsync（旧 tokenA gen41）
    DRV->>DB: FenceCheck: è¡¨å†… gen=42 â‰  41
    DRV-->>P1: âŒ LEASE_STALE â†’ æœ¬åœ°ç†”断，会话转 RecoveryRequired
</div>

<h3>5.3 æ ¸å¿ƒ SQL（原子申请，一次事务完成回收+检查+写入）</h3>
<pre><code>BEGIN IMMEDIATE;                        <span class="cmt">-- æ‹¿å†™é”ï¼šè·¨è¿›ç¨‹ä¸²è¡ŒåŒ–入口（SQLite WAL ä¸‹è¯»å†™ä¸äº’斥，写写排队）</span>

<span class="cmt">-- â‘  é¡ºå¸¦å›žæ”¶æ‰€æœ‰å·²è¿‡æœŸç§Ÿçº¦ï¼ˆæ‡’回收，无需独立守护也能自愈）</span>
DELETE FROM device_lease
 WHERE resource_key = @rk AND expires_at &lt; datetime('now');

<span class="cmt">-- â‘¡ æ£€æŸ¥å½“前有效占用</span>
SELECT owner_id, owner_type, state, grace_until INTO @cur FROM device_lease WHERE resource_key = @rk;

<span class="cmt">-- â‘¢ æ— å ç”¨ â†’ æ’入新租约（generation å–全局序）</span>
INSERT INTO device_lease(resource_key, owner_id, owner_type, token_id, generation,
                         machine_name, host_process_id, state, acquired_at, heartbeat_at, expires_at)
VALUES(@rk, @owner, @otype, @token, @gen, @machine, @pid, 0,
        datetime('now'), datetime('now'), datetime('now', '+30 seconds'));

<span class="cmt">-- â‘£ æœ‰å ç”¨ä¸”请求者是 Maintenance â†’ ä¸ç›´æŽ¥æŠ¢ï¼Œæ ‡è®°è®©æ¸¡çª—口</span>
UPDATE device_lease SET state = 1, grace_until = datetime('now','+30 seconds')
 WHERE resource_key = @rk AND state = 0;

COMMIT;</code></pre>

<h3>5.4 ç»­æœŸï¼ˆå¿ƒè·³ï¼‰ä¸Žå¤±æ•ˆåˆ¤å®š</h3>
<pre><code><span class="cmt">// AutoDeviceLease å†…部：TTL/3 å‘¨æœŸå®šæ—¶å™¨ï¼ˆPhase 1 å³å®žçŽ°ï¼‰</span>
<span class="kwd">var</span> affected = db.<span class="fn">ExecuteNonQuery</span>(<span class="str">@"
    UPDATE device_lease
       SET heartbeat_at = datetime('now'),
           expires_at   = datetime('now', '+30 seconds'),
           state        = CASE WHEN state = 1 THEN state ELSE 0 END   <span class="cmt">-- ä¿ç•™è®©æ¸¡æ ‡è®°</span>
     WHERE resource_key = @rk AND token_id = @token AND generation = @gen"</span>);

<span class="kwd">if</span> (affected == 0) {
    <span class="cmt">// è¡Œä¸åœ¨äº†æˆ– generation å·²è¢«è¶…越 â‡’ æˆ‘已被抢占/回收 â€”— æœ¬åœ°ç«‹å³ç†”断：</span>
    <span class="cmt">// 1) åœæ­¢ä¸‹å‘任何命令  2) é‡Šæ”¾ç‰©ç†è¿žæŽ¥  3) ä¼šè¯æ ‡è®° RecoveryRequired  4) ä¸ŠæŠ¥ä¸€æ¬¡å‘Šè­¦</span>
    <span class="fn">OnLeaseLost</span>();
}
<span class="kwd">if</span> (db.<span class="fn">ReadState</span>() == PendingHandover &amp;&amp; InStepBoundary) {
    <span class="fn">Dispose</span>();   <span class="cmt">// ä¼˜é›…让渡：只在 TestStep è¾¹ç•Œé‡Šæ”¾ï¼Œç»ä¸åœ¨ä¸€æ¡å‘½ä»¤ä¸­é—´æ”¾æ‰‹</span>
}</code></pre>

<div class="highlight"><strong>三条铁律：</strong>① æ‰€æœ‰æ—¶é—´æˆ³ä¸€å¾‹ç”¨ <code>datetime('now')</code>（DB æ—¶é’Ÿï¼‰ï¼Œå®¢æˆ·ç«¯æ—¶é—´ä»…作参考列；② æ¯æ¡å‘½ä»¤ä¸‹å‘前必须 <code>FenceCheck</code>（一行点查，成本≈1ms）；③ è®©æ¸¡/释放只发生在 TestStep è¾¹ç•Œï¼Œä¿è¯è®¾å¤‡ä¸å¤„于"半条指令"状态。</div>

<!-- ================================================================= -->
<h2 id="s6">6. å…¨è‡ªåŠ¨ vs æ‰‹åŠ¨ç»´æŠ¤çš„互斥仲裁规则</h2>

<p>目标场景：工程师正打开机柜接 CAN çº¿ï¼ˆç»´æŠ¤æ¨¡å¼ï¼‰ï¼Œå…¨è‡ªåŠ¨ç¨‹åºç»ä¸èƒ½çªç„¶ä¸‹å‘ <code>OUTP ON</code>。规则明确定义如下（策略引擎集中实现于新增 <span class="path">Aging.Infrastructure/Core/LeaseArbiter.cs</span>）：</p>

<h3>6.1 ä¼˜å…ˆçº§çŸ©é˜µï¼ˆè¡Œ=当前持有者，列=新请求者）</h3>
<table>
    <tr><th></th><th>请求：Production（全自动）</th><th>请求：Maintenance（手动维护）</th><th>请求：ReadOnly（监控/看数据）</th></tr>
    <tr>
        <td><strong>持有：Production</strong></td>
        <td class="mid">排队（FIFO æˆ–按工位优先级，带超时）</td>
        <td class="mid"><strong>让渡流程</strong>：PendingHandover + grace 30s；超时未让渡 â†’ å…è®¸å¼ºå  + æ—§æŒæœ‰è€…栅栏失效</td>
        <td class="good">放行（不建租约，走旁路只读）</td>
    </tr>
    <tr>
        <td><strong>持有：Maintenance</strong></td>
        <td class="bad"><strong>直接拒绝</strong>（ResourceConflictException，"有人在维护"；UI å¼¹çª—告知工程师）</td>
        <td class="bad">拒绝（第二个人也不许碰——一台设备同时只允许一个维护会话，复用现有 OpenSession é‡å¤æ£€æŸ¥é€»è¾‘）</td>
        <td class="good">放行</td>
    </tr>
    <tr>
        <td><strong>持有：ReadOnly</strong></td>
        <td class="good">立即放行（读锁不构成障碍）</td>
        <td class="good">立即放行</td>
        <td class="good">放行</td>
    </tr>
</table>

<div class="info"><strong>与现有代码的挂接点：</strong><span class="path">DebugSessionManager.RequestMaintenance()</span> å·²ç»åšäº† <code>ReserveAsync</code> + æ•èŽ· <code>ResourceConflictException</code> â†’ åªéœ€æŠŠå†…存版换成 Layered ç‰ˆå³è‡ªåŠ¨èŽ·å¾—跨进程拒绝；<span class="path">ValidateCommand()</span> å·²æœ‰"MaintenanceActive + ValidateOwner"双重检查，把 <code>ValidateOwner</code> æ”¹ä¸ºæŸ¥ DB æ …栏，就得到<strong>"人在接线时程序连命令都发不出"</strong>的硬保证——即使自动程序逻辑有 bug。</div>

<h3>6.2 ç»´æŠ¤æ¨¡å¼é€€å‡ºä¸Žè‡ªåŠ¨æµç¨‹æ¢å¤</h3>
<ul>
<li>工程师退出维护（<span class="path">ExitMaintenanceBtn_Click â†’ CloseSession</span>）：释放行 + <code>UPDATE debug_session SET state=Closed</code>（现有逻辑保持）；</li>
<li>自动工位对 PendingHandover çš„感知延迟 â‰¤ å¿ƒè·³å‘¨æœŸï¼ˆ10s），老化长步骤（小时级）不适用抢占——对 <code>grace</code> å†…未完成的步骤，策略改为<strong>"拒绝进入，已运行不打断"</strong>（可配置：安全类工位选择强占+设备紧急安全态；产能类工位选择排队等待）；</li>
<li>HMI ä¾§å»ºè®®ï¼šè®¾å¤‡è¢«è‡ªåŠ¨å ç”¨æ—¶ï¼Œç»´æŠ¤ç”³è¯·æ˜¾ç¤º"占用者:Station-3 Â· å·²è¿è¡Œ 01:23:45 Â· é¢„计剩余 02:10"（数据全在 <code>device_lease</code> + <code>debug_session</code>，一条 JOIN å³å¯ï¼‰ã€‚</li>
</ul>

<h3>6.3 å®¡è®¡é—­çŽ¯</h3>
<ul>
<li><code>device_lease</code> è¡¨æœ¬èº«å°±æ˜¯"占用历史"（Release æ—¶æ”¹å†™ <code>released_at</code> å†ä¿ç•™ 7 å¤©ï¼Œæˆ–双表：当前 + å½’档）；</li>
<li>每条经 <code>DeviceService</code> çš„命令继续写 <code>debug_operation</code>，新增两列 <code>owner_type, lease_generation</code>，即可回答"这条 OUTP ON æ˜¯å“ªä¸ªå·¥ä½ã€å“ªä¸€ä»£æŒæœ‰è€…发的"——事故追溯闭环。</li>
</ul>

<!-- ================================================================= -->
<h2 id="s7">7. å¼‚常场景处理：死锁 / å­¤å„¿é” / æ—¶é’Ÿ / å¹‚ç­‰</h2>

<table>
    <tr><th>异常场景</th><th>成因</th><th>对策</th><th>机制落点</th></tr>
    <tr>
        <td><strong>多设备死锁</strong>（工位A锁{电源}等{CAN}，B反序）</td>
        <td>组申请加锁顺序不一致</td>
        <td class="good">① å…¨å±€å¼ºåˆ¶æŒ‰ <code>resource_key</code> å­—典序申请（AcquireGroupAsync å†…部排序）<br>② äº‹åŠ¡å†…"全有或全无"：任一冲突则整体回滚重试（<strong>wait-die</strong>：新请求者退避重试，老持有者不被饿死）<br>③ ç»„申请总超时（默认 60s）</td>
        <td>AutoDeviceFacade æ–°å¢ž <code>AcquireGroupAsync</code></td>
    </tr>
    <tr>
        <td><strong>进程崩溃 â†’ å­¤å„¿é”</strong></td>
        <td>kill / BSOD / æ–­ç”µï¼ŒRelease æ²¡è·‘</td>
        <td class="good">① TTL 30s è‡ªåŠ¨è¿‡æœŸï¼ˆä»»ä½• Acquire é¡ºå¸¦ DELETE è¿‡æœŸè¡Œ = æ‡’回收）<br>② åŒæœºçœ‹é—¨ç‹—：lease è®°å½• <code>machine_name + host_process_id</code>，本机新进程启动时枚举存活 PID æå‰å›žæ”¶ï¼ˆä¸ç”¨ç­‰ TTL）<br>③ HMI"强制释放"按钮（需 ADMIN è§’色，写审计 note="force_release"）</td>
        <td>device_lease åˆ— + Bootstrapper å¯åŠ¨è‡ªæ£€</td>
    </tr>
    <tr>
        <td><strong>僵尸持有者</strong>（网络分区/GC停顿后复活继续发命令）</td>
        <td>进程活着但被抢占过</td>
        <td class="good">栅栏令牌：命令必须携带 <code>(token_id, generation)</code>，DB ä¸­ generation å·²å˜ â†’ é©±åŠ¨å…¥å£ç›´æŽ¥æ‹’绝（§5.2 æ—¶åº 15-17 æ­¥ï¼‰ã€‚<strong>这是比 TTL æ›´æ ¹æœ¬çš„安全网</strong>——TTL ç®¡"谁能拿"，栅栏管"拿过的人过期后不能碰"。</td>
        <td>DeviceService.ExecuteCommandAsync å…¥å£ FenceCheck</td>
    </tr>
    <tr>
        <td><strong>时钟不一致</strong>（多机 NTP æ¼‚移）</td>
        <td>expires ç”¨æœ¬åœ°æ—¶é—´æ¯”较会误判</td>
        <td class="good">① å…¨éƒ¨æ—¶é—´åˆ¤å®šç”¨ DB ä¾§æ—¶é’Ÿï¼ˆ<code>datetime('now')</code>），客户端只传相对 TTL（"+30 seconds"），从不传绝对时间<br>② Phase 3 Broker åŒ–后统一用 Broker æ—¶é’Ÿ<br>③ å¤šæœº + å…±äº« DB åœºæ™¯è¦æ±‚ NTP（运维项，误差&lt;1s å³å¯ï¼‰</td>
        <td>SQL å†™æ³•çº¦æŸï¼ˆÂ§5.3 å…¨éƒ¨åˆè§„）</td>
    </tr>
    <tr>
        <td><strong>心跳线程被 UI å¡é¡¿é¥¿æ­»</strong></td>
        <td>WPF ä¸»çº¿ç¨‹é˜»å¡ž / è¿›ç¨‹å‡æ­»</td>
        <td class="good">心跳用<strong>独立后台线程</strong>（非 UI Dispatcher），且心跳失败连续 2 æ¬¡å³æœ¬åœ°ç†”断——宁可误停不可漏停</td>
        <td>AutoDeviceLease å†… Timer å®žçŽ°</td>
    </tr>
    <tr>
        <td><strong>重试不幂等</strong>（超时后重发"OUTP ON"是安全的，重发"计数器+1"不安全）</td>
        <td>网络/DB æŠ–动自动重试</td>
        <td class="good">① å‘½ä»¤åˆ†çº§ï¼šè®¾å¤‡å±‚可安全重发（设置型 SET xx=yy âœ… å¹‚等；累加/触发型 âš ï¸ ç¦æ­¢è‡ªåŠ¨é‡è¯•ï¼Œä¸ŠæŠ›ï¼‰<br>② <code>debug_operation.operation_id</code> å·²æ˜¯å®¢æˆ·ç«¯ç”Ÿæˆ GUID â†’ ä½œä¸ºå¹‚等键 INSERT OR IGNORE，重复到达不二次执行<br>③ è€åŒ–场景的 SCPI/CAN å†™å‘½ä»¤å¤šä¸ºè®¾ç½®åž‹ï¼Œå¤©ç„¶å¹‚等友好，但必须在驱动接口上用 <code>CommandSemantics.Idempotent</code> æ˜¾å¼å£°æ˜Ž</td>
        <td>DeviceCommandResult + é©±åŠ¨è£…饰器</td>
    </tr>
    <tr>
        <td><strong>SQLite å†™ç«žäº‰</strong>（N ä¸ªå·¥ä½ Ã— å¿ƒè·³+申请集中写一行区域）</td>
        <td>写锁串行化</td>
        <td class="good">WAL æ¨¡å¼ + busy_timeout=5000 + äº‹åŠ¡åªåŒ…住 2~3 æ¡ç‚¹å†™ï¼ˆ&lt;5ms）；老化命令节奏（秒级）下并发写压力可忽略。真到高频（&gt;100 å†™/秒）再迁服务端 DB</td>
        <td>连接串 PRAGMA（见 Â§9 DbLeaseStore）</td>
    </tr>
    <tr>
        <td><strong>抢占风暴</strong>（两个高优请求同时到达）</td>
        <td>并发 PendingHandover æ ‡è®°</td>
        <td class="good">仲裁在 <code>BEGIN IMMEDIATE</code> äº‹åŠ¡å†…串行判定；第二个维护请求会看到"已有维护排队"而被告知排队位置，不产生双 grace ç«žäº‰</td>
        <td>事务天然覆盖</td>
    </tr>
</table>

<!-- ================================================================= -->
<h2 id="s8">8. ç‹¬å  or åˆ†æ—¶å¤ç”¨ï¼šè®¾å¤‡åˆ†ç»„与 Slot ç»‘定策略</h2>

<h3>8.1 è®¾å¤‡è®¿é—®æ¨¡å¼ï¼ˆæ–°å¢žåˆ—，注册页可配）</h3>
<table>
    <tr><th>模式</th><th>语义</th><th>租约形态</th><th>典型设备（本项目）</th></tr>
    <tr>
        <td><code>Exclusive</code> ç‹¬å </td>
        <td>一个工位全程持有，测试期间别人碰不到</td>
        <td>整步骤级长租约（TTL é å¿ƒè·³ç»´æŒæ•°å°æ—¶ï¼‰</td>
        <td>工位专用电源、DUT ä¸“用 CAN å¡é€šé“</td>
    </tr>
    <tr>
        <td><code>TimeShared</code> åˆ†æ—¶ä¸²è¡Œ</td>
        <td>多条命令排队过设备，每条原子</td>
        <td>命令级短租约（秒级）或 Broker é˜Ÿåˆ—</td>
        <td>共享 DAQ è¯»æ•°ã€å…¬ç”¨ä¸‡ç”¨è¡¨</td>
    </tr>
    <tr>
        <td><code>SharedRead</code> å…±äº«è¯»+独占写</td>
        <td>监控随便读（旁路），写必须抢租约</td>
        <td>读不走仲裁；写=Exclusive ç§Ÿçº¦</td>
        <td>温箱（状态人人可看，设温必须独占）、CAN æ€»çº¿ç›‘听</td>
    </tr>
</table>

<h3>8.2 å†³ç­–规则（新增 <code>DeviceDefinition.access_mode</code> åˆ—，注册页下拉选择）</h3>
<div class="card">
<b>一问：</b>"两个工位<strong>同时</strong>用这台设备，物理上/协议上会不会互相干扰？"<br>
<b>会</b>（串口指令交叉、电源被改压）→ <code>Exclusive</code>；<br>
<b>不会但语义会乱</b>（万用表 A è¯»æ•°æ˜¯ B è§¦å‘下产生的）→ <code>TimeShared</code>（串行队列）；<br>
<b>读无害、写有害</b>（温箱状态广播）→ <code>SharedRead</code>。<br>
<b>判据来源：</b>设备传输层类型 + åè®®æ˜¯å¦æ”¯æŒä¼šè¯éš”离。CAN å¡é»˜è®¤ Exclusive（通道级可细分），TCP SCPI çœ‹ä»ªå™¨è¿žæŽ¥æ•°é™åˆ¶ï¼ˆå¤šæ•° DMM åªå…è®¸ 1 ä¸ª socket â†’ å®žè´¨ Exclusive）。
</div>

<h3>8.3 å·¥ä½ â†” è®¾å¤‡åˆ†ç»„：绑定到 Slot ä½“ç³»</h3>
<div class="mermaid">
graph LR
    subgraph å°æž¶["物理台架"]
        S1["Slot-A（工位1）"] --- S2["Slot-B（工位2）"]
        P1["PS-001 ä¸“用电源"] --- S1
        C1["CAN-001 å¡ CH0"] --- S1
        C2["CAN-002 å¡ CH1"] --- S2
        T1["CHAMBER-01 å…±äº«æ¸©ç®±"] --- S1 & S2
    end
    subgraph æ•°æ®["data.db æ˜ å°„（已有表 + æ–°åˆ—）"]
        M1["SlotDeviceMapping<br/>SlotId â†” DeviceId+ChannelId"]
        G1["新增 device_group:<br/>group_key â†’ {resource_keys}<br/>access_mode æŒ‰è®¾å¤‡å–"]
    end
</div>

<ul>
<li><strong>复用现有 <span class="path">SlotDeviceMapping</span> è¡¨</strong>：工位身份 = <code>SlotId</code>。工位进程启动参数带 SlotId â†’ ç»„租约自动展开为该 Slot ç»‘定的全部设备 resource_key åˆ—表（按字典序申请）；</li>
<li><strong>组申请原子化</strong>：新增 <code>AcquireGroupAsync(groupKey, ...)</code>：查 <code>device_group</code>（或即时 JOIN SlotDeviceMapping）→ æŽ’序 â†’ å•äº‹åŠ¡é€å° INSERT，任一冲突整体回滚 â†’ é¿å…"占了一半"的半死状态；</li>
<li><strong>共享设备不进组</strong>：<code>CHAMBER-01</code> è¿™ç±»è·¨ Slot è®¾å¤‡åœ¨ <code>DeviceDefinition.access_mode</code> æ ‡ TimeShared/SharedRead，组申请时跳过，命令执行时才抢短租约；</li>
<li><strong>CAN å¤šå·¥ä½å…±å¡</strong>：resource key ç»†åŒ–到 <code>CAN_CARD01:CH2</code>——<code>ResourceKey</code> æœ¬æ¥å°±æ”¯æŒ Channel（见 <span class="path">Contracts/ResourceKey.cs</span>），CAN å¸§ ID çº§å†ç»†åˆ†å¯ç”¨ <code>resource_type='CAN_FRAME'</code> + channel=帧段（Broker é˜¶æ®µå®žçŽ°å‘½ä»¤çº§ä¸²è¡ŒåŒ–时够用）。</li>
</ul>

<!-- ================================================================= -->
<h2 id="s9">9. æœ¬ä»“库改造清单（具体到文件）</h2>

<h3>9.1 æ•°æ®åº“ DDL（新增到 <span class="path">Plugin.DeviceConfig/Model/DeviceConfigModel.cs</span> InitDatabase çš„ sqls åˆ—表）</h3>
<pre><code><span class="cmt">-- â‘  è·¨è¿›ç¨‹ç§Ÿçº¦è¡¨ï¼ˆæ ¸å¿ƒæ–°è¡¨ï¼‰</span>
CREATE TABLE IF NOT EXISTS device_lease (
    resource_key     TEXT PRIMARY KEY,        <span class="cmt">-- 'CAN-001:Generic' ä¸Ž ResourceKey.ToString() ä¸€è‡´</span>
    owner_id         TEXT NOT NULL,           <span class="cmt">-- 'Station3.Run20261103' å·¥ä½å¯è¯»æ ‡è¯†</span>
    owner_type       INTEGER NOT NULL,        <span class="cmt">-- 0=Production 1=Maintenance 2=ReadOnly</span>
    token_id         TEXT NOT NULL,           <span class="cmt">-- ResourceOwnerToken.TokenId</span>
    generation       INTEGER NOT NULL,        <span class="cmt">-- æ …栏令牌：每次成功申请 +1（全局取 max+1）</span>
    machine_name     TEXT NOT NULL DEFAULT '',
    host_process_id  INTEGER NOT NULL DEFAULT 0,
    slot_id          TEXT,                    <span class="cmt">-- å…³è”工位 Slot（组审计用）</span>
    state            INTEGER NOT NULL DEFAULT 0,  <span class="cmt">-- 0=Active 1=PendingHandover</span>
    acquired_at      TEXT NOT NULL,
    heartbeat_at     TEXT NOT NULL,
    expires_at       TEXT NOT NULL,           <span class="cmt">-- å…¨éƒ¨ç”± DB datetime('now') ç”Ÿæˆ</span>
    grace_until      TEXT,
    note             TEXT DEFAULT ''
);
CREATE INDEX IF NOT EXISTS idx_lease_expire ON device_lease(expires_at);

<span class="cmt">-- â‘¡ è®¾å¤‡è®¿é—®æ¨¡å¼ï¼ˆçŽ°æœ‰è¡¨åŠ åˆ—，老库幂等迁移）</span>
ALTER TABLE DeviceDefinition ADD COLUMN access_mode INTEGER NOT NULL DEFAULT 0;
<span class="cmt">--    0=Exclusive 1=TimeShared 2=SharedRead</span>

<span class="cmt">-- â‘¢ å·¥ä½è®¾å¤‡ç»„（组租约的展开依据；也可不建表，运行时 JOIN SlotDeviceMapping）</span>
CREATE TABLE IF NOT EXISTS device_group (
    group_key   TEXT PRIMARY KEY,     <span class="cmt">-- = SlotId æˆ–自定义</span>
    resource_key TEXT NOT NULL,
    order_hint  INTEGER DEFAULT 0,
    PRIMARY KEY (group_key, resource_key)
);

<span class="cmt">-- â‘£ debug_session åŠ  3 åˆ—（会话↔租约联动可视化）</span>
ALTER TABLE debug_session ADD COLUMN lease_generation INTEGER;
ALTER TABLE debug_session ADD COLUMN lease_owner_type INTEGER;
ALTER TABLE debug_session ADD COLUMN heartbeat_at TEXT;

<span class="cmt">-- â‘¤ debug_operation åŠ  2 åˆ—（命令级追溯）</span>
ALTER TABLE debug_operation ADD COLUMN lease_generation INTEGER;
ALTER TABLE debug_operation ADD COLUMN idempotency_key TEXT;   <span class="cmt">-- å¹‚等重试去重</span>
CREATE UNIQUE INDEX IF NOT EXISTS idx_op_dedup ON debug_operation(idempotency_key) WHERE idempotency_key != '';</code></pre>

<h3>9.2 æŽ¥å£ä¸Žå®žçŽ°æ”¹åŠ¨</h3>
<table>
    <tr><th>文件</th><th>改动类型</th><th>内容</th></tr>
    <tr>
        <td><span class="path">Aging.Infrastructure/Contracts/IResourceManager.cs</span></td>
        <td>扩展（向后兼容）</td>
        <td>新增 3 ä¸ªæ–¹æ³•ï¼Œé»˜è®¤å®žçŽ°å§”托现有语义：<br>
        <code>Task&lt;bool&gt; RenewAsync(ResourceOwnerToken, ResourceKey, int ttlSeconds, CancellationToken)</code><br>
        <code>(bool valid, string? holderInfo, int? graceSeconds) ProbeConflict(ResourceKey)</code> <span class="cmt">// UI æ˜¾ç¤º"被谁占用"</span><br>
        <code>Task&lt;GroupLeaseHandle&gt; AcquireGroupAsync(string groupKey, ResourceOwnerToken owner, CancellationToken ct)</code></td>
    </tr>
    <tr>
        <td><span class="path">Aging.Infrastructure/Core/DbLeaseStore.cs</span> â˜…新建</td>
        <td>新增</td>
        <td>§5.3/§5.4 çš„ SQL å°è£…ï¼›WAL/busy_timeout PRAGMA；懒回收；同机 PID çœ‹é—¨ç‹—。约 250 è¡Œ</td>
    </tr>
    <tr>
        <td><span class="path">Aging.Infrastructure/Core/ResourceManager.cs</span></td>
        <td>改造为组合</td>
        <td>保留内存字典 + SemaphoreSlim（快速路径）；预约/校验转发 <code>DbLeaseStore</code>；离线模式（DB ä¸å¯è¾¾ï¼‰é™çº§ä¸ºçº¯å†…å­˜ + æ¯ 5s é‡è¿žå¹¶åœ¨é‡è¿žåŽæ …栏自检</td>
    </tr>
    <tr>
        <td><span class="path">Aging.Infrastructure/Core/LeaseArbiter.cs</span> â˜…新建</td>
        <td>新增</td>
        <td>§6.1 ä¼˜å…ˆçº§çŸ©é˜µçš„策略引擎：让渡/拒绝/排队判定，策略参数（grace、抢占开关）进配置</td>
    </tr>
    <tr>
        <td><span class="path">Aging.Infrastructure/Services/AutoDeviceFacade.cs</span></td>
        <td>增强</td>
        <td>① <code>ReserveCoreAsync</code> çš„ owner æ ‡è¯†ä»Žéšæœº Guid æ”¹ä¸ºå¯é…ç½® <code>StationGlobals.StationId</code>（多机/多工位可读性）；② <code>AutoDeviceLease</code> æž„造函数启动后台心跳 Timer（TTL/3），Dispose åœæ­¢ï¼›â‘¢ æ•èŽ· PendingHandover â†’ <code>TryYieldAtBoundary()</code></td>
    </tr>
    <tr>
        <td><span class="path">Aging.Infrastructure/Services/DeviceService.cs</span></td>
        <td>增强</td>
        <td><code>ValidateOwner</code> å‡çº§ä¸º DB æ …栏校验（查 generation åŒ¹é…ï¼‰ï¼›ä¸åŒ¹é…è¿”回 <code>ErrorCode="LEASE_STALE"</code> ç»“构化失败，不抛裸异常</td>
    </tr>
    <tr>
        <td><span class="path">Aging.Infrastructure/Drivers/DriverFactory.cs</span> + å„驱动</td>
        <td>Phase 3</td>
        <td>新增 <code>transport=="CAN-REMOTE"</code> ç­‰ä»£ç†åž‹é©±åŠ¨ï¼ˆæŠŠå‘½ä»¤åºåˆ—化为 Broker è¯·æ±‚）；现有直连驱动不动。<code>IBrokeredTransport</code> æŽ¥å£å®šä¹‰äºŽ Contracts</td>
    </tr>
    <tr>
        <td><span class="path">Plugin.DeviceDebug/Model/DebugSessionManager.cs</span></td>
        <td>微调</td>
        <td><code>RequestMaintenance</code> å¤„理 <code>PendingHandover</code>（转异步等待 + UI å›žè°ƒ"等待工位让渡，剩余 X ç§’"）；冲突异常 message å·²å«å ç”¨è€… â†’ ç›´æŽ¥ç»™ ToastHelper</td>
    </tr>
    <tr>
        <td><span class="path">Plugin.DeviceDebug/Model/DeviceDebugModel.cs</span></td>
        <td>微调</td>
        <td>debug_session æ–°å¢žåˆ—写入；启动时 <code>SELECT ... WHERE state NOT IN (Closed) AND heartbeat过期</code> åšå­¤å„¿ä¼šè¯å›žæ”¶ï¼ˆç½® Faulted）</td>
    </tr>
    <tr>
        <td><span class="path">Plugin.DeviceConfig/Model/DeviceConfigModel.cs</span></td>
        <td>DDL</td>
        <td>§9.1 çš„建表/加列（幂等，IF NOT EXISTS / try-catch ALTER）；<span class="path">DeviceEditModal.xaml(.cs)</span> å¢žåŠ  access_mode ä¸‹æ‹‰</td>
    </tr>
    <tr>
        <td><span class="path">Aging.Infrastructure/InfrastructureBootstrapper.cs</span></td>
        <td>配置点</td>
        <td>注册 <code>LayeredResourceManager</code>（带 dbPath）替代纯内存版；读 <code>StationId</code>；可选注册 BrokerClient ä¼ è¾“</td>
    </tr>
    <tr>
        <td>★新建 <span class="path">DeviceBroker/</span> æŽ§åˆ¶å°å·¥ç¨‹ï¼ˆPhase 3）</span></td>
        <td>新增</td>
        <td>引用 ConnectionUtil çŽ°æˆ PipeServer；协议：<code>{op, deviceId, channel, payload, token, gen, idemKey}</code>；内部按设备队列 + å¤ç”¨ DriverFactory åˆ›å»ºçœŸå®žé©±åŠ¨ï¼›å´©æºƒçœ‹é—¨ç‹—（父进程句柄失联自动退出交 HMI æ‹‰èµ·ï¼‰</td>
    </tr>
</table>

<h3>9.3 å…³é”®æŽ¥å£ç­¾åï¼ˆPhase 1 æ ¸å¿ƒä»£ç ç¤ºä¾‹ï¼‰</h3>
<pre><code><span class="cmt">// DbLeaseStore â€”— åŽŸå­ç”³è¯·ï¼ˆå¯¹åº” Â§5.3 SQL）</span>
<span class="kwd">public sealed class</span> DbLeaseStore
{
    <span class="kwd">public</span> DbLeaseStore(<span class="kwd">string</span> dataDbPath) { <span class="cmt">/* PRAGMA journal_mode=WAL; busy_timeout=5000 */</span> }

    <span class="kwd">public enum</span> AcquireResult { Acquired, Renewed, QueuedHandover, RejectedMaintenanceHeld, RejectedByProductionHeld }

    <span class="kwd">public</span> AcquireResult TryAcquire(<span class="kwd">string</span> resourceKey, ResourceOwnerToken owner, OwnerType type,
                                <span class="kwd">string</span> machine, <span class="kwd">int</span> pid, <span class="kwd">string</span>? slotId, <span class="kwd">int</span> ttlSeconds);
    <span class="kwd">public bool</span>  Renew(<span class="kwd">string</span> resourceKey, <span class="kwd">string</span> tokenId, <span class="kwd">long</span> generation, <span class="kwd">int</span> ttlSeconds);
    <span class="kwd">public bool</span>  Release(<span class="kwd">string</span> resourceKey, <span class="kwd">string</span> tokenId);
    <span class="kwd">public long</span>  CurrentGeneration(<span class="kwd">string</span> resourceKey);          <span class="cmt">// FenceCheck ç”¨</span>
    <span class="kwd">public int</span>   SweepExpired();                                   <span class="cmt">// æ‡’回收兜底</span>
    <span class="kwd">public</span> (bool valid, <span class="kwd">string</span>? holder, <span class="kwd">int</span>? graceSec) ProbeConflict(<span class="kwd">string</span> resourceKey);
}

<span class="cmt">// AutoDeviceLease å¿ƒè·³ï¼ˆPhase 1）——独立线程，UI å¡é¡¿ä¸å½±å“</span>
_beacon = <span class="kwd">new</span> Timer(_ =&gt; {
    <span class="kwd">try</span> {
        <span class="kwd">if</span> (!_store.Renew(DeviceId, _owner.TokenId, _owner.Generation, _ttl))
            { LeaseLost?.Invoke(<span class="kwd">this</span>, EventArgs.Empty); <span class="kwd">return</span>; }
        <span class="kwd">if</span> (_store.IsPendingHandover(DeviceId)) _handoverTcs.TrySetResult(<span class="kwd">true</span>);
        _failCount = 0;
    } <span class="kwd">catch</span> { <span class="kwd">if</span> (++_failCount &gt;= 2) LeaseLost?.Invoke(<span class="kwd">this</span>, EventArgs.Empty); }
}, <span class="kwd">null</span>, _ttlMs/3, _ttlMs/3);

<span class="cmt">// TestStep åŸºç±»åœ¨æ­¥éª¤è¾¹ç•Œè®©æ¸¡ï¼ˆé›†æˆæµ‹è¯•æ¼”示用法）</span>
<span class="kwd">if</span> (lease.HandoverRequested) lease.Dispose();   <span class="cmt">// æ­¥éª¤ç»“束点检查，绝不在命令中途放手</span></code></pre>

<!-- ================================================================= -->
<h2 id="s10">10. æµ‹è¯•è¦ç‚¹</h2>

<h3>10.1 å•å…ƒï¼ˆ<span class="path">HMI.UnitTest</span> æˆ–新建 xUnit）</h3>
<table>
    <tr><th>用例</th><th>验证点</th></tr>
    <tr><td>Acquire å¹¶å‘ 20 çº¿ç¨‹åŒ key</td><td>恰好 1 ä¸ª Acquired，其余 Rejected/Renewed（同 token）；generation ä¸¥æ ¼ +1 æ— è·³å˜ç«žäº‰</td></tr>
    <tr><td>Renew ç”¨æ—§ generation</td><td>返回 false（栅栏语义）</td></tr>
    <tr><td>TTL è¿‡æœŸ â†’ ç›´æŽ¥ Acquire è¿‡æœŸæŒæœ‰è€…çš„ key</td><td>懒回收生效：先 DELETE è¿‡æœŸè¡Œå†æ’入成功</td></tr>
    <tr><td>仲裁矩阵全遍历（3×3 æŒæœ‰Ã—请求）</td><td>§6.1 æ¯ä¸ªæ ¼å­ä¸€ä¸ªæ–­è¨€</td></tr>
    <tr><td>组申请部分冲突</td><td>全回滚，不留下"占了一半"的行</td></tr>
</table>

<h3>10.2 å¤šè¿›ç¨‹é›†æˆï¼ˆåˆ©ç”¨ <span class="path">Plugin.IntegrationTest</span> æ‰©å±•ï¼Œé‡ç‚¹ï¼‰</h3>
<div class="card">
在"全自动测试" Tab å¢žåŠ  <strong>【多进程压力用例】</strong>按钮：
<pre><code><span class="cmt">// ä¼ªä»£ç ï¼šä¸»è¿›ç¨‹ fork N ä¸ªè‡ªèº« --station-worker æ¨¡å¼çš„子进程</span>
<span class="kwd">for</span> (<span class="kwd">int</span> s = 0; s &lt; 4; s++)
    Process.Start(exe, $<span class="str">"--worker {s} --device CAN-001 --loops 200"</span>);

<span class="cmt">// å­ worker é€»è¾‘：循环 [TryAcquire â†’ å‘一帧 â†’ æ ¡éªŒ â†’ Dispose]，统计成功轮转次数</span>
<span class="cmt">// ä¸»è¿›ç¨‹æ–­è¨€ï¼šâ‘  ä»»æ„æ—¶åˆ» device_lease åªæœ‰ 1 è¡Œæœ‰æ•ˆ â‘¡ æ‰€æœ‰å¸§çš„ generation å•è°ƒ â‘¢ æ— åŒå†™</span>
<span class="cmt">//           â‘£ ä¸­é€” Kill(随机 worker) â†’ å…¶ä½™ worker â‰¤ TTL+5s å†…接管，测试继续收敛为 PASS</span></code></pre>
额外两个杀手级用例：
<ul>
<li><strong>崩溃孤儿锁</strong>：<code>Process.Kill</code> æŒæœ‰è€…（不跑 Dispose）→ æ–­è¨€ â‰¤35s åŽè¢«å…¶ä»–工位自动接管；<code>host_process_id</code> åŒæœºçœ‹é—¨ç‹—路径则 â‰¤2s å›žæ”¶ï¼›</li>
<li><strong>维护抢占演练</strong>：worker A é•¿å¾ªçŽ¯æŒç§Ÿ â†’ UI å‘èµ· RequestMaintenance â†’ æ–­è¨€ grace å†…让渡、Maintenance èŽ·å¾—、A é‡ç”³è¯·è¢«æ‹’（RejectionMessage å«"维护"）；期间 A è‹¥è¿è§„硬发命令 â†’ é©±åŠ¨è¿”回 <code>LEASE_STALE</code>。</li>
</ul>
</div>

<!-- ================================================================= -->
<h2 id="s11">11. åˆ†é˜¶æ®µå®žæ–½è®¡åˆ’与工作量</h2>

<table>
    <tr><th>阶段</th><th>交付物</th><th>解决的痛点</th><th>工作量</th></tr>
    <tr>
        <td><strong>Phase 1<br>跨进程租约</strong></td>
        <td>device_lease DDL；<code>DbLeaseStore</code>；<code>ResourceManager</code> ç»„合化；心跳 + æ …栏 + æ‡’回收；Bootstrapper åˆ‡æ¢ï¼›å¤šè¿›ç¨‹é›†æˆæµ‹è¯•</td>
        <td class="good">多进程互斥仲裁 âœ… å´©æºƒè‡ªæ„ˆ âœ… å®¡è®¡å¯è¿½æº¯ âœ… ä¸Šå±‚零改动 âœ…</td>
        <td><strong>3~4 äººæ—¥</strong></td>
    </tr>
    <tr>
        <td><strong>Phase 2<br>仲裁规则 & UI</strong></td>
        <td><code>LeaseArbiter</code> ä¼˜å…ˆçº§çŸ©é˜µï¼›ç»´æŠ¤æŠ¢å /让渡流程；<span class="path">DebugSessionManager</span> PendingHandover；HMI"占用者信息/强制释放"；access_mode æ³¨å†Œé¡µ + ç»„租约 <code>AcquireGroupAsync</code></td>
        <td class="good">"人在接线程序不能动"硬保证 âœ… å·¥ä½åˆ†ç»„ âœ…</td>
        <td><strong>2~3 äººæ—¥</strong></td>
    </tr>
    <tr>
        <td><strong>Phase 3<br>Device Broker（按需触发）</strong></td>
        <td><span class="path">DeviceBroker</span> å·¥ç¨‹ï¼ˆå¤ç”¨ ConnectionUtil ç®¡é“）；代理型驱动 <code>*BrokeredDriver</code>；多机接入；命令队列 + TimeShared ç­–略落地</td>
        <td class="good">串口/USB å¥æŸ„独占根治 âœ… å¤šæœºå…±äº« âœ… åˆ†æ—¶å‘½ä»¤ä¸²è¡ŒåŒ– âœ…</td>
        <td><strong>5~8 äººæ—¥</strong></td>
    </tr>
    <tr>
        <td><strong>Phase 4<br>演进（可选）</strong></td>
        <td>驱动迁移为 OpenTAP Instrument æ’件包（.opentap）；Bench é…ç½®ä¸Ž DeviceConfig å•æºåŒ–ï¼›HMI å†…嵌驱动管理（Image API）</td>
        <td class="good">厂商驱动生态复用、分发运维</td>
        <td>另评估</td>
    </tr>
</table>

<div class="success"><strong>触发 Phase 3 çš„判断标准（避免过度设计）：</strong>出现以下任一情况才立项——①串口/USB è®¾å¤‡ç§Ÿçº¦æ˜“手频率高到 close/open æŠ–动成为瓶颈；②确有 2 å°ä»¥ä¸Šç”µè„‘需要操作同一台物理仪器；③出现 â‰¥1 å° TimeShared å‘½ä»¤çº§ä¸²è¡Œè®¾å¤‡æœ‰å¹¶è¡ŒæŽ’队需求。否则 Phase 1+2 å·²é—­çŽ¯ä¸»è¦é£Žé™©ã€‚</div>

<!-- ================================================================= -->
<h2 id="s12">12. é£Žé™©ã€åæ¨¡å¼ä¸Žä¸æŽ¨èåšæ³•</h2>

<table>
    <tr><th>反模式</th><th>后果</th><th>正确做法</th></tr>
    <tr><td class="bad">多进程各自 open åŒä¸€ COM å£/CAN å¡å¥æŸ„"碰运气"</td><td>WriteFile äº¤é”™ã€æ•°æ®æ’•è£‚、蓝屏级未定义行为</td><td>要么租约保证单持有者（Phase 1），要么 Broker å”¯ä¸€æŒæœ‰ï¼ˆPhase 3）。<strong>物理层不允许并发是硬约束，任何软件方案不能挑战</strong></td></tr>
    <tr><td class="bad">仅用 Named Mutex å½“租约</td><td>崩溃后接管方对设备状态全盲（输出可能还开着）</td><td>Mutex åªé…åšåŒæœºå¿«é€Ÿä¿¡å·ï¼ŒçŠ¶æ€ä¸Žäº¤æŽ¥è¯­ä¹‰å¿…须在 DB è¡¨ï¼ˆÂ§3 æ–¹æ¡ˆâ‘¡è¯„估）</td></tr>
    <tr><td class="bad">网络共享盘（SMB）上放 data.db ä¾›å¤šæœºå†™</td><td>SQLite é”åœ¨ SMB è¯­ä¹‰ä¸å¯é  â†’ åŒæŒæœ‰è€… = çœŸå®žç‚¸æœºé£Žé™©</td><td>多机场景：Phase 3 Broker（每台物理机一份 DB）或租约表迁到服务端 SQL</td></tr>
    <tr><td class="bad">客户端自己算 expires_at ä¼ ç»å¯¹æ—¶é—´</td><td>时钟漂移导致提前/延迟回收</td><td>只传相对 TTL，DB ä¾§ <code>datetime('now')</code> è®¡ç®—（§7）</td></tr>
    <tr><td class="bad">TTL è®¾ 5 åˆ†é’Ÿ"求稳"</td><td>崩溃后其他工位干等 5 åˆ†é’Ÿ</td><td>TTL 30s + å¿ƒè·³ 10s；同机 PID çœ‹é—¨ç‹—秒级兜底</td></tr>
    <tr><td class="bad">抢占发生在一条多字节 CAN äº‹åŠ¡ä¸­é—´</td><td>设备卡在半包状态</td><td>让渡点严格对齐 TestStep è¾¹ç•Œ/单条命令完成（§5.4 é“å¾‹â‘¢ï¼‰</td></tr>
    <tr><td class="bad">维护模式不做栅栏校验"反正有 UI å¼¹çª—"</td><td>UI å¼¹çª—可被忽略，程序 bug ç»•ä¸è¿‡</td><td>驱动入口 FenceCheck æ˜¯ç‰©ç†é—¸é—¨ï¼ˆÂ§7 åƒµå°¸è¡Œï¼‰ï¼Œå¼¹çª—只是体验层</td></tr>
    <tr><td class="bad">心跳挂在 UI Dispatcher</td><td>WPF ä¸»çº¿ç¨‹å¡é¡¿â†’假死误判被抢占</td><td>独立后台线程（§9.3 ä»£ç å·²åˆè§„）</td></tr>
</table>

<h3>已知局限（诚实声明）</h3>
<ul>
<li><strong>SQLite å•å†™è€…</strong>：租约写 QPS ä¸Šé™çº¦ç™¾çº§ï¼›è€åŒ–节拍（秒级）远低于此，但高频遥测不要走租约表（走结果通路）。</li>
<li><strong>Phase 1 åŽå¤šæœºä»å—限</strong>：单机内多进程完全解决；多机需要把 <code>device_lease</code> æ‰€åœ¨åº“放到服务器（表结构不变，<code>DbLeaseStore</code> æ¢è¿žæŽ¥å·¥åŽ‚即可——这是 Phase 3 å‰çš„最小台阶）。</li>
<li><strong>Broker å•ç‚¹</strong>：Phase 3 å¼•å…¥çœ‹é—¨ç‹—拉起；Broker é‡å¯æœŸé—´å‘½ä»¤çŸ­æš‚不可用（设备本身不受影响）。</li>
</ul>

<!-- ================================================================= -->
<h2 id="s13">13. ç»“论</h2>

<div class="success">
<ol>
<li><strong>两类场景分别治理</strong>：进程内多线程继续用现有内存锁 + OpenTAP åŒæ­¥ï¼›è·¨è¿›ç¨‹æ‰æ˜¯çœŸæ­£ç¼ºå£ï¼Œä¸è¦ç”¨ä¸€ä¸ªæœºåˆ¶ç¡¬åƒä¸¤ä¸ªåœºæ™¯ã€‚</li>
<li><strong>主体方案 = SQLite ç§Ÿçº¦è¡¨ï¼ˆTTL+心跳+generation æ …栏+懒回收）</strong>，作为 <code>IResourceManager</code> çš„跨进程实现，上层 <code>IAutoDeviceFacade</code>/<code>AutoDeviceLease</code>/<code>DebugSessionManager</code> æŽ¥å£ç­¾åä¸Žä¸šåŠ¡ä»£ç <strong>零改动</strong>（Phase 1，3~4 äººæ—¥ï¼‰ã€‚</li>
<li><strong>安全硬保证靠栅栏，不靠礼貌</strong>：每条命令驱动入口校验 generation，实现"人在接线时程序物理发不出指令"（§6 ä¿¡æ¯+§7 åƒµå°¸è¡Œï¼‰ã€‚抢占/让渡只在 TestStep è¾¹ç•Œï¼Œgrace é»˜è®¤ 30s。</li>
<li><strong>Device Broker（Phase 3）仅在触发条件出现时立项</strong>：串口/USB å¥æŸ„抖动、多机共测、分时排队——三者任一。传输层直接复用仓库现成的 <code>ConnectionUtil.PipeServer/PipeClient</code>，不必引入 WCF/gRPC。</li>
<li><strong>OpenTAP ç”Ÿæ€è§£å†³çš„是"分发与形态"而非"运行时仲裁"</strong>——跨进程仲裁是它的空白，你们的 IResourceManager + ç§Ÿçº¦è¡¨æ°å¥½è¡¥ä½ï¼Œè¿™æ˜¯æœ¬é¡¹ç›®å·®å¼‚化资产；长期把物理仪器包装成 OpenTAP Instrument æ’件包与租约体系并行不悖。</li>
<li><strong>独占 vs åˆ†æ—¶ç”¨ <code>access_mode</code> æ˜¾å¼å»ºæ¨¡</strong>（注册页可选），工位分组复用 <code>SlotDeviceMapping</code> + ç»„租约按 key å­—典序原子申请，杜绝死锁。</li>
<li><strong>崩溃残留是唯一真正难的问题，TTL+看门狗+懒回收三层冗余解决</strong>；测试用 Kill è¿›ç¨‹æ¼”练接管收敛（§10.2），上线前必须过。</li>
</ol>
</div>

<footer>
    å¤šè¿›ç¨‹/多线程仪器资源独占与共享方案 Â· TapProject Aging Infrastructure æž¶æž„设计 Â· 2026-11-03<br>
    å…³è”文档：<a href="./OpenTAP_Instrument_Package_Analysis.html">OpenTAP Instrument + æ’件包机制分析</a> Â·
    <a href="./DeviceConfig_DeviceDebug_Architecture.html">仪器注册与硬件调试调用关系</a>
</footer>

<script>
    mermaid.initialize({ 
        startOnLoad: true, theme: 'default', securityLevel: 'loose',
        fontFamily: 'Segoe UI, Microsoft YaHei, sans-serif',
        flowchart: { curve: 'basis', padding: 16 },
        sequence: { showSequenceNumbers: false, actorMargin: 50 }
    });
</script>

</body>
</html>

 docs/OpenTAP_Instrument_Package_Analysis.html

New file
@@ -0,0 +1,486 @@
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>OpenTAP Instrument + æ’件包机制分析报告</title>
<script src="https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js"></script>
<style>
    * { box-sizing: border-box; }
    body {
        font-family: -apple-system, "Segoe UI", "Microsoft YaHei", "PingFang SC", sans-serif;
        max-width: 1240px;
        margin: 0 auto;
        padding: 32px 24px 80px;
        background: #FAFAFA;
        color: #212121;
        line-height: 1.75;
    }
    h1 { font-size: 30px; color: #1565C0; border-bottom: 3px solid #1976D2; padding-bottom: 12px; }
    h2 { font-size: 23px; color: #0D47A1; margin-top: 42px; padding-left: 12px; border-left: 4px solid #FF9800; }
    h3 { font-size: 17px; color: #37474F; margin-top: 24px; }
    .subtitle { color: #757575; font-size: 14px; margin-bottom: 24px; }
    .card { background: white; border-radius: 8px; padding: 18px 22px; margin: 16px 0; box-shadow: 0 2px 8px rgba(0,0,0,0.06); }
    .highlight { background: #FFF8E1; border-left: 4px solid #FFC107; padding: 12px 16px; margin: 12px 0; border-radius: 4px; }
    .info { background: #E3F2FD; border-left: 4px solid #2196F3; padding: 12px 16px; margin: 12px 0; border-radius: 4px; }
    .success { background: #E8F5E9; border-left: 4px solid #4CAF50; padding: 12px 16px; margin: 12px 0; border-radius: 4px; }
    .warn { background: #FBE9E7; border-left: 4px solid #FF5722; padding: 12px 16px; margin: 12px 0; border-radius: 4px; }
    table { width: 100%; border-collapse: collapse; margin: 16px 0; background: white; border-radius: 6px; overflow: hidden; box-shadow: 0 1px 4px rgba(0,0,0,0.06); font-size: 14px; }
    th { background: #1976D2; color: white; padding: 10px 14px; text-align: left; font-weight: 600; }
    td { padding: 9px 14px; border-bottom: 1px solid #EEEEEE; vertical-align: top; }
    tr:nth-child(even) td { background: #FAFAFA; }
    tr:hover td { background: #E3F2FD; }
    code { font-family: "Consolas", "Monaco", monospace; background: #F5F5F5; color: #C62828; padding: 2px 6px; border-radius: 3px; font-size: 13px; }
    pre { background: #263238; color: #ECEFF1; padding: 16px 20px; border-radius: 6px; overflow-x: auto; font-family: "Consolas", monospace; font-size: 13px; line-height: 1.55; }
    pre code { background: transparent; color: inherit; padding: 0; font-size: 13px; }
    .mermaid { background: white; padding: 20px; border-radius: 8px; margin: 20px 0; text-align: center; box-shadow: 0 2px 8px rgba(0,0,0,0.06); overflow-x: auto; }
    ul { padding-left: 22px; }
    li { margin: 4px 0; }
    .toc { background: #F5F5F5; padding: 16px 24px; border-radius: 6px; margin: 20px 0; }
    .toc a { color: #1976D2; text-decoration: none; display: block; padding: 3px 0; }
    .toc a:hover { text-decoration: underline; }
    .kwd { color: #FFCC80; } .str { color: #C5E1A5; . } .cmt { color: #546E7A; }
    footer { margin-top: 60px; padding-top: 20px; border-top: 1px solid #E0E0E0; color: #757575; font-size: 12px; text-align: center; }
    .tag { display:inline-block; background:#E1F5FE; color:#0277BD; border-radius:12px; padding:1px 10px; font-size:12px; margin:2px; }
</style>
</head>
<body>

<h1>OpenTAP Instrument + æ’件包机制分析报告</h1>
<div class="subtitle">针对 TestPlatform Aging Software（.NET Framework 4.7.2 + OpenTAP 9.31.0）驱动热插拔改造的技术调研 Â· 2026-11-03</div>

<div class="toc">
    <strong>目录</strong>
    <a href="#s1">1. OpenTAP æ’件体系总览</a>
    <a href="#s2">2. Instrument æŠ½è±¡æ·±å…¥è§£æž</a>
    <a href="#s3">3. æµ‹è¯•æ­¥éª¤å¦‚何引用仪器</a>
    <a href="#s4">4. åŒ…（Package）机制全景</a>
    <a href="#s5">5. package.xml æ¸…单文件详解</a>
    <a href="#s6">6. ä¾èµ–解析与版本模型</a>
    <a href="#s7">7. é©±åŠ¨æ’件开发-分发-安装工作流</a>
    <a href="#s8">8. Image API：安装目录状态管理</a>
    <a href="#s9">9. ä¸Ž TapProject çŽ°æœ‰æž¶æž„的映射与差距</a>
    <a href="#s10">10. è½åœ°è·¯çº¿å»ºè®®ä¸Žæˆæœ¬è¯„ä¼°</a>
    <a href="#s11">11. ç»“论</a>
</div>

<!-- ============================================================ -->
<h2 id="s1">1. OpenTAP æ’件体系总览</h2>

<div class="card">
OpenTAP çš„核心哲学是 <strong>“一切皆插件（Everything is a Plugin）”</strong>。测试步骤、仪器驱动、被测件（DUT）、结果监听器、甚至 CLI å‘½ä»¤æœ¬èº«ï¼Œéƒ½æ˜¯ç»§æ‰¿è‡ªæŸä¸ªæŠ½è±¡åŸºç±»çš„ C# ç±»ã€‚引擎启动时通过 <code>PluginSearcher</code> æ‰«æå®‰è£…目录下所有程序集，构建插件类型图谱，供序列化器与编辑器（Editor）动态发现使用。
</div>

<div class="mermaid">
graph TB
    subgraph æ‰«æ["启动时插件发现 (PluginSearcher)"]
        A["扫描安装根目录 *.dll"] --> B["扫描 Packages/** å­ç›®å½•"]
        B --> C["反射提取继承自插件基类的类型"]
        C --> D["构建类型缓存<br/>PluginManager å¯æŸ¥è¯¢"]
    end
    subgraph åŸºç±»["插件基类（OpenTap.dll / æ’件包）"]
        T1["TestStep"]
        T2["Instrument : Resource"]
        T3["Dut : Resource"]
        T4["ResultListener"]
        T5["SerializerPlugin"]
        T6["ICliAction (tap å­å‘½ä»¤)"]
    end
    D --> T1 & T2 & T3 & T4 & T5 & T6
</div>

<h3>关键组件</h3>
<table>
    <tr><th>组件</th><th>所在 DLL</th><th>职责</th></tr>
    <tr><td>Engine（序列化/序列执行）</td><td><code>OpenTap.dll</code></td><td>TestPlan æ‰§è¡Œã€æ’件对象生命周期、XML åºåˆ—化</td></tr>
    <tr><td>PluginSearcher</td><td><code>OpenTap.dll</code>（内置 Mono.Cecil）</td><td>不加载 CLR ç±»åž‹å³å¯è§£æžç¨‹åºé›†çš„插件元数据（快、支持延迟加载）</td></tr>
    <tr><td>PackageManager / Image</td><td><code>OpenTap.Package.dll</code></td><td>包安装、依赖解析、下载、卸载</td></tr>
    <tr><td>CLI</td><td><code>tap.dll</code> / <code>tap.exe</code></td><td><code>tap package install / run / plan</code> ç­‰å‘½ä»¤å…¥å£</td></tr>
    <tr><td>基础步骤包</td><td><code>OpenTap.Plugins.BasicSteps.dll</code></td><td>Delay、Loop、If、Scpi ä»ªå™¨æŽ§åˆ¶ç­‰é€šç”¨ TestStep</td></tr>
</table>

<div class="info">
    <strong>安装目录布局（实测官方 OpenTAP åŒ…）：</strong>
    æ ¸å¿ƒå¼•æ“Ž DLL（<code>tap.dll</code>、<code>OpenTap.dll</code>、<code>OpenTap.Package.dll</code>）放在根目录；
    <strong>每个第三方包的文件被隔离到自己的子目录</strong> <code>Packages/&lt;包名&gt;/</code>（如 <code>Packages/OpenTAP/OpenTap.Plugins.BasicSteps.dll</code>），卸载包时按清单删除这些文件，天然避免文件冲突。
</div>

<!-- ============================================================ -->
<h2 id="s2">2. Instrument æŠ½è±¡æ·±å…¥è§£æž</h2>

<h3>类层次</h3>
<div class="mermaid">
classDiagram
    class IResource {
        <<interface>>
        +string Name
        +bool Enabled
        +Open()
        +Close()
    }
    class Resource {
        <<abstract>>
        +string Name
        +virtual bool Enabled
        +virtual Open()
        +virtual Close()
    }
    class IInstrument { <<interface>> }
    class Instrument {
        <<abstract>>
        Instrument() é»˜è®¤Name= INST
    }
    class ScpiInstrument {
        +IdnQuery
        +Query/Write
        +Connection ç±»åž‹
        +Open/Close å®žçŽ°
    }
    class Dut {
        <<abstract>>
        è¢«æµ‹ä»¶æ¨¡åž‹
    }
    IResource <|-- Resource
    IResource <.. IInstrument
    IInstrument <|.. Instrument
    Resource <|-- Instrument
    Instrument <|-- ScpiInstrument
    Resource <|-- Dut
</code></pre>
</div>

<ul>
    <li><strong><code>Resource</code>（抽象基类）</strong>：统一"台架资源"模型 â€”— åç§°å”¯ä¸€ã€å¯å¯ç”¨/禁用、<code>Open()</code>/<code>Close()</code> ç”Ÿå‘½å‘¨æœŸã€‚Instrument ä¸Ž DUT éƒ½ç»§æ‰¿å®ƒã€‚</li>
    <li><strong><code>Instrument : Resource, IInstrument</code></strong>：源码仅 ~20 è¡Œï¼ˆéªŒè¯è‡ª GitHub opentap/opentap Engine/Instrument.cs），构造函数默认 <code>Name="INST"</code>。派生类重写 <code>Open/Close</code> å®Œæˆç¡¬ä»¶è¿žæŽ¥ã€‚</li>
    <li><strong><code>ScpiInstrument</code></strong>（SCPI æ’件包提供）：最常用的仪器基类，封装 SCPI åè®®æ ˆï¼š
        <ul>
            <li>IDN æŸ¥è¯¢ï¼ˆ*IDN? è‡ªåŠ¨è¯†åˆ«åŽ‚商/型号/固件）</li>
            <li>多传输层：VISA（Keysight/NI）、Raw TCP/Socket、Serial、USB-TMC、GPIB、HiSLIP</li>
            <li>分层协议模型（Layer）：可在 Message/Resource å±‚插入日志、超时、重试策略</li>
        </ul>
    </li>
    <li><strong>连接配置持久化</strong>：9.23+ å¼•å…¥ <code>BenchStore</code>/<code>ResourceSettings</code> ä½“系，将仪器的地址、超时、别名从测试序列中剥离成台架级配置（对应旧版 <code>InstrumentSettings.xml</code> æ–‡ä»¶ï¼‰ã€‚</li>
</ul>

<div class="highlight">
<strong>与你们 <code>IDeviceDriver</code> çš„关键差异：</strong>OpenTAP çš„ Instrument å¯¹è±¡åŒæ—¶æ‰¿æ‹…"驱动 + è¿žæŽ¥é…ç½® + ç”Ÿå‘½å‘¨æœŸ"三种角色，且由序列化器在反序列化 TestPlan æ—¶<strong>自动按类型名从插件图谱创建实例</strong>。你们的 <code>CanDriverAdapter(deviceId, busName, nodeIndex)</code> åˆ™æ˜¯å·¥åŽ‚显式构造，配置来自 SQLite çš„ <code>DeviceDefinition</code> è¡¨ã€‚
</div>

<!-- ============================================================ -->
<h2 id="s3">3. æµ‹è¯•æ­¥éª¤å¦‚何引用仪器</h2>

<pre><code><span class="cmt">// OpenTAP é£Žæ ¼çš„ TestStep å¼•ç”¨ä»ªå™¨ï¼ˆç¼–辑器自动渲染为下拉框）</span>
<span class="kwd">public class</span> PowerOnStep : TestStep
{
    <span class="cmt">// ä»»ä½•æš´éœ² Instrument å±žæ€§çš„ TestStep，编辑器显示可选仪器列表；</span>
    <span class="cmt">// åˆ—表来源 = PluginSearcher æ‰«æå‡ºçš„所有非抽象 Instrument å­ç±»å®žä¾‹ï¼ˆæ¥è‡ª settings store）</span>
    <span class="kwd">public</span> ScpiInstrument PowerSupply { <span class="kwd">get</span>; <span class="kwd">set</span>; }
    <span class="kwd">public double</span> Voltage { <span class="kwd">get</span>; <span class="kwd">set</span>; } = 12.0;

    <span class="kwd">public override void</span> Run()
    {
        <span class="kwd">using</span> <span class="kwd">var</span> _ = SynchronizationManager.RequestLock(PowerSupply, TimeSpan.FromSeconds(10));
        PowerSupply.Write($&quot;VOLT {Voltage:F2}&quot;);
        PowerSupply.Write(&quot;OUTP ON&quot;);
        <span class="kwd">var</span> readback = PowerSupply.QueryDouble(&quot;MEAS:VOLT?&quot;);
        <span class="kwd">if</span> (Math.Abs(readback - Voltage) &gt; 0.5)
            Upwards.Find(Voltage, readback).Fail(&quot;电压偏差过大&quot;);
    }
}</code></pre>

<table>
    <tr><th>机制</th><th>说明</th></tr>
    <tr><td>属性类型即选择器</td><td><code>public Instrument X</code> å±žæ€§åœ¨ç¼–辑器/CLI ä¸­æ¸²æŸ“成仪器下拉框；[ResourceProperty] ç­‰ Attribute å¯é™åˆ¶å€™é€‰ç±»åž‹ï¼ˆåªåˆ— CAN / åªåˆ—电源）</td></tr>
    <tr><td>自动 Open/Close</td><td>TestPlanRun å¼€å§‹æ—¶å¼•æ“Žå¯¹æ‰€æœ‰ Enabled çš„ Instrument è°ƒ <code>Open()</code>（懒打开），结束后 <code>Close()</code>；步骤代码不关心连接细节</td></tr>
    <tr><td>并发保护</td><td><code>SynchronizationManager.RequestLock(resource, timeout)</code> æä¾›è¿›ç¨‹å†…对同一仪器的互斥锁；跨进程互斥 OpenTAP <strong>不提供</strong>，需外部仲裁（见 Â§9）</td></tr>
    <tr><td>序列化</td><td>TestPlan XML é‡Œä¿å­˜çš„是仪器 <code>Name</code> å¼•ç”¨ï¼ˆéžå®žä¾‹ï¼‰ï¼Œè¿è¡Œæ—¶æŒ‰åå­—解析到 settings store ä¸­é…ç½®çš„实例</td></tr>
</table>

<!-- ============================================================ -->
<h2 id="s4">4. åŒ…（Package）机制全景</h2>

<div class="card">
<strong>包文件本质：</strong><code>.opentap</code> æ–‡ä»¶å°±æ˜¯ä¸€ä¸ª <strong>ZIP åŽ‹ç¼©åŒ…</strong>，根目录含 <code>package.xml</code> æ¸…单，其余为载荷文件（DLL、配置、文档等）。清单声明了包名、语义化版本、平台约束、依赖关系和文件部署布局。
</div>

<div class="mermaid">
graph LR
    subgraph åŒ…文件
        Z[".opentap (ZIP)"] --> PX["package.xml æ¸…单"]
        Z --> PL["载荷文件"]
    end
    subgraph ä»“库
        REPO["packages.opentap.io<br/>(官方 NuGet é£Žæ ¼ä»“库)"]
        PRIV["私有仓库<br/>tap repo add"]
    end
    PLAT["Developer's Platform<br/>(桌面版包浏览器/CI)"] --> REPO
    REPO -->|tap package install| IMG["Image = å®‰è£…目录<br/>状态 + å·²è£…包清单"]
    PRIV -->|同协议| IMG
    PX --> IMG
    IMG -->|部署到| FILES["根目录 + Packages/&lt;name&gt;/<br/>+ Dependencies/"]
    IMG -->|卸载| DEL["按清单删除文件<br/>（不影响其他包）"]
</div>

<h3>核心 CLI å‘½ä»¤</h3>
<pre><code><span class="cmt"># åˆ—出可安装 / å·²å®‰è£…</span>
tap package list
tap package list -i

<span class="cmt"># å®‰è£…（可指定仓库、版本、通道）</span>
tap package install "Developer's System CE" -y
tap package install MyCanDriver -v 2.1.0 -c candidate
tap package install Keysight.34461A -s https://packages.opentap.io

<span class="cmt"># ä»Žæºç å·¥ç¨‹æž„建包</span>
tap package create package.xml

<span class="cmt"># ç®¡ç†ç§æœ‰ä»“库源</span>
tap repo add http://192.168.1.50/opentap-repo
tap repo list

<span class="cmt"># ä¿®å¤ / åºåˆ—化 / ä¼šè¯</span>
tap package recover
tap package serialize-package / deserialize-package</code></pre>

<table>
    <tr><th>特性</th><th>机制</th></tr>
    <tr><td>包隔离安装</td><td>包文件部署到 <code>Packages/&lt;包名&gt;/</code>，同名 DLL ä¸åŒç‰ˆæœ¬å¯å…±å­˜ï¼ˆå¼•æ“ŽæŒ‰åŒ…清单加载）</td></tr>
    <tr><td>平台/架构区分</td><td><code>OS="Windows|Linux|MacOS"</code>、<code>Architecture="x64|x86|arm"</code>，清单内可按条件包含不同原生依赖（官方包用 <code>$(Architecture)</code> å˜é‡åˆ‡åˆ† libgit2 çš„ .dll/.so/.dylib）</td></tr>
    <tr><td>安装钩子</td><td><code>PackageActionExtensions</code> å¯åœ¨ pre/post install æ‰§è¡Œå¤–部命令（官方包用 <code>chmod +x tap</code> ä¿® Linux æƒé™ï¼‰</td></tr>
    <tr><td>通道（Channels）</td><td>release / candidate / alpha，同一包可按不同通道发布；CI åœºæ™¯é”å®šé€šé“即可控制更新节奏</td></tr>
    <tr><td>自动更新</td><td><code>tap package install --force</code> æˆ–桌面版包浏览器；版本比较使用严格 SemVer 2.0</td></tr>
</table>

<!-- ============================================================ -->
<h2 id="s5">5. package.xml æ¸…单文件详解</h2>

<p>以下骨架提炼自 <strong>官方 OpenTAP åŒ…的真实 package.xml</strong>（GitHub opentap/opentap@main）：</p>

<pre><code>&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;Package Name="MyCompany.CanDriver"
         xmlns="http://opentap.io/schemas/package"
         Version="$(GitVersion)"          <span class="cmt">&lt;!-- MSBuild é£Žæ ¼å˜é‡æ³¨å…¥ --&gt;</span>
         OS="$(Platform)" Architecture="$(Architecture)"&gt;

  &lt;Description&gt;CAN æ€»çº¿ä»ªå™¨é©±åŠ¨æ’件（PCAN/虚拟总线）&lt;/Description&gt;
  &lt;Status&gt;Released&lt;/Status&gt;
  &lt;Organisation&gt;我司&lt;/Organisation&gt;
  &lt;SourceUrl&gt;https://git.internal/CanDriver&lt;/SourceUrl&gt;
  &lt;SourceLicense&gt;Proprietary&lt;/SourceLicense&gt;
  &lt;Owner&gt;MyCompany&lt;/Owner&gt;

  <span class="cmt">&lt;!-- â‘  å˜é‡ä¸Žæ¡ä»¶ï¼ˆMSBuild è¡¨è¾¾å¼ï¼‰--&gt;</span>
  &lt;Variables&gt;
    &lt;ArchitectureCondition Condition="$(Architecture) == ''"&gt;x64&lt;/Architecture&gt;
    &lt;PlatformCondition Condition="$(Platform) == ''"&gt;Windows&lt;/Platform&gt;
  &lt;/Variables&gt;

  <span class="cmt">&lt;!-- â‘¡ ä¾èµ–：指向其他"包"（版本范围/必需/推荐）--&gt;</span>
  &lt;Dependencies&gt;
    &lt;PackageDependency Name="OpenTAP" Version="9.31.0" Action="Required"/&gt;
    &lt;PackageDependency Name="Keysight.SCPI" Version="9.x" Action="Optional"/&gt;
  &lt;/Dependencies&gt;

  <span class="cmt">&lt;!-- â‘¢ æ–‡ä»¶ï¼šå®‰è£…路径 / æºè·¯å¾„ / å…ƒæ•°æ®æ“ä½œ --&gt;</span>
  &lt;Files&gt;
    <span class="cmt">&lt;!-- æ’件 DLL æ”¾è¿›åŒ…隔离目录 --&gt;</span>
    &lt;File Path="Packages/MyCompany.CanDriver/CanDriverPlugin.dll"&gt;
      &lt;SetAssemblyInfo Attributes="Version"/&gt;   <span class="cmt">&lt;!-- è‡ªåŠ¨å†™å…¥ç¨‹åºé›†ç‰ˆæœ¬å· --&gt;</span>
    &lt;/File&gt;
    &lt;File Path="Packages/MyCompany.CanDriver/peak_pcans.dll" SourcePath="native/pcans.dll"/&gt;
    &lt;File Path="Docs/**" SourcePath="doc/"/&gt;                    <span class="cmt">&lt;!-- glob --&gt;</span>
  &lt;/Files&gt;

  <span class="cmt">&lt;!-- â‘£ å¹³å°å·®å¼‚化 --&gt;</span>
  &lt;Files Condition="$(Platform) == Linux"&gt;
    &lt;File Path="Packages/MyCompany.CanDriver/libpcans.so"/&gt;
  &lt;/Files&gt;
&lt;/Package&gt;</code></pre>

<table>
    <tr><th>元素</th><th>作用</th></tr>
    <tr><td><code>Package</code> æ ¹å±žæ€§</td><td>Name/Version/OS/Architecture，支持 <code>$(变量)</code> + <code>Condition</code></td></tr>
    <tr><td><code>Dependencies</code> / <code>PackageDependency</code></td><td>声明对其他包的最小版本要求；Action = Required / Recommended / Optional</td></tr>
    <tr><td><code>PluginDependencies</code></td><td>声明运行时 .NET ç¨‹åºé›†ä¾èµ–（非包级），用于加载顺序与冲突提示</td></tr>
    <tr><td><code>Files</code> / <code>File</code></td><td>部署布局：<code>Path</code>（目标）+ <code>SourcePath</code>（源），可带 <code>Action="Install|WriteCode"</code>、<code>SetAssemblyInfo</code>（写版本/公司元数据）、<code>SignCertificate</code>（ Authenticode ç­¾åï¼‰</td></tr>
    <tr><td><code>PackageActionExtensions</code></td><td>安装前后执行外部可执行/脚本（如权限修复、驱动安装器）</td></tr>
    <tr><td><code>Variables/Condition</code></td><td>一份清单跨平台复用，构建时按变量裁剪文件集</td></tr>
    <tr><td><code>TypeTags</code></td><td>给插件类打标签，编辑器可按 tag è¿‡æ»¤ï¼ˆå¦‚ "PowerSupply" tag åªæ˜¾ç¤ºç”µæºï¼‰</td></tr>
</table>

<!-- ============================================================ -->
<h2 id="s6">6. ä¾èµ–解析与版本模型</h2>

<ul>
    <li><strong>SemVer 2.0</strong>：包版本严格遵循 <code>MAJOR.MINOR.PATCH</code> + é¢„发布标识（<code>-alpha.1</code>）。</li>
    <li><strong>解析器</strong>：<code>OpenTap.Package</code> å†…置求解器，处理 <code>安装 A â†’ A ä¾èµ– B â‰¥2.0 â†’ å·²è£… B 1.3 â†’ ç”Ÿæˆ"升级 B"计划</code>；多包交叉依赖用回溯搜索求最小变更集。</li>
    <li><strong>降级保护</strong>：<code>install</code> é»˜è®¤æ‹’绝降级已安装包，除非 <code>--force</code>。</li>
    <li><strong>冲突处理</strong>：同一文件被两个包声明 â†’ åŽè€…安装报错提示 ownership å†²çªï¼›é€šè¿‡ <code>Packages/&lt;name&gt;/</code> ç›®å½•çº¦å®šåŸºæœ¬å¯é¿å…ã€‚</li>
    <li><strong>OpenTAP å†…核版本兼容</strong>：所有包都依赖 <code>OpenTAP</code> åŒ…本身；内核升级后旧包按 <code>&lt;PackageDependency Version="9.31.0"&gt;</code> çš„最小版本匹配保持兼容，9.x ä¿æŒ ABI æ‰¿è¯ºã€‚</li>
</ul>

<!-- ============================================================ -->
<h2 id="s7">7. é©±åŠ¨æ’件开发-分发-安装工作流</h2>

<div class="mermaid">
sequenceDiagram
    participant Dev as é©±åŠ¨å¼€å‘者
    participant VS as VS / dotnet CLI
    participant Tap as tap CLI
    participant Repo as åŒ…仓库
    participant User as çŽ°åœºå·¥ç¨‹å¸ˆ

    Dev->>VS: NuGet å¼•ç”¨ OpenTap / OpenTap.Package SDK
    Dev->>VS: ç¼–写 `class MyCanInstrument : Instrument`
    VS->>VS: dotnet build â†’ ç”Ÿæˆ DLL
    Dev->>Tap: tap package create package.xml
    Tap->>Tap: æ ¡éªŒæ¸…单 + ZIP æ‰“包 â†’ MyCan.opentap
    Dev->>Repo: ä¸Šä¼ åˆ°ç§æœ‰ä»“库 (HTTP æœåŠ¡å™¨/文件共享)
    User->>Tap: tap repo add http://内网仓库
    User->>Tap: tap package install MyCan -y
    Tap->>Repo: è§£æžä¾èµ– â†’ ä¸‹è½½ .opentap
    Tap->>Tap: æŒ‰æ¸…单部署到 Packages/MyCan/
    Note over User: é‡å¯ç¼–辑器/CLI，新仪器自动出现在下拉列表
</div>

<h3>开发环境依赖</h3>
<ul>
    <li>NuGet åŒ…：<code>OpenTap</code>、<code>OpenTap.Package</code>（提供 SDK å¼•ç”¨ï¼Œç¼–译期）</li>
    <li>VS æ‰©å±•ï¼š<em>OpenTAP Project Templates</em>（含 Instrument æ’件项目模板）</li>
    <li>调试方式：把编译产物 DLL ç›´æŽ¥æ‹·åˆ°å®‰è£…目录 <code>Packages/xxx/</code>，启动 <code>tap ui</code>（桌面版）或你们自己的编辑器宿主调试</li>
    <li>注意：<strong>插件 SDK æ˜¯ netstandard2.0/net472 åŒç›®æ ‡</strong>，与你们 .NET Framework 4.7.2 ä¸»ç¨‹åºå…¼å®¹</li>
</ul>

<!-- ============================================================ -->
<h2 id="s8">8. Image API：安装目录状态管理</h2>

<p>OpenTAP 9.15+ å¼•å…¥ <code>OpenTap.Package.Image</code> æ¦‚念，把"安装目录当前状态"抽象成对象：</p>

<pre><code><span class="cmt">// ç¨‹åºåŒ–管理一个 OpenTAP å®‰è£…目录（CLI åº•å±‚就是它）</span>
<span class="kwd">var</span> image = <span class="kwd">new</span> Image(<span class="str">"C:/Program Files/OpenTAP"</span>);
image.InstallPackage(<span class="str">"MyCompany.CanDriver"</span>, <span class="str">"latest"</span>, <span class="str">"release"</span>);
image.QueryAvailable(<span class="str">"CAN"</span>);           <span class="cmt">// åˆ—出候选包</span>
image.UninstallPackage(<span class="str">"OldDriver"</span>);    <span class="cmt">// æŒ‰æ¸…单精确删除</span></code></pre>

<div class="info">对你们的价值：未来如果做"HMI å†…嵌驱动市场"，可以直接调 Image API å®žçŽ°<strong>界面里点几下完成驱动升级</strong>，无需运维介入。</div>

<!-- ============================================================ -->
<h2 id="s9">9. ä¸Ž TapProject çŽ°æœ‰æž¶æž„的映射与差距</h2>

<h3>9.1 æ¦‚念对照表</h3>
<table>
    <tr><th>TapProject çŽ°æœ‰</th><th>OpenTAP å¯¹åº”物</th><th>匹配度</th></tr>
    <tr><td>IDeviceDriver + DriverFactory switch</td><td>Instrument å­ç±» + PluginSearcher åå°„发现</td><td>✅ ç›´æŽ¥æ›¿æ¢</td></tr>
    <tr><td>DeviceConfig（SQLite DeviceDefinition）</td><td>BenchStore / ResourceSettings（XML settings store）</td><td>⚠️ éœ€è¦åŒå‘同步适配器</td></tr>
    <tr><td>IResourceManager é¢„约 + ResourceOwnerToken ç§Ÿçº¦</td><td>SynchronizationManager（仅进程内锁）</td><td>❌ OpenTAP æ²¡æœ‰è·¨è¿›ç¨‹/跨会话仲裁，<strong>必须保留你们的</strong></td></tr>
    <tr><td>IAutoDeviceFacade + IAutoDeviceLease（Per-Step）</td><td>TestStep å±žæ€§ç»‘定 Instrument + RequestLock</td><td>✅ è¯­ä¹‰ç­‰ä»·ï¼Œç§Ÿçº¦æ›´ç»†</td></tr>
    <tr><td>HMI æ’件 PluginLoader（WPF UI）</td><td>无对应（OpenTAP ä¸ç®¡ UI）</td><td>— ä¿æŒç‹¬ç«‹</td></tr>
    <tr><td>驱动分发=拷 DLL+重编译</td><td>.opentap åŒ… + tap package install + ç§æœ‰ä»“库</td><td>✅ æœ¬æ¬¡æ”¹é€ æ ¸å¿ƒæ”¶ç›Š</td></tr>
</table>

<h3>9.2 æ¡¥æŽ¥è®¾è®¡ï¼šåŒè½¨å¹¶è¡Œ</h3>
<div class="mermaid">
graph TB
    subgraph ç»Ÿä¸€å±‚["Aging.Infrastructure（保留）"]
        F["IAutoDeviceFacade"]
        L["IAutoDeviceLease"]
        RM["IResourceManager（跨会话仲裁）"]
    end
    subgraph é€‚配层["新增：Driver é€‚配"]
        REG["DriverRegistry<br/>反射扫描 Drivers/*.dll<br/>（阶段一，自研轻量）"]
        BRIDGE["TapInstrumentBridge<br/>OpenTAP Instrument â†” IDeviceDriver<br/>（阶段二，可选）"]
    end
    subgraph é©±åŠ¨ç”Ÿæ€["两种驱动形态并存"]
        D1["自研驱动<br/>IDeviceDriverProvider<br/>→ æ‰“ .opentap åŒ…分发"]
        D2["第三方 OpenTAP ä»ªå™¨åŒ…<br/>Keysight/NationalInstruments<br/>→ tap package install ç›´æŽ¥ç”¨"]
    end
    F --> RM
    F --> REG
    REG --> D1
    BRIDGE --> D2
    BRIDGE --> REG
</div>

<h3>9.3 ä¸‰ä¸ªå…³é”®å·®è·ä¸Žå¯¹ç­–</h3>
<table>
    <tr><th>差距</th><th>影响</th><th>对策</th></tr>
    <tr><td>OpenTAP æ— ç”Ÿäº§/维护互斥仲裁</td><td>全自动与手动调试可能撞车（正是你们做租约的动机）</td><td>保留 IResourceManager，在 Instrument.Open() é‡Œè°ƒç”¨ Reserve；Close() é‡Œ Release</td></tr>
    <tr><td>仪器配置双源（SQLite vs settings store）</td><td>注册页改端点、序列里用旧地址</td><td>以 DeviceConfig ä¸ºå”¯ä¸€çœŸæºï¼Œå†™ä¸€ä¸ªå¯¼å‡ºå™¨ç”Ÿæˆ <code>InstrumentSettings.xml</code>；或反向导入</td></tr>
    <tr><td>你们的 HMI å®¿ä¸» â‰  OpenTAP Editor</td><td>仪器下拉框在 WPF é‡Œä¸ä¼šè‡ªåŠ¨å‡ºçŽ°</td><td>你们的 DeviceEditModal ä»Ž DriverRegistry/PluginManager æžšä¸¾ç±»åž‹å¡«å…… ComboBox（已有 ForceRefreshForTest æ¨¡å¼ï¼ŒåŒç†ï¼‰</td></tr>
</table>

<!-- ============================================================ -->
<h2 id="s10">10. è½åœ°è·¯çº¿å»ºè®®ä¸Žæˆæœ¬è¯„ä¼°</h2>

<table>
    <tr><th>阶段</th><th>做什么</th><th>工作量</th><th>收益</th></tr>
    <tr>
        <td><strong>阶段 0（已完成）</strong></td>
        <td>AutoDeviceFacade + Lease + ç±»åž‹åŒ– CAN æœåŠ¡</td>
        <td>—</td>
        <td>调用体验已解决</td>
    </tr>
    <tr>
        <td><strong>阶段 1</strong></td>
        <td>自研 <code>IDeviceDriverProvider</code> + <code>DriverRegistry</code> åå°„扫描 <code>Drivers/*.dll</code>；<br>CAN é©±åŠ¨æ‹†æˆç‹¬ç«‹é¡¹ç›®ï¼ˆä¸¢ DLL å…ç¼–译主程序）</td>
        <td>~2-3 äººæ—¥</td>
        <td>解决"加驱动必须重编译"的 80% ç—›ç‚¹ï¼›æŠ€æœ¯æ ˆæ— å¼•å…¥</td>
    </tr>
    <tr>
        <td><strong>阶段 2</strong></td>
        <td>给每个驱动工程加 <code>package.xml</code>，用 <code>tap package create</code> äº§å‡º <code>.opentap</code>；搭内网私有仓库（文件服务器即可）</td>
        <td>~2 äººæ—¥</td>
        <td>版本化分发、依赖检查、现场 <code>tap package install</code> ä¸€é”®è£…</td>
    </tr>
    <tr>
        <td><strong>阶段 3（可选）</strong></td>
        <td><code>TapInstrumentBridge</code>：新真硬件仪器直接写 <code>Instrument</code> å­ç±»èµ° OpenTAP ç”Ÿæ€ï¼›æ¡¥æŽ¥å›ž IDeviceDriver å¤ç”¨ç§Ÿçº¦</td>
        <td>~5-10 äººæ—¥</td>
        <td>可直接复用 Keysight NI-DMM、Pickering å¼€å…³ç­‰æ•°ç™¾ä¸ªçŽ°æˆå®˜æ–¹åŒ…，<strong>省去自研 SCPI é©±åŠ¨</strong></td>
    </tr>
    <tr>
        <td><strong>阶段 4（远期）</strong></td>
        <td>HMI å†…嵌"驱动管理器"页面调 Image API åšç•Œé¢çº§å‡çº§</td>
        <td>~3 äººæ—¥</td>
        <td>运维自动化</td>
    </tr>
</table>

<div class="warn">
<strong>风险提示：</strong>
<ul>
    <li>阶段 1 åå°„加载若用 <code>Assembly.LoadFrom</code> ä¼šé”æ–‡ä»¶å¯¼è‡´æ— æ³•çƒ­æ›¿æ¢ï¼›å»ºè®® <code>AssemblyLoadContext</code>（.NET Core é£Žæ ¼ï¼Œnet472 æ— æ­¤ API â†’ é€€åŒ–为 <code>AppDomain</code> éš”离或接受"重启生效"）。</li>
    <li>OpenTAP 9.31 çš„ netstandard2.0 æ’件 SDK åœ¨ net472 è¿è¡Œæ­£å¸¸ï¼Œä½† <strong>不要假设</strong>其包管理器会管理 net472 ä¸»ç¨‹åºâ€”—它管理的是 OpenTAP å®‰è£…目录；你们主程序若要利用 .opentap，需要把引擎装成一个"嵌入式 OpenTAP ç›®å½•"。</li>
    <li>私有包仓库无鉴权时注意内网隔离；官方仓库地址可 <code>tap repo remove</code> ç¦ç”¨å¤–网访问。</li>
</ul>
</div>

<!-- ============================================================ -->
<h2 id="s11">11. ç»“论</h2>

<div class="success">
<ol>
    <li><strong>OpenTAP çš„ Instrument æ˜¯"资源型插件"</strong>：继承 <code>Instrument : Resource</code> å³è‡ªåŠ¨èŽ·å¾—发现、序列化绑定、生命周期托管；SCPI åœºæ™¯æœ‰å¼€ç®±å³ç”¨çš„ <code>ScpiInstrument</code>。</li>
    <li><strong>插件包（.opentap）是分发单元而非引用单元</strong>：ZIP + package.xml，依赖解析用 SemVer，平台差异化靠条件变量；安装到 <code>Packages/&lt;name&gt;/</code> éš”离目录，卸载精确按清单。</li>
    <li><strong>"免重编译加驱动"两条路都能走</strong>：轻量自研 DriverRegistry（阶段 1，立刻见效），或拥抱 OpenTAP åŒ…生态（阶段 2/3，长期收益大，可白嫖厂商官方驱动）。</li>
    <li><strong>你们的 IResourceManager ç§Ÿçº¦ä½“系是 OpenTAP ç¼ºå¤±çš„能力</strong>，改造中应保留并前移到 Instrument.Open()/Close() é’©å­ï¼Œè€Œä¸æ˜¯è¢«æ›¿ä»£ã€‚</li>
    <li><strong>推荐组合</strong>：阶段 1 å…ˆè¡Œï¼ˆ2-3 äººæ—¥è§£å†³ä¸»ç—›ç‚¹ï¼‰â†’ é˜¶æ®µ 2 ä¸Šç§æœ‰ä»“库（再 2 äººæ—¥ï¼‰â†’ æŒ‰çœŸå®žç¡¬ä»¶éœ€æ±‚决定是否进阶段 3。</li>
</ol>
</div>

<footer>
    OpenTAP Instrument + æ’件包机制分析 Â· TapProject é©±åŠ¨çƒ­æ’拔调研 Â· 2026-11-03<br>
    å‚考：opentap.io æ–‡æ¡£ã€github.com/opentap/opentap（package.xml / Engine/Instrument.cs æºç å®žæµ‹ï¼‰
</footer>

<script>
    mermaid.initialize({ 
        startOnLoad: true, theme: 'default', securityLevel: 'loose',
        fontFamily: 'Segoe UI, Microsoft YaHei, sans-serif',
        flowchart: { curve: 'basis', padding: 16 },
        sequence: { showSequenceNumbers: false, actorMargin: 50 }
    });
</script>

</body>
</html>

 docs/System_Architecture_V3_Restructured.html

New file
@@ -0,0 +1,578 @@
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>仪器注册与仪器调试 ç³»ç»Ÿæž¶æž„说明 Â· V3.0 é‡æ¢³ç†ç‰ˆ</title>
<script src="https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js"></script>
<style>
    * { box-sizing: border-box; }
    body {
        font-family: -apple-system, "Segoe UI", "Microsoft YaHei", "PingFang SC", sans-serif;
        max-width: 1240px; margin: 0 auto; padding: 32px 24px 80px;
        background: #FAFAFA; color: #212121; line-height: 1.75;
    }
    h1 { font-size: 29px; color: #1565C0; border-bottom: 3px solid #1976D2; padding-bottom: 12px; }
    h2 { font-size: 23px; color: #0D47A1; margin-top: 42px; padding-left: 12px; border-left: 4px solid #FF9800; }
    h3 { font-size: 17px; color: #37474F; margin-top: 26px; }
    h4 { font-size: 15px; color: #455A64; margin-top: 18px; }
    .subtitle { color: #757575; font-size: 14px; margin-bottom: 24px; }
    .card { background: white; border-radius: 8px; padding: 18px 22px; margin: 16px 0; box-shadow: 0 2px 8px rgba(0,0,0,0.06); }
    .highlight { background: #FFF8E1; border-left: 4px solid #FFC107; padding: 12px 16px; margin: 12px 0; border-radius: 4px; }
    .info { background: #E3F2FD; border-left: 4px solid #2196F3; padding: 12px 16px; margin: 12px 0; border-radius: 4px; }
    .success { background: #E8F5E9; border-left: 4px solid #4CAF50; padding: 12px 16px; margin: 12px 0; border-radius: 4px; }
    .warn { background: #FBE9E7; border-left: 4px solid #FF5722; padding: 12px 16px; margin: 12px 0; border-radius: 4px; }
    table { width: 100%; border-collapse: collapse; margin: 16px 0; background: white; border-radius: 6px; overflow: hidden; box-shadow: 0 1px 4px rgba(0,0,0,0.06); font-size: 13.5px; }
    th { background: #1976D2; color: white; padding: 9px 12px; text-align: left; font-weight: 600; }
    td { padding: 8px 12px; border-bottom: 1px solid #EEEEEE; vertical-align: top; }
    tr:nth-child(even) td { background: #FAFAFA; }
    tr:hover td { background: #E3F2FD; }
    code { font-family: "Consolas", "Monaco", monospace; background: #F5F5F5; color: #C62828; padding: 2px 6px; border-radius: 3px; font-size: 13px; }
    pre { background: #263238; color: #ECEFF1; padding: 16px 20px; border-radius: 6px; overflow-x: auto; font-family: "Consolas", monospace; font-size: 13px; line-height: 1.55; }
    pre code { background: transparent; color: inherit; padding: 0; font-size: 13px; }
    .mermaid { background: white; padding: 20px; border-radius: 8px; margin: 20px 0; text-align: center; box-shadow: 0 2px 8px rgba(0,0,0,0.06); overflow-x: auto; }
    ul { padding-left: 22px; } li { margin: 4px 0; }
    .toc { background: #F5F5F5; padding: 16px 24px; border-radius: 6px; margin: 20px 0; column-count: 2; column-gap: 40px; }
    .toc a { color: #1976D2; text-decoration: none; display: block; padding: 3px 0; break-inside: avoid; }
    .toc a:hover { text-decoration: underline; }
    .kwd { color: #FFCC80; } .str { color: #C5E1A5; } .cmt { color: #546E7A; } .fn { color: #82AAFF; } .num { color: #F78C6C; }
    .good { color: #2E7D32; font-weight: 600; } .bad { color: #C62828; font-weight: 600; } .mid { color: #EF6C00; font-weight: 600; }
    footer { margin-top: 60px; padding-top: 20px; border-top: 1px solid #E0E0E0; color: #757575; font-size: 12px; text-align: center; }
    .path { font-family: Consolas, monospace; font-size: 12.5px; background: #ECEFF1; color: #37474F; padding: 1px 6px; border-radius: 3px; }
    .iron { display:inline-block; background:#E8EAF6; color:#283593; border-radius:12px; padding:1px 10px; font-size:12px; font-weight:700; margin-right:6px; }
</style>
</head>
<body>

<h1>仪器注册与仪器调试 Â· ç³»ç»Ÿæž¶æž„说明（V3.0 é‡æ¢³ç†ç‰ˆï¼‰</h1>
<div class="subtitle">基于《Local + DeviceBroker æ··åˆæž¶æž„详细设计说明书 V3.0》对现有系统的一次完整重构叙述 â€”— å« TestStep ä»ªå™¨ä½¿ç”¨è§„范 Â· 2026-11-03</div>

<div class="toc">
    <a href="#s1">一、总定位：一句话读新架构</a>
    <a href="#s2">二、五域分层模型</a>
    <a href="#s3">三、仪器注册（DeviceConfig）的角色重塑</a>
    <a href="#s4">四、仪器调试（DeviceDebug）的角色重塑</a>
    <a href="#s5">五、进程拓扑与责任边界</a>
    <a href="#s6">六、接口契约演化映射（现有代码 â†’ V3.0）</a>
    <a href="#s7">七、三条核心数据流</a>
    <a href="#s8">八、保持不变的部分（架构连续性资产）</a>
    <a href="#s9">九、TestStep ä»ªå™¨ä½¿ç”¨è§„范</a>
    <a href="#s10">十、结论</a>
</div>

<!-- ======================================================== -->
<h2 id="s1">一、总定位：一句话读新架构</h2>

<div class="highlight">
<strong>配置域生产"不可变真理"，仲裁域守护"谁有权碰"，宿主域执行"谁来动手"，业务域决定"该不该判 FAIL"，数据域保证"事后能说清"。</strong>
<br><br>
仪器注册不再只是"增删改查表单"，而是配置域的<strong>发布管线</strong>；仪器调试不再只是"连上发命令"，而是仲裁域中一个特殊的写权限持有者（<strong>Maintenance Lease</strong>）。
</div>

<div class="card">
<strong>与旧架构的根本区别：</strong>旧架构里 DeviceConfig â†’ <code>data.db</code> â†’ DeviceDebug æ˜¯"两个模块共享一张表"的隐式契约；新架构里<strong>没有任何模块直接操作别人的库</strong>——注册产物是哈希锁定的快照，调试/生产消费的永远是快照 + ç§Ÿçº¦å¥æŸ„，物理 I/O æ°¸è¿œåªå‘生在唯一宿主内。
</div>

<!-- ======================================================== -->
<h2 id="s2">二、五域分层模型</h2>

<div class="mermaid">
graph TB
    subgraph D1["① é…ç½®åŸŸï¼ˆè®¾è®¡æ—¶ï¼‰"]
        CFG["DeviceConfig æ³¨å†Œé¡µ<br/>Draft â†’ Validated â†’ Published<br/>→ Prepared â†’ Effective â†’ Retired"]
        SNAP["config_snapshot（不可变+SHA256）<br/>resource_definition Â· slot_binding<br/>broker_task_template Â· effective_config"]
        CFG --> SNAP
    end
    subgraph D2["② ä»²è£åŸŸï¼ˆè¿è¡Œæ—¶ï¼‰"]
        LS["LeaseStore<br/>arb.db（Local åŸŸï¼‰<br/>broker-bxx.db（Broker åŸŸï¼‰"]
        RS["resource_state（generation/phase/epoch）<br/>parent_permit Â· lease_history"]
        ARB["LeaseArbiter<br/>优先级矩阵 Â· è®©æ¸¡ Â· æŠ¢å æ‹’绝"]
        LS --- RS
    end
    subgraph D3["③ æ‰§è¡Œå®¿ä¸»åŸŸï¼ˆç‰©ç† I/O）"]
        WKR["Worker Ã—6（W01–W06）<br/>Local è®¾å¤‡å”¯ä¸€å®¿ä¸»<br/>连接守卫 Mutex ä¸“用线程"]
        BRK["Broker Ã—3（B01–B03）+B00<br/>SessionActor Â· TaskScheduler<br/>Journal/Outbox Â· Watchdog"]
        DF["DriverFactory åˆ†åŒ–<br/>宿主驱动（载SDK） vs BrokerProxy（不载SDK）"]
    end
    subgraph D4["④ ä¸šåŠ¡æ‰§è¡ŒåŸŸ"]
        TAP["OpenTAP TestPlan / Recipe<br/>120 Ã— DUTContext（异步计时）<br/>逻辑能力绑定：空位+能力<br/>不选 COM / IP / è¿›ç¨‹"]
        RUNS["RunService<br/>中断窗口 Â· ç»­è·‘/重测决策"]
    end
    subgraph D5["⑤ æ•°æ®åŸŸ"]
        DB1[("aging_system.db<br/>配置+审计索引")]
        DB2[("arb.db / broker-bxx.db<br/>各守单写者")]
        DB3[("每 Run aging_data.db<br/>采样分片归档")]
    end
    SNAP -->|"冻结 RunSnapshot<br/>五元 Hash å¯¹è´¦"| TAP
    TAP -->|"AcquireGroup"| ARB
    ARB --> RS
    TAP -->|"DeviceOperation<br/>Grants+IdemKey"| WKR & BRK
    WKR & BRK --> DB2
    TAP --> DB3
    CFG --> DB1
</div>

<table>
    <tr><th>域</th><th>解决什么</th><th>核心产物</th><th>不变量</th></tr>
    <tr><td>① é…ç½®åŸŸ</td><td>物理世界的数字孪生 + ç”Ÿæ•ˆä»ªå¼</td><td>不可变快照 + Hash</td><td>INV-04 å¯åŠ¨åŽå†»ç»“ Recipe/Config/Driver/DBC/UDS/映射 Hash</td></tr>
    <tr><td>② ä»²è£åŸŸ</td><td>谁有权在这台仪器上发命令</td><td>LeaseGrant（每资源一代）</td><td>INV-02 é¢„约授权与命令串行化分层</td></tr>
    <tr><td>③ æ‰§è¡Œå®¿ä¸»åŸŸ</td><td>物理句柄独占 + åŽŸå­ç‰‡æ®µ</td><td>SessionGate + Task Journal</td><td>INV-01 åŒä¸€ PhysicalSessionKey åªæœ‰ä¸€ä¸ª I/O å®¿ä¸»</td></tr>
    <tr><td>④ ä¸šåŠ¡æ‰§è¡ŒåŸŸ</td><td>工艺编排与合格判定</td><td>Verdict / DUTContext</td><td>INV-05 å†™æ“ä½œåœ¨å®žé™…宿主入口校验，客户端仅提示</td></tr>
    <tr><td>⑤ æ•°æ®åŸŸ</td><td>事后追溯与容量治理</td><td>四库分离 + Outbox</td><td>INV-06 å·²å‘未回记 Unknown，禁止当未执行</td></tr>
</table>

<!-- ======================================================== -->
<h2 id="s3">三、仪器注册（DeviceConfig）的角色重塑</h2>

<h3>3.1 æ–°æ—§èŒè´£å¯¹ç…§</h3>
<table>
    <tr><th>维度</th><th>旧模型（现状代码）</th><th>V3.0 æ¨¡åž‹</th></tr>
    <tr><td>本质</td><td>设备信息 CRUD è¡¨å•</td><td><strong>配置发布管线</strong>（Draft→Validated→Published→Prepared→Effective→Retired）</td></tr>
    <tr><td>存储</td><td><code>DeviceDefinition</code> å¯å˜è¡Œï¼Œæ”¹äº†ç«‹å³ç”Ÿæ•ˆ</td><td><code>config_snapshot</code> <strong>不可变</strong>，<code>(config_hash, resource_key)</code> å¤åˆä¸»é”®ï¼Œå›žæ»šä¹Ÿæ–°å»ºç‰ˆæœ¬è®°å½•</td></tr>
    <tr><td>版本管理</td><td><code>SaveDraft/Publish/Apply</code> æ”¹çŠ¶æ€åˆ—</td><td>发布产物 = JSON å¿«ç…§ + SHA256；运行时冻结 RunSnapshot（Recipe/Driver/DBC/UDS/映射 äº”件套）</td></tr>
    <tr><td>设备标识</td><td>Endpoint å­—符串直写（<code>CAN_BUS_1:0</code>）</td><td><strong>EndpointRef</strong>（凭据/地址引用分离）+ <strong>PhysicalIdentity</strong>（SN ç‰©ç†èº«ä»½ï¼Œé˜²æ¢æœºåŽèº«ä»½æ¼‚移）</td></tr>
    <tr><td>工位绑定</td><td><code>SlotDeviceMapping</code> ä¸€å¼ æ˜ å°„表</td><td><code>slot_binding</code>（随快照版本化）+ 120 æ¡æ˜ å°„由公式生成器产出并离线校验</td></tr>
    <tr><td>冲突检测</td><td><code>DetectConflicts()</code> è·‘一次 SQL åˆ†ç»„</td><td>发布门禁：身份去重、驱动位数、能力覆盖、Authority ä¸€è‡´ã€<strong>同一 PhysicalSessionKey åªå…è®¸ä¸€ä¸ª I/O å®¿ä¸»ï¼ˆINV-01）</strong>，不过审禁止发布</td></tr>
</table>

<h3>3.2 è®¾å¤‡æ³¨å†Œé¡µéœ€æ–°å¢žçš„字段（改造清单）</h3>
<pre><code>executionMode       Local | Broker            <span class="cmt">// æŒ‰ç‰©ç†æ‹“扑决定，禁止运行时混用</span>
authorityId         broker-b01 / local-ipc01  <span class="cmt">// æ‰€å±žä»²è£åŸŸ</span>
brokerId            + ownerProcessId          <span class="cmt">// Broker åŸŸå½’属</span>
physicalSessionKey  psu01/main                <span class="cmt">// åŒä¸€ç‰©ç†è¿žæŽ¥æ ‡è¯†ï¼ˆSessionGate é”®ï¼‰</span>
physicalIdentity    serial:TBD-PSU01          <span class="cmt">// SN ç‰©ç†èº«ä»½ï¼›TBD ç¦æ­¢è¿‡å‘布门禁</span>
accessPolicy        Exclusive | ExclusiveChannelWithParentPermit
                    | TimeShared | SharedRead <span class="cmt">// ç‹¬å /分时的策略声明位置</span>
safeStateProfile    PSU-SAFE-001              <span class="cmt">// æ¢å¤/交接时的安全态模板</span>
leasePolicy         TTL / Renew / Handover    <span class="cmt">// å…¨å±€é»˜è®¤ + åŸŸçº§è¦†ç›–</span></code></pre>

<h3>3.3 å‘布流程（替代现在的"应用"按钮）</h3>
<div class="mermaid">
flowchart LR
    A[编辑草稿<br/>Draft] --> B[离线校验<br/>身份冲突/能力覆盖<br/>限值/驱动依赖]
    B --> C[Validated]
    C --> D["维护窗口探测<br/>连接/通道寻址/读回"]
    D --> E["Published<br/>不可变快照+Hash"]
    E --> F["分发 Prepare<br/>各宿主回执同 Hash"]
    F --> G["停机窗口 Apply<br/>停Run→撤写权→安全断连<br/>→各宿主Apply+自检"]
    G --> H{全部成功?}
    H -->|是| I["更新 Effective æŒ‡é’ˆ<br/>Run åˆ›å»ºæ—¶å¤åˆ¶å¿«ç…§"]
    H -->|部分失败| J["整组 ApplyFailed<br/>阻止 Run å¯åŠ¨<br/>统一回旧版或新版"]
    J -.-> F
</div>

<div class="info"><strong>关键语义变化：</strong>"生效"从一次 UPDATE å˜æˆä¸€åœºéœ€è¦<strong>所有宿主回执确认</strong>的两阶段仪式。旧稿 <code>ApplyVersion()</code> é‚£ç§å•ç‚¹æ”¹çŠ¶æ€çš„逻辑不复存在；既有 Run ç»§ç»­å¼•ç”¨æ—§ Hash，不允许静默切版。</div>

<!-- ======================================================== -->
<h2 id="s4">四、仪器调试（DeviceDebug）的角色重塑</h2>

<h3>4.1 æœ€é‡è¦çš„拆分：监控 â‰  å†™æƒé™</h3>
<div class="mermaid">
graph TB
    OLD["旧模型：选设备 â†’ OpenSession(ReadOnly)<br/>→ [RequestMaintenance â†’ Activate] â†’ å‘命令<br/>⚠️ ç›‘控和写权限混在同一个会话状态机里"]
    OLD ==> NEW1["新模型 Â· ç›‘控通路（常驻，无租约）<br/>宿主状态缓存 / Telemetry Fanout â†’ DeviceMonitorView<br/>数据带 æ¥æº+质量+序列号+时间；Gap å¿…须显式呈现"]
    OLD ==> NEW2["新模型 Â· å†™æƒé™é€šè·¯ï¼ˆç»´æŠ¤ä¼šè¯ = ç”³è¯· Maintenance ç§Ÿçº¦ï¼‰<br/>必须经过仲裁域：看占用 â†’ Draining â†’ æŽ’空 â†’ å®‰å…¨ç¡®è®¤ â†’ Grant"]
</div>

<h3>4.2 ç»´æŠ¤ä¼šè¯çŠ¶æ€æœºï¼ˆå¯¹çŽ°æœ‰ DebugSessionState çš„扩展）</h3>
<div class="mermaid">
stateDiagram-v2
    [*] --> ViewOnly: æ‰“开设备(仅监控)
    ViewOnly --> Requested: ç”³è¯·ç»´æŠ¤(填理由)
    Requested --> Draining: Run协调安全暂停该空位
    Draining --> MaintenanceActive: æŽ’空+安全动作读回+旧句柄关闭\n+Mutex守卫移交+联锁手续确认
    Draining --> RecoveryRequired: äº¤æŽ¥è¶…æ—¶(30s)
    RecoveryRequired --> ViewOnly: æ¢å¤æ ¸å¯¹å®Œæˆ\n(不能因"等了30秒"直接给维护者—INV-03)
    MaintenanceActive --> Exiting: é€€å‡ºç»´æŠ¤
    Exiting --> Released: è¯»å›žå¤æ ¸+恢复通信配置+报警基线
    Released --> [*]: RunService显式恢复或新建Run
</div>

<table>
    <tr><th>现有状态/方法</th><th>V3.0 åŽ»å‘</th></tr>
    <tr><td>ReadOnly / OpenSession</td><td>拆为 ViewOnly（监控）+ Requested（写权申请）两个概念</td></tr>
    <tr><td>RequestMaintenance（内存 Reserve）</td><td>进入仲裁域：显示占用者/Run/DUT/剩余租约/父子影响 â†’ Draining</td></tr>
    <tr><td>ActivateMaintenance</td><td>仅在"排空 + å®‰å…¨åŠ¨ä½œè¯»å›ž + æ—§å¥æŸ„/守卫确认"后签发维护 Grant</td></tr>
    <tr><td>CloseSession（释放内存字典）</td><td>升级为"排空 I/O + ç‰©ç†è¯»å›ž + ReleaseAsync"三步，失败进 RecoveryRequired è€Œéžå‡è£…成功</td></tr>
    <tr><td>Faulted / RecoveryRequired</td><td>语义保留，但进入路径增加：交接超时、续期失败、释放失败</td></tr>
</table>

<h3>4.3 "强制释放"按钮的正确语义</h3>
<div class="warn">
<strong>旧直觉：</strong>Admin ç‚¹ä¸€ä¸‹ â†’ UPDATE/DELETE ç§Ÿçº¦è¡Œ â†’ è®¾å¤‡å½’我。<br>
<strong>V3.0：</strong>Force release <strong>只能触发"隔离 + æ¢å¤æµç¨‹"</strong>——先在物理层确认旧 I/O å·²ç»ˆæ­¢ï¼ˆæ—§è¿›ç¨‹å¥æŸ„关闭、Named Mutex å¯èŽ·å–、设备输出读回），否则宁可保持 RecoveryRequired。多人作业、拔线、接线的许可<strong>不由软件 token å•ç‹¬åˆ¤å®š</strong>（INV-07：软件租约不替代断电与硬件联锁）。
</div>

<h3>4.4 å®¡è®¡å‡çº§</h3>
<p><code>debug_operation</code> ä¿ç•™ï¼Œæ–°å¢žä¸¤åˆ—：<code>lease_generation</code>（哪一代持有者）、<code>idempotency_key</code>（重试去重，UNIQUE éƒ¨åˆ†ç´¢å¼•ï¼‰ã€‚任何一条历史指令可回答：<strong>谁（OwnerId+Principal）、以哪次授权（Grant å¿«ç…§ï¼‰ã€åœ¨å“ªä¸ªé…ç½®ç‰ˆæœ¬ï¼ˆConfigHash）下、是否可能被重复执行过</strong>。</p>

<!-- ======================================================== -->
<h2 id="s5">五、进程拓扑与责任边界</h2>

<div class="mermaid">
graph TB
    HMI["HMI è¿›ç¨‹ï¼ˆå·¥ç¨‹å¸ˆ/操作员）<br/>DeviceConfigView â‘  Â· DeviceDebugView â‘¡<br/>DeviceMonitorView â‘¢ (新建)"]
    W["Worker Ã—6（W01–W06，每20空位）<br/>Local è®¾å¤‡ I/O å®¿ä¸»ï¼ˆè¿žæŽ¥å®ˆå« Mutex ä¸“用线程）<br/>DUTExecution çŠ¶æ€æœº / æ­¥éª¤å¼•æ“Žï¼ˆOpenTAP）<br/>独立续期任务（不占UI；失败立即阻断新操作）"]
    B["Broker Ã—3（B01–B03）+ å¯é€‰ B00（全局共享域）<br/>共享会话设备唯一 I/O å®¿ä¸»<br/>SessionActor（每真连接单队列，一次一段原子 I/O）<br/>Task执行 Â· Journal/Outbox单写器 Â· Recovery检查点"]
    SUP["Supervisor<br/>单实例守卫 Â· é™é¢‘拉起 Â· epoch æå‡"]
    DEV["物理设备<br/>工位专用电源(Local) / å¤šé€šé“PSU·CAN·温箱·PLC(Broker)"]
    HMI -->|"配置发布/维护申请(申请只到仲裁域)"| W & B
    W -->|"Local直连"| DEV
    B -->|"唯一句柄"| DEV
    SUP -.->|看护| W & B
</div>

<table>
    <tr><th>进程</th><th>职责</th><th>明确不做</th></tr>
    <tr><td>HMI</td><td>配置视图、维护写权申请、只读监控</td><td>不持有生产设备的物理连接</td></tr>
    <tr><td>Worker</td><td>Local è®¾å¤‡å®¿ä¸» + æœ¬ç©ºä½ç»„步骤引擎 + å¼‚步等待（120 ç©ºä½ â‰  120 çº¿ç¨‹ï¼‰</td><td>不加载共享设备的 SDK</td></tr>
    <tr><td>Broker</td><td>共享会话设备唯一 I/O å®¿ä¸»ã€Task æœ‰ç•Œæ‰§è¡Œã€å‘¨æœŸä»»åŠ¡ã€è®¢é˜…遥测</td><td><strong>不做 DUT åˆæ ¼åˆ¤å®šã€ä¸è£…整条 Recipe、不管 MES äº‹åŠ¡</strong>（不是第二套测试引擎）</td></tr>
    <tr><td>Supervisor</td><td>拉起、限频防快速重启循环、epoch ç®¡ç†</td><td>不执行业务命令</td></tr>
</table>

<div class="highlight"><strong>边界铁律：</strong>
<ul>
<li>Recipe/步骤引擎<strong>从不</strong>直接选 COM å£/IP/进程——只写"空位 S024 + èƒ½åŠ› Power"，由 SnapshotResolver + ResourceRouter æŒ‰å†»ç»“版本解析出资源集与宿主；</li>
<li>跨域多资源组申请 = åè°ƒå¼é¢„留（Prepare→Activate，任一失败 Abort），<strong>不承诺跨库原子</strong>；严格全有全无的动作必须落在同一 Broker åŸŸæˆ–打包成一个 Task；</li>
<li>SQLite ä¸€å¾‹æœ¬æœºç£ç›˜ï¼Œç¦æ­¢ SMB/NAS å¤šæœºå…±å†™ï¼›è¿žæŽ¥æ˜¾å¼ <code>foreign_keys/busy_timeout</code>；事务内禁做 I/O。</li>
</ul></div>

<!-- ======================================================== -->
<h2 id="s6">六、接口契约演化映射（现有代码 â†’ V3.0）</h2>

<table>
    <tr><th>现有实现（本仓库）</th><th>V3.0 åŽ»å‘</th><th>变化性质</th></tr>
    <tr>
        <td><span class="path">Core/ResourceManager.cs</span>（内存 Reserve/Release/ValidateOwner）</td>
        <td>旧单资源方法保留为过渡 Adapter；新增 <code>IResourceCoordinator</code>（AcquireGroup / RenewGroup / RequestHandover）</td>
        <td class="mid">兼容扩展</td>
    </tr>
    <tr>
        <td><span class="path">Contracts/ResourceOwnerToken.cs</span>（单一可变 Generation）</td>
        <td>业务元数据保留；I/O æ”¹ç”¨<strong>每资源独立 LeaseGrant</strong>（AuthorityId / Epoch / LeaseId / Generation / ExpiresUtcMs）</td>
        <td class="bad">破坏性：一 owner å¤šèµ„源不能共用 Generation</td>
    </tr>
    <tr>
        <td><span class="path">Services/AutoDeviceFacade.cs</span> + IAutoDeviceLease（同步 Dispose é˜»å¡žé‡Šæ”¾ï¼‰</td>
        <td>门面语义保留；Lease æ³¨å…¥ç‹¬ç«‹ç»­æœŸä»»åŠ¡ + <code>LeaseLost</code> ä¿¡å· + <code>HandoverRequested</code>；Dispose æ”¹æ˜¾å¼å¼‚æ­¥ Release（失败可查询、进恢复）</td>
        <td class="mid">语义增强</td>
    </tr>
    <tr>
        <td><span class="path">Services/DeviceService.cs</span>（deviceId+command+token è£¸å‘½ä»¤ï¼‰</td>
        <td>升级为 <code>IDeviceExecutor</code>：类型化 OpCode + Grants é›† + IdempotencyKey + Deadline；raw command ä»…保留受控维护入口</td>
        <td class="bad">生产路径重构</td>
    </tr>
    <tr>
        <td><span class="path">Drivers/DriverFactory.cs</span>（静态 switch）</td>
        <td>区分<strong>宿主驱动</strong>（Local/Broker å†…加载 SDK）与 <strong>BrokerProxy</strong>（客户端，不加载 SDK）；配合 .opentap åŒ…分发（见姊妹篇）</td>
        <td class="mid">分发解耦</td>
    </tr>
    <tr>
        <td><span class="path">Plugin.DeviceDebug/Model/DebugSessionManager.cs</span></td>
        <td>增 Draining / RecoveryRequired；恢复时<strong>不可重造 owner token</strong>，必须使用持久化 Grant；监控与写权限分离</td>
        <td class="mid">状态扩展</td>
    </tr>
    <tr>
        <td><span class="path">Plugin.DeviceConfig/Model/DeviceConfigModel.cs</span>（DetectConflicts/SaveDevice）</td>
        <td>冲突检测移入发布门禁（离线校验 + ç»´æŠ¤çª—口探测）；可变表升级为不可变快照</td>
        <td class="mid">位置前移</td>
    </tr>
    <tr>
        <td><span class="path">data.db</span>（一库三用）+ debug.db</td>
        <td>拆四库：aging_system.db / arb.db / broker-bxx.db / æ¯Run aging_data.db</td>
        <td class="bad">最大的一次性工程：存储边界重组</td>
    </tr>
    <tr>
        <td><span class="path">ConnectionUtil/PipeClient.cs</span></td>
        <td>V3.0 Â§13 è®¤å®šå…¶"响应不可达"（SendMessage å†™åŽç›´æŽ¥ return，读取为死代码）、serverName æœªç”Ÿæ•ˆâ€”—修复后方可作为 IPC å€™é€‰åŸºç¡€</td>
        <td class="bad">P0 å‰ç½®ä¿®å¤é¡¹</td>
    </tr>
</table>

<div class="info"><strong>建议：</strong>契约（ILeaseScope / LeaseGrant / DeviceOperation / IDeviceExecutor / BrokerTaskRequest ç­‰ï¼‰æŠ½å‡ºä¸ºç‹¬ç«‹ç±»åº“ <span class="path">Aging.ResourceContracts</span>，避免 Broker / Worker / HMI ä¸‰ç«¯äº’带 WPF ä¾èµ–。</div>

<!-- ======================================================== -->
<h2 id="s7">七、三条核心数据流</h2>

<h3>7.1 ç”Ÿäº§å†™å‘½ä»¤ï¼ˆä»Žæ­¥éª¤åˆ°ç‰©ç† I/O çš„完整一跳链）</h3>
<div class="mermaid">
sequenceDiagram
    autonumber
    participant STEP as TestStep<br/>(④业务域)
    participant CO as IResourceCoordinator<br/>(②仲裁域)
    participant EX as IDeviceExecutor<br/>(③宿主域)
    participant SG as SessionGate/Actor<br/>(③宿主域)
    participant DRV as å®¿ä¸»é©±åŠ¨
    participant DB as è¿è¡Œåº“(Journal/Outbox)

    STEP->>CO: AcquireGroup(资源集, OwnerKind=Production, ConfigHash)
    CO->>DB: BEGIN IMMEDIATE äº‹åŠ¡CAS(逐资源 Free→Active, generation+1)<br/>+ parent_permit æ£€æŸ¥ + lease_history
    DB-->>CO: æäº¤æˆåŠŸ
    CO-->>STEP: ILeaseScope（Grants + ç»­æœŸä»»åŠ¡ + LeaseLost）
    STEP->>EX: DeviceOperation(OpCode, Params, IdemKey, Grants, Deadline)
    EX->>EX: å…¥é˜Ÿæ ¡éªŒ: grant集/epoch/ConfigHash/deadline/连接身份
    EX->>SG: å‡ºé˜ŸæŒé—¨: [选通道→写→读响应] åŽŸå­ç‰‡æ®µ
    SG->>DB: MarkRunning å…ˆæŒä¹…化（I/O ä¹‹å‰ï¼‰
    SG->>DRV: ç‰©ç†æ‰§è¡Œ
    DRV-->>SG: è¯»å›žå€¼
    SG->>DB: åŒäº‹åŠ¡æäº¤ Task终态+事件+Outbox
    SG-->>STEP: OperationResult(Readback, Quality)
    Note over STEP: åˆ¤å®š PASS/FAIL åœ¨æ­¥éª¤/引擎（INV-05/T-3）
    STEP->>CO: ReleaseAsync（排空→读回/交接→释放）
</div>

<h3>7.2 ç»´æŠ¤äº¤æŽ¥ï¼ˆæ‘˜è¦ï¼Œå¯¹åº”文档 14.2 å…­æ­¥ï¼‰</h3>
<div class="card">
占用可见化（Run/DUT/剩余租约/父子影响）→ Run åè°ƒå®‰å…¨æš‚停，资源转 <code>Draining</code>，拒新写、停周期 â†’ ç­‰åœ¨é€”片段结束 + æ‰§è¡Œ SafeStateProfile å¹¶è¯»å›žï¼ˆè¶…æ—¶ â†’ <code>RecoveryRequired</code>，<strong>不等于</strong>自动给维护者）→ æ—§ owner æŽ’空释放 + æ—§å¥æŸ„关闭 + Mutex å®ˆå«å¯èŽ·å– â†’ ç‹¬ç«‹è”锁/断电手续确认 â†’ ç­¾å‘维护 Grant，动作全量审计；退出维护反向复核后才交还生产。
</div>

<h3>7.3 Broker é‡å¯æ¢å¤</h3>
<div class="card">
取单实例守卫 â†’ <strong>epoch+1 è½ç›˜</strong>（旧 Grant/排队任务全部失效）→ é˜»æ–­æ™®é€šå†™ â†’ è®¾å¤‡èº«ä»½éªŒè¯ â†’ è¯»å›žè¾“出/通道/协议状态 â†’ æŒ‰è®¾å¤‡å®‰å…¨æ¨¡æ¿æ¢å¤ï¼ˆ<strong>安全态 â‰  ç»Ÿä¸€"输出全关"</strong>：温箱、冷却、被测件各有要求）→ æ¢å¤æ£€æŸ¥ç‚¹ä¸Žè¯æ®æŒä¹…化（需人工审批则等待）→ Free/Ready â†’ RunService è®°å½•ä¸­æ–­çª—口与数据 Gap，决定续跑/重测。
</div>

<!-- ======================================================== -->
<h2 id="s8">八、保持不变的部分（架构连续性资产）</h2>

<div class="success">
<ol>
<li><strong>插件化 UI éª¨æž¶</strong>：SimpleMaskControl / PluginLoader / MVVM å…¨éƒ¨ä¿ç•™ï¼Œä¸‰ä¸ªè§†å›¾ä»æ˜¯çƒ­æ’拔插件（注意现状命名对齐：实际为 <code>Plugin.DeviceConfig.DeviceConfig</code> ç­‰ï¼Œä¸” <code>DeviceMonitorView</code> éœ€æ–°å»ºï¼‰ï¼›</li>
<li><strong>SQLite æŠ€æœ¯é€‰åž‹</strong>（本机盘 + WAL + çŸ­äº‹åŠ¡ + busy_timeout），但数据库边界重划；</li>
<li><strong>调试会话"状态机 + å®¡è®¡"设计思想</strong>——V3.0 æ˜¯åŠ çŠ¶æ€ï¼Œä¸æ˜¯æŽ¨ç¿»ï¼›</li>
<li><strong>Draft/Published/Effective ç‰ˆæœ¬ç†å¿µ</strong>——升级为不可变快照 + å“ˆå¸Œå¯¹è´¦ï¼›</li>
<li><strong>全自动门面 B+C æ¨¡å¼</strong>（作用域租约 + ç±»åž‹åŒ–服务，本项目已实现）——正是 V3.0 <code>ILeaseScope + DeviceOperation</code> çš„雏形。</li>
</ol>
</table>
</div>

<!-- ======================================================== -->
<h2 id="s9">九、TestStep ä»ªå™¨ä½¿ç”¨è§„范（业务执行域使用视图）</h2>

<p>前八章定义“系统与职责”，本章定义“使用者怎么写”——Recipe/TestStep é¢å‘测试开发人员的<strong>使用契约</strong>。</p>

<h3>9.1 ä¸‰æ¡é“å¾‹ï¼ˆå…ˆç«‹è§„矩）</h3>
<table>
    <tr><th>#</th><th>铁律</th><th>原因</th></tr>
    <tr><td><span class="iron">T-1</span></td>
        <td>TestStep <strong>永不</strong>直接 new é©±åŠ¨ã€å¡« COM å£ã€IP åœ°å€ã€è¿›ç¨‹å</td>
        <td>物理路由属于配置域（冻结快照）；写死在步骤里 = æ¢å°æž¶å…¨é‡æ”¹åºåˆ—，且破坏 INV-01/04</td></tr>
    <tr><td><span class="iron">T-2</span></td>
        <td>TestStep <strong>永不</strong>自己调 ResourceManager.Reserve / æ‹¼ LeaseGrant</td>
        <td>租约生命周期归框架（Scope + ç‹¬ç«‹ç»­æœŸä»»åŠ¡ï¼‰ï¼Œæ­¥éª¤è‡ªå·±æ‹¿ç§Ÿçº¦å¿…然忘续期/忘释放</td></tr>
    <tr><td><span class="iron">T-3</span></td>
        <td>TestStep <strong>永不</strong>把 Broker è¯»å›žå€¼ç›´æŽ¥å½“合格判定</td>
        <td>“数据从哪来、新不新鲜”是宿主责任；“是否达到工艺条件”是步骤/引擎判定（§20.6 åˆ†æƒï¼‰</td></tr>
</table>

<h3>9.2 è§£æžé“¾ï¼šæ­¥éª¤å£°æ˜Žé€»è¾‘能力，框架解析物理资源</h3>
<div class="mermaid">
flowchart LR
    A["TestStep å£°æ˜Ž<br/>SlotId=S024, Capability=Power"] --> B["SnapshotResolver<br/>（Run启动时已冻结 RunSnapshot）"]
    B --> C["slot_binding<br/>S024+Power â†’ psu/psu03/ch/5<br/>+ çˆ¶ Permit psu/psu03"]
    C --> D["ResourceRouter<br/>resource_definition:<br/>executionMode=Broker, authority=B01"]
    D --> E1["LocalExecutor（W0x）"]
    D --> E2["BrokerClient（B01）"]
    style A fill:#E8F5E9
    style E1 fill:#FFF8E1
    style E2 fill:#FFF8E1
</div>
<p>步骤作者面对的只有两个概念：<strong>空位号 + èƒ½åŠ›å</strong>。DUTContext æ¯ç©ºä½ç‹¬ç«‹ä¿å­˜ SN/步骤/计时/结果，<strong>120 ä¸ªç©ºä½ â‰  120 æ¡çº¿ç¨‹</strong>（等待用异步计时）。</p>

<h3>9.3 ä¸‰ç§ä½¿ç”¨æ¨¡å¼</h3>

<h4>模式 B（首选）：作用域租约 â€”— ä¸€ä¸ªæ­¥éª¤å¤šæ¬¡æ“ä½œåŒä¸€èµ„源</h4>
<pre><code><span class="cmt">// net472 æ—  await using，显式 ReleaseAsync + try/finally</span>
<span class="kwd">public override async void</span> Run()
{
    <span class="kwd">var</span> req = <span class="kwd">new</span> AcquireRequest {
        OwnerId           = RunContext.StationId,          <span class="cmt">// å¦‚ "W02.Run-20261103-A"</span>
        OwnerKind         = OwnerKind.Production,
        ProcessInstanceId = RunContext.ProcessInstanceId,  <span class="cmt">// boot_id+pid，防串台</span>
        ConfigHash        = RunContext.RunSnapshot.ConfigHash,
        ResourceKeys      = <span class="kwd">new</span>[] { <span class="str">"psu/psu03/ch/5"</span>, <span class="str">"can/can01/ch/2"</span> }, <span class="cmt">// æ¡†æž¶æŒ‰åºå±•å¼€ç»„申请</span>
        WaitTimeoutMs     = <span class="num">60_000</span>
    };

    ILeaseScope scope = <span class="kwd">null</span>;
    <span class="kwd">try</span>
    {
        scope = <span class="kwd">await</span> coordinator.<span class="fn">AcquireGroupAsync</span>(req, ct);   <span class="cmt">// åŒåŸŸï¼šäº‹åŠ¡å…¨æœ‰å…¨æ— ï¼›è·¨åŸŸï¼šåè°ƒå¼é¢„ç•™</span>
        <span class="cmt">// LeaseLost ä¿¡å·ï¼šç»­æœŸå¤±è´¥/被隔离 â†’ ç«‹å³åœæ­¢ä¸‹å‘</span>
        <span class="kwd">var</span> ioCts = CancellationTokenSource.<span class="fn">CreateLinkedTokenSource</span>(ct, scope.LeaseLost);

        <span class="kwd">var</span> psu = executorFactory.<span class="fn">For</span>(scope, <span class="str">"psu/psu03/ch/5"</span>); <span class="cmt">// Local/Broker è·¯ç”±å¯¹æ­¥éª¤é€æ˜Ž</span>
        <span class="kwd">await</span> psu.<span class="fn">SetVoltageAsync</span>(<span class="num">12.0</span>, ctx.<span class="fn">NextIdempotencyKey</span>(), ioCts.Token);
        <span class="kwd">await</span> psu.<span class="fn">OutputOn</span>(ioCts.Token);
        <span class="kwd">var</span> v = <span class="kwd">await</span> psu.<span class="fn">ReadVoltage</span>(ioCts.Token);

        Upwards.<span class="fn">Find</span>(<span class="num">12.0</span>, v.Readback).Verdict =               <span class="cmt">// â† åˆ¤å®šåœ¨å¼•æ“Žä¾§ï¼ˆT-3）</span>
            Math.<span class="fn">Abs</span>(v.Readback - <span class="num">12.0</span>) &lt;= <span class="num">0.5</span> ? Verdict.Pass : Verdict.Fail;
    }
    <span class="kwd">finally</span>
    {
        <span class="cmt">// æ˜¾å¼å¼‚步释放：排空 I/O â†’ è¯»å›ž/安全交接 â†’ é‡Šæ”¾ï¼›</span>
        <span class="cmt">// å¤±è´¥è¿›æ¢å¤ï¼Œç»ä¸å‡è£…成功；终态保存用独立有界 token，不受调用方取消影响</span>
        <span class="kwd">if</span> (scope != <span class="kwd">null</span>)
            <span class="kwd">await</span> scope.<span class="fn">ReleaseAsync</span>(CancellationToken.None);
    }
}</code></pre>

<h4>模式 C（常用封装）：类型化服务 + åŒç­¾å</h4>
<pre><code><span class="cmt">// ç‹¬ç«‹è°ƒç”¨ï¼ˆæ¡†æž¶å†…部走完 ç”³è¯·â†’执行→释放）——适合单命令步骤</span>
<span class="kwd">await</span> canBus.<span class="fn">SendFrameAsync</span>(<span class="str">"CAN-001"</span>, <span class="num">0x100</span>, data, ct);

<span class="cmt">// å€Ÿç”¨ä½œç”¨åŸŸï¼ˆæŽ¨èï¼šä¸Žæ¨¡å¼B组合，复用已持有租约）</span>
<span class="kwd">await</span> canBus.<span class="fn">SendFrameAsync</span>(scope.<span class="fn">LeaseOf</span>(<span class="str">"can/can01/ch/2"</span>), <span class="num">0x100</span>, data, ct);</code></pre>

<h4>模式选择速查</h4>
<table>
    <tr><th>场景</th><th>模式</th></tr>
    <tr><td>单条查询类步骤（如扫一条 UDS DID）</td><td>A ä¸€æ¬¡æ€§</td></tr>
    <tr><td>多命令原子工艺段（上电→设压→读数→关输出）</td><td class="good">B ä½œç”¨åŸŸï¼ˆ+C å°è£…）</td></tr>
    <tr><td>跨资源联动（同一 DUT ç”µæº + CAN）</td><td class="good">B ç»„申请（同域才承诺全有全无）</td></tr>
    <tr><td>周期性激励 / é•¿æ—¶ç›‘控</td><td>B + Â§9.6 åŽå°ä»»åŠ¡æ¨¡æ¿ï¼Œ<strong>不是循环 A</strong></td></tr>
</table>

<h3>9.4 å¹‚等键与超时重试规范</h3>
<pre><code><span class="cmt">// é”®çš„生成规则：全局唯一、可重放定位、重试不换内容只增 attempt åºå·</span>
<span class="kwd">string</span> idemKey = $<span class="str">"{RunId}/{DutExecId}/{StepExecId}/attempt-{attempt}"</span>;</code></pre>
<table>
    <tr><th>动作类型</th><th>超时后可自动重发？</th><th>依据</th></tr>
    <tr><td>设置型（SetVoltage=12.0）</td><td class="good">✅ å…ˆ Query å¯¹è´¦å†é‡å‘</td><td>幂等，重复执行结果同</td></tr>
    <tr><td>触发/复位/烧写/计数型</td><td class="bad">❌ åªèƒ½æŒ‰ Unknown èµ°è¯»å›žæ ¸å¯¹</td><td>文档 Â§11.2：跨执行与提交之间无硬件事务，不承诺 exactly-once</td></tr>
    <tr><td>任意动作，结果未收到</td><td class="mid">先同键 Query/重提，Journal æœ‰ç»ˆæ€è¿”回原结果</td><td>§20.4：绝不生成新键再触发一次</td></tr>
</table>
<p>客户端重连必须<strong>保留原 ClientInstanceId æŸ¥è¯¢</strong>，不生成新键重发。</p>

<h3>9.5 äº¤æŽ¥ã€ç»­æœŸä¸Ž LeaseLost：步骤作者的义务</h3>
<table>
    <tr><th>框架职责</th><th>步骤职责</th></tr>
    <tr><td>后台独立线程续期（TTL/3）</td><td>监听 <code>scope.LeaseLost</code>，联进所有下发的 CTS</td></tr>
    <tr><td>Draining é€šçŸ¥ï¼ˆç»´æŠ¤è€…申请进入）</td><td>只在【步骤边界】让渡，绝不在半条命令间放手</td></tr>
    <tr><td>续期连续失败 2 æ¬¡ â†’ LeaseLost</td><td>立即停止下发新操作</td></tr>
    <tr><td>Release å¤±è´¥</td><td>如实上报，等待恢复，不“记日志后继续”</td></tr>
</table>
<pre><code><span class="cmt">// æ­¥éª¤æ”¶å°¾ç‚¹æ£€æŸ¥ï¼ˆæ¡†æž¶åœ¨ HandoverRequested æ—¶ç½®ä½ï¼‰</span>
<span class="kwd">if</span> (scope.HandoverRequested) <span class="kwd">return</span>;  <span class="cmt">// æœ¬æ­¥éª¤æ­£å¸¸ç»“束，作用域退出时安全让渡</span>
<span class="cmt">// æ³¨æ„ï¼šé•¿ Delay åº”拆成可中断的异步等待片段，保证 30s handover çª—口内能到达边界</span></code></pre>
<div class="info"><strong>取消的三种语义</strong>（框架已处理，作者只需知道）：排队中取消 = ç¡®å®šæœªæ‰§è¡Œï¼›æ‰§è¡Œä¸­å–消 = éœ€é©±åŠ¨å®‰å…¨åœæ­¢ç¡®è®¤ï¼›å“åº”等待取消 = åªæ˜¯ä¸ç­‰äº†ï¼Œ<strong>不能反推设备没动</strong>——结果仍走 Unknown/读回通道。</div>

<h3>9.6 é•¿å‘¨æœŸä»»åŠ¡ï¼šäº¤ç»™ Broker，步骤不养线程</h3>
<table>
    <tr><th>需求</th><th>❌ é”™è¯¯åšæ³•</th><th>✅ æ­£ç¡®åšæ³•ï¼ˆTask ç±»åž‹ï¼‰</th></tr>
    <tr><td>CAN å‘¨æœŸå‘送 0x100@100ms</td><td>TestStep å†… while+Sleep</td><td><strong>PeriodicTx</strong> æ¨¡æ¿é©»ç•™ Broker，随 owner ç§Ÿçº¦å­˜ç»­/到期/失效；禁止重连后补发旧帧</td></tr>
    <tr><td>老化期间监控总线信号</td><td>120 ç©ºä½è½®è¯¢çº¿ç¨‹</td><td><strong>Acquisition</strong> è®¢é˜… + äº‹ä»¶æ¸¸æ ‡å¢žé‡æ‹‰å–；数据 Gap å¸¦è´¨é‡æ ‡è®° Stale/Disconnected</td></tr>
    <tr><td>UDS ä¼šè¯ä¿æ´»</td><td>步骤定时器发 TesterPresent</td><td><strong>ProtocolSession</strong>：会话归一调度，TesterPresent ä¸Žä¸šåŠ¡åŠ¨ä½œåŒé˜Ÿ</td></tr>
    <tr><td>等 30 åˆ†é’Ÿ</td><td>Thread.Sleep å çº¿ç¨‹</td><td>异步计时留在执行引擎（Recipe çš„é•¿ Delay <strong>不进 Broker</strong>——Broker åªåšæœ‰ç•Œè®¾å¤‡åŠ¨ä½œï¼‰</td></tr>
</table>
<pre><code><span class="cmt">// æ­¥éª¤ä¾§è®¢é˜…形态：提交-查询-ACK，不驻留</span>
<span class="kwd">var</span> sub = <span class="kwd">await</span> broker.<span class="fn">SubscribeAsync</span>(<span class="kwd">new</span> { resource = <span class="str">"can/can01/ch/2"</span>,
    signal = <span class="str">"Motor.Temp"</span>, templateId = <span class="str">"can.acq.motor-temp"</span> }, ct);

<span class="cmt">// ç­‰å¾…信号达标（判定仍在引擎）</span>
<span class="kwd">var</span> sample = <span class="kwd">await</span> sub.<span class="fn">WaitMatchingAsync</span>(s =&gt; s.Value &gt; <span class="num">85.0</span>, TimeSpan.<span class="fn">FromMinutes</span>(<span class="num">30</span>), ct);
<span class="kwd">if</span> (sample == <span class="kwd">null</span>) Upwards.<span class="fn">Find</span>().<span class="fn">Fail</span>(<span class="str">$"超时未达85℃，Gap={sub.GapCount}"</span>);

<span class="kwd">await</span> sub.<span class="fn">UnsubscribeAsync</span>(ct);   <span class="cmt">// å–消并确认停采/解绑</span></code></pre>
<p>结果消费遵循 Outbox：<strong>ACK åªåœ¨ç»“果落盘成功后发送</strong>，步骤崩溃重启用同 IdempotencyKey æ‰¾å›žæœª ACK ç»“果，不重跑设备动作。</p>

<h3>9.7 å®Œæ•´ç¤ºä¾‹ï¼šå¤šå·¥ä½ CAN è€åŒ–步骤（B + C + è®¢é˜… æ‹¼æˆçœŸå®žå·¥è‰ºï¼‰</h3>
<pre><code>[Display(<span class="str">"CAN é€šä¿¡è€åŒ–"</span>, Group = <span class="str">"Aging"</span>)]
<span class="kwd">public class</span> CanCommAgingStep : TestStep
{
    [ResourceProperty(<span class="str">"CAN"</span>)] <span class="kwd">public string</span> SlotId { <span class="kwd">get</span>; <span class="kwd">set</span>; } = <span class="str">"S001"</span>;
    <span class="kwd">public int</span> Cycles { <span class="kwd">get</span>; <span class="kwd">set</span>; } = <span class="num">100</span>;

    <span class="kwd">public override async void</span> Run()
    {
        <span class="kwd">var</span> ctx  = RunContext.Current;                     <span class="cmt">// Run/DUT/Step å…³è”ID</span>
        <span class="kwd">var</span> auto = AgingRuntime.Coordinator;               <span class="cmt">// IResourceCoordinator</span>
        <span class="kwd">var</span> cans = AgingRuntime.CanBus;                    <span class="cmt">// ICanBusService(类型化)</span>

        <span class="kwd">var</span> req  = ctx.<span class="fn">BuildAcquire</span>(<span class="kwd">new</span>[] { <span class="str">"can/"</span> + ctx.<span class="fn">SlotOf</span>(SlotId) + <span class="str">"/ch/2"</span> });
        <span class="kwd">using var</span> cts = Utils.<span class="fn">LinkedWithVerdictCancel</span>(Upwards);

        ILeaseScope scope = <span class="kwd">await</span> auto.<span class="fn">AcquireGroupAsync</span>(req, cts.Token);
        <span class="kwd">try</span>
        {
            <span class="kwd">var</span> lease = scope.<span class="fn">LeaseOf</span>(ctx.<span class="fn">ResourceOf</span>(SlotId));

            <span class="cmt">// â‘  èµ·å‘¨æœŸæ¿€åŠ±ï¼ˆé©»ç•™ Broker，随租约失效自动停）</span>
            <span class="kwd">var</span> periodic = <span class="kwd">await</span> lease.<span class="fn">StartTemplateAsync</span>(<span class="str">"can.periodic.keepalive"</span>,
                <span class="kwd">new</span> { frameId = <span class="num">0x3E0</span>, periodMs = <span class="num">500</span> }, cts.Token);

            <span class="cmt">// â‘¡ è®¢é˜…响应信号</span>
            <span class="kwd">var</span> sub = <span class="kwd">await</span> lease.<span class="fn">SubscribeAsync</span>(<span class="str">"can.acq.response-0x3E1"</span>, cts.Token);

            <span class="kwd">for</span> (<span class="kwd">int</span> i = <span class="num">0</span>; i &lt; Cycles &amp;&amp; !scope.HandoverRequested; i++)
            {
                <span class="kwd">await</span> cans.<span class="fn">SendFrameAsync</span>(lease, <span class="num">0x100</span> + (uint)i, ctx.<span class="fn">Payload</span>(i),
                    ctx.<span class="fn">NextIdempotencyKey</span>(), cts.Token);

                <span class="kwd">var</span> echo = <span class="kwd">await</span> sub.<span class="fn">WaitMatchingAsync</span>(f =&gt; f.<span class="fn">MatchRequest</span>(<span class="num">0x100</span> + i),
                    TimeSpan.<span class="fn">FromSeconds</span>(<span class="num">2</span>), cts.Token);

                <span class="kwd">if</span> (echo == <span class="kwd">null</span>) { Verdict = Verdict.Fail; <span class="kwd">break</span>; }  <span class="cmt">// åˆ¤å®šåœ¨å¼•æ“Ž</span>
                Report.<span class="fn">Sample</span>(i, echo);                                <span class="cmt">// é‡‡æ ·èµ°ç»“果通路</span>
            }

            <span class="kwd">await</span> periodic.<span class="fn">StopAsync</span>(cts.Token);   <span class="cmt">// å‘¨æœŸä»»åŠ¡æ˜¾å¼åœæ­¢å¹¶â€œç¡®è®¤åœæ­¢â€</span>
            <span class="kwd">await</span> sub.<span class="fn">UnsubscribeAsync</span>(cts.Token);
        }
        <span class="kwd">finally</span>
        {
            <span class="kwd">await</span> scope.<span class="fn">ReleaseAsync</span>(CancellationToken.None);  <span class="cmt">// å¼‚步、可失败进恢复</span>
        }
    }
}</code></pre>

<h3>9.8 æ­¥éª¤ç”Ÿå‘½å‘¨æœŸæ—¶åº</h3>
<pre><code>OnPlanLoad    è§£æž Slot+Capability â†’ é¢„检配置存在性（不占资源）
Run() å…¥å£     DUTContext çŠ¶æ€æ£€æŸ¥ â†’ AcquireGroup（排队等待=异步，不阻塞他位）
持租阶段      ç±»åž‹åŒ–操作/订阅 â†’ æ¯å‘½ä»¤å¸¦ Grant+IdemKey+Deadline â†’ è¯»å›žè´¨é‡æ ¸å¯¹
退出边界      HandoverRequested? â†’ è®©æ¸¡æˆ–ç»­è·‘
finally       åœåŽå°ä»»åŠ¡(确认) â†’ ReleaseAsync â†’ ç»“æžœ Outbox ACK åŽç»ˆæ€ä¿å­˜
异常路径      LeaseLost / Unknown â†’ åœæ­¢ä¸‹å‘ â†’ ä¸ŠæŠ¥ â†’ äº¤ç»™æ¢å¤/RunService å†³ç­–（不自动判合否）</code></pre>

<h3>9.9 åæ¨¡å¼æ¸…单（TestStep ä¾§æ±‡æ€»ï¼‰</h3>
<table>
    <tr><th>反模式</th><th>后果</th><th>正解</th></tr>
    <tr><td class="bad">步骤里 new CanDriverAdapter(...)</td><td>绕过仲裁与快照，双宿主冲突（INV-01）</td><td>只经 Scope/Executor è·¯ç”±</td></tr>
    <tr><td class="bad">超时后换新 IdempotencyKey é‡å‘</td><td>触发型动作执行两次</td><td>同键 Query å¯¹è´¦ï¼ˆÂ§20.4）</td></tr>
    <tr><td class="bad">在 await è·¨çº¿ç¨‹å¤„释放守卫 Mutex</td><td>AbandonedMutex / éžæ³•é‡Šæ”¾</td><td>守卫归宿主专用线程，步骤只操作租约</td></tr>
    <tr><td class="bad">scope.Dispose() åŒæ­¥é˜»å¡ž UI/线程池</td><td>排空等待卡死调度</td><td>显式 ReleaseAsync</td></tr>
    <tr><td class="bad">用 Thread.Sleep ç­‰è€åŒ–时长</td><td>120 ç©ºä½ = 120 çº¿ç¨‹</td><td>异步计时 + Broker Periodic/Acquisition</td></tr>
    <tr><td class="bad">把 Broker è¯»å›žç›´æŽ¥å½“ PASS</td><td>掩盖通信故障（数据质量≠工艺判定）</td><td>判定在步骤/引擎，Gap å¿…须计入</td></tr>
    <tr><td class="bad">捕获 LeaseLost åŽç»§ç»­å‘命令</td><td>僵尸写入（栅栏只挡坏结果，挡不住你没查）</td><td>LeaseLost è”进所有下发的 CTS</td></tr>
</table>

<!-- ======================================================== -->
<h2 id="s10">十、结论</h2>

<div class="success">
<p><strong>新架构图的一句话读法：</strong>仪器注册生产<strong>带哈希的配置真理</strong>，仪器调试申请<strong>带栅栏的临时写权</strong>，Worker/Broker æ‰§è¡Œ<strong>带原子片段的物理 I/O</strong>，Recipe åªåš<strong>空位→能力→判定</strong>，四本数据库各守各的单写者——任何一次“碰设备”都要同时回答：<strong>授权是谁（Grant）、配置是哪版（Hash）、物理状态信不信得过（读回）</strong>。</p>
<p>落地顺序遵循 P0～P4 è£å‰ªï¼ˆPipeClient ä¿®å¤ä¸Žç¡¬ä»¶æ‹“扑冻结 â†’ å• Authority ç§Ÿçº¦å†…æ ¸ â†’ Broker MVP â†’ æ¢å¤ç¼–排 â†’ é…ç½®å‘布体系），详见《多进程仪器资源方案评估》。本文与以下文档配套阅读：</p>
<ul>
    <li><a href="./Local + DeviceBroker æ··åˆæž¶æž„详细设计说明书 V3.0.html">Local + DeviceBroker æ··åˆæž¶æž„详细设计说明书 V3.0</a>（权威设计源）</li>
    <li><a href="./MultiProcess_Instrument_Resource_Solution.html">多进程/多线程仪器资源独占与共享方案</a>（已被 V3.0 ä¿®æ­£ï¼šåˆ°æœŸä¸è‡ªåŠ¨æŽ¥ç®¡ç­‰ï¼‰</li>
    <li><a href="./OpenTAP_Instrument_Package_Analysis.html">OpenTAP Instrument + æ’件包机制分析</a>（驱动分发形态）</li>
    <li><a href="./DeviceConfig_DeviceDebug_Architecture.html">仪器注册与硬件调试调用关系</a>（现状实现快照）</li>
</ul>
</div>

<footer>
    ä»ªå™¨æ³¨å†Œä¸Žä»ªå™¨è°ƒè¯• Â· ç³»ç»Ÿæž¶æž„说明 V3.0 é‡æ¢³ç†ç‰ˆï¼ˆå« TestStep ä½¿ç”¨è§„范）· 2026-11-03<br>
    åŸºå‡†ï¼šã€ŠLocal + DeviceBroker æ··åˆæž¶æž„详细设计说明书 V3.0》· æœ¬æ–‡çŽ°çŠ¶æè¿°éƒ¨åˆ†å·²å¯¹ç…§çœŸå®žä»£ç æ ¸å®ž
</footer>

<script>
    mermaid.initialize({ 
        startOnLoad: true, theme: 'default', securityLevel: 'loose',
        fontFamily: 'Segoe UI, Microsoft YaHei, sans-serif',
        flowchart: { curve: 'basis', padding: 16 },
        sequence: { showSequenceNumbers: false, actorMargin: 50 }
    });
</script>

</body>
</html>

 docs/broker-ipc-comparison.html

New file
@@ -0,0 +1,348 @@
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Broker IPC æ–¹æ¡ˆå¯¹æ¯”：Named Pipes vs COM Interop</title>
    <style>
        :root {
            --primary: #2563eb;
            --primary-light: #dbeafe;
            --success: #16a34a;
            --success-light: #dcfce7;
            --warning: #d97706;
            --warning-light: #fef3c7;
            --danger: #dc2626;
            --danger-light: #fee2e2;
            --gray-50: #f9fafb;
            --gray-100: #f3f4f6;
            --gray-200: #e5e7eb;
            --gray-600: #4b5563;
            --gray-800: #1f2937;
            --gray-900: #111827;
        }

        * { margin: 0; padding: 0; box-sizing: border-box; }

        body {
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Noto Sans SC", sans-serif;
            line-height: 1.7;
            color: var(--gray-800);
            background: linear-gradient(135deg, #f0f4ff 0%, #fafbff 100%);
            padding: 2rem 1rem;
        }

        .container {
            max-width: 960px;
            margin: 0 auto;
        }

        header {
            text-align: center;
            margin-bottom: 2.5rem;
        }

        header h1 {
            font-size: 1.8rem;
            color: var(--gray-900);
            margin-bottom: 0.5rem;
        }

        header .subtitle {
            color: var(--gray-600);
            font-size: 0.95rem;
        }

        .badge {
            display: inline-block;
            padding: 0.15rem 0.6rem;
            border-radius: 999px;
            font-size: 0.75rem;
            font-weight: 600;
            margin-left: 0.4rem;
            vertical-align: middle;
        }
        .badge-rec { background: var(--success-light); color: var(--success); }
        .badge-alt { background: var(--warning-light); color: var(--warning); }

        /* ---- Comparison Table ---- */
        .table-wrap {
            overflow-x: auto;
            margin-bottom: 2rem;
            border-radius: 12px;
            box-shadow: 0 1px 3px rgba(0,0,0,.08);
        }

        table {
            width: 100%;
            border-collapse: collapse;
            background: #fff;
            font-size: 0.92rem;
        }

        thead th {
            background: var(--primary);
            color: #fff;
            padding: 0.85rem 1rem;
            text-align: left;
            font-weight: 600;
            white-space: nowrap;
        }
        thead th:first-child { border-radius: 12px 0 0 0; }
        thead th:last-child  { border-radius: 0 12px 0 0; }

        tbody td {
            padding: 0.75rem 1rem;
            border-bottom: 1px solid var(--gray-200);
            vertical-align: top;
        }

        tbody tr:last-child td { border-bottom: none; }
        tbody tr:nth-child(even) { background: var(--gray-50); }

        td:first-child {
            font-weight: 600;
            color: var(--gray-900);
            white-space: nowrap;
        }

        .cell-good { color: var(--success); font-weight: 500; }
        .cell-bad  { color: var(--danger);  font-weight: 500; }
        .cell-neutral { color: var(--warning); font-weight: 500; }

        /* ---- Sections ---- */
        .section {
            background: #fff;
            border-radius: 12px;
            padding: 1.8rem 2rem;
            margin-bottom: 1.5rem;
            box-shadow: 0 1px 3px rgba(0,0,0,.08);
        }

        .section h2 {
            font-size: 1.2rem;
            color: var(--primary);
            margin-bottom: 1rem;
            padding-bottom: 0.5rem;
            border-bottom: 2px solid var(--primary-light);
        }

        .section h3 {
            font-size: 1rem;
            color: var(--gray-900);
            margin: 1.2rem 0 0.6rem;
        }

        /* ---- Factor Cards ---- */
        .factor-grid {
            display: grid;
            grid-template-columns: 1fr 1fr;
            gap: 1rem;
            margin-top: 1rem;
        }
        @media (max-width: 640px) { .factor-grid { grid-template-columns: 1fr; } }

        .factor-card {
            border: 1px solid var(--gray-200);
            border-radius: 8px;
            padding: 1rem 1.2rem;
        }
        .factor-card h4 {
            font-size: 0.88rem;
            margin-bottom: 0.4rem;
            color: var(--gray-900);
        }
        .factor-card p {
            font-size: 0.85rem;
            color: var(--gray-600);
            line-height: 1.6;
        }
        .factor-card.pro  { border-left: 4px solid var(--success); }
        .factor-card.con  { border-left: 4px solid var(--danger); }

        /* ---- Recommendation ---- */
        .recommendation {
            background: var(--success-light);
            border: 1px solid #86efac;
            border-radius: 10px;
            padding: 1.5rem 2rem;
            margin-top: 1.5rem;
        }
        .recommendation h2 {
            color: var(--success);
            border-bottom-color: #86efac;
        }
        .recommendation ul {
            margin: 0.8rem 0 0 1.2rem;
        }
        .recommendation li {
            margin-bottom: 0.4rem;
            font-size: 0.92rem;
        }

        /* ---- Code Hint ---- */
        code {
            background: var(--gray-100);
            padding: 0.15rem 0.4rem;
            border-radius: 4px;
            font-size: 0.88em;
            font-family: "Cascadia Code", "Fira Code", Consolas, monospace;
        }

        footer {
            text-align: center;
            margin-top: 2rem;
            color: var(--gray-600);
            font-size: 0.8rem;
        }
    </style>
</head>
<body>
<div class="container">

    <header>
        <h1>Broker IPC æ–¹æ¡ˆå¯¹æ¯”</h1>
        <p class="subtitle">Named Pipes&nbsp;&nbsp;vs&nbsp;&nbsp;COM Interop&nbsp;&nbsp;|&nbsp;&nbsp;TapProject V3.0 MVP æž¶æž„评估</p>
    </header>

    <!-- ===================== Comparison Table ===================== -->
    <div class="table-wrap">
        <table>
            <thead>
                <tr>
                    <th>评估维度</th>
                    <th>Named Pipes <span class="badge badge-rec">推荐</span></th>
                    <th>COM Interop <span class="badge badge-alt">备选</span></th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>部署复杂度</td>
                    <td class="cell-good">低 â€” åªéœ€ç®¡é“名约定，无需注册组件</td>
                    <td class="cell-bad">高 â€” éœ€ RegAsm / regsvr32 æ³¨å†Œ COM ç»„件，配置 DCOM æƒé™</td>
                </tr>
                <tr>
                    <td>强类型体验</td>
                    <td class="cell-neutral">å¼± â€” éœ€æ‰‹åŠ¨åºåˆ—化/反序列化（JSON / Protobuf）</td>
                    <td class="cell-good">强 â€” .NET è‡ªåŠ¨ç”Ÿæˆ RCW，接口调用如同本地对象</td>
                </tr>
                <tr>
                    <td>跨机器扩展</td>
                    <td class="cell-good">天然支持 â€” å¯å¹³æ»‘切换到 TCP / gRPC</td>
                    <td class="cell-bad">需 DCOM，防火墙与网络配置复杂</td>
                </tr>
                <tr>
                    <td>权限要求</td>
                    <td class="cell-good">低 â€” åŒæœºç®¡é“访问即可，无需特殊权限</td>
                    <td class="cell-bad">需 DCOM æƒé™é…ç½®ï¼Œä¼ä¸šå®‰å…¨ç­–略常受限</td>
                </tr>
                <tr>
                    <td>未来 .NET å…¼å®¹æ€§</td>
                    <td class="cell-good">完全兼容 .NET 6 / 7 / 8+</td>
                    <td class="cell-bad">Microsoft å·²é€æ­¥å¼±åŒ– COM æŠ•å…¥ï¼Œ.NET Core æ”¯æŒæœ‰é™</td>
                </tr>
                <tr>
                    <td>性能</td>
                    <td class="cell-neutral">JSON æœ‰åºåˆ—化开销，但管道本身高效；可换 Protobuf ä¼˜åŒ–</td>
                    <td class="cell-good">二进制 marshaling å¼€é”€å°ï¼Œä½†æœ‰é¢å¤– proxy/stub å±‚</td>
                </tr>
                <tr>
                    <td>调试 / è¿ç»´</td>
                    <td class="cell-good">管道状态易排查，日志直观</td>
                    <td class="cell-bad">COM æ³¨å†Œé—®é¢˜ã€æƒé™é—®é¢˜æ˜¯å¸¸è§æ•…障源</td>
                </tr>
                <tr>
                    <td>与现有代码集成</td>
                    <td class="cell-neutral">需编写连接管理、帧解析逻辑</td>
                    <td class="cell-good">接口定义后客户端代码简洁，类似本地调用</td>
                </tr>
            </tbody>
        </table>
    </div>

    <!-- ===================== Key Factors ===================== -->
    <div class="section">
        <h2>关键考量因素</h2>

        <h3>COM Interop é€‚合的场景</h3>
        <div class="factor-grid">
            <div class="factor-card pro">
                <h4>✅ åŒæœºé€šä¿¡ + å¼ºç±»åž‹éœ€æ±‚</h4>
                <p>Broker ä¸Žå®¢æˆ·ç«¯æ°¸è¿œåœ¨åŒä¸€å°æœºå™¨ï¼Œå›¢é˜Ÿç†Ÿæ‚‰ COM éƒ¨ç½²ï¼Œå¸Œæœ›èŽ·å¾—透明代理般的调用体验。</p>
            </div>
            <div class="factor-card pro">
                <h4>✅ å·²æœ‰ COM ç»„件资产</h4>
                <p>项目中已有成熟的 COM æŽ¥å£å®šä¹‰æˆ–第三方 COM ç»„件，可直接复用。</p>
            </div>
        </div>

        <h3>Named Pipes æ›´é€‚合的理由</h3>
        <div class="factor-grid">
            <div class="factor-card con">
                <h4>🚀 éƒ¨ç½²ç®€å•</h4>
                <p>无需注册 COM ç»„件，管道名约定即可通信，运维成本极低。</p>
            </div>
            <div class="factor-card con">
                <h4>🔗 è·¨æœºå™¨æ‰©å±•</h4>
                <p>未来若 Broker éœ€éƒ¨ç½²åˆ°è¿œç¨‹æœºå™¨ï¼ŒNamed Pipes å¯å¹³æ»‘切换到 TCP/gRPC，COM Interop åˆ™éœ€å¤§å¹…改造。</p>
            </div>
            <div class="factor-card con">
                <h4>🛡️ ä¼ä¸šçŽ¯å¢ƒå‹å¥½</h4>
                <p>DCOM æƒé™åœ¨ä¼ä¸šå®‰å…¨ç­–略下经常受限，Named Pipes æ— æ­¤é—®é¢˜ã€‚</p>
            </div>
            <div class="factor-card con">
                <h4>📦 çŽ°ä»£ .NET å…¼å®¹</h4>
                <p>项目虽当前为 .NET Framework 4.7.2，但 COM Interop åœ¨ .NET 5+ ä¸Šæ”¯æŒé€æ­¥å¼±åŒ–，Named Pipes æ— æ­¤é¡¾è™‘。</p>
            </div>
        </div>
    </div>

    <!-- ===================== Recommendation ===================== -->
    <div class="recommendation">
        <h2>结论与建议</h2>
        <p><strong>保持 Named Pipes æ–¹æ¡ˆã€‚</strong></p>
        <p>对于 Broker è·¨è¿›ç¨‹é€šä¿¡åœºæ™¯ï¼ŒNamed Pipes åœ¨<strong>部署简易性</strong>、<strong>未来扩展性</strong>和<strong>平台兼容性</strong>上均优于 COM Interop。</p>
        <ul>
            <li>如果担心 JSON åºåˆ—化开销，可考虑用 <code>MemoryPack</code> æˆ– <code>Protobuf-net</code> æ›¿ä»£ï¼ŒåŒæ—¶ä¿ç•™ Named Pipes çš„架构优势。</li>
            <li>当前 MVP å¸§åè®®è®¾è®¡ï¼ˆ4 å­—节长度前缀 + UTF8 JSON）已足够清晰，后续优化空间大。</li>
            <li>COM Interop ä»…在"团队已有成熟 COM èµ„产 + ç¡®å®šæ°¸ä¸è·¨æœºå™¨"的前提下才值得考虑。</li>
        </ul>
    </div>

    <!-- ===================== Architecture Context ===================== -->
    <div class="section">
        <h2>当前 MVP æž¶æž„中的 IPC å®šä½</h2>
        <p>在已完成的 MVP å®žæ–½ä¸­ï¼Œè·¨è¿›ç¨‹é€šä¿¡åˆ†ä¸ºä¸¤å±‚：</p>
        <table style="margin-top: 1rem;">
            <thead>
                <tr>
                    <th style="width:30%">层级</th>
                    <th>机制</th>
                    <th>状态</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>仲裁层（arb.db）</td>
                    <td>SQLite WAL æ¨¡å¼ + BEGIN IMMEDIATE äº‹åŠ¡ â€” è¿›ç¨‹é—´ä»²è£å®Œå…¨ä¾èµ–数据库事务，无需 IPC</td>
                    <td class="cell-good">✅ å·²å®žçŽ°</td>
                </tr>
                <tr>
                    <td>Broker å‘½ä»¤é€šé“</td>
                    <td>Named Pipes å¸§åè®®ï¼ˆ4B é•¿åº¦ + JSON）— ç”¨äºŽå®¢æˆ·ç«¯å‘ DeviceBroker.exe ä¸‹å‘设备操作</td>
                    <td class="cell-neutral">⏳ è®¡åˆ’中（P2+）</td>
                </tr>
            </tbody>
        </table>
        <p style="margin-top: 1rem; color: var(--gray-600); font-size: 0.88rem;">
            æ³¨ï¼šå½“前 MVP ä»…实现了 Local æ¨¡å¼ï¼ˆè¿›ç¨‹å†…直驱）和 DbLeaseStore（SQLite ä»²è£ï¼‰ã€‚Broker æ¨¡å¼çš„命令通道属于后续迭代范围，此时选择 Named Pipes ä½œä¸º IPC æ–¹æ¡ˆä»æœ‰å……分调整空间。
        </p>
    </div>

    <footer>
        TapProject V3.0 MVP â€” Broker IPC æ–¹æ¡ˆè¯„ä¼° &nbsp;|&nbsp; ç”ŸæˆäºŽ 2026-11-03
    </footer>

</div>
</body>
</html>

 docs/superpowers/plans/2026-11-03-local-broker-mvp.md

New file
@@ -0,0 +1,1328 @@
# Local + Broker ä»²è£æœºåˆ¶ MVP å®žæ–½è®¡åˆ’

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** åœ¨çŽ°æœ‰ TapProject ä¸­ä»¥æœ€å°ä»£ä»·è½åœ° V3.0 æž¶æž„的两大核心机制——**Local ç›´è¿žå®¿ä¸»**与 **DeviceBroker ä»£ç†å®¿ä¸»**——并使跨进程租约仲裁贯穿"仪器注册（执行位选择/发布门禁）"与"手动调试（维护写权申请/占用可见/释放）"两条主路径。

**Architecture:** ä¸‰å±‚递进：① `Aging.ResourceContracts`（零依赖契约库：LeaseGrant / DeviceOperation / IPC å°å¥—）；② `DbLeaseStore`（SQLite `arb.db` ä¸Šçš„跨进程租约：BEGIN IMMEDIATE äº‹åŠ¡ CAS + generation æ …栏 + epoch + TTL/心跳 + è¿‡æœŸè¿› RecoveryRequired äººå·¥å›žæ”¶ï¼‰ï¼›â‘¢ æ‰§è¡ŒåŒé€šé“——Local è®¾å¤‡ç”±å½“前进程直驱（保持现状路径），Broker è®¾å¤‡ç”±ç‹¬ç«‹ `DeviceBroker.exe` å”¯ä¸€æŒæœ‰ç‰©ç†ä¼šè¯ï¼Œå®¢æˆ·ç«¯ç» `BrokeredCanDriver` ä»£ç†é©±åŠ¨ + å¸§åè®® RPC è½¬å‘，Broker å‡ºé˜Ÿæ—¶å†åšæ …栏与配置哈希双重校验（INV-01/05 é—­çŽ¯ï¼‰ã€‚现有 `IResourceManager/IAutoDeviceFacade/DebugSessionManager` é€šè¿‡ç»„合（不破坏签名）切换为跨进程实现。

**Tech Stack:** .NET Framework 4.7.2、C# 10、WPF（现有插件 UI）、System.Data.SQLite（arb.db + WAL）、Named Pipes（帧协议：4 å­—节长度前缀 + UTF8 JSON）、xUnit（新 SDK é£Žæ ¼æµ‹è¯•å·¥ç¨‹ï¼‰ã€MSBuild（编译旧式 WPF å·¥ç¨‹ï¼Œè§è®°å¿†è§„则）。

---

## MVP èŒƒå›´è£å‰ªï¼ˆæ˜Žç¡®ä¿ç•™ä¸ŽæŽ¨è¿Ÿï¼‰

| V3.0 èƒ½åŠ› | MVP å¤„ç½® | è¯´æ˜Ž |
|-----------|---------|------|
| è·¨è¿›ç¨‹ç§Ÿçº¦ + generation æ …栏 + epoch | âœ… å®žçŽ° | æ ¸å¿ƒä¸­çš„核心 |
| INV-03：过期不自动移交 â†’ RecoveryRequired | âœ… å®žçŽ°ï¼ˆäººå·¥å›žæ”¶æŒ‰é’®ç‰ˆï¼‰ | å›žæ”¶=宿主读回探测+登记证据+ç½® Free |
| Local æ¨¡å¼ï¼ˆè¿›ç¨‹å†…直驱 + è¿žæŽ¥å®ˆå« Mutex） | âœ… å®žçŽ° | æ²¿ç”¨çŽ°æœ‰é©±åŠ¨ |
| Broker æ¨¡å¼ï¼ˆSessionGate åŽŸå­ç‰‡æ®µ + æ …栏再校验） | âœ… å®žçŽ°ï¼ˆOneShot å‘½ä»¤åŒæ­¥æ¨¡åž‹ï¼‰ | å‘¨æœŸä»»åŠ¡/订阅/Outbox æŽ¨è¿Ÿ |
| æ³¨å†Œé¡µ executionMode/authorityId/sessionKey/accessPolicy + å‘布门禁 + ä¸å¯å˜å¿«ç…§å“ˆå¸Œ | âœ… å®žçŽ°ï¼ˆæœ€å°ç‰ˆï¼‰ | Broker è¿žæŽ¥æº configHash å¯¹è´¦ï¼ˆINV-04 é›å½¢ï¼‰ |
| è°ƒè¯•é¡µç»´æŠ¤å†™æƒè·¨è¿›ç¨‹ç”³è¯·ã€å ç”¨è€…可见、拒绝语义 | âœ… å®žçŽ° | å¤ç”¨ DebugSessionManager çŽ°æœ‰è°ƒç”¨é“¾ |
| Draining è‡ªåŠ¨è®©æ¸¡ / ç»´æŠ¤æŠ¢å  grace æµç¨‹ | â­ æŽ¨è¿Ÿï¼ˆMVP ç”¨"占用即拒绝"矩阵合法分支） | æ–‡æ¡£ Â§6.1 å…è®¸ |
| Task Journal/Outbox、PeriodicTx/Acquisition、父 Permit å¤šé€šé“、Prepare/Activate ä¸¤æ®µå¼è·¨åŸŸé¢„留、120 ç©ºä½å…¬å¼ã€arb æœåŠ¡ç«¯ DB åŒ– | â­ æŽ¨è¿Ÿ | P2+ |

**决策完备性说明（实施者不需再做决定）：**
- ä»²è£åº“路径：`%LOCALAPPDATA%\PluginIntegrationTest\arb.db`（与 data.db åŒç›®å½•ï¼‰
- lease_id ç›´æŽ¥å¤ç”¨çŽ°æœ‰ `ResourceOwnerToken.TokenId`，两套体系一个身份
- MVP æƒé™ä¼˜å…ˆçº§ç®€åŒ–为：**任何 Active ç§Ÿçº¦ â†’ ä»–人一律拒绝（ConflictHeld + å ç”¨è€…信息）**；不区分 Maintenance æŠ¢å 
- Broker åŸŸæ¼”示设备：`CAN-002`（executionMode=Broker，authorityId=broker-b01，sessionKey=canbus1）；Local æ¼”示设备：`CAN-001`
- æ¶ˆæ¯æ¨¡åž‹ä¸º**单连接同步请求-响应**（_sendLock ä¸²è¡Œï¼‰ï¼Œå¤šè·¯å¤ç”¨æŽ¨è¿Ÿ
- å¿ƒè·³ 8s / TTL 30s / æŽ¢æµ‹è¶…æ—¶ 3s（可后续入配置）

---

## Task 0: åŸºçº¿ç¡®è®¤ä¸Žå·¥ç¨‹éª¨æž¶

**Files:**
- Create: `Aging.ResourceContracts/Aging.ResourceContracts.csproj`
- Create: `tests/Aging.MvpTests/Aging.MvpTests.csproj`
- Modify: `WPFProject/TapProject.sln`（加入两个新工程）

- [ ] **Step 1: éªŒè¯å½“前基线可编译**

```powershell
cd d:\TestPlatform\TapProject
& "C:\Program Files\Microsoft Visual Studio\2022\Community\MSBuild\Current\Bin\MSBuild.exe" Plugin.IntegrationTest\Plugin.IntegrationTest.csproj /p:Configuration=Debug /p:Platform=AnyCPU /t:Build /v:minimal
```
预期：最后一行 `Plugin.IntegrationTest -> ...exe`，无 error。（注意：本仓库旧式工程必须用 MSBuild，但本工程链上 SDK-style å·¥ç¨‹ä¹Ÿå¯ç”¨ MSBuild ç¼–译，统一用 MSBuild。）

- [ ] **Step 2: åˆ›å»ºå¥‘约类库工程（零依赖）**

创建 `Aging.ResourceContracts/Aging.ResourceContracts.csproj`：

```xml
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net472</TargetFramework>
    <Nullable>enable</Nullable>
    <LangVersion>10.0</LangVersion>
    <ImplicitUsings>disable</ImplicitUsings>
  </PropertyGroup>
</Project>
```

- [ ] **Step 3: åˆ›å»º xUnit æµ‹è¯•å·¥ç¨‹**

```powershell
cd d:\TestPlatform\TapProject\tests
dotnet new xunit -n Aging.MvpTests -f net472
```
编辑 `Aging.MvpTests/Aging.MvpTests.csproj` è¿½åŠ å¯¹å¥‘约库与后续设施的引用与 SQLite å¤åˆ¶ï¼š

```xml
<ItemGroup>
  <ProjectReference Include="..\..\Aging.ResourceContracts\Aging.ResourceContracts.csproj" />
</ItemGroup>
<ItemGroup>
  <Content Include="..\..\Libs\SQLite.Interop.dll" Link="x64\SQLite.Interop.dll">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  </Content>
</ItemGroup>
```

- [ ] **Step 4: åŠ å…¥è§£å†³æ–¹æ¡ˆå¹¶éªŒè¯**

```powershell
cd d:\TestPlatform\TapProject
dotnet sln WPFProject\TapProject.sln add Aging.ResourceContracts\Aging.ResourceContracts.csproj tests\Aging.MvpTests\Aging.MvpTests.csproj
dotnet test tests\Aging.MvpTests\Aging.MvpTests.csproj
```
预期：`Passed! - 1 failed: 0, passed: 1`（模板自带 UnitTest1）。若 `dotnet sln add` å› æ—§å¼å·¥ç¨‹æ ¼å¼æŠ¥é”™ï¼Œè®°å½•åŽåœ¨ VS ä¸­æ‰‹å·¥æ·»åŠ ï¼Œä¸é˜»å¡žåŽç»­ä»»åŠ¡ã€‚

- [ ] **Step 5: Commit**

```powershell
git add Aging.ResourceContracts tests WPFProject/TapProject.sln
git commit -m "chore(mvp): å¥‘约库与测试工程骨架"
```

---

## Task 1: å¥‘约类型（LeaseGrant / AcquireRequest / DeviceOperation / IPC å°å¥—）

**Files:**
- Create: `Aging.ResourceContracts/LeaseTypes.cs`
- Create: `Aging.ResourceContracts/DeviceOperationTypes.cs`
- Create: `Aging.ResourceContracts/IpcEnvelope.cs`
- Test: `tests/Aging.MvpTests/ContractSerializeTests.cs`

- [ ] **Step 1: å†™å¤±è´¥æµ‹è¯•ï¼ˆJSON å¾€è¿”不丢字段）**

`tests/Aging.MvpTests/ContractSerializeTests.cs`：

```csharp
using System.Text.Json;
using Aging.ResourceContracts;
using Xunit;

namespace Aging.MvpTests
{
    public class ContractSerializeTests
    {
        [Fact]
        public void LeaseGrant_RoundTrips_Json()
        {
            var g = new LeaseGrant("broker-b01", "can/can02", "lease_abc",
                "W01.RunA", OwnerTypeV3.Maintenance, epoch: 7, generation: 42,
                expiresUtcMs: 1793673600000);
            var json = JsonSerializer.Serialize(g);
            var back = JsonSerializer.Deserialize<LeaseGrant>(json)!;
            Assert.Equal(g.Generation, back.Generation);
            Assert.Equal(g.Epoch, back.Epoch);
            Assert.Equal(g.LeaseId, back.LeaseId);
            Assert.Equal(g.OwnerType, back.OwnerType);
        }

        [Fact]
        public void IpcEnvelope_Carries_BodyAndIdentity()
        {
            var e = new IpcEnvelope
            {
                ProtocolVersion = 1, MessageType = "SubmitTask",
                RequestId = "req-1", ClientInstanceId = "hmi/bootA/123",
                AuthorityId = "broker-b01", ConfigHash = "sha256:x",
                BodyJson = "{\"operationCode\":\"SEND\"}"
            };
            var json = JsonSerializer.Serialize(e);
            var back = JsonSerializer.Deserialize<IpcEnvelope>(json)!;
            Assert.Equal("SubmitTask", back.MessageType);
            Assert.Equal("sha256:x", back.ConfigHash);
        }
    }
}
```

- [ ] **Step 2: è¿è¡Œç¡®è®¤å¤±è´¥**

```powershell
dotnet test tests\Aging.MvpTests\Aging.MvpTests.csproj --filter ContractSerializeTests
```
预期：编译错误 `The type LeaseGrant does not exist`（工程未引用实现前的自然失败）。

- [ ] **Step 3: å®žçŽ°å¥‘约类型**

`Aging.ResourceContracts/LeaseTypes.cs`：

```csharp
using System;
using System.Threading;
using System.Threading.Tasks;

namespace Aging.ResourceContracts
{
    /// <summary>与现有 OwnerType æ•°å€¼å¯¹é½ï¼šProduction=0, Maintenance=1。</summary>
    public enum OwnerTypeV3 { Production = 0, Maintenance = 1 }

    /// <summary>MVP ç›¸ä½ï¼šFree å¯ç”¨ / Active æŒæœ‰ / RecoveryRequired è¿‡æœŸå¾…回收（INV-03）。</summary>
    public enum LeasePhase { Free = 0, Active = 1, RecoveryRequired = 2 }

    /// <summary>每资源一张租约凭证；栅栏=(AuthorityId, Epoch, ResourceKey, LeaseId, Generation)。</summary>
    public sealed class LeaseGrant
    {
        public string AuthorityId { get; }
        public string ResourceKey { get; }
        public string LeaseId { get; }
        public string OwnerId { get; }
        public OwnerTypeV3 OwnerType { get; }
        public long Epoch { get; }
        public long Generation { get; }
        public long ExpiresUtcMs { get; }

        public LeaseGrant(string authorityId, string resourceKey, string leaseId,
            string ownerId, OwnerTypeV3 ownerType, long epoch, long generation, long expiresUtcMs)
        {
            AuthorityId = authorityId; ResourceKey = resourceKey; LeaseId = leaseId;
            OwnerId = ownerId; OwnerType = ownerType; Epoch = epoch;
            Generation = generation; ExpiresUtcMs = expiresUtcMs;
        }
    }

    public sealed class AcquireRequest
    {
        public string OwnerId { get; set; } = "";
        public OwnerTypeV3 OwnerType { get; set; }
        /// <summary>boot_id + pid，同机进程区分。</summary>
        public string ProcessInstanceId { get; set; } = "";
        public string MachineName { get; set; } = Environment.MachineName;
        public int HostProcessId { get; set; } = System.Diagnostics.Process.GetCurrentProcess().Id;
        /// <summary>申请理由（维护会话填操作员与原因，进 lease_history）。</summary>
        public string Reason { get; set; } = "";
        /// <summary>Ordinals å‡åºã€åŽ»é‡åŽç”³è¯·ï¼ˆç»„申请 = å•äº‹åŠ¡å…¨æœ‰å…¨æ— ï¼‰ã€‚</summary>
        public string[] ResourceKeys { get; set; } = new string[0];
        public int WaitTimeoutMs { get; set; } = 1000;
        public int TtlSeconds { get; set; } = 30;
    }

    public enum AcquireResultCode { Acquired, Reused, ConflictHeld, RecoveryBlocked, Timeout }

    public sealed class ConflictInfo
    {
        public string OwnerId { get; set; } = "";
        public OwnerTypeV3 OwnerType { get; set; }
        public string MachineName { get; set; } = "";
        public int HostProcessId { get; set; }
        public string Reason { get; set; } = "";
        public long ExpiresUtcMs { get; set; }
    }

    public sealed class AcquireOutcome
    {
        public AcquireResultCode Code { get; set; }
        public LeaseGrant[] Grants { get; set; } = new LeaseGrant[0];
        public ConflictInfo? Holder { get; set; }
        /// <summary>RecoveryBlocked æ—¶æŒ‡å‘ recovery_checkpoint çš„键。</summary>
        public string? RecoveryCheckpointKey { get; set; }
    }

    /// <summary>租约协调器：仲裁域唯一入口。实现方：DbLeaseStore。</summary>
    public interface ILeaseCoordinator
    {
        /// <summary>权威域当前 epoch（重启后递增，旧 Grant è‡ªåŠ¨å¤±æ•ˆï¼‰ã€‚</summary>
        long CurrentEpoch { get; }

        AcquireOutcome Acquire(AcquireRequest request);
        /// <summary>同 LeaseId+Generation ç»­æœŸï¼›è¿”回 false=已被回收/超越（本地须熔断）。</summary>
        bool Renew(LeaseGrant grant, int extendSeconds);
        bool Release(LeaseGrant grant, string note);
        ConflictInfo? ProbeConflict(string resourceKey);
        int SweepExpired();
        /// <summary>RecoveryRequired â†’ Free：宿主完成读回探测后登记证据并放行。</summary>
        bool ApproveRecovery(string resourceKey, string readbackJson, string approvedBy);
    }
}
```

`Aging.ResourceContracts/DeviceOperationTypes.cs`：

```csharp
namespace Aging.ResourceContracts
{
    public enum OperationState
    {
        Succeeded, Failed,
        /// <summary>栅栏校验失败：Grant çš„ epoch/generation å·²å¤±æ•ˆï¼ˆå« Broker é‡å¯ï¼‰ã€‚</summary>
        RejectedStaleLease,
        /// <summary>INV-04 é›å½¢ï¼šå®¢æˆ·ç«¯ configHash ä¸Ž Broker ç”Ÿæ•ˆé…ç½®ä¸ä¸€è‡´ã€‚</summary>
        RejectedConfigMismatch,
        /// <summary>会话队列满。</summary>
        RejectedQueueFull,
        /// <summary>已发送但结果未知（INV-06：禁止当未执行）。</summary>
        Unknown
    }

    /// <summary>一次有界设备动作（MVP=OneShot）。Grants å¿…须覆盖 resources。</summary>
    public sealed class DeviceOperation
    {
        /// <summary>白名单操作码，如 "CAN_SEND"/"CAN_RECV"/"CAN_AUTO_RESPONSE"/"CAN_STATUS"。</summary>
        public string OperationCode { get; set; } = "";
        public string ParametersJson { get; set; } = "{}";
        public string IdempotencyKey { get; set; } = "";
        public string ConfigHash { get; set; } = "";
        public LeaseGrant[] Grants { get; set; } = new LeaseGrant[0];
        public long DeadlineUtcMs { get; set; }
    }

    public sealed class OperationResult
    {
        public string RequestId { get; set; } = "";
        public OperationState State { get; set; }
        public string ErrorCode { get; set; } = "";
        public string ReadbackJson { get; set; } = "{}";
        public long ServerEpoch { get; set; }
    }
}
```

`Aging.ResourceContracts/IpcEnvelope.cs`：

```csharp
namespace Aging.ResourceContracts
{
    /// <summary>IPC æ¶ˆæ¯ç±»åž‹å¸¸é‡ï¼ˆMVP ä»…四种）。</summary>
    public static class IpcMessageTypes
    {
        public const string Hello = "Hello";                 // æ¡æ‰‹ï¼šå›ž epoch/configHash
        public const string SubmitTask = "SubmitTask";       // body=DeviceOperation
        public const string CancelTask = "CancelTask";
        public const string ProbeReadback = "ProbeReadback"; // æ¢å¤å›žæ”¶å‰çš„读回探测
    }

    /// <summary>请求/响应共同封套。协议版本不匹配直接拒绝连接。</summary>
    public sealed class IpcEnvelope
    {
        public int ProtocolVersion { get; set; } = 1;
        public string MessageType { get; set; } = "";
        public string RequestId { get; set; } = "";
        public string CorrelationId { get; set; } = "";
        public string ClientInstanceId { get; set; } = "";
        public string AuthorityId { get; set; } = "";
        public string ConfigHash { get; set; } = "";
        public long DeadlineUtcMs { get; set; }
        public string BodyJson { get; set; } = "{}";
    }

    public sealed class HelloResult
    {
        public long ServerEpoch { get; set; }
        public string ConfigHash { get; set; } = "";
        public int ProtocolVersion { get; set; } = 1;
        public string BrokerId { get; set; } = "";
    }
}
```

测试工程 csproj è¿½åŠ  `<PackageReference Include="System.Text.Json" Version="6.0.5" />`（net472 å¯ç”¨ï¼›å¥‘约库同样加此包）。

- [ ] **Step 4: è¿è¡Œç¡®è®¤é€šè¿‡**

```powershell
dotnet test tests\Aging.MvpTests\Aging.MvpTests.csproj --filter ContractSerializeTests
```
预期：`Passed! - failed: 0, passed: 2`

- [ ] **Step 5: Commit**

```powershell
git add Aging.ResourceContracts tests
git commit -m "feat(contracts): LeaseGrant/ILeaseCoordinator/DeviceOperation/IPC å°å¥—"
```

---

## Task 2: DbLeaseStore â€”— è·¨è¿›ç¨‹ç§Ÿçº¦æ ¸å¿ƒï¼ˆarb.db）

**Files:**
- Create: `Aging.Infrastructure/Core/DbLeaseStore.cs`
- Modify: `Aging.Infrastructure/Aging.Infrastructure.csproj`（加 PackageReference System.Data.SQLite + å¥‘约工程引用）
- Test: `tests/Aging.MvpTests/DbLeaseStoreTests.cs`

- [ ] **Step 1: å†™å¤±è´¥æµ‹è¯•ï¼ˆå¹¶å‘申请互斥 + æ …栏 + è¿‡æœŸå›žæ”¶ + epoch å¤±æ•ˆï¼‰**

`tests/Aging.MvpTests/DbLeaseStoreTests.cs`：

```csharp
using System;
using System.IO;
using System.Threading.Tasks;
using Aging.Infrastructure.Core;
using Aging.ResourceContracts;
using Xunit;

namespace Aging.MvpTests
{
    public class DbLeaseStoreTests : IDisposable
    {
        private readonly string _dbPath;
        private readonly DbLeaseStore _store;

        public DbLeaseStoreTests()
        {
            _dbPath = Path.Combine(Path.GetTempPath(),
                "arb_test_" + Guid.NewGuid().ToString("N") + ".db");
            _store = new DbLeaseStore(_dbPath, "local-main");
        }
        public void Dispose() { try { File.Delete(_dbPath); } catch { } }

        private AcquireRequest Req(string key, OwnerTypeV3 type = OwnerTypeV3.Maintenance,
            int ttl = 30) => new AcquireRequest
        {
            OwnerId = "test-owner", OwnerType = type,
            ProcessInstanceId = Guid.NewGuid().ToString("N"),
            ResourceKeys = new[] { key }, TtlSeconds = ttl
        };

        [Fact]
        public void Acquire_FirstOwner_Succeeds()
        {
            var r = _store.Acquire(Req("can/can02"));
            Assert.Equal(AcquireResultCode.Acquired, r.Code);
            Assert.Equal(1, r.Grants[0].Generation);
        }

        [Fact]
        public void Acquire_WhileActiveByOther_ReturnsConflictWithHolder()
        {
            _store.Acquire(Req("can/can02"));
            var second = new AcquireRequest
            {
                OwnerId = "other-owner", OwnerType = OwnerTypeV3.Production,
                ProcessInstanceId = "x", ResourceKeys = new[] { "can/can02" }
            };
            var r = _store.Acquire(second);
            Assert.Equal(AcquireResultCode.ConflictHeld, r.Code);
            Assert.Equal("test-owner", r.Holder!.OwnerId);
        }

        [Fact]
        public void TwoIndependentStores_SameFile_SimulatesTwoProcesses()
        {
            // ä¸¤ä¸ªå®žä¾‹æŒ‡å‘同一 arb.db = ç­‰ä»·äºŽä¸¤ä¸ªè¿›ç¨‹ï¼ˆSQLite äº‹åŠ¡ä¸ºä»²è£å±‚）
            var storeB = new DbLeaseStore(_dbPath, "local-main");
            var a = _store.Acquire(Req("psu/psu01/ch/5"));
            var b = storeB.Acquire(new AcquireRequest
            {
                OwnerId = "W02", OwnerType = OwnerTypeV3.Production,
                ProcessInstanceId = "p2", ResourceKeys = new[] { "psu/psu01/ch/5" }
            });
            Assert.Equal(AcquireResultCode.Acquired, a.Code);
            Assert.Equal(AcquireResultCode.ConflictHeld, b.Code);
        }

        [Fact]
        public void Concurrent_50Threads_OnlyOneWins()
        {
            int winners = 0;
            Parallel.For(0, 50, _ =>
            {
                var s = new DbLeaseStore(_dbPath, "local-main");
                var r = s.Acquire(new AcquireRequest
                {
                    OwnerId = Guid.NewGuid().ToString("N"), OwnerType = OwnerTypeV3.Production,
                    ProcessInstanceId = "p", ResourceKeys = new[] { "can/bus" }, WaitTimeoutMs = 3000
                });
                if (r.Code == AcquireResultCode.Acquired) Interlocked.Increment(ref winners);
            });
            Assert.Equal(1, winners);
        }

        [Fact]
        public void ExpiredLease_EntersRecoveryRequired_NotAutoReclaim()
        {
            _store.Acquire(Req("can/can02", ttl: -1)); // ç«‹å³è¿‡æœŸï¼ˆæµ‹è¯•é’©å­ï¼šè´Ÿ TTL）
            _store.SweepExpired();
            var r = _store.Acquire(Req("can/can02", OwnerTypeV3.Production));
            Assert.Equal(AcquireResultCode.RecoveryBlocked, r.Code);

            // äººå·¥å›žæ”¶ï¼šè¯»å›žè¯æ®åˆæ ¼åŽæ”¾è¡Œ
            Assert.True(_store.ApproveRecovery("can/can02", "{\"output\":\"off\"}", "admin"));
            var again = _store.Acquire(Req("can/can02", OwnerTypeV3.Production));
            Assert.Equal(AcquireResultCode.Acquired, again.Code);
            Assert.Equal(2, again.Grants[0].Generation); // generation å•è°ƒï¼Œæ°¸ä¸å›žé€€
        }

        [Fact]
        public void Renew_WithStaleGeneration_Fails()
        {
            var g = _store.Acquire(Req("can/can02")).Grants[0];
            var stale = new LeaseGrant(g.AuthorityId, g.ResourceKey, g.LeaseId,
                g.OwnerId, g.OwnerType, g.Epoch, generation: 999, g.ExpiresUtcMs);
            Assert.False(_store.Renew(stale, 30));
            Assert.True(_store.Renew(g, 30));
        }

        [Fact]
        public void BumpEpoch_InvalidatesAllActiveGrants()
        {
            var g = _store.Acquire(Req("can/can02")).Grants[0];
            _store.BumpEpochForTest("arb.db é‡å¯æ¨¡æ‹Ÿ");
            Assert.False(_store.Renew(g, 30)); // æ—§ epoch Grant å…¨éƒ¨å¤±æ•ˆ
        }

        [Fact]
        public void GroupAcquire_PartialConflict_RollsBackAll()
        {
            _store.Acquire(Req("psu/b")); // å…ˆå  b
            var r = _store.Acquire(new AcquireRequest
            {
                OwnerId = "W09", OwnerType = OwnerTypeV3.Production, ProcessInstanceId = "p",
                ResourceKeys = new[] { "psu/a", "psu/b", "psu/c" }  // å®žçŽ°å†…部会 Ordinal æŽ’序
            });
            Assert.Equal(AcquireResultCode.ConflictHeld, r.Code);
            Assert.Null(_store.ProbeConflict("psu/a")); // a æœªè¢«åŠå ç”¨
        }
    }
}
```

- [ ] **Step 2: è¿è¡Œç¡®è®¤å¤±è´¥**

```powershell
dotnet test tests\Aging.MvpTests\Aging.MvpTests.csproj --filter DbLeaseStoreTests
```
预期：编译失败（`DbLeaseStore` ä¸å­˜åœ¨ï¼‰ã€‚若契约测试工程编译报 `System.Data.SQLite` ç¼ºå¤±ï¼Œå…ˆåœ¨æµ‹è¯• csproj åŠ  `<PackageReference Include="System.Data.SQLite" Version="1.0.118" />`（Interop ç”± Step 3 çš„ Content å¤åˆ¶è§£å†³ï¼‰ã€‚

- [ ] **Step 3: å®žçŽ° DbLeaseStore**

先修改 `Aging.Infrastructure/Aging.Infrastructure.csproj`，ItemGroup è¿½åŠ ï¼š

```xml
<ProjectReference Include="..\Aging.ResourceContracts\Aging.ResourceContracts.csproj" />
<PackageReference Include="System.Data.SQLite" Version="1.0.118" />
```

`Aging.Infrastructure/Core/DbLeaseStore.cs`：

```csharp
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using Aging.ResourceContracts;
using log4net;
using SQLite;

namespace Aging.Infrastructure.Core
{
    /// <summary>
    /// è·¨è¿›ç¨‹ç§Ÿçº¦å­˜å‚¨ï¼ˆV3.0 Â§8 MVP）。arb.db ç‹¬ç«‹äºŽ data.db。
    /// æ—¶é—´ä¸€å¾‹ DB ä¾§ UTC æ¯«ç§’（DateTime.UtcNow å­˜ INTEGER），
    /// ç”³è¯·/续期/释放全部走 BEGIN IMMEDIATE å•å†™äº‹åŠ¡ â€”— SQLite äº‹åŠ¡å³è¿›ç¨‹é—´ä»²è£å±‚。
    /// INV-03：过期 â†’ RecoveryRequired，禁止自动移交；ApproveRecovery ç™»è®°è¯æ®åŽç½® Free。
    /// </summary>
    public sealed class DbLeaseStore : ILeaseCoordinator
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(DbLeaseStore));

        private readonly string _dbPath;
        private readonly string _authorityId;
        private readonly long _bootNowMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

        public string AuthorityId => _authorityId;
        public long CurrentEpoch { get; private set; }

        public DbLeaseStore(string dbPath, string authorityId)
        {
            _dbPath = dbPath;
            _authorityId = authorityId;
            EnsureDirectory();
            InitializeSchema();
            CurrentEpoch = ReadOrInitEpoch();
        }

        private void EnsureDirectory()
        {
            var dir = Path.GetDirectoryName(_dbPath);
            if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir)) Directory.CreateDirectory(dir);
        }

        private SQLiteConnection Open()
        {
            var conn = new SQLiteConnection(_dbPath);
            conn.Execute("PRAGMA journal_mode=WAL;");
            conn.Execute("PRAGMA busy_timeout=3000;");
            conn.Execute("PRAGMA synchronous=FULL;");
            return conn;
        }

        private void InitializeSchema()
        {
            using var conn = Open();
            conn.Execute(@"
                CREATE TABLE IF NOT EXISTS authority_meta(
                  authority_id TEXT PRIMARY KEY, epoch INTEGER NOT NULL,
                  boot_id TEXT NOT NULL, schema_version INTEGER NOT NULL);
                CREATE TABLE IF NOT EXISTS resource_state(
                  resource_key TEXT PRIMARY KEY,
                  generation INTEGER NOT NULL DEFAULT 0,
                  phase INTEGER NOT NULL DEFAULT 0,          -- LeasePhase
                  lease_id TEXT, owner_id TEXT, owner_type INTEGER,
                  process_instance_id TEXT, machine_name TEXT, host_process_id INTEGER,
                  epoch INTEGER NOT NULL DEFAULT 0, reason TEXT,
                  acquired_utc_ms INTEGER, expires_utc_ms INTEGER, updated_utc_ms INTEGER);
                CREATE TABLE IF NOT EXISTS lease_history(
                  event_id INTEGER PRIMARY KEY AUTOINCREMENT,
                  resource_key TEXT NOT NULL, generation INTEGER NOT NULL,
                  epoch INTEGER NOT NULL, lease_id TEXT, owner_id TEXT,
                  event_type TEXT NOT NULL, reason TEXT, utc_ms INTEGER NOT NULL);
                CREATE TABLE IF NOT EXISTS recovery_checkpoint(
                  resource_key TEXT PRIMARY KEY, epoch INTEGER NOT NULL,
                  status INTEGER NOT NULL,                    -- 0=Pending 1=Approved
                  physical_readback_json TEXT NOT NULL, approved_by TEXT,
                  evidence_utc_ms INTEGER NOT NULL);");
        }

        private long ReadOrInitEpoch()
        {
            using var conn = Open();
            var row = conn.Query<AuthorityMetaRow>(
                "SELECT epoch, boot_id FROM authority_meta WHERE authority_id=?", _authorityId)
                .FirstOrDefault();
            long nowMs = NowMs();
            if (row == null)
            {
                conn.Execute("INSERT INTO authority_meta VALUES(?,?,?,1)",
                    _authorityId, 1L, Guid.NewGuid().ToString("N"));
                return 1;
            }
            // æ¯æ¬¡è¿›ç¨‹æ‰“开同一权威域 â†’ boot_id å˜åŒ– â†’ epoch+1（重启使旧 Grant å¤±æ•ˆï¼‰
            conn.Execute("UPDATE authority_meta SET epoch=epoch+1, boot_id=? WHERE authority_id=?",
                Guid.NewGuid().ToString("N"), _authorityId);
            CurrentEpoch = row.epoch + 1;
            conn.Execute("INSERT INTO lease_history(resource_key,generation,epoch,lease_id,owner_id,event_type,reason,utc_ms)" +
                " VALUES('*',{0},{1},'','system','EpochBump','open-authority',{2})",
                CurrentEpoch, "", nowMs);
            return CurrentEpoch;
        }

        // ================= ILeaseCoordinator =================

        public AcquireOutcome Acquire(AcquireRequest request)
        {
            if (request.ResourceKeys.Length == 0)
                throw new ArgumentException("ResourceKeys ä¸èƒ½ä¸ºç©º");
            var keys = request.ResourceKeys.Select(NormKey).OrderBy(k => k, StringComparer.Ordinal)
                .Distinct().ToArray();

            var deadline = NowMs() + Math.Max(0, request.WaitTimeoutMs);
            while (true)
            {
                var outcome = TryAcquireOnce(keys, request);
                if (outcome.Code != AcquireResultCode.Timeout) return outcome;
                if (NowMs() >= deadline) { outcome.Code = AcquireResultCode.Timeout; return outcome; }
                System.Threading.Thread.Sleep(50);
            }
        }

        private AcquireOutcome TryAcquireOnce(string[] keys, AcquireRequest req)
        {
            long now = NowMs();
            using var conn = Open();
            using var tx = conn.BeginTransaction();   // é»˜è®¤å³ IMMEDIATE
            try
            {
                var grants = new List<LeaseGrant>(keys.Length);
                foreach (var key in keys)
                {
                    var st = conn.Query<ResourceStateRow>(
                        "SELECT * FROM resource_state WHERE resource_key=?", key).FirstOrDefault();
                    if (st != null && st.Phase == (int)LeasePhase.RecoveryRequired)
                    {
                        tx.Rollback();
                        return new AcquireOutcome
                        {
                            Code = AcquireResultCode.RecoveryBlocked,
                            RecoveryCheckpointKey = key
                        };
                    }
                    bool activeHeld = st != null && st.Phase == (int)LeasePhase.Active
                                      && st.ExpiresUtcMs > now;
                    if (activeHeld)
                    {
                        // åŒä¸€ LeaseId é‡å…¥ = ç»­æœŸè¯­ä¹‰ï¼ˆMVP ä¸åšè·¨è¿›ç¨‹ Reused，冲突即返回）
                        tx.Rollback();
                        return new AcquireOutcome
                        {
                            Code = AcquireResultCode.ConflictHeld,
                            Holder = new ConflictInfo
                            {
                                OwnerId = st!.OwnerId, OwnerType = (OwnerTypeV3)st.OwnerType,
                                MachineName = st.MachineName, HostProcessId = st.HostProcessId,
                                Reason = st.Reason, ExpiresUtcMs = st.ExpiresUtcMs
                            }
                        };
                    }

                    long gen = (st?.Generation ?? 0) + 1;
                    string leaseId = "lease_" + Guid.NewGuid().ToString("N").Substring(0, 12);
                    var exp = now + req.TtlSeconds * 1000L;

                    if (st == null)
                        conn.Execute(
                            @"INSERT INTO resource_state(resource_key,generation,phase,lease_id,owner_id,
                              owner_type,process_instance_id,machine_name,host_process_id,epoch,reason,
                              acquired_utc_ms,expires_utc_ms,updated_utc_ms)
                              VALUES(?,?,1,?,?,?,?,?,?,?,?,?,?,?,?)",
                            key, gen, leaseId, req.OwnerId, (int)req.OwnerType,
                            req.ProcessInstanceId, req.MachineName, req.HostProcessId,
                            CurrentEpoch, req.Reason, now, exp, now);
                    else
                        conn.Execute(
                            @"UPDATE resource_state SET generation=?, phase=1, lease_id=?, owner_id=?,
                              owner_type=?, process_instance_id=?, machine_name=?, host_process_id=?,
                              epoch=?, reason=?, acquired_utc_ms=?, expires_utc_ms=?, updated_utc_ms=?
                              WHERE resource_key=?",
                            gen, leaseId, req.OwnerId, (int)req.OwnerType, req.ProcessInstanceId,
                            req.MachineName, req.HostProcessId, CurrentEpoch, req.Reason,
                            now, exp, now, key);

                    conn.Execute(
                        @"INSERT INTO lease_history(resource_key,generation,epoch,lease_id,owner_id,event_type,reason,utc_ms)
                          VALUES(?,?,?,?,?,'Acquire',?,?)",
                        key, gen, CurrentEpoch, leaseId, req.OwnerId, req.Reason, now);
                    grants.Add(new LeaseGrant(_authorityId, key, leaseId, req.OwnerId,
                        req.OwnerType, CurrentEpoch, gen, exp));
                }
                tx.Commit();
                return new AcquireOutcome { Code = AcquireResultCode.Acquired, Grants = grants.ToArray() };
            }
            catch
            {
                try { tx.Rollback(); } catch { }
                throw;
            }
        }

        public bool Renew(LeaseGrant grant, int extendSeconds)
        {
            long now = NowMs();
            using var conn = Open();
            using var tx = conn.BeginTransaction();
            int n = conn.Execute(
                @"UPDATE resource_state SET expires_utc_ms=?, updated_utc_ms=?
                  WHERE resource_key=? AND lease_id=? AND generation=? AND epoch=?
                    AND phase=1 AND expires_utc_ms>?",
                now + extendSeconds * 1000L, now,
                NormKey(grant.ResourceKey), grant.LeaseId, grant.Generation, grant.Epoch, now);
            if (n == 1) tx.Commit(); else { tx.Rollback(); Log.Warn($"[Lease] ç»­æœŸå¤±è´¥(栅栏不符): {grant.ResourceKey} gen={grant.Generation}"); }
            return n == 1;
        }

        public bool Release(LeaseGrant grant, string note)
        {
            long now = NowMs();
            using var conn = Open();
            using var tx = conn.BeginTransaction();
            int n = conn.Execute(
                @"UPDATE resource_state SET phase=0, lease_id=NULL, owner_id=NULL,
                  expires_utc_ms=0, updated_utc_ms=?
                  WHERE resource_key=? AND lease_id=? AND generation=?",
                now, NormKey(grant.ResourceKey), grant.LeaseId, grant.Generation);
            conn.Execute(
                @"INSERT INTO lease_history(resource_key,generation,epoch,lease_id,owner_id,event_type,reason,utc_ms)
                  SELECT ?,?,?,?,?, 'Release', ?, ? WHERE ?=1",
                NormKey(grant.ResourceKey), grant.Generation, grant.Epoch, grant.LeaseId,
                grant.OwnerId, note, now, n);
            if (n == 1) tx.Commit(); else tx.Rollback();
            return n == 1;
        }

        public ConflictInfo? ProbeConflict(string resourceKey)
        {
            long now = NowMs();
            using var conn = Open();
            var st = conn.Query<ResourceStateRow>(
                "SELECT * FROM resource_state WHERE resource_key=? AND phase=1 AND expires_utc_ms>?",
                NormKey(resourceKey), now).FirstOrDefault();
            if (st == null) return null;
            return new ConflictInfo
            {
                OwnerId = st.OwnerId, OwnerType = (OwnerTypeV3)st.OwnerType,
                MachineName = st.MachineName, HostProcessId = st.HostProcessId,
                Reason = st.Reason, ExpiresUtcMs = st.ExpiresUtcMs
            };
        }

        public LeasePhase PhaseOf(string resourceKey)
        {
            using var conn = Open();
            var st = connQuery(conn, resourceKey);
            if (st == null) return LeasePhase.Free;
            if (st.Phase == (int)LeasePhase.RecoveryRequired) return LeasePhase.RecoveryRequired;
            if (st.Phase == (int)LeasePhase.Active && st.ExpiresUtcMs <= NowMs())
                return LeasePhase.RecoveryRequired; // è¯»ä¾§æƒ°æ€§åˆ¤å®šï¼Œå†™ä¾§ç”± SweepExpired è½åº“
            return (LeasePhase)st.Phase;
        }

        public int SweepExpired()
        {
            long now = NowMs();
            using var conn = Open();
            using var tx = conn.BeginTransaction();
            var expired = conn.Query<ResourceStateRow>(
                "SELECT * FROM resource_state WHERE phase=1 AND expires_utc_ms<=?", now);
            foreach (var st in expired)
            {
                conn.Execute("UPDATE resource_state SET phase=2, updated_utc_ms=? WHERE resource_key=?",
                    now, st.ResourceKey);
                conn.Execute(
                    @"INSERT INTO lease_history(resource_key,generation,epoch,lease_id,owner_id,event_type,reason,utc_ms)
                      VALUES(?,?,?,?,?,'ExpiredToRecovery','ttl-missed',?)",
                    st.ResourceKey, st.Generation, st.Epoch, st.LeaseId, st.OwnerId, now);
                conn.Execute(
                    @"INSERT OR REPLACE INTO recovery_checkpoint(resource_key,epoch,status,physical_readback_json,approved_by,evidence_utc_ms)
                      VALUES(?,?,0,'{}',NULL,?)", st.ResourceKey, st.Epoch, now);
            }
            tx.Commit();
            return expired.Count;
        }

        public bool ApproveRecovery(string resourceKey, string readbackJson, string approvedBy)
        {
            long now = NowMs();
            using var conn = Open();
            using var tx = conn.BeginTransaction();
            conn.Execute(
                @"INSERT OR REPLACE INTO recovery_checkpoint(resource_key,epoch,status,physical_readback_json,approved_by,evidence_utc_ms)
                  VALUES(?,?,1,?,?,?)", NormKey(resourceKey), CurrentEpoch, readbackJson, approvedBy, now);
            int n = conn.Execute(
                @"UPDATE resource_state SET phase=0, lease_id=NULL, owner_id=NULL, updated_utc_ms=?
                  WHERE resource_key=? AND phase=2", now, NormKey(resourceKey));
            conn.Execute(
                @"INSERT INTO lease_history(resource_key,generation,epoch,lease_id,owner_id,event_type,reason,utc_ms)
                  SELECT resource_key,generation,epoch,'','system','RecoveryApproved',?,? FROM resource_state WHERE resource_key=?",
                approvedBy, now, NormKey(resourceKey));
            tx.Commit();
            return n == 1;
        }

        /// <summary>测试与 Supervisor ç”¨ï¼šå¤–部强制提升 epoch（等效 Broker/宿主重启）。</summary>
        public void BumpEpochForTest(string reason)
        {
            using var conn = Open();
            conn.Execute("UPDATE authority_meta SET epoch=epoch+1, boot_id=? WHERE authority_id=?",
                Guid.NewGuid().ToString("N"), _authorityId);
            CurrentEpoch = conn.Query<AuthorityMetaRow>(
                "SELECT epoch, boot_id FROM authority_meta WHERE authority_id=?", _authorityId)
                .First().epoch;
            Log.Info($"[Lease] epoch æå‡è‡³ {CurrentEpoch}: {reason}");
        }

        // ================= è¾…助 =================

        /// <summary>V3 è§„范：统一小写、固定分隔符、Ordinal æ¯”较（§4.1）。</summary>
        public static string NormKey(string key) => key.Trim().ToLowerInvariant().Replace(' ', '-');

        private static long NowMs() => DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
        private ResourceStateRow? connQuery(SQLiteConnection c, string k) =>
            c.Query<ResourceStateRow>("SELECT * FROM resource_state WHERE resource_key=?", NormKey(k)).FirstOrDefault();

        private class AuthorityMetaRow
        {
            public long epoch { get; set; }
            public string boot_id { get; set; } = "";
        }
        private class ResourceStateRow
        {
            public string ResourceKey { get; set; } = "";
            public long Generation { get; set; }
            public int Phase { get; set; }
            public string? LeaseId { get; set; }
            public string? OwnerId { get; set; }
            public int OwnerType { get; set; }
            public string? MachineName { get; set; }
            public int HostProcessId { get; set; }
            public long Epoch { get; set; }
            public string? Reason { get; set; }
            public long ExpiresUtcMs { get; set; }
            public static implicit operator bool(ResourceStateRow? r) => r is not null;
        }
    }
}
```

> æ³¨æ„ï¼šåˆ—名与行属性映射依赖 `SQLite.NET` çš„列名匹配（下划线列需显式 `[Column]`）。上表 DDL ç”¨ `resource_key` ç­‰ snake_case，而 `ResourceStateRow` å±žæ€§æ˜¯ PascalCase——实现时在类上启用 `SQLite.NET` æ˜ å°„修正：**统一改 DDL åˆ—名为与属性一致的 PascalCase**（SQLite åˆ—名大小写不敏感但查询串要一致）。落地执行者以此为准调整 DDL，保证二者一致（这是本任务唯一的“对齐”工作，测试会立刻暴露不匹配）。

- [ ] **Step 4: Aging.Infrastructure ç¼–译验证**

```powershell
cd d:\TestPlatform\TapProject
& "C:\Program Files\Microsoft Visual Studio\2022\Community\MSBuild\Current\Bin\MSBuild.exe" Aging.Infrastructure\Aging.Infrastructure.csproj /p:Configuration=Debug /p:Platform=AnyCPU /t:Build /v:minimal
```
预期：无 error；出现 `Aging.Infrastructure -> ...dll`。

- [ ] **Step 5: è¿è¡Œç§Ÿçº¦æµ‹è¯•å…¨ç»¿**

```powershell
dotnet test tests\Aging.MvpTests\Aging.MvpTests.csproj --filter DbLeaseStoreTests
```
预期：`failed: 0, passed: 8`

- [ ] **Step 6: Commit**

```powershell
git add Aging.Infrastructure tests
git commit -m "feat(lease): DbLeaseStore è·¨è¿›ç¨‹ç§Ÿçº¦ï¼ˆTTL/栅栏/epoch/RecoveryRequired）"
```

---

## Task 3: LayeredResourceManager + Bootstrapper æŽ¥çº¿ï¼ˆä¸Šå±‚零改动打通跨进程）

**Files:**
- Create: `Aging.Infrastructure/Core/LayeredResourceManager.cs`
- Modify: `Aging.Infrastructure/InfrastructureBootstrapper.cs`（注册处）
- Test: `tests/Aging.MvpTests/LayeredResourceManagerTests.cs`

- [ ] **Step 1: å†™å¤±è´¥æµ‹è¯•**

`tests/Aging.MvpTests/LayeredResourceManagerTests.cs`：

```csharp
using System.IO;
using System.Threading;
using Aging.Infrastructure.Core;
using Aging.Infrastructure.Contracts;
using Xunit;

namespace Aging.MvpTests
{
    public class LayeredResourceManagerTests : System.IDisposable
    {
        private readonly string _dbPath;
        private readonly LayeredResourceManager _rm;

        public LayeredResourceManagerTests()
        {
            _dbPath = Path.Combine(Path.GetTempPath(), "arb_" + System.Guid.NewGuid().ToString("N") + ".db");
            _rm = new LayeredResourceManager(new DbLeaseStore(_dbPath, "local-main"));
        }
        public void Dispose() { try { File.Delete(_dbPath); } catch { } }

        [Fact]
        public void ReserveAsync_Then_ValidateOwner_True()
        {
            var owner = new ResourceOwnerToken(OwnerType.Maintenance, "W01");
            var key = new ResourceKey("CAN-002", "CAN");
            var res = _rm.ReserveAsync(owner, key, CancellationToken.None).GetAwaiter().GetResult();
            Assert.Equal(ReservationState.Active, res.State);
            Assert.True(_rm.ValidateOwner(owner, key));
        }

        [Fact]
        public void ReserveAsync_Conflict_ExceptionCarriesHolder()
        {
            var a = new ResourceOwnerToken(OwnerType.Maintenance, "holder-A");
            var b = new ResourceOwnerToken(OwnerType.Production, "requester-B");
            var key = new ResourceKey("CAN-002", "CAN");
            _rm.ReserveAsync(a, key, CancellationToken.None).GetAwaiter().GetResult();
            var ex = Assert.Throws<ResourceConflictException>(() =>
                _rm.ReserveAsync(b, key, CancellationToken.None).GetAwaiter().GetResult());
            Assert.Contains("holder-A", ex.Message);   // UI ç›´æŽ¥å¼¹å ç”¨è€…
        }

        [Fact]
        public void ReleaseReservationAsync_Then_OtherCanReserve()
        {
            var a = new ResourceOwnerToken(OwnerType.Maintenance, "A");
            var b = new ResourceOwnerToken(OwnerType.Production, "B");
            var key = new ResourceKey("CAN-002", "CAN");
            _rm.ReserveAsync(a, key, CancellationToken.None).GetAwaiter().GetResult();
            _rm.ReleaseReservationAsync(a, key, CancellationToken.None).GetAwaiter().GetResult();
            var ok = _rm.ReserveAsync(b, key, CancellationToken.None).GetAwaiter().GetResult();
            Assert.Equal(ReservationState.Active, ok.State);
        }
    }
}
```

- [ ] **Step 2: è¿è¡Œç¡®è®¤å¤±è´¥** â€” `dotnet test ... --filter LayeredResourceManagerTests`，预期编译失败（类型不存在）。

- [ ] **Step 3: å®žçŽ° LayeredResourceManager**

`Aging.Infrastructure/Core/LayeredResourceManager.cs`（内存细锁 + DbLeaseStore ç»„合，对上层 `IResourceManager` ç­¾åé›¶æ”¹åŠ¨ï¼‰ï¼š

```csharp
using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
using Aging.Infrastructure.Contracts;
using Aging.ResourceContracts;
using log4net;

namespace Aging.Infrastructure.Core
{
    /// <summary>V3.0 Â§9 è¿‡æ¸¡ Adapter è·¯çº¿ï¼šReserve/Validate/Release è½¬å‘ arb.db ç§Ÿçº¦è¡¨ï¼Œ
    /// grant å›žå­˜ TokenId→LeaseGrant[]，供门面/调试会话取用。</summary>
    public sealed class LayeredResourceManager : IResourceManager
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(LayeredResourceManager));
        private readonly ILeaseCoordinator _lease;
        private readonly ConcurrentDictionary<string, SemaphoreSlim> _localLocks = new();
        private readonly ConcurrentDictionary<string, LeaseGrant[]> _grantsByToken = new();

        public LayeredResourceManager(ILeaseCoordinator lease) => _lease = lease;
        public ILeaseCoordinator Lease => _lease;
        public bool TryGetGrants(string tokenId, out LeaseGrant[] grants) => _grantsByToken.TryGetValue(tokenId, out grants!);

        public async Task<ResourceReservation> ReserveAsync(
            ResourceOwnerToken owner, ResourceKey resource, CancellationToken ct)
        {
            var sem = _localLocks.GetOrAdd(resource.ToString(), _ => new SemaphoreSlim(1, 1));
            await sem.WaitAsync(ct).ConfigureAwait(false);
            try
            {
                var req = new AcquireRequest
                {
                    OwnerId = owner.OwnerId,
                    OwnerType = owner.OwnerType == OwnerType.Maintenance
                        ? OwnerTypeV3.Maintenance : OwnerTypeV3.Production,
                    Reason = "ReserveAsync",
                    ResourceKeys = new[] { resource.ToString() },
                    WaitTimeoutMs = 0     // MVP：占用即拒，不排队（V3 çŸ©é˜µåˆæ³•åˆ†æ”¯ï¼‰
                };
                var outcome = _lease.Acquire(req);
                switch (outcome.Code)
                {
                    case AcquireResultCode.Acquired:
                        _grantsByToken[owner.TokenId] = outcome.Grants;
                        owner.Generation = outcome.Grants[0].Generation;
                        return new ResourceReservation(resource, owner) { State = ReservationState.Active };
                    case AcquireResultCode.ConflictHeld:
                        var h = outcome.Holder!;
                        long leftSec = Math.Max(0, (h.ExpiresUtcMs - DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()) / 1000);
                        throw new ResourceConflictException(
                            $"资源 {resource} æ­£è¢«å ç”¨ï¼š{h.OwnerId}（{(h.OwnerType == OwnerTypeV3.Maintenance ? "维护" : "生产")}，机器 {h.MachineName} PID {h.HostProcessId}，剩余租约 {leftSec}s）");
                    case AcquireResultCode.RecoveryBlocked:
                        throw new ResourceConflictException(
                            $"资源 {resource} ä¸Šæ¬¡æŒæœ‰è€…崩溃，待恢复回收（需读回探测证据后在监控页批准）");
                    default:
                        throw new TimeoutException($"资源 {resource} ç”³è¯·è¶…æ—¶");
                }
            }
            finally { sem.Release(); }
        }

        public Task<IOperationLease> AcquireOperationAsync(
            ResourceOwnerToken owner, ResourceKey resource, CancellationToken ct)
        {
            // MVP：命令级串行由 SessionGate（Broker é˜Ÿåˆ—）/Local å†… SemaphoreSlim æä¾›ï¼›
            // æœ¬å±‚只校验栅栏。NoopLease éœ€æŒ‰ Contracts/IOperationLease.cs å®žé™…成员补齐空实现。
            if (!ValidateOwner(owner, resource))
                throw new InvalidOperationException($"资源 {resource} æ …栏校验失败（owner å·²å¤±æ•ˆï¼‰");
            return Task.FromResult<IOperationLease>(new NoopLease());
        }

        public async Task ReleaseReservationAsync(
            ResourceOwnerToken owner, ResourceKey resource, CancellationToken ct)
        {
            var sem = _localLocks.GetOrAdd(resource.ToString(), _ => new SemaphoreSlim(1, 1));
            await sem.WaitAsync(ct).ConfigureAwait(false);
            try
            {
                if (_grantsByToken.TryGetValue(owner.TokenId, out var grants))
                {
                    foreach (var g in grants) _lease.Release(g, "ReleaseReservationAsync");
                    _grantsByToken.TryRemove(owner.TokenId, out _);
                }
            }
            finally { sem.Release(); }
        }

        public bool IsReserved(ResourceKey resource, out ResourceReservation? reservation)
        {
            var holder = _lease.ProbeConflict(resource.ToString());
            reservation = holder == null ? null : new ResourceReservation(resource,
                new ResourceOwnerToken(holder.OwnerType == OwnerTypeV3.Maintenance
                    ? OwnerType.Maintenance : OwnerType.Production, holder.OwnerId))
                { State = ReservationState.Active };
            return holder != null;
        }

        public bool ValidateOwner(ResourceOwnerToken owner, ResourceKey resource)
        {
            if (!_grantsByToken.TryGetValue(owner.TokenId, out var grants)) return false;
            string key = resource.ToString();
            foreach (var g in grants)
            {
                if (!string.Equals(g.ResourceKey, key, StringComparison.OrdinalIgnoreCase)) continue;
                // æ …栏：用 extendSeconds=1 çš„续期作存在性检查（epoch/generation/phase å¿…须全命中）
                try { return _lease.Renew(g, 1); } catch { return false; }
            }
            return false;
        }

        private sealed class NoopLease : IOperationLease
        {
            public void Dispose() { }
        }
    }
}
```

> æ³¨ï¼šè‹¥ `IOperationLease` å« `ReleaseAsync` ç­‰é¢å¤–成员，NoopLease æŒ‰å…¶å®žé™…签名补齐；先看 `Contracts/IOperationLease.cs`。

- [ ] **Step 4: Bootstrapper æŽ¥çº¿**

`InfrastructureBootstrapper.Initialize` ä¸­ï¼Œå°† `var resourceManager = new ResourceManager();` æ›¿æ¢ä¸ºï¼š

```csharp
// V3.0 MVP：仲裁库 arb.db（与 data.db åŒç›®å½•ï¼‰
string arbPath = Path.Combine(Path.GetDirectoryName(deviceConfigDbPath)!, "arb.db");
var leaseStore = new DbLeaseStore(arbPath, "local-main");
var resourceManager = new LayeredResourceManager(leaseStore);
UtilContainer.RegisterUtil("LeaseCoordinator", leaseStore);
```

其余注册不变（DeviceService/AutoDeviceFacade æŒæœ‰çš„ resourceManager å·²æ˜¯è·¨è¿›ç¨‹ç‰ˆï¼‰ã€‚æ—§ `ResourceManager` ç±»ä¿ç•™ä¸åˆ ï¼ˆä½œä¸ºæ—  DB é™çº§å¤‡é€‰ï¼‰ã€‚

- [ ] **Step 5: ç¼–译 + æµ‹è¯•å…¨ç»¿**

```powershell
& "C:\Program Files\Microsoft Visual Studio\2022\Community\MSBuild\Current\Bin\MSBuild.exe" Aging.Infrastructure\Aging.Infrastructure.csproj /p:Configuration=Debug /p:Platform=AnyCPU /t:Build /v:minimal
dotnet test tests\Aging.MvpTests\Aging.MvpTests.csproj
```
预期：MSBuild æ—  error；全部测试 Pass。

- [ ] **Step 6: Commit**

```powershell
git add Aging.Infrastructure
git commit -m "feat(lease): LayeredResourceManager ç»„合仲裁，上层零改动跨进程生效"
```

---

## Task 4: AutoDeviceFacade å‡çº§ â€”— å¿ƒè·³ç»­æœŸ + LeaseLost + ReleaseAsync

**Files:**
- Modify: `Aging.Infrastructure/Contracts/IAutoDeviceFacade.cs`
- Modify: `Aging.Infrastructure/Services/AutoDeviceFacade.cs`
- Test: `tests/Aging.MvpTests/FacadeLeaseLifecycleTests.cs`

- [ ] **Step 1: å†™æµ‹è¯•ï¼ˆéªŒè¯é—¨é¢ä¾èµ–的租约语义）**

```csharp
using System;
using System.IO;
using System.Threading;
using Aging.Infrastructure.Core;
using Aging.ResourceContracts;
using Xunit;

namespace Aging.MvpTests
{
    public class FacadeLeaseLifecycleTests : IDisposable
    {
        private readonly string _dbPath;
        private readonly DbLeaseStore _store;
        public FacadeLeaseLifecycleTests()
        {
            _dbPath = Path.Combine(Path.GetTempPath(), "arb_" + Guid.NewGuid().ToString("N") + ".db");
            _store = new DbLeaseStore(_dbPath, "local-main");
        }
        public void Dispose() { try { File.Delete(_dbPath); } catch { } }

        private LeaseGrant Grab(string key, int ttl)
            => _store.Acquire(new AcquireRequest
            {
                OwnerId = "f", OwnerType = OwnerTypeV3.Production,
                ResourceKeys = new[] { key }, TtlSeconds = ttl
            }).Grants[0];

        [Fact]
        public void Heartbeat_Renew_Extends_Expiry()
        {
            var g = Grab("can/x", 2);
            long before = g.ExpiresUtcMs;
            Thread.Sleep(1200);
            Assert.True(_store.Renew(g, 2));
            Assert.True(_store.ProbeConflict("can/x").ExpiresUtcMs > before);
        }

        [Fact]
        public void Expired_Sweep_StaleRenew_False_And_RecoveryBlocked()
        {
            var g = Grab("can/y", 1);
            Thread.Sleep(1500);
            Assert.Equal(1, _store.SweepExpired());                 // è¿‡æœŸâ†’RecoveryRequired
            Assert.False(_store.Renew(g, 5));                        // ç†”断信号：续期必败
            Assert.Null(_store.ProbeConflict("can/y"));              // ä¸å†æ˜¾ç¤º Active
            Assert.Equal(LeasePhase.RecoveryRequired, _store.PhaseOf("can/y"));
        }
    }
}
```

- [ ] **Step 2: è¿è¡Œæµ‹è¯•** â€” `dotnet test ... --filter FacadeLeaseLifecycleTests`。两测试直接验证 Task 2 è¯­ä¹‰ï¼Œåº” Pass；若 Fail å…ˆä¿® Task 2 å†ç»§ç»­ã€‚

- [ ] **Step 3: æ‰©å±• IAutoDeviceLease æŽ¥å£ï¼ˆå åŠ æˆå‘˜ï¼Œæ—¢æœ‰ä¸åŠ¨ï¼‰**

```csharp
        /// <summary>V3.0：租约失效（续期连续失败/被回收）时触发；订阅者应停止下发。</summary>
        event EventHandler LeaseLost;
        /// <summary>V3.0：显式异步释放。Dispose() ä»åŒæ­¥å¯ç”¨ã€‚</summary>
        System.Threading.Tasks.Task ReleaseAsync(System.Threading.CancellationToken ct = default);
        /// <summary>V3.0：维护让渡请求（Draining é¢„留，MVP æ’ false）。</summary>
        bool HandoverRequested { get; }
```

- [ ] **Step 4: AutoDeviceLease å®žçŽ°å¿ƒè·³**

`AutoDeviceFacade.cs` å…³é”®ç‚¹ï¼š
1. æž„造新增可选参数 `ILeaseCoordinator leaseCoordinator = null`（Bootstrapper ä¼ å…¥ï¼›null ä¿æŒæ—§è¡Œä¸ºï¼‰ï¼›
2. `AcquireAsync` ä¿ç•™æ—¢æœ‰ Reserve，若持有 LayeredResourceManager åˆ™ `TryGetGrants(owner.TokenId, out grants)` åŽ `lease.StartHeartbeat(coordinator, grants)`；
3. Lease å†…新增：

```csharp
        private LeaseGrant[] _grants = new LeaseGrant[0];
        private Timer _beacon;
        private int _renewFailures;
        private ILeaseCoordinator _coordinator;
        public event EventHandler LeaseLost;
        public bool HandoverRequested => false;

        internal void StartHeartbeat(ILeaseCoordinator coordinator, LeaseGrant[] grants)
        {
            _coordinator = coordinator; _grants = grants;
            _beacon = new Timer(_ =>
            {
                if (_disposed) return;
                try
                {
                    bool allOk = true;
                    foreach (var g in _grants)
                        if (!_coordinator.Renew(g, 30)) { allOk = false; break; }
                    _renewFailures = allOk ? 0 : _renewFailures + 1;
                    if (_renewFailures >= 2) LeaseLost?.Invoke(this, EventArgs.Empty);  // è¿ž2失败→熔断
                }
                catch { if (++_renewFailures >= 2) LeaseLost?.Invoke(this, EventArgs.Empty); }
            }, null, 8000, 8000);
        }

        public Task ReleaseAsync(CancellationToken ct = default)
        {
            _beacon?.Dispose(); _beacon = null;   // å…ˆåœå¿ƒè·³ï¼Œå†èµ°æ—¢æœ‰é‡Šæ”¾é“¾
            Dispose();
            return Task.CompletedTask;
        }
```

`Dispose()` å¼€å¤´åŠ  `_beacon?.Dispose()`；`ExecuteAsync/QueryAsync` å¼€å¤´åŠ  `if (_renewFailures >= 2) throw new InvalidOperationException("LEASE_STALE: ç§Ÿçº¦å·²å¤±æ•ˆ");`。

- [ ] **Step 5: å…¨é‡æµ‹è¯• + ç¼–译 + Commit**

```powershell
dotnet test tests\Aging.MvpTests\Aging.MvpTests.csproj
& "...MSBuild.exe" Aging.Infrastructure\Aging.Infrastructure.csproj /p:Configuration=Debug /p:Platform=AnyCPU /t:Build /v:minimal
git add Aging.Infrastructure tests
git commit -m "feat(facade): å¿ƒè·³ç»­æœŸ+LeaseLost熔断+ReleaseAsync"
```

---

## Task 5: æ³¨å†Œé¡µ"执行位置"UI + å‘布门禁（最小版，补齐范围表已承诺项）

> èƒŒæ™¯ï¼šèŒƒå›´è¡¨ä¸­â€œæ³¨å†Œé¡µ executionMode/authorityId/sessionKey/accessPolicy + å‘布门禁 + ä¸å¯å˜å¿«ç…§å“ˆå¸Œâ€æ­¤å‰æ— å¯¹åº”实施任务，本节为补齐。

**Files:**
- Modify: `Plugin.DeviceConfig/Entity/DeviceDefinition.cs`（新增 ExecutionModeKind æžšä¸¾ + 5 å­—段 + åªè¯»æ´¾ç”Ÿ AccessPolicy）
- Create: `Plugin.DeviceConfig/V3AuthorityCatalog.cs`（仲裁域/Broker å€™é€‰ç”±å®¿ä¸» appSettings æžšä¸¾ï¼Œæœªé…ç½®å›žé€€é»˜è®¤ local-main;broker-b01）
- Modify: `Plugin.DeviceConfig/Plugin.DeviceConfig.csproj`（引用 System.Configuration）
- Modify: `Plugin.DeviceConfig/DeviceEditModal.xaml(.cs)`（“执行位置”区块：Local/Broker å•é€‰ã€AuthorityId å¿…填下拉、Broker æ—¶ BrokerId/OwnerProcessId/PhysicalSessionKey å†™æ­»å€™é€‰ã€AccessPolicy åªè¯»ï¼‰
- Modify: `Plugin.DeviceConfig/Model/DeviceConfigModel.cs`（建表新列 + PRAGMA è¿ç§»ã€SaveDevice/Map å«æ–°åˆ—、ComputeConfigHash çº³å…¥æ‰§è¡Œä½ç½®ã€æ–°å¢ž ValidatePublishGate）
- Modify: `Plugin.DeviceConfig/DeviceConfig.xaml(.cs)`（详情栏展示执行位置/仲裁域；PublishVersion å…ˆè·‘门禁，未通过拦截）
- Create: `Plugin.IntegrationTest/App.config`（V3.AuthorityIds / V3.BrokerIds å€™é€‰æžšä¸¾ï¼‰

- [ ] **Step 1: å­—段定义按 V3.0 Â§05“执行位置”行：**

| æŽ§ä»¶ | å­—段 | è§„则 |
|---|---|---|
| RadioButton Ã—2 | ExecutionMode=Local/Broker | é»˜è®¤ Local；互斥联动仲裁域 |
| ComboBox | AuthorityId | å¿…填，候选来自 V3AuthorityCatalog.AuthorityIds（配置枚举） |
| ComboBox | BrokerId | ä»… Broker；候选 BrokerIds；门禁要求 BrokerId==AuthorityId（设备域一致） |
| åªè¯» TextBox | OwnerProcessId | MVP å ä½å½“前进程 PID；不入配置哈希（运行期信息） |
| å¯ç¼–辑 ComboBox | PhysicalSessionKey | ä»… Broker；候选为端点规范化的写死字符串（can/{bus}/main、tcp/{ip:port}/main、serial/{COM}/main、{deviceId}/main ç­‰ï¼‰ |
| åªè¯» TextBox | AccessPolicy | æ´¾ç”Ÿï¼šLocal→独占直连；Broker→共享仲裁 SessionGate ä»£ç†ï¼›ä¸è½åº“ |

- [ ] **Step 2: å‘布门禁 ValidatePublishGate（V3.0 Â§05 æ ¡éªŒåˆ—）：** AuthorityId å¿…填且在候选枚举内；Local è®¾å¤‡åŸŸå¿…é¡» local- å‰ç¼€ï¼›Broker è®¾å¤‡ BrokerId å¿…填、在枚举内且与 AuthorityId ä¸€è‡´ã€PhysicalSessionKey å¿…填；同一 PhysicalSessionKey åªå…è®¸ä¸€ä¸ªå®¿ä¸»åŸŸï¼ˆâ€œåŒä¸€ä¼šè¯åªèƒ½æœ‰ä¸€ä¸ªå®¿ä¸»â€ï¼‰ã€‚任一失败阻止发布并列出错误。

- [ ] **Step 3: å…¼å®¹æ€§ï¼š** æ—§åº“经 PRAGMA+ALTER è¡¥åˆ—；存量设备 ExecutionMode é»˜è®¤ Local、AuthorityId ç©ºâ€”—注册页打开时预选本机 Local åŸŸï¼Œå‘布时要求重新保存（门禁提示存量数据）；集成测试预置设备（不经发布链路）不受影响；配置哈希新增执行位置段，旧草稿哈希与新计算不一致属预期（配置确实变更）。

- [ ] **Step 4: æ‰‹å·¥éªŒè¯ + ç¼–译**

验证路径：新增设备选 Broker â†’ ç¡®è®¤ BrokerId/会话键候选自动生成且访问策略只读；保存后编辑回显；带空 AuthorityId å­˜é‡è®¾å¤‡ç‚¹â€œå‘布” â†’ é—¨ç¦æ‹¦æˆªå¹¶æç¤ºï¼›é‡æ–°ä¿å­˜åŽå‘布成功且 Hash å˜åŒ–。编译（用 VS MSBuild，不加 Platform）：

```powershell
& "...MSBuild.exe" Plugin.IntegrationTest\Plugin.IntegrationTest.csproj /t:Build /p:Configuration=Debug /v:minimal
```

- [ ] **Step 5: Commit**

```powershell
git add Plugin.DeviceConfig Plugin.IntegrationTest\App.config docs
git commit -m "feat(deviceconfig): æ³¨å†Œé¡µæ‰§è¡Œä½ç½®åŒºå—+发布门禁（V3.0 Â§05 æœ€å°ç‰ˆï¼‰"
```

推迟项（P2+）：多 Authority è·¨æœºå€™é€‰è‡ªåŠ¨å‘现、发布预览差异展示、SlotDeviceMapping â€œå…±äº«æ˜ å°„显式标注”。

---

## Task 6: Broker IPC å¸§åè®® + ä»£ç†é©±åŠ¨ï¼ˆå®¢æˆ·ç«¯ä¾§ï¼‰

**Files:**
- Create: `Aging.ResourceContracts/BrokerIpc.cs`（4 å­—节大端长度前缀 + UTF8 JSON å°å¥—编解码；SubmitBody/ResultBody çº¿æ ¼å¼ DTO，规避 LeaseGrant åªè¯»æž„造器反序列化限制）
- Create: `Aging.Infrastructure/Broker/BrokerClientChannel.cs`（命名管道客户端：Hello æ¡æ‰‹éªŒåè®®ä¸»ç‰ˆæœ¬ï¼›RequestId/CorrelationId å“åº”关联；deadline/超时；读循环断线感知 + æƒ°æ€§é‡è¿žï¼›ä¿®å¤æ—§ PipeClient â€œWriteMessage åŽç«‹å³ return”不可达响应问题）
- Create: `Aging.Infrastructure/Broker/BrokerPipeName.cs`（服务名 `aging.{brokerId}.v{协议主版本}`，V3.0 Â§13）
- Create: `Aging.Infrastructure/Broker/DeviceConfigHash.cs`（从 data.db è®¡ç®—与 DeviceConfigModel.ComputeConfigHash åŒè§„则的快照哈希，表缺失时跳过空段；两侧同函数保证可对账）
- Create: `Aging.Infrastructure/Drivers/BrokeredCanDriver.cs`（实现 IDeviceDriver，命令语义与 CanDriverAdapter å¯¹é½ï¼›Broker è¿”回态→本地异常：RejectedStaleLease→LEASE_STALE、RejectedConfigMismatch→CONFIG_MISMATCH、Unknown→TimeoutException ç¦æ­¢å‡å®šæœªæ‰§è¡Œï¼‰
- Modify: `Aging.Infrastructure/InfrastructureBootstrapper.cs`（新增 RegisterBrokeredDrivers：扫 data.db ä¸­ ExecutionMode=Broker è®¾å¤‡â†’注册代理驱动 + æºå¯åŠ¨æ—¶ configHash；失败降级不阻塞 Local é“¾è·¯ï¼‰

- [x] **Step 1: åè®®/通道/驱动实现**（帧=4字节大端长度+JSON；OneShot åŒæ­¥æ¨¡åž‹ï¼šCONNECT/DISCONNECT/SEND/QUERY/STATUS ç™½åå•ï¼‰
- [x] **Step 2: æŽ¥çº¿**（上层 IDeviceService/IAutoDeviceFacade/调试页零改动：代理点选在驱动层）
- [x] **Step 3: ç¼–译通过 + åŽç»­ Task 7 e2e éªŒè¯**

---

## Task 7: DeviceBroker.exe å®¿ä¸» + å…¨é“¾è·¯ e2e + ä¸»ç¨‹åºè‡ªåŠ¨æ‹‰èµ·

**Files:**
- Create: `DeviceBroker/DeviceBroker.csproj`（net472 Exe，x64；已加入 `WPFProject\TapProject.sln`）
- Create: `DeviceBroker/BrokerServer.cs`（管道多实例接受循环；每请求三重关卡：①OpCode ç™½åå•+域内设备过滤 â‘¡INV-04 configHash å¯¹è´¦ï¼ˆ2s æƒ°æ€§é‡ç®—）③INV-01/03 æ …栏再校验（PhaseOf/ProbeConflict，无活跃租约拒绝直接 I/O，仅 DISCONNECT è±å…ï¼‰ï¼›SessionGate æŒ‰ PhysicalSessionKey ä¸²è¡ŒåŽŸå­ç‰‡æ®µï¼›é˜Ÿåˆ—超时→RESOURCE_BUSY（确定未执行可安重试）；片段中异常→SEND/QUERY ä¿å®ˆåˆ¤ Unknown）
- Create: `DeviceBroker/Program.cs`（--db/--arb/--broker å‚数，默认指向集成测试环境目录；Ctrl+C ä¼˜é›…退出，租约靠 TTL è¿‡æœŸ+人工回收）
- Create: `tests/Aging.MvpTests/BrokerE2ETests.cs`（6 ç”¨ä¾‹ï¼šæœ‰ç§Ÿçº¦æ­£å‘链路 / æ— ç§Ÿçº¦æ‹’绝 / å“ˆå¸Œä¸åŒ¹é…æ‹’绝 / å½’还后拒绝 / åŒä¼šè¯ä¸²è¡Œ / ç»´æŠ¤å†™æƒæ”¾è¡Œï¼›æ¯ç”¨ä¾‹å”¯ä¸€ brokerId â†’ ç‹¬ç«‹ç®¡é“名隔离并行）
- Modify: `Plugin.IntegrationTest/MainWindow.xaml.cs`（InitializeAutoServices æ£€æµ‹ Broker è®¾å¤‡â†’自动拉起 DeviceBroker.exe；Window_Closing åœæœºæ¸…理）
- Modify: `tests/Aging.MvpTests/Aging.MvpTests.csproj`（引用 DeviceBroker）

- [x] **Step 1: å®¿ä¸»å®žçŽ° + å·¥ç¨‹å…¥ sln**
- [x] **Step 2: e2e æµ‹è¯•ï¼ˆTDD）** â€” é¦–轮红：DeviceConfigHash å¯¹ç¼ºè¡¨å´©æºƒï¼ˆno such table: DeviceChannel）；修复：缺表跳过空段（哈希对“不存在”与“零行”一致）；二轮全绿
- [x] **Step 3: è°ƒè¯•é¡µç»´æŠ¤å†™æƒé“¾è·¯ç¡®è®¤** â€” DeviceDebug.InitFinish å·²ä»Ž UtilContainer å– LayeredResourceManager；RequestMaintenance çš„维护租约经 arb.db è·¨è¿›ç¨‹äº’斥（占用即拒绝）；Broker è®¾å¤‡ç»´æŠ¤å†™ = ç»´æŠ¤ç§Ÿçº¦å…¥ arb.db â†’ broker æ …栏检出 Active æ”¾è¡Œï¼Œæ— éœ€æ–°ä»£ç ï¼›e2e ä»¥ MaintenanceLease_BrokeredWrite_Succeeds è¦†ç›–
- [x] **Step 4: å…¨é‡éªŒè¯** â€” MvpTests 22/22；主程序/宿主 MSBuild exit 0

已知简化（P2+）：owner↔clientInstanceId ç²¾ç¡®å¯¹é½ï¼ˆå½“前同机 arb.db åªåšå­˜åœ¨æ€§/相位检查）、周期任务/订阅/Outbox、跨机部署。

---

 docs/ÒÇÆ÷×¢²áÓëµ÷ÊÔ_Âß¼­ÓëʱÐòÊáÀí.html

New file
@@ -0,0 +1,333 @@
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>仪器注册与硬件调试 Â· è½¯ä»¶é€»è¾‘与时序梳理（V3.0 æ··åˆæž¶æž„ Â· 2026-11-09）</title>
<style>
:root{--bg:#f6f7f9;--card:#fff;--ink:#24292f;--sub:#57606a;--line:#d0d7de;--blue:#0b5cad;--green:#1a7f37;--red:#cf222e;--orange:#bc4c00;--purple:#8250df;--code:#f0f2f5}
*{box-sizing:border-box}body{margin:0;font-family:"Microsoft YaHei","Segoe UI",sans-serif;background:var(--bg);color:var(--ink);line-height:1.7}
.wrap{max-width:1080px;margin:0 auto;padding:24px 20px 80px}
header{background:linear-gradient(135deg,#0b3d6e,#0b5cad 60%,#127fc4);color:#fff;border-radius:12px;padding:26px 30px;margin-bottom:22px}
header h1{margin:0 0 8px;font-size:24px}header p{margin:2px 0;opacity:.88;font-size:13.5px}
.badge{display:inline-block;background:rgba(255,255,255,.16);border:1px solid rgba(255,255,255,.35);border-radius:20px;padding:1px 12px;font-size:12px;margin:6px 8px 0 0}
h2{font-size:19px;margin:34px 0 12px;padding-left:12px;border-left:5px solid var(--blue)}
h3{font-size:15.5px;margin:22px 0 8px;color:#0b3d6e}
.card{background:var(--card);border:1px solid var(--line);border-radius:10px;padding:16px 20px;margin:10px 0}
pre.seq{background:#0f1720;color:#cfe3f5;border-radius:8px;padding:14px 16px;overflow-x:auto;font-family:Consolas,monospace;font-size:12.5px;line-height:1.55}
pre.seq b{color:#7fd0ff}pre.seq i{color:#85e3a5;font-style:normal}pre.seq u{color:#ffc46b;text-decoration:none}pre.seq s{color:#ff9b9b;text-decoration:none}
table{border-collapse:collapse;width:100%;margin:10px 0;font-size:13px}
th{background:#eef3f8;text-align:left}th,td{border:1px solid var(--line);padding:6px 10px;vertical-align:top}
code{background:var(--code);border-radius:4px;padding:1px 6px;font-family:Consolas,monospace;font-size:12.5px}
.tag{display:inline-block;border-radius:4px;padding:0 8px;font-size:11.5px;font-weight:600;color:#fff;margin-right:6px;white-space:nowrap}
.t-local{background:var(--green)}.t-broker{background:var(--blue)}.t-warn{background:var(--orange)}.t-err{background:var(--red)}.t-core{background:var(--purple)}
.note{background:#fff8e6;border:1px solid #e8d48a;border-radius:8px;padding:10px 14px;font-size:13px;margin:10px 0}
.fixed{background:#e8f5ec;border:1px solid #9fd3ae;border-radius:8px;padding:10px 14px;font-size:13px;margin:10px 0}
ul,ol{margin:6px 0;padding-left:24px}li{margin:3px 0}
.small{font-size:12px;color:var(--sub)}
.grid2{display:grid;grid-template-columns:1fr 1fr;gap:14px}@media(max-width:820px){.grid2{grid-template-columns:1fr}}
.toc a{display:inline-block;margin:2px 10px 2px 0;font-size:13px;color:var(--blue);text-decoration:none}.toc a:hover{text-decoration:underline}
</style>
</head>
<body><div class="wrap">

<header>
<h1>仪器注册与硬件调试 Â· è½¯ä»¶é€»è¾‘与时序梳理</h1>
<p>依据《Local + DeviceBroker æ··åˆæž¶æž„详细设计说明书 V3.0》与当前代码实况整理（含近期缺陷修复后的最终逻辑）</p>
<p class="small">范围：Plugin.DeviceConfig（仪器仪表注册） Â· Plugin.DeviceDebug（硬件调试） Â· Aging.Infrastructure / Aging.ResourceContracts（基础设施与契约） Â· DeviceBroker.exe（共享仪器宿主） Â· Plugin.IntegrationTest（集成测试环境）</p>
<span class="badge">状态：现行实现基线 2026-11-09</span><span class="badge">net472 / WPF / SQLite / Named Pipes</span><span class="badge">两进程仲裁域：local-main + broker-b01</span>
</header>

<div class="card toc">
<b>目录</b>：
<a href="#s1">1 è¿›ç¨‹ä¸Žæ•°æ®æ‹“扑</a><a href="#s2">2 å¯åŠ¨åˆå§‹åŒ–时序</a><a href="#s3">3 ä»ªå™¨æ³¨å†Œé€»è¾‘</a><a href="#s4">4 é©±åŠ¨åˆ†æ´¾ä¸Žé…ç½®å“ˆå¸Œ</a><a href="#s5">5 è°ƒè¯•é¡µé€‰è®¾å¤‡æ—¶åº</a><a href="#s6">6 ç»´æŠ¤æ¨¡å¼çŠ¶æ€æœºä¸Žç§Ÿçº¦</a><a href="#s7">7 æŠ¥æ–‡æ”¶å‘全链路</a><a href="#s8">8 å¼‚常与自愈机制</a><a href="#s9">9 å…³é”®ä»£ç ç´¢å¼•</a><a href="#s10">10 å·²çŸ¥é™åˆ¶</a>
</div>

<!-- ============================================================ -->
<h2 id="s1">1　进程与数据拓扑</h2>
<div class="card">
<pre class="seq">
┌───────────────────────── æµ‹è¯•/操作员工作站（单机） â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”
│                                                                            â”‚
│  <b>Plugin.IntegrationTest.exe</b>（主程序进程，一切 UI ä¸Žä¸šåŠ¡è°ƒç”¨æ–¹çš„宿主）      â”‚
│  â”œâ”€ Plugin.DeviceConfig   ä»ªå™¨ä»ªè¡¨æ³¨å†Œé¡µï¼ˆç¼–辑草稿/发布门禁/版本管理）      â”‚
│  â”œâ”€ Plugin.DeviceDebug    ç¡¬ä»¶è°ƒè¯•é¡µï¼ˆä¼šè¯çŠ¶æ€æœº/维护申请/CAN·电源·PLC面板）│
│  â”œâ”€ Aging.Infrastructure  DeviceManager / DeviceService / AutoDeviceFacade  â”‚
│  â”‚   â”œâ”€ Local è®¾å¤‡ â†’ ç›´é©±é©±åŠ¨ï¼ˆCanDriverAdapter ç­‰ï¼Œç‰©ç†ä¼šè¯åœ¨æœ¬è¿›ç¨‹ï¼‰      â”‚
│  â”‚   â””─ Broker è®¾å¤‡ â†’ <b>BrokeredCanDriver ä»£ç†é©±åŠ¨</b>（不持物理会话）         â”‚
│  â””─ LayeredResourceManager â”€â”€â”ï¼ˆè¿›ç¨‹å†…缓存 grants + å§”托 DbLeaseStore）     â”‚
│                               â”‚                                            â”‚
│        å‘½åç®¡é“ RPC           â”‚        â”Œâ”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”¤
│   aging.<u>brokerId</u>.v1（帧协议） â”‚        â”‚  <b>DeviceBroker.exe</b>（共享仪器宿主进程）│
│        â—„──────────────────────┴────────┤  BrokerServer：三重关卡+SessionGate â”‚
│                                        â”‚  DbLeaseStore(broker-b01) è¯»ä»²è£åº“ â”‚
│                                        â”‚  CanDriverAdapter â†’ ç‰©ç†ä¼šè¯å”¯ä¸€æŒæœ‰â”‚
│                                        â””───────────────────────────────────┘
│  æ•°æ®å±‚（本机 SQLite，禁止网络盘）：                                        â”‚
│   <i>data.db</i>  é…ç½®åº“：DeviceDefinition(含执行位置5列)/DeviceChannel/Slot映射/版本 â”‚
│   <i>arb.db</i>   ä»²è£åº“：resource_state/lease_history/recovery_checkpoint/authority_meta â”‚
│   <u>debug.db</u>  è°ƒè¯•ä¼šè¯åº“：debug_session（状态机持久化）＋操作日志              â”‚
└────────────────────────────────────────────────────────────────────────────┘
</pre>
<p><span class="tag t-local">Local ç›´è¿ž</span>适合已分配给唯一执行进程、可独立连接的设备；物理会话在客户端进程内。<br>
<span class="tag t-broker">Broker ä»£ç†</span>适合跨进程共享设备：物理会话由 DeviceBroker.exe <b>唯一持有</b>，客户端只做 RPC å§”托。</p>
<p class="small">注：CAN æ€»çº¿æ¨¡æ‹Ÿå™¨ï¼ˆCanSimulator）是<b>进程内</b>虚拟总线——主程序与宿主各自持有一套 CAN_BUS_1 å®žä¾‹ï¼Œè·¨è¿›ç¨‹ä¸å¯è§ï¼›çœŸå®žç¡¬ä»¶ï¼ˆç‰©ç†å¡/总线）天然共享，无此限制。测试环境用同宿主的 CAN-004 ä½œä¸º CAN-003 çš„对端。</p>
</div>

<!-- ============================================================ -->
<h2 id="s2">2　启动初始化时序（MainWindow.InitializePlugins）</h2>
<div class="card">
<pre class="seq">
 1. DeviceConfig.InitFinish          â†’ å»ºåº“/迁移 data.db（PRAGMA æ£€æŸ¥â†’ALTER è¡¥æ‰§è¡Œä½ç½®5列）
 2. SeedPresetCanDevices()           â†’ é¢„ç½® CAN-001/002/003（<b>必须先于基础设施</b>：Bootstrapper æ‰«åº“决定驱动注册）
 3. InitializeAutoServices()
    3.1 InfrastructureBootstrapper.Initialize(data.db è·¯å¾„)
        a. DbLeaseStore(arb.db, "local-main")
        b. <u>ReconcileAfterBoot</u>          â† å¯åŠ¨å¯¹è´¦ï¼šSweepExpired + ApproveRecovery å›žæ”¶ä¸Šæ¬¡è¿›ç¨‹æ³„漏租约
        c. LayeredResourceManager æ³¨å†Œè¿› UtilContainer（"ResourceManager"/"LeaseCoordinator"）
        d. DeviceManager / DeviceService / PowerSupplyService / AutoDeviceFacade / CanBusService
        e. <b>RegisterBrokeredDrivers</b>   â† æ‰« data.db：ExecutionMode='Broker' çš„设备注册
                                           BrokeredCanDriver(管道=aging.{BrokerId}.v1, æºå¯åŠ¨æ—¶ configHash)
    3.2 ä»Ž UtilContainer æ‹‰å– IAutoDeviceFacade / ICanBusService，注册 Local CAN ç›´é©±
    3.3 <b>TryStartDeviceBroker()</b>       â† è‹¥å­˜åœ¨ Broker è®¾å¤‡ï¼šProcess.Start DeviceBroker.exe
                                           --db data.db --arb arb.db --broker broker-b01
 4. DeviceDebug.InitFinish           â†’ ä»Ž UtilContainer å– DeviceManager/DeviceService/ResourceManager
                                       <b>（必须在 3 ä¹‹åŽï¼å€’置会取到 null，仲裁/驱动复用链路全部静默降级）</b>
 5. ForceRefreshForTest()×2          â†’ ä¸¤æ’件列表刷新
 Window_Closing：Kill DeviceBroker å­è¿›ç¨‹ï¼ˆå…¶ç‰©ç†ä¼šè¯éšè¿›ç¨‹æ¶ˆäº¡ï¼Œç§Ÿçº¦é  TTL+启动对账收口）
</pre>
<div class="fixed">✅ <b>修复记录</b>：原时序中 DeviceDebug.InitFinish æ—©äºŽ Bootstrapper.Initialize，导致调试页取到 null æœåŠ¡â€”—维护仲裁被绕过、Broker è®¾å¤‡è¿žæŽ¥çŠ¶æ€æ’"未连接"、面板退化为本地直驱。现已调整为"建库→预置→基础设施→调试插件"。</div>
</div>

<!-- ============================================================ -->
<h2 id="s3">3　仪器注册逻辑（Plugin.DeviceConfig）</h2>
<div class="grid2">
<div class="card">
<h3>3.1 ç¼–辑弹窗（DeviceEditModal）字段与联动</h3>
<table>
<tr><th>区块</th><th>字段</th><th>规则</th></tr>
<tr><td rowspan="5">设备信息</td><td>DeviceId</td><td>新增可编辑、编辑只读；保存时查重</td></tr>
<tr><td>Kind / DriverType</td><td>类型联动驱动建议（CanDevice→CAN，PowerSupply→SCPI…）</td></tr>
<tr><td>Transport</td><td>Tcp/Serial/Visa/SDK/Can</td></tr>
<tr><td>Endpoint</td><td>按 Transport æ ¡éªŒæ ¼å¼å¹¶æ›´æ–°æç¤ºï¼ˆCAN：总线:节点）</td></tr>
<tr><td>通道列表</td><td>ChannelId å”¯ä¸€ï¼Œèƒ½åŠ›/电压/电流/SessionKey</td></tr>
<tr><td rowspan="5">执行位置<br>(V3.0 Â§05)</td><td>ExecutionMode</td><td>单选 <span class="tag t-local">Local</span>（默认）/<span class="tag t-broker">Broker</span>；与仲裁域<b>双向联动</b></td></tr>
<tr><td>AuthorityId</td><td>必填下拉，候选来自 <code>V3AuthorityCatalog</code>（appSettings <code>V3.AuthorityIds</code>，未配置回退 <code>local-main;broker-b01</code>）</td></tr>
<tr><td>BrokerId</td><td>仅 Broker æ˜¾ç¤ºï¼›å€™é€‰ <code>V3.BrokerIds</code>；门禁要求 BrokerId==AuthorityId</td></tr>
<tr><td>OwnerProcessId</td><td>只读=当前进程 PID（MVP å ä½ï¼‰ï¼›<b>不入配置哈希</b>（运行期信息）</td></tr>
<tr><td>PhysicalSessionKey</td><td>仅 Broker；候选为端点规范化的写死字符串：<code>can/{bus}/main</code>、<code>tcp/{ip:port}/main</code>、<code>serial/{COM}/main</code>、<code>{deviceId}/main</code>、已存通道 SessionKey</td></tr>
<tr><td>访问策略</td><td>AccessPolicy</td><td><b>只读派生</b>不落库：Local→"独占直连·本进程持有物理会话"；Broker→"共享仲裁·Broker SessionGate ä»£ç†"</td></tr>
</table>
<p class="small">联动规则：选 Broker â†’ ä»²è£åŸŸè‡ªåŠ¨åˆ‡åˆ°é¦–个 Broker å€™é€‰ï¼›é€‰ local- åŸŸ â†’ è‡ªåŠ¨åˆ‡å›ž Local。XAML åˆå§‹åŒ–期事件加控件空引用守卫。</p>
</div>
<div class="card">
<h3>3.2 æ•°æ®æ¨¡åž‹ä¸ŽæŒä¹…化</h3>
<ul>
<li><code>DeviceDefinition</code> è¡¨ 13 åˆ— = åŽŸ 8 åˆ— + æ‰§è¡Œä½ç½® 5 åˆ—；旧库经 <code>PRAGMA table_info</code> æ£€æŸ¥åŽ <code>ALTER TABLE ADD COLUMN</code> è¿ç§»ï¼Œå­˜é‡æ•°æ®é»˜è®¤ <code>Local/空AuthorityId</code>。</li>
<li>实体默认值 <code>ExecutionMode=Local</code>；读取端 <code>HasColumn</code> å®¹é”™ç¼ºåˆ—。</li>
<li>批量生成（BatchGenerateModal）走同一 <code>SaveDevice</code>，新列取默认。</li>
</ul>
<h3>3.3 ç‰ˆæœ¬çŠ¶æ€æœºï¼ˆå‘布工作流 Â§05）</h3>
<pre class="seq">
Draft â”€â”€ä¿å­˜è‰ç¨¿â”€â”€â–º (重算 hash è½åº“)
Draft â”€â”€å‘布(PublishVersion)──► â‘  ValidatePublishGate() æ‹¦æˆª
                               â‘¡ é€šè¿‡â†’重算 hash→status=Published
Published â”€â”€åº”用(Apply)──► Effective（旧 Effective é€€å›ž Published）
</pre>
<h3>3.4 å‘布门禁校验项（ValidatePublishGate）</h3>
<ol>
<li>AuthorityId å¿…填且在配置枚举内（存量空值 â†’ æç¤º"旧数据请重新保存"）</li>
<li>Local è®¾å¤‡çš„域必须 <code>local-</code> å‰ç¼€</li>
<li>Broker è®¾å¤‡ï¼šBrokerId å¿…填、在枚举内、且与 AuthorityId ä¸€è‡´ï¼ˆåŸŸä¸€è‡´ï¼‰</li>
<li>Broker è®¾å¤‡ï¼šPhysicalSessionKey å¿…å¡«</li>
<li>同一 PhysicalSessionKey åªå…è®¸ä¸€ä¸ªå®¿ä¸»åŸŸï¼ˆ"同一会话只能有一个宿主"）</li>
</ol>
<div class="note">任一失败 â†’ å¼¹çª—列出错误（最多显示 8 æ¡ï¼‰å¹¶é˜»æ­¢å‘布；冲突检测（IP/Slot/越界）仍走 <code>DetectConflicts</code>。</div>
</div>
</div>

<!-- ============================================================ -->
<h2 id="s4">4　驱动分派与配置哈希（INV-04）</h2>
<div class="card">
<pre class="seq">
                    æ³¨å†Œé¡µä¿å­˜è®¾å¤‡(含执行位置) â”€â”€â–º data.db
                                  â”‚
 Bootstrapper å¯åŠ¨æ‰«æ             â–¼
   ExecutionMode='Local'  â”€â”€â–º DriverFactory.CreateDriver â”€â”€â–º ç›´é©±ï¼ˆæœ¬è¿›ç¨‹ç‰©ç†ä¼šè¯ï¼‰
   ExecutionMode='Broker' â”€â”€â–º <b>BrokeredCanDriver</b>(deviceId, aging.{BrokerId}.v1, hash₀)
                                  â”‚  hash₀ = DeviceConfigHash.Compute(data.db)
                                  â”‚  è§„则与 DeviceConfigModel.ComputeConfigHash å®Œå…¨ä¸€è‡´ï¼š
                                  â”‚  DEVICE(id|kind|driver|transport|endpoint|<b>mode|authority|broker|sessionKey</b>)
                                  â”‚  + CHANNEL + SLOT ä¸‰æ®µæ‹¼æŽ¥ SHA256；OwnerProcessId ä¸å‚与
                                  â–¼ æ¯æ¬¡ RPC æºå¸¦
                     å®¿ä¸»å‡ºé˜Ÿæ—¶ä¸Žè‡ªå·±é‡ç®—的生效 hash å¯¹è´¦ â†’ ä¸ä¸€è‡´ RejectedConfigMismatch
</pre>
<ul>
<li><b>分派点在驱动层</b>：<code>DeviceService</code> ä¸æ„ŸçŸ¥ Local/Broker——它只从 <code>DeviceManager.GetDriver(deviceId)</code> å–驱动。上层（自动化门面、调试面板）零改动。</li>
<li>配置哈希 = å¿«ç…§æŒ‡çº¹ï¼šBroker ç”¨ <code>DeviceConfigHash.Compute</code>（与注册页同算法，缺表跳过空段）每 2s æƒ°æ€§é‡ç®—。</li>
</ul>
</div>

<!-- ============================================================ -->
<h2 id="s5">5　调试页选设备时序（OnDeviceSelected）</h2>
<div class="card">
<pre class="seq">
设备下拉变更
 1. LoadDeviceInfo(deviceId)              â† è¯» data.db：Kind/Endpoint/EffectiveVersion
 2. OpenSession(deviceId)                 â† DebugSessionManager
      a. GetActiveSessionByDevice â†’ å‘½ä¸­ä¸”<b>在本进程内存</b> â†’ å¤ç”¨è¿”回
      b. å‘½ä¸­ä½†ä»…存在于 debug.db（进程重启遗留死会话）→ <u>强制回收为 Closed</u> å†æ–°å»º
      c. æ–°å»º session（State=ReadOnly，写 debug_session è¡¨ + å…¥å†…存缓存）
 3. DeviceManager.ConnectAsync(deviceId)
      <span class="tag t-local">Local</span>  ç›´é©± ConnectAsync：注册总线节点/建立 TCP…
      <span class="tag t-broker">Broker</span> BrokeredCanDriver â†’ RPC CONNECT（<b>无租约也允许</b>：仅登记宿主物理会话，无总线输出）
      å¼‚常→仅连接状态显示"连接失败"，不抛出
 4. UpdateButtonStates()                  â† "进入维护"仅 ReadOnly æ—¶å¯ç”¨
 5. LoadPanel(kind)
      CAN é¢æ¿ï¼šExistingDriver = DeviceManager.GetDriver(deviceId)
        â”œâ”€ éž null（Broker è®¾å¤‡ï¼‰â†’ é¢æ¿å¤ç”¨è¯¥é©±åŠ¨ï¼Œ<b>禁止本地直驱</b>（不 Dispose å¤–部驱动）
        â””─ null（未注册）→ é™çº§æœ¬åœ°ç›´é©±ï¼ˆæ¨¡æ‹Ÿå™¨è¯­ä¹‰ï¼Œowns=true）
      é¢æ¿è¿žæŽ¥åŽï¼šDispatcherTimer 100ms è½®è¯¢å¯åŠ¨ï¼ˆUpdateStats + ä»£ç†é©±åŠ¨é‚®ç®±æŠ½å–）
 é¡¶éƒ¨"连接状态"与面板内"状态"为两个指标：前者=DeviceManager é€šè·¯ï¼ŒåŽè€…=面板实际使用的驱动
</pre>
</div>

<!-- ============================================================ -->
<h2 id="s6">6　维护模式状态机与租约时序</h2>
<div class="grid2">
<div class="card">
<h3>6.1 ä¼šè¯çŠ¶æ€æœº</h3>
<pre class="seq">
             RequestMaintenance âœ”            ActivateMaintenance
  ReadOnly â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â–º AcquiringMaintenance â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â–º <b>MaintenanceActive</b>
     â–²                               â”‚失败(占用/超时)                     â”‚ CloseSession
     â”‚回收死会话(Closed)             â–¼                                   â–¼
     â””────────────────────────  ä¿æŒ ReadOnly                     Closing â†’ Closed
                                                                    ï¼ˆé‡Šæ”¾ç»´æŠ¤ç§Ÿçº¦ï¼‰
</pre>
<h3>6.2 è¿›å…¥ç»´æŠ¤ï¼ˆå«è·¨è¿›ç¨‹ä»²è£ï¼‰</h3>
<pre class="seq">
"进入维护" â†’ RequestMaintenance(sessionId)
 1. ä¼šè¯åœ¨å†…存缓存？不在→debug.db æ¢å¤å…œåº•ï¼›ä»æ— â†’拒绝
 2. State==ReadOnly？否则拒绝（按钮已按此置灰）
 3. <b>取/建会话→令牌缓存 _sessionOwnerTokens[sessionId]</b>
    ï¼ˆResourceOwnerToken.TokenId æ˜¯éšæœº GUID，<u>必须复用同一实例</u>，
      å¦åˆ™ LayeredResourceManager æŒ‰ TokenId ç´¢å¼•çš„ grants é‡Šæ”¾æ—¶æ‰¾ä¸å›žï¼‰
 4. ResourceManager.ReserveAsync(token, key=deviceId)
      â†’ DbLeaseStore.Acquire（arb.db BEGIN IMMEDIATE å•äº‹åŠ¡ï¼‰
        â”œ Acquired/Reused â†’ Active ç§Ÿçº¦ï¼ˆTTL 300s，Generation+1）
        â”œ ConflictHeld    â†’ æŠ› ResourceConflictException â†’ æ‹’绝（提示含占用者/机器/PID）
        â”” RecoveryBlocked â†’ æ‹’绝（过期待回收，见 Â§8）
 5. State=AcquiringMaintenance â†’ ActivateMaintenance â†’ MaintenanceActive
 6. LoadPanel é‡å»º â†’ é¢æ¿ IsMaintenanceMode=true（写控件解锁）
</pre>
</div>
<div class="card">
<h3>6.3 é€€å‡ºç»´æŠ¤</h3>
<pre class="seq">
"退出维护" â†’ CloseSession
 1. State=MaintenanceActive？→ Closing
 2. ReleaseReservationAsync(<b>复用进入时的同一令牌</b>)
      â†’ DbLeaseStore.Release â†’ Phase=0(Free)，lease_history è®° Released
 3. Closed + closed_at è½åº“、移出内存缓存、清令牌缓存
 <b>校验点</b>：arb.db resource_state åº”变回 Free â€”— æ³„漏租约曾导致
 "第二次进入维护永久失败"，根因与修复见 Â§8/§10
</pre>
<h3>6.4 ç»´æŠ¤ä¸Žå†™æƒé™çŸ©é˜µï¼ˆå®¿ä¸»ä¾§æ‰§è¡Œè¯­ä¹‰ï¼‰</h3>
<table>
<tr><th>操作</th><th>租约要求</th><th>原因</th></tr>
<tr><td>CONNECT / DISCONNECT</td><td><i>豁免</i></td><td>仅登记/释放宿主物理会话，无总线输出</td></tr>
<tr><td>RECV / RECV_ALL / LOG / STATUS</td><td><i>豁免</i></td><td>纯读邮箱/状态，被动监控支持调试页只读监听</td></tr>
<tr><td>SEND（帧发送）</td><td><b>必须 Active</b></td><td>总线写，INV-01 ç¦æ­¢æ— ç§Ÿçº¦ç›´æŽ¥ I/O</td></tr>
<tr><td>AUTO_RESPONSE / FILTER / PROMISCUOUS</td><td><b>必须 Active</b></td><td>有副作用的 QUERY，改变节点行为</td></tr>
</table>
<div class="fixed">✅ å› æ­¤æ­£ç¡®æ“ä½œé¡ºåºå³æ‚¨æŒ‡å‡ºçš„：<b>先进入维护模式 â†’ æ‰èƒ½æ‰“开自动响应/发送</b>；只读"看帧"不需要维护。</div>
</div>
</div>

<!-- ============================================================ -->
<h2 id="s7">7　报文收发全链路时序（Broker è®¾å¤‡ï¼‰</h2>
<div class="card">
<h3>7.1 å‘送（维护模式下，CAN-003 â†’ æ€»çº¿ï¼‰</h3>
<pre class="seq">
面板"发送" â†’ BrokeredCanDriver.SendCommandAsync("SEND:0x123:55 66")
 â””─ BrokerClientChannel.EnsureConnectedAsync     â† æƒ°æ€§ï¼šç®¡é“断开自动重连+重握手
     â””─ <b>Hello</b> â†’ å®¿ä¸»å›ž {ServerEpoch, ConfigHash, BrokerId, ProtocolVersion}
        åè®®ä¸»ç‰ˆæœ¬ä¸ç¬¦ â†’ æ–­å¼€æ‹’绝
 â””─ <b>SubmitTask</b>（帧=4字节大端长度+UTF8 JSON å°å¥—ï¼›RequestId å…³è”、deadline è¶…时）
     Body={DeviceId, OpCode=SEND, Payload, ResourceKey=deviceId, ClientInstanceId}
          â–¼ â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€ DeviceBroker.exe â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
     â‘ ç™½åå•+域内设备过滤          éžæœ¬åŸŸ/未知op â†’ Failed
     â‘¡<b>configHash å¯¹è´¦</b>(INV-04)    ä¸ä¸€è‡´ â†’ RejectedConfigMismatch("先 Apply å† I/O")
     â‘¢<b>栅栏再校验</b>(INV-01/03)      RecoveryRequired→拒绝；无 Active ç§Ÿçº¦â†’RejectedStaleLease
     â‘£<b>SessionGate</b>（按 PhysicalSessionKey ä¸²è¡ŒåŽŸå­ç‰‡æ®µï¼‰
        é˜Ÿåˆ—等待 5s è¶…æ—¶ â†’ Failed RESOURCE_BUSY（确定未执行，可安全重试）
     â‘¤CanDriverAdapter.SendFrame（宿主进程物理/模拟总线）
     â‘¥ResultBody{State, Readback, ServerEpoch} åŒç®¡é“返回
          â–¼ â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€ å®¢æˆ·ç«¯ â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
     Succeeded→返回设备响应串 | RejectedStaleLease→抛 LEASE_STALE
     ConfigMismatch→抛异常 | Unknown(超时/片段中异常)→<u>TimeoutException ç¦æ­¢å‡å®šæœªæ‰§è¡Œ(INV-06)</u>
</pre>
<h3>7.2 æŽ¥æ”¶ï¼ˆæ€»çº¿å¸§ â†’ é¢æ¿æ˜¾ç¤ºï¼‰</h3>
<pre class="seq">
总线广播 â†’ å®¿ä¸»å†… node(CAN-003) æ”¶å¸§ â†’ RxCount++，帧入 _recvBuffer + èŠ‚点邮箱
客户端面板 DispatcherTimer(100ms) æ¯ 10 tick（≈1s）：
   DrainBrokerMailbox â†’ RPC QUERY <b>"RECV_ALL"</b>（只读，<u>无需租约</u>）
     â†’ è§£æž "RECV_ALL:n:id:data[:ts]|…" â†’ AddReceivedFrame(RX, æ¥æº=<b>BUS@broker</b>)
     RPC å¤±è´¥ï¼ˆå®¿ä¸»ä¸å¯è¾¾ç­‰ï¼‰é™é»˜è·³è¿‡ï¼Œä¸‹ä¸€ç§’重试，不弹错误
（Local ç›´é©±è®¾å¤‡æ— éœ€è½®è¯¢ï¼šDriverFrameReceived äº‹ä»¶å³æ—¶æ˜¾ç¤ºï¼‰
对端模拟：真实硬件同一总线天然互通；模拟器场景用<b>同宿主的 CAN-004</b> ä½œå¯¹ç«¯éªŒè¯ã€‚
</pre>
<div class="fixed">✅ <b>修复记录</b>：① ä»£ç†é©±åŠ¨æ— å¸§äº‹ä»¶ä¸”面板从不查邮箱 â†’ "只有发送没有接收"，现增加 RECV_ALL åªè¯»è½®è¯¢ï¼›â‘¡ å®¿ä¸» <code>HandleRecvAll</code> æ›¾æŠŠåŒä¸€å¸§ç» buffer+邮箱双路上报（RX é‡å¤è¡Œï¼‰ï¼Œå·²æ”¹ä¸º buffer ä¼˜å…ˆã€é‚®ç®±ä»…兜底。</div>
</div>

<!-- ============================================================ -->
<h2 id="s8">8　异常与自愈机制</h2>
<div class="card">
<table>
<tr><th>场景</th><th>机制</th><th>表现/去向</th></tr>
<tr><td>进程异常退出（崩溃/被杀）</td><td>租约不再续期 â†’ TTL(300s) è¿‡æœŸ â†’ <b>RecoveryRequired</b>（INV-03 ç¦æ­¢è‡ªåŠ¨ç§»äº¤ï¼‰</td><td>下次 Acquire è¿”回 RecoveryBlocked â†’ "无法进入维护"</td></tr>
<tr><td>宿主/主程序<b>重启</b></td><td><b>ReconcileAfterBoot</b>：SweepExpired（过期→待回收+历史）→ é€ä¸ª ApproveRecovery（登记读回证据进 recovery_checkpoint，Phase=Free，Generation ä¸å›žé€€ï¼‰</td><td>启动即自愈；证据可在 arb.db å®¡è®¡</td></tr>
<tr><td>调试页维护租约泄漏</td><td>根因：进出维护各自 new Token（TokenId éšæœº GUID）→ é‡Šæ”¾æŒ‰ TokenId æŸ¥æ‰¾è½ç©ºã€‚修复：会话→令牌实例缓存复用</td><td>退出维护后 resource_state å¿…回 Free</td></tr>
<tr><td>debug.db æ­»ä¼šè¯æ®‹ç•™</td><td>OpenSession æ£€å‡º"DB æœ‰ã€å†…存无"的未关闭会话 â†’ å›žæ”¶ Closed å†æ–°å»º</td><td>不再出现"会话不存在"型拒绝</td></tr>
<tr><td>租约过期后使用（作用域租约）</td><td>AutoDeviceLease å¿ƒè·³ 8s Renew；连续 2 æ¬¡å¤±è´¥ â†’ LeaseLost äº‹ä»¶ + åŽç»­è°ƒç”¨æŠ› <b>LEASE_STALE</b>（熔断）</td><td>自动化步骤快速失败而非静默半执行</td></tr>
<tr><td>RPC è¶…æ—¶/断线</td><td>响应关联超时 â†’ State=<b>Unknown</b>（INV-06）；读循环断线感知 â†’ ä¸‹æ¬¡è°ƒç”¨æƒ°æ€§é‡è¿žé‡æ¡æ‰‹</td><td>面板轮询静默重试；显式 I/O æŠ›å¼‚常禁止重试假定未执行</td></tr>
<tr><td>配置版本错位（客户端快照旧）</td><td>宿主每次出队对账 configHash â†’ RejectedConfigMismatch</td><td>强制"先 Apply å† I/O"</td></tr>
</table>
</div>

<!-- ============================================================ -->
<h2 id="s9">9　关键代码索引</h2>
<div class="card">
<table>
<tr><th>职责</th><th>文件</th><th>关键成员</th></tr>
<tr><td>启动装配</td><td>Plugin.IntegrationTest/MainWindow.xaml.cs</td><td>InitializePlugins / SeedPresetCanDevices / InitializeAutoServices / TryStartDeviceBroker</td></tr>
<tr><td>注册 UI/联动/校验</td><td>Plugin.DeviceConfig/DeviceEditModal.xaml(.cs)</td><td>Open / ExecMode_Changed / CbAuthority_SelectionChanged / RefreshSessionKeyCandidates / SaveBtn_Click</td></tr>
<tr><td>候选枚举配置</td><td>Plugin.DeviceConfig/V3AuthorityCatalog.cs + Plugin.IntegrationTest/App.config</td><td>AuthorityIds / BrokerIds / LocalAuthorityId / IsLocalAuthority</td></tr>
<tr><td>发布门禁/哈希/迁移</td><td>Plugin.DeviceConfig/Model/DeviceConfigModel.cs</td><td>MigrateExecutionColumns / ValidatePublishGate / ComputeConfigHash / SaveDevice</td></tr>
<tr><td>实体</td><td>Plugin.DeviceConfig/Entity/DeviceDefinition.cs</td><td>ExecutionModeKind / AuthorityId / BrokerId / PhysicalSessionKey / AccessPolicy(派生)</td></tr>
<tr><td>服务装配</td><td>Aging.Infrastructure/InfrastructureBootstrapper.cs</td><td>Initialize / RegisterBrokeredDrivers</td></tr>
<tr><td>跨进程租约</td><td>Aging.Infrastructure/Core/DbLeaseStore.cs Â· LayeredResourceManager.cs</td><td>Acquire/Renew/Release/PhaseOf/SweepExpired/ApproveRecovery/<b>ReconcileAfterBoot</b></td></tr>
<tr><td>维护会话状态机</td><td>Plugin.DeviceDebug/Model/DebugSessionManager.cs</td><td>OpenSession(死会话回收) / RequestMaintenance(令牌复用) / ActivateMaintenance / CloseSession</td></tr>
<tr><td>调试页时序</td><td>Plugin.DeviceDebug/DeviceDebug.xaml.cs Â· Panels/CanDebugPanel.xaml.cs</td><td>OnDeviceSelected / LoadPanel(ExistingDriver æ³¨å…¥) / DoConnect / PollTimer_Tick / DrainBrokerMailbox</td></tr>
<tr><td>Broker å®¢æˆ·ç«¯</td><td>Aging.Infrastructure/Broker/BrokerClientChannel.cs Â· Drivers/BrokeredCanDriver.cs</td><td>EnsureConnectedAsync(Hello) / SendAsync(关联+超时) / SubmitAsync / ThrowForState</td></tr>
<tr><td>Broker å®¿ä¸»</td><td>DeviceBroker/BrokerServer.cs Â· Program.cs</td><td>LoadDevices / ExecuteOneShotAsync(三重关卡) / SessionGate / RunFragmentAsync / ProbeReadback</td></tr>
<tr><td>线协议/契约</td><td>Aging.ResourceContracts/BrokerIpc.cs Â· IpcEnvelope.cs Â· DeviceOperationTypes.cs Â· LeaseTypes.cs</td><td>帧编解码 / SubmitBody·ResultBody / LeaseGrant·AcquireRequest</td></tr>
</table>
</div>

<!-- ============================================================ -->
<h2 id="s10">10　已知限制与简化（P2 è®¡åˆ’项）</h2>
<div class="card">
<ul>
<li><b>owner↔clientInstanceId å¼±å¯¹é½</b>：同机 arb.db æ …栏只做存在性/相位检查，未校验申请者身份与请求连接一一对应（待签名凭据/epoch token）。</li>
<li><b>模拟器跨进程总线</b>：CanSimulator è¿›ç¨‹å†…实例互不相通，跨进程收发仅同宿主设备间可达；真实硬件无此限制。</li>
<li><b>推迟能力</b>：Draining è‡ªåŠ¨è®©æ¸¡ã€å‘¨æœŸä»»åŠ¡/订阅/ResultOutbox、父设备 Permit å¤šé€šé“仲裁、Prepare/Activate ä¸¤æ®µå¼è·¨åŸŸé¢„留、发布预览差异。</li>
<li><b>UI å¾…办</b>：App.Success/App.Warn æ ‡é¢˜æœªæœ¬åœ°åŒ–；退出维护后设备选择器被重置；临时诊断日志（brokerrx_diag.log）待验证通过后撤除；RecoveryRequired å°šæ— äººå·¥å®¡æ‰¹ UI（当前由启动对账代偿）。</li>
<li><b>BrokerId/OwnerProcessId è¯­ä¹‰</b>：OwnerProcessId ä¸º MVP å ä½ï¼ˆå½“前进程 PID），Broker å¸¸é©»è¿›ç¨‹åº”为其宿主 PID ä¸”随宿主重启更新——不入哈希的设计已预留。</li>
</ul>
<p class="small">本文档与代码实况同步于 2026-11-09；实现变更请同步更新本文件。</p>
</div>

</div></body>
</html>

 docs/ÒÇÆ÷µ÷Óüܹ¹ÓëÊý¾ÝÁ÷ת_V3.1.html

New file
@@ -0,0 +1,282 @@
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="utf-8"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>仪器调用架构与数据流转说明（V3.1）</title>
<style>
:root{--bg:#f7f8fa;--card:#fff;--ink:#1f2430;--muted:#5b6472;--line:#e4e8ef;--accent:#2f6fed;--ok:#2e8b57;--warn:#b7791f;--bad:#c0392b;--code:#0d1117;}
*{box-sizing:border-box}
body{margin:0;background:var(--bg);color:var(--ink);font:15px/1.7 "Segoe UI","Microsoft YaHei",Arial,sans-serif}
.wrap{max-width:1120px;margin:0 auto;padding:32px 20px 90px}
h1{font-size:25px;margin:0 0 6px}
h2{font-size:20px;margin:34px 0 12px;padding-bottom:6px;border-bottom:2px solid var(--line)}
h3{font-size:16px;margin:20px 0 8px;color:var(--accent)}
.sub{color:var(--muted);margin:0 0 18px}
.card{background:var(--card);border:1px solid var(--line);border-radius:12px;padding:16px 18px;margin:14px 0;box-shadow:0 1px 2px rgba(0,0,0,.03)}
pre{background:var(--code);color:#e6edf3;border-radius:10px;padding:14px 16px;overflow:auto;font:12.5px/1.55 "Cascadia Code",Consolas,monospace;margin:10px 0}
code{font-family:"Cascadia Code",Consolas,monospace;background:#eef1f6;padding:1px 5px;border-radius:4px;font-size:13px}
pre code{background:none;padding:0;color:inherit}
table{border-collapse:collapse;width:100%;margin:10px 0;font-size:14px}
th,td{border:1px solid var(--line);padding:7px 10px;text-align:left;vertical-align:top}
th{background:#eef2f8}
.tag{display:inline-block;padding:1px 8px;border-radius:999px;font-size:12px;font-weight:600;margin-right:4px}
.t-auto{background:#e6f0ff;color:#1b4fa0}
.t-dbg{background:#f3e8ff;color:#6b21a8}
.t-svc{background:#e7f6ec;color:#1f7a3d}
.t-dev{background:#fdeee0;color:#a35a12}
.ok{color:var(--ok);font-weight:600}.bad{color:var(--bad);font-weight:600}.warn{color:var(--warn);font-weight:600}
.small{font-size:13px;color:var(--muted)}
.toc{columns:2;font-size:14px}.toc a{color:var(--accent);text-decoration:none}
.note{background:#fff6d6;border-left:4px solid var(--warn);padding:10px 12px;border-radius:6px;margin:10px 0}
.fx{background:#e8f5e9;border-left:4px solid var(--ok);padding:10px 12px;border-radius:6px;margin:10px 0}
.layer{border-left:4px solid var(--accent);padding-left:12px;margin:8px 0}
</style>
</head>
<body>
<div class="wrap">

<h1>仪器调用架构与数据流转说明</h1>
<p class="sub">聚焦"一次仪器调用从入口到硬件、再回到调用方"的完整路径与类引用结构。V3.1（TCP æ¨¡æ‹Ÿå™¨ + ç»Ÿä¸€ <code>CanDeviceDriver</code> + å¤šè®¾å¤‡å¹¶å‘）。与代码同步 2026-11-09。</p>

<div class="card">
<b>目录</b>
<div class="toc">
<div><a href="#s1">1. è°ƒç”¨å…¥å£å…¨æ™¯</a></div>
<div><a href="#s2">2. åˆ†å±‚类引用结构</a></div>
<div><a href="#s3">3. è‡ªåŠ¨åŒ–调用数据流转</a></div>
<div><a href="#s4">4. è°ƒè¯•è°ƒç”¨æ•°æ®æµè½¬</a></div>
<div><a href="#s5">5. é©±åŠ¨â†’传输→服务端 é€è·³</a></div>
<div><a href="#s6">6. ä¸€æ¬¡ CAN å‘送完整时序</a></div>
<div><a href="#s7">7. æƒé™/租约在链路中的位置</a></div>
<div><a href="#s8">8. å…³é”®æ•°æ®ç»“构一览</a></div>
<div><a href="#s9">9. ç±»å¼•ç”¨å…³ç³»æ€»å›¾</a></div>
</div>
</div>

<!-- ============================================================ -->
<h2 id="s1">1　调用入口全景</h2>
<div class="card">
<p>仪器调用只有<b>两类入口</b>，但都汇聚到同一套"服务层 â†’ é©±åŠ¨å±‚ â†’ ä¼ è¾“层"，最终落到模拟器服务里的总线：</p>
<table>
<tr><th>入口</th><th>触发者</th><th>首跳 API</th><th>令牌类型</th></tr>
<tr><td><span class="tag t-auto">自动化</span>测试程序</td><td>TestPlan / æ­¥éª¤è„šæœ¬</td><td><code>ICanBusService</code> / <code>IAutoDeviceFacade</code></td><td>OwnerType.<b>Production</b></td></tr>
<tr><td><span class="tag t-dbg">调试</span>硬件调试页</td><td>人工（DeviceDebugTab）</td><td>面板直调驱动 æˆ– <code>IDeviceService</code></td><td>OwnerType.<b>Maintenance</b></td></tr>
</table>
<p class="small">两条入口互斥于同一 arb.db ç§Ÿçº¦ï¼šæŸè®¾å¤‡è¢«ç”Ÿäº§é¢„约时维护进不去，反之亦然（INV ç”±èµ„源层栅栏保证）。</p>
</div>

<!-- ============================================================ -->
<h2 id="s2">2　分层类引用结构</h2>
<div class="card">
<pre>
【入口层】
  CanBusService â”€â”                         DeviceDebugTab â”€â”
  (类型化封装)    â”‚  IAutoDeviceFacade                       â”‚ (每设备一 Tab)
                 â–¼                                           â–¼
【门面/编排层】  AutoDeviceFacade â”€â”€â–º IDeviceService â—„── ExecuteViaDeviceService / é¢æ¿ç›´è°ƒ
                 (预约+释放编排)        (DeviceService：校验+租约+分派)
                                           â”‚
【资源层】        IResourceManager â—„───────┤  (ValidateOwner / AcquireOperationAsync)
                 LayeredResourceManager â”€â”€â”€â”¼â”€â–º ILeaseCoordinator â”€â–º DbLeaseStore(arb.db)
                                           â”‚
【设备/驱动层】   IDeviceManager.GetDriver(deviceId) â”€â–º IDeviceDriver
                                           â”‚
                       CanDeviceDriver（唯一 CAN é©±åŠ¨ï¼Œå®žçŽ° IDeviceDriver）
                         â”œâ”€ ICanTransport
                         â”‚    â”œâ”€ NodeChannelTransport â”€â–º TCP â”€â–º CanSimulatorServer
                         â”‚    â””─ BrokerRpcTransport   â”€â–º å‘½åç®¡é“ â”€â–º DeviceBroker
                         â”‚                                   â””â–º(宿主内) CanDeviceDriver(NodeChannel) â”€â–º TCP â”€â–º æ¨¡æ‹Ÿå™¨
                         â””─ å…¶å®ƒé©±åŠ¨ï¼šTcpRaw/Scpi/ModBus/S7（非 CAN ä»ªå™¨ï¼‰

【服务/总线层】   TcpSimulatorHost â”€â–º ServerSession â”€â–º CanCommandExecutor â”€â–º CanBusSimulator/CanNode
</pre>
<p class="small">依赖方向自上而下；上层只依赖接口（IAutoDeviceFacade/IDeviceService/IResourceManager/IDeviceManager/IDeviceDriver），实现由 <code>InfrastructureBootstrapper</code> è£…配进 <code>UtilContainer</code>。</p>
</div>

<!-- ============================================================ -->
<h2 id="s3">3　自动化调用数据流转</h2>
<div class="card">
<h3>3.1 ä¸€æ¬¡æ€§è°ƒç”¨ï¼ˆOneShot）</h3>
<pre class="seq">
TestPlan æ­¥éª¤
  â†’ CanBusService.SendFrameAsync(deviceId, 0x300, data)
      Â· æ ¡éªŒå¸§(≤0x1FFFFFFF, â‰¤8字节) â†’ æ‹¼å‘½ä»¤ä¸² "SEND:0x300:AA BB"
  â†’ AutoDeviceFacade.ExecuteAsync(deviceId, "SEND:…")
      â‘  ReserveCoreAsync: new ResourceOwnerToken(Production, auto_guid)
         ResourceManager.ReserveAsync(token, ResourceKey(deviceId,"Generic"))  â† ç”³è¯·é¢„约(写 arb.db, TTL)
      â‘¡ DeviceService.ExecuteCommandAsync(deviceId, cmd, token)
      â‘¢ finally ReleaseCoreAsync â†’ ReleaseReservationAsync  â† é‡Šæ”¾é¢„约
  â†’ è¿”回 DeviceCommandResult{Success, Readback, LatencyMs}
</pre>
<h3>3.2 ä½œç”¨åŸŸç§Ÿçº¦ï¼ˆä¸€æ­¥å†…多次调用）</h3>
<pre class="seq">
using (var lease = await AutoDeviceFacade.AcquireAsync(deviceId, "Step1"))
{
   // å†…部 ReserveAsync + è‹¥ LayeredResourceManager åˆ™ lease.StartHeartbeat(Coordinator, grants)
   //   å¿ƒè·³ï¼šæ¯ 8s Coordinator.Renew(grant,30)，连续失败≥2 â†’ LeaseLost äº‹ä»¶
   await CanBusService.SendFrameAsync(lease, 0x100, d);   // lease.ExecuteAsync â†’ DeviceService…
   var f   = await CanBusService.ReceiveFrameAsync(lease); // lease.QueryAsync("RECV")
}   // Dispose: åœå¿ƒè·³ + ReleaseReservationAsync
</pre>
<div class="note"><b>心跳差异</b>：自动化作用域租约自带 8s å¿ƒè·³ç»­æœŸï¼ˆ<code>AutoDeviceLease.StartHeartbeat</code>）；人工维护会话的心跳在 <code>DebugSessionManager</code>（120s），两条路径都要续期，否则到 TTL è¿‡æœŸè§¦å‘ RECOVERY_REQUIRED。</div>
</div>

<!-- ============================================================ -->
<h2 id="s4">4　调试调用数据流转</h2>
<div class="card">
<p>硬件调试页每个设备一个 <code>DeviceDebugTab</code>（独立会话）。CAN ä¸Ž éžCAN çš„调用路径不同：</p>
<h3>4.1 CAN é¢æ¿ï¼ˆç›´è°ƒé©±åŠ¨ï¼Œä¸ç» DeviceService）</h3>
<pre class="seq">
DeviceDebugTab.LoadPanel("CanDevice")
  â†’ CanDebugPanel(多通道壳) â†’ CanChannelView(单通道, ExistingDriver=DeviceManager.GetDriver(deviceId))
  è¿žæŽ¥ï¼šDoConnect â†’ å¤ç”¨å·²æ³¨å†Œ CanDeviceDriver（Broker ä»£ç† æˆ– Local NodeChannel）→ ConnectAsync
  å‘送：SendBtn_Click â†’ _driver.SendCommandAsync("SEND:0x300:…")   â† ç›´æŽ¥è°ƒé©±åŠ¨
  æŽ¥æ”¶ï¼šé©±åŠ¨ DriverFrameReceived äº‹ä»¶ â†’ AddReceivedFrame â†’ Dispatcher.BeginInvoke ä¸Šå±
  ç»´æŠ¤é—¨æŽ§ï¼šé¢æ¿ IsMaintenanceMode（由会话状态驱动），进入维护经 DebugSessionManager
</pre>
<h3>4.2 ç”µæº/PLC é¢æ¿ï¼ˆç» DeviceService）</h3>
<pre class="seq">
PowerSupplyDebugPanel/PlcDebugPanel â†’ OnCommandExecute(DebugCommand)
  â†’ DeviceDebugTab.ExecuteViaDeviceService
     Â· new ResourceOwnerToken(Maintenance, sessionId)
     Â· BuildDeviceCommand(cmd) â†’ å¦‚ "VOLT â€¦;CURR â€¦;OUTP ON" / "WRITE:addr:TRUE"
     Â· DeviceService.ExecuteCommandAsync(deviceId, cmd, token)   â† èµ°æœåŠ¡å±‚校验+租约+驱动
  â†’ DebugOperation è½ debug.db + æ“ä½œæ—¥å¿—
</pre>
<div class="note">CAN èµ°"面板直调驱动 + ä¼šè¯çº§ç»´æŠ¤é—¨"是为了低延迟实时收发；电源/PLC èµ°"服务层"以获得统一权限校验与操作审计。二者最终都经 <code>IDeviceDriver</code> è½åˆ°è®¾å¤‡ã€‚</div>
</div>

<!-- ============================================================ -->
<h2 id="s5">5　驱动 â†’ ä¼ è¾“ â†’ æœåŠ¡ç«¯ é€è·³</h2>
<div class="card">
<p><code>CanDeviceDriver</code> æŠŠå‘½ä»¤äº¤ç»™é€‰å®šçš„ <code>ICanTransport</code>，两条后端各自到总线的物理路径不同：</p>
<h3>5.1 Local（NodeChannelTransport）</h3>
<pre class="seq">
CanDeviceDriver.QueryAsync/SendCommandAsync
  â†’ NodeChannelTransport.TransceiveAsync(line)
     Â· é¦–è¿ž HandshakeAsync: å†™ "HELLO:bus:node:tag" ç›´è¯» "OK:HELLO…"（读循环未起）
     Â· ä¹‹åŽ RequestLineAsync: _requestLock ä¸²è¡Œ â†’ å†™å‘½ä»¤å¸§ â†’ ç­‰ TCS（deadline 5s）
     Â· åŽå° ReadLoopAsync: åˆ†æµ OK/ERR→完成 TCS；EV:RECV→FramePushed äº‹ä»¶
  â†’ TCP 9000 â†’ ServerSession â†’ CanCommandExecutor â†’ CanBusSimulator/CanNode
</pre>
<h3>5.2 Broker（BrokerRpcTransport）</h3>
<pre class="seq">
CanDeviceDriver(Broker).SendCommandAsync("SEND:…")
  â†’ BrokerRpcTransport.TransceiveAsync
     Â· æ˜ å°„ opCode(SEND/QUERY)+payload â†’ SubmitBody â†’ BrokerClientChannel(命名管道 RPC)
     Â· EnsureConnectedAsync(Hello æ¡æ‰‹) â†’ SubmitAsync(configHash éšä¿¡å°)
  â†’ DeviceBroker.BrokerServer.ExecuteOneShotAsync
     â‘  ç™½åå•/域内  â‘¡ configHash å¯¹è´¦  â‘¢ ç§Ÿçº¦æ …栏  â‘£ SessionGate ä¸²è¡Œ
     â‘¤ å®¿ä¸»å†… CanDeviceDriver(NodeChannel) â†’ TCP â†’ æ¨¡æ‹Ÿå™¨è·¯ç”±
     â‘¥ ResultBody.Readback æœ«å°¾ AppendPushes("|PUSHED:n|EV:RECV…")
  â†’ å®¢æˆ·ç«¯ DrainPiggyback å‰¥ç¦» PUSHED â†’ FramePushed â†’ é©±åŠ¨ç¼“冲+事件
</pre>
<p class="small">Broker çš„接收靠"请求驱动捎带"：客户端每次 STATUS/SEND éƒ½ä¼šè®©å®¿ä¸»æŠŠè‡ªä¸Šæ¬¡ä»¥æ¥æ”¶åˆ°çš„推送带回；面板每 100ms çš„ STATUS è½®è¯¢ä¿è¯æœ€ç»ˆæ˜¾ç¤ºã€‚</p>
</div>

<!-- ============================================================ -->
<h2 id="s6">6　一次 CAN å‘送完整时序</h2>
<div class="card">
<h3>6.1 è‡ªåŠ¨åŒ– Â· Local è®¾å¤‡ CAN-001</h3>
<pre class="seq">
CanBusService.SendFrameAsync("CAN-001",0x300,[AA BB])
 â†’ AutoDeviceFacade.ExecuteAsync â†’ ReserveAsync(Production) â†’ arb.db å†™ç§Ÿçº¦
 â†’ DeviceService.ExecuteCommandAsync
     GetDriver("CAN-001")→CanDeviceDriver(NodeChannel)
     ValidateOwner→Renew(grant,1) æ …栏校验
     AcquireOperationAsync→OperationLease
     driver.SendCommandAsync("SEND:0x300:AA BB")
       â†’ TCP HELLO/SEND â†’ ServerSession â†’ CanCommandExecutor.HandleSend
       â†’ CanNode.SendFrame â†’ CanBusSimulator è·¯ç”±åˆ°å…¶å®ƒèŠ‚点(+应答器回显)
       â†’ "OK:TX:0x300:2"
 â†’ DeviceCommandResult{Success=true,Readback="OK:TX…"}
 â†’ ReleaseReservationAsync â†’ arb.db é‡Šæ”¾
</pre>
<h3>6.2 è°ƒè¯• Â· Broker è®¾å¤‡ CAN-003</h3>
<pre class="seq">
CanChannelView.SendBtn â†’ _driver(CanDeviceDriver/BrokerRpc).SendCommandAsync("SEND:0x300:AA BB")
 â†’ BrokerRpcTransport â†’ å‘½åç®¡é“ SubmitBody{SEND,"SEND:0x300:AA BB"}
 â†’ BrokerServer ä¸‰é‡å…³å¡+SessionGate â†’ å®¿ä¸» CanDeviceDriver(NodeChannel) â†’ TCP â†’ æ¨¡æ‹Ÿå™¨è·¯ç”±
 â†’ ResultBody{Readback="OK:TX…" (|PUSHED è‹¥æœ‰å›žæ˜¾)} å›žç®¡é“
 â†’ å®¢æˆ·ç«¯ DrainPiggyback â†’ è‹¥å« PUSHED åˆ™ FramePushed→DriverFrameReceived→面板 RX è¡Œ
（应答器开启时，模拟器把 0x300 å›žæ˜¾ç»™å®¿ä¸»èŠ‚点→宿主暂存→本次/下次响应捎带回客户端）
</pre>
</div>

<!-- ============================================================ -->
<h2 id="s7">7　权限 / ç§Ÿçº¦åœ¨é“¾è·¯ä¸­çš„位置</h2>
<div class="card">
<pre>
入口            é—¨é¢/编排           æœåŠ¡å±‚(DeviceService)          èµ„源层                é©±åŠ¨/传输/服务端
───────────────────────────────────────────────────────────────────────────────────────────────
自动化  â”€â–º AutoDeviceFacade â”€â–º ExecuteCommandAsync â”€â–º ReserveAsync(预约,写租约)
              (Reserve/Release)   ValidateOwner(栅栏) â”€â–º Renew(grant,1)
                                  AcquireOperationAsync â”€â–º OperationLease
                                  driver.SendCommandAsync â”€â–º (Local TCP / Broker RPC)
调试    â”€â–º DebugSessionManager.RequestMaintenance â”€â–º ReserveAsync(Maintenance) + 120s å¿ƒè·³
              CAN: é¢æ¿ç›´è°ƒ driver；电源/PLC: ç» DeviceService
Broker å®¿ä¸»ä¾§ â”€â–º BrokerServer.ExecuteOneShotAsync å‡ºé˜Ÿå†æ ¡éªŒï¼š
              â‘  ç™½åå• â‘¡ configHash(INV-04) â‘¢ PhaseOf/ProbeConflict(INV-01/03) â‘£ SessionGate
</pre>
<table>
<tr><th>校验点</th><th>方法</th><th>失败结果</th></tr>
<tr><td>预约归属</td><td>ResourceManager.ValidateOwner â†’ Renew(grant,1)</td><td>PERMISSION_DENIED</td></tr>
<tr><td>操作互斥</td><td>AcquireOperationAsync â†’ OperationLease</td><td>ResourceConflictException</td></tr>
<tr><td>Broker å‡ºé˜Ÿæ …栏</td><td>PhaseOf==Active ä¸”有 holder</td><td>RejectedStaleLease / RECOVERY_REQUIRED</td></tr>
<tr><td>配置一致</td><td>configHash å¯¹è´¦</td><td>RejectedConfigMismatch(INV-04)</td></tr>
<tr><td>租约续期</td><td>Coordinator.Renew(grant,ttl)</td><td>失败≥2 â†’ LeaseLost / è¿‡æœŸ RECOVERY_REQUIRED</td></tr>
</table>
</div>

<!-- ============================================================ -->
<h2 id="s8">8　关键数据结构一览</h2>
<div class="card">
<table>
<tr><th>类型</th><th>所在</th><th>作用</th></tr>
<tr><td><code>ResourceOwnerToken</code></td><td>Contracts</td><td>调用者身份(OwnerType+OwnerId+TokenId GUID)；租约按 TokenId ç´¢å¼•ï¼Œé¡»å¤ç”¨åŒä¸€å®žä¾‹</td></tr>
<tr><td><code>ResourceKey</code></td><td>Contracts</td><td>(deviceId,"Generic") èµ„源键，仲裁与预约的粒度</td></tr>
<tr><td><code>IOperationLease</code>/OperationLease</td><td>资源层</td><td>单次操作互斥租约（DeviceService å†… using）</td></tr>
<tr><td><code>IAutoDeviceLease</code>/AutoDeviceLease</td><td>AutoDeviceFacade</td><td>作用域租约 + 8s å¿ƒè·³ + LeaseLost</td></tr>
<tr><td><code>DeviceCommandResult</code></td><td>Contracts</td><td>{Success,Readback,RawResponse,ErrorCode,LatencyMs}</td></tr>
<tr><td><code>DebugCommand</code>(+子类)</td><td>DeviceDebug.Entity</td><td>面板→服务的命令对象(PowerSet/CanSend/PlcWrite…)</td></tr>
<tr><td><code>DebugSession</code></td><td>DeviceDebug.Entity</td><td>会话状态机持久化(debug.db)</td></tr>
<tr><td><code>SubmitBody</code>/<code>ResultBody</code>/<code>IpcEnvelope</code></td><td>ResourceContracts.BrokerIpc</td><td>Broker RPC çº¿æ ¼å¼(设备/操作码/载荷/资源键/客户端实例；状态+读回+epoch)</td></tr>
<tr><td><code>LeaseGrant</code></td><td>ResourceContracts</td><td>arb.db ç§Ÿçº¦å‡­æ®(LeaseId/Generation/Epoch/Expires)</td></tr>
<tr><td>命令串 / <code>EV:RECV</code></td><td>SimulatorFraming åè®®</td><td>SEND:/QUERY:/HELLO: ä¸ŽæŽ¨é€è¡Œï¼›4B å¤§ç«¯é•¿åº¦+UTF8 åˆ†å¸§</td></tr>
<tr><td><code>CanFrame</code>/<code>CanFrameDisplay</code></td><td>CanSimulator / DeviceDebug</td><td>总线帧模型 / é¢æ¿æ˜¾ç¤ºè¡Œ</td></tr>
</table>
</div>

<!-- ============================================================ -->
<h2 id="s9">9　类引用关系总图</h2>
<div class="card">
<pre>
        [自动化]  CanBusService â”€â”€uses──► IAutoDeviceFacade(AutoDeviceFacade)
                                                   â”‚ uses
        [调试] DeviceDebugTab â”€â”€â”                  â–¼
                   â”‚            â”‚        IDeviceService(DeviceService)
                   â”‚ç›´è°ƒ         â”‚                  â”‚ uses
                   â–¼            â–¼        â”Œâ”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”´â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”
        IDeviceDriver(CanDeviceDriver)   IResourceManager        IDeviceManager
                   â”‚ holds               (LayeredResourceManager)│ GetDriver
                   â–¼                          â”‚ uses              â–¼
             ICanTransport â”€â”€â”          ILeaseCoordinator   æ³¨å†Œè¡¨: deviceId→CanDeviceDriver
              â”‚              â”‚              â”‚                      â”‚
   NodeChannelTransport  BrokerRpcTransport â”‚              (Broker è®¾å¤‡=CreateBrokerProxy)
              â”‚              â”‚              â–¼
          TCP 9000       å‘½åç®¡é“      DbLeaseStore(arb.db)
              â”‚              â”‚
              â–¼              â–¼
   TcpSimulatorHost   BrokerServer â”€â”€(宿主内再建)──► CanDeviceDriver(NodeChannel) â”€â”€â–º TCP 9000
              â””──────┬──────┘
                     â–¼
        ServerSession â†’ CanCommandExecutor â†’ CanBusSimulator/CanNode
</pre>
<div class="fx"><b>一句话理解</b>：所有仪器调用都归一到 <code>IDeviceDriver</code>；CAN çš„唯一实现 <code>CanDeviceDriver</code> ç”¨ <code>ICanTransport</code> å±è”½"本地 TCP ç›´è¿ž"与"Broker ç®¡é“委托"的差异；权限/租约在门面层(预约)与服务层(校验/操作租约)与 Broker å‡ºé˜Ÿæ …栏三处把关；数据最终以命令串/推送行经 TCP è½åˆ°æ¨¡æ‹Ÿå™¨æœåŠ¡çš„同一总线上。</div>
<p class="small">配套阅读：<a href="程序架构解析报告_V3.1_TCP模拟器与统一驱动.html">程序架构解析报告 V3.1</a>（进程拓扑/协议/应答器/多设备/心跳全景）。</p>
</div>

</div>
</body>
</html>

 docs/ÒÇÆ÷µ÷ÓóÌÐò½á¹¹ÓëÀàµ÷ÓÃ˵Ã÷.html

New file
@@ -0,0 +1,53 @@
<!doctype html>
<html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>仪器调用程序结构与类调用说明</title>
<style>
:root{--navy:#112e45;--blue:#176b87;--ink:#1b2e3b;--muted:#506576;--line:#d9e2e8;--bg:#edf2f4;--green:#e4f3ec;--amber:#fff3d8;--red:#fbe9e7}*{box-sizing:border-box}html{scroll-behavior:smooth}body{margin:0;background:var(--bg);color:var(--ink);font:15px/1.7 "Segoe UI","Microsoft YaHei",sans-serif}.layout{display:grid;grid-template-columns:245px minmax(0,1fr);min-height:100vh}.side{position:sticky;top:0;height:100vh;overflow:auto;background:var(--navy);color:#edf5f8;padding:22px 16px}.brand{font-weight:800;font-size:17px}.side small{display:block;color:#aec5d0;margin:5px 0 18px}.side a{display:block;color:#d5e6ec;text-decoration:none;padding:6px 9px;border-radius:6px;font-size:13px}.side a:hover{background:#1b435d}main{max-width:1250px;width:100%;margin:auto;padding:26px 32px 55px}.hero{color:white;background:linear-gradient(125deg,#112e45,#176b87);padding:32px 36px;border-radius:16px}.hero h1{font-size:32px;line-height:1.25;margin:8px 0}.hero p{color:#d7eaf0;max-width:850px}.pill{display:inline-block;border:1px solid #71a3b5;border-radius:18px;padding:2px 10px;margin:4px 5px 0 0;font-size:12px}.toolbar{display:flex;gap:9px;margin:13px 0;align-items:center}.toolbar input{flex:1;min-width:200px;padding:10px;border:1px solid var(--line);border-radius:8px;font:inherit}.toolbar button{border:0;background:var(--navy);color:white;padding:10px 13px;border-radius:8px}.count{font-size:12px;color:var(--muted)}section{background:white;border:1px solid var(--line);border-radius:13px;padding:24px 28px;margin:15px 0;scroll-margin-top:14px}h2{margin:0 0 13px;color:var(--navy);font-size:22px}h3{color:#17536d;font-size:17px;margin:20px 0 7px}p{margin:8px 0}.tag{display:inline-block;padding:1px 7px;border-radius:5px;font-size:11px;font-weight:bold}.fact{background:var(--green);color:#247455}.target{background:var(--amber);color:#946313}.risk{background:var(--red);color:#9d3939}.note{padding:12px 14px;border-left:4px solid var(--blue);background:#edf7f9;border-radius:0 8px 8px 0;margin:12px 0}.warn{border-left-color:#c7871e;background:#fff8e8}.danger{border-left-color:#b74444;background:#fff0ee}table{border-collapse:collapse;width:100%;font-size:13px;margin:10px 0 16px}th,td{text-align:left;vertical-align:top;border-bottom:1px solid var(--line);padding:8px 9px}th{background:#edf3f6;color:#24495d}tr:hover td{background:#f8fbfc}code{background:#edf2f4;color:#183e55;padding:1px 4px;border-radius:3px;font:12px Consolas,monospace;overflow-wrap:anywhere}.path{font:12px Consolas,monospace;color:#435c6a;overflow-wrap:anywhere}.call{display:grid;grid-template-columns:34px 1fr;gap:10px;padding:11px 7px;border-bottom:1px solid var(--line)}.call:last-child{border:0}.num{width:28px;height:28px;border-radius:50%;display:grid;place-items:center;background:#d8eef2;color:#12526b;font-weight:bold}.call strong{color:#173f55}.call p{font-size:13px;color:var(--muted);margin:2px 0}.cols{display:grid;grid-template-columns:1fr 1fr;gap:12px}.card{border:1px solid var(--line);border-radius:9px;padding:15px;background:#fbfdfe}.card h3{margin:0 0 6px}@media(max-width:820px){.layout{display:block}.side{position:static;height:auto}.side nav{display:grid;grid-template-columns:1fr 1fr}main{padding:14px}.hero{padding:23px}.hero h1{font-size:27px}section{padding:18px}.cols{grid-template-columns:1fr}table{display:block;overflow:auto}}@media print{body{background:white}.layout{display:block}.side,.toolbar{display:none}.hero{print-color-adjust:exact}.hero,section{break-inside:avoid}}
</style></head><body><div class="layout">
<aside class="side"><div class="brand">TESTPLATFORM<br>仪器调用结构</div><small>类职责 Â· è°ƒç”¨é¡ºåº Â· ç”Ÿå‘½å‘¨æœŸ</small><nav>
<a href="#summary">01 ç»“论与边界</a><a href="#layers">02 ç±»èŒè´£åˆ†å±‚</a><a href="#can">03 CAN å•æ¬¡è°ƒç”¨</a><a href="#lease">04 ä½œç”¨åŸŸç§Ÿçº¦</a><a href="#power">05 ç”µæº Slot è°ƒç”¨</a><a href="#broker">06 Broker è°ƒç”¨</a><a href="#startup">07 å¯åŠ¨ä¸Žè¿žæŽ¥</a><a href="#result">08 ç»“果与错误</a><a href="#gaps">09 å¾…完善项</a><a href="#sources">10 æºç å®šä½</a></nav></aside>
<main><header class="hero"><div>TapProject / Aging.Infrastructure / DeviceBroker</div><h1>仪器调用程序结构<br>与类调用说明</h1><p>根据源码梳理测试动作如何到达驱动、驱动如何访问物理通道、结果怎样返回；区分当前实现与 V3.1 ç›®æ ‡è®¾è®¡ã€‚</p><span class="pill">D:\TestPlatform\TapProject</span><span class="pill">离线 HTML</span><span class="pill">2026-11-09</span><span class="pill">不使用 OpenTAP åŽŸç”Ÿ Instrument</span></header>
<div class="toolbar"><input id="filter" type="search" placeholder="筛选本页文字：例如 CanBusService、租约、Broker"><button id="reset">清除筛选</button><span id="count" class="count">10 ä¸ªç« èŠ‚</span></div>
<section id="summary"><h2>01　结论与阅读边界</h2><p>仪器访问主链路：<strong>测试动作 â†’ ç±»åž‹åŒ–服务/自动化门面 â†’ èµ„源授权与操作租约 â†’ DeviceService â†’ DeviceManager â†’ IDeviceDriver â†’ Transport â†’ ä»ªå™¨æˆ– DeviceBroker</strong>。返回结果沿反方向逐层包装，最终由测试步骤保存结果并生成 Verdict。</p><div class="note"><b>OpenTAP æŽ¥å…¥çº¦æŸï¼š</b>本系统不实现原生 <code>Instrument</code>。未来仪器类 StepType åªç»§æ‰¿ <code>TestStep</code>，在 <code>Run()</code> è°ƒç”¨ç³»ç»ŸæœåŠ¡ã€‚该接入点属于目标方案；当前 TapProject å¯ç›´æŽ¥è¿½è¸ªçš„自动化示例主要位于 IntegrationTest UI，不能据此认为生产 OpenTAP æ’件已接通。</div><div class="note warn"><b>连接与租约不同：</b>步骤租约是短期资源授权，物理连接由唯一 I/O å®¿ä¸»æŒæœ‰ã€‚V3.1 è§„定驱动注册后连接、HostReady å‰å°±ç»ªæ£€æŸ¥ï¼›å½“前代码仍有首次 I/O æ‰è¿žæŽ¥çš„路径。</div><p><span class="tag fact">代码事实</span> æºç å·²æœ‰ã€‚　<span class="tag target">V3.1 ç›®æ ‡</span> è®¾è®¡è¦æ±‚。　<span class="tag risk">缺口</span> å°šéœ€å®žçŽ°æˆ–验证。</p></section>
<section id="layers"><h2>02　分层与类职责</h2><table><thead><tr><th>层</th><th>ç±» / æŽ¥å£</th><th>职责与调用关系</th><th>状态</th></tr></thead><tbody>
<tr><td>测试入口</td><td><code>TestStep</code></td><td>保存逻辑设备/Slot、通道和工艺参数；调用服务、发布结果、设置 Verdict。不连接物理设备，不创建厂家 SDK。</td><td><span class="tag target">计划接入</span></td></tr>
<tr><td>类型化 API</td><td><code>ICanBusService / CanBusService</code></td><td>校验 CAN å¸§ã€ç¼–码命令、解析读回。单次调用走 Facade；多操作可借用 Lease。</td><td><span class="tag fact">已有实现</span></td></tr>
<tr><td>自动化门面</td><td><code>IAutoDeviceFacade / AutoDeviceFacade</code></td><td>单次 Reserve→Execute→Release，或 Acquire åŽç”± Lease.Dispose é‡Šæ”¾é¢„约。</td><td><span class="tag fact">已有实现</span></td></tr>
<tr><td>Slot æœåŠ¡</td><td><code>PowerSupplyService</code>、<code>SlotDeviceMappingResolver</code></td><td>按 Slot+Capability è§£æžç«¯ç‚¹/资源键，完成电源设定、测量、状态查询。</td><td><span class="tag fact">已有实现</span></td></tr>
<tr><td>设备执行服务</td><td><code>IDeviceService / DeviceService</code></td><td>查驱动、校验 Owner、取得单次操作租约、调用 Driver å¹¶åŒ…装结果。</td><td><span class="tag fact">已有实现</span></td></tr>
<tr><td>资源授权</td><td><code>IResourceManager</code>、Owner Token、Operation Lease</td><td>Owner Reservation è¦†ç›–步骤作用域；Operation Lease è¦†ç›–一次 I/O ç‰‡æ®µï¼Œä¸¤è€…不可混为一谈。</td><td><span class="tag fact">已有接口</span></td></tr>
<tr><td>驱动管理</td><td><code>IDeviceManager / DeviceManager</code></td><td>按 DeviceId ä¿å­˜ Driver、缓存状态、提供连接/断开 API。<code>RegisterDriver()</code> åªæ³¨å†Œï¼Œä¸è‡ªåŠ¨ Connect。</td><td><span class="tag fact">已有实现</span></td></tr>
<tr><td>驱动创建/协议</td><td><code>DriverFactory</code>、<code>IDeviceDriver</code>、<code>CanDeviceDriver</code>、SCPI/ModBus/S7 adapters</td><td>按 transport åˆ›å»ºé©±åŠ¨å¹¶å°è£…协议交互；Serial åˆ†æ”¯å°šæœªå®žçŽ°ã€‚</td><td><span class="tag fact">部分实现</span></td></tr>
<tr><td>传输与宿主</td><td><code>ICanTransport</code>、<code>NodeChannelTransport</code>、<code>BrokerRpcTransport</code>、<code>BrokerServer</code></td><td>区分 Local é€šé“与 Broker IPC；Broker å®¿ä¸»æŒæœ‰å…¶é…ç½®ä¸‹çœŸå®žé©±åŠ¨ã€‚</td><td><span class="tag fact">已有实现</span></td></tr></tbody></table><div class="note">依赖方向：StepType â†’ ç¨³å®šæœåŠ¡ API/client â†’ æœåŠ¡å®žçŽ° â†’ èµ„源/设备管理契约 â†’ Driver å¥‘约 â†’ Transport。上层不要 new åŽ‚家 SDK、直连 IP/串口或依赖 Broker ç§æœ‰å®žçŽ°ã€‚</div></section>
<section id="can"><h2>03　CAN å•æ¬¡è°ƒç”¨ï¼šæ¯æ¡æ“ä½œå•ç‹¬é¢„约</h2><p>示例：<code>ICanBusService.SendFrameAsync(deviceId, frameId, data)</code>。</p>
<div class="call"><div class="num">1</div><div><strong>TestStep æˆ–当前测试 UI</strong><p>提供逻辑 deviceId、CAN ID å’Œæ•°æ®å­—节。TestStep æ˜¯é¢„期接入点；当前可查到的自动化调用入口主要在 IntegrationTest çš„ AutoRunBtn_Click。</p></div></div>
<div class="call"><div class="num">2</div><div><strong>CanBusService.SendFrameAsync(deviceId,...)</strong><p>校验帧 ID/长度，编码为 SEND å‘½ä»¤ï¼Œè°ƒç”¨ AutoDeviceFacade.ExecuteAsync。</p></div></div>
<div class="call"><div class="num">3</div><div><strong>AutoDeviceFacade.ExecuteAsync()</strong><p>创建 Owner，按当前实现申请 <code>ResourceKey(deviceId, Generic)</code>；委托 DeviceService，finally ä¸­é‡Šæ”¾é¢„约。</p></div></div>
<div class="call"><div class="num">4</div><div><strong>DeviceService.ExecuteCommandAsync()</strong><p>通过 DeviceManager æ‰¾ Driver，验证 Generic èµ„源 Owner，取得一次 Operation Lease，然后调用驱动。</p></div></div>
<div class="call"><div class="num">5</div><div><strong>IDeviceDriver â†’ CanDeviceDriver â†’ ICanTransport</strong><p>当前 CAN Driver åœ¨ Send/Query å‰è¿è¡Œ EnsureConnectedAsync；未连接时第一次 I/O ä¼šå»ºè¿žã€‚</p></div></div>
<div class="call"><div class="num">6</div><div><strong>NodeChannelTransport æˆ– BrokerRpcTransport â†’ è¿”回</strong><p>Local èµ° NodeChannelTransport；Broker èµ°å‘½åç®¡é“ RPC åˆ° DeviceBroker。结果回到 DeviceService，再由 CanBusService è½¬ä¸º bool æˆ–帧 DTO。</p></div></div><div class="note warn">单次调用会释放资源预约，不代表调用 DeviceManager.Disconnect。CAN driver/transport å¯ç»§ç»­æŒæœ‰å·²å»ºç«‹çš„连接；首次 I/O æŒ‰éœ€å»ºè¿žæ˜¯çŽ°çŠ¶ï¼Œä¸æ˜¯ V3.1 å¯åŠ¨å»ºè¿žç›®æ ‡ã€‚</div></section>
<section id="lease"><h2>04　作用域租约：一个 Step å†…多次操作</h2><ol><li><code>AutoDeviceFacade.AcquireAsync(deviceId, stepName)</code> é¢„约资源并返回 <code>IAutoDeviceLease</code>。</li><li>调用 <code>CanBusService.SendFrameAsync(lease,...)</code>、<code>ReceiveFrameAsync(lease)</code> ç­‰é‡è½½ã€‚</li><li>CanBusService å§”托 Lease.Execute/Query；AutoDeviceLease è¿›å…¥ DeviceService，每次 I/O å†å–å¾— Operation Lease。</li><li>步骤结束 Dispose Lease，释放外层预约；不会等价调用 Driver.Disconnect。</li></ol><div class="note">外层 Reservation è¡¨ç¤ºæ­¥éª¤å½“前获准使用设备；Operation Lease è¡¨ç¤ºå…·ä½“命令/响应片段正在执行。共享物理会话安全串行还依赖资源管理器/SessionGate çš„实际锁范围。</div></section>
<section id="power"><h2>05　电源 Slot è°ƒç”¨ï¼šé€»è¾‘位置映射到设备</h2><ol><li><code>PowerSupplyService.ConfigureAsync(slotId, command, owner, ct)</code> æŽ¥æ”¶ Slot、目标值和 Owner。</li><li><code>SlotDeviceMappingResolver.ResolveEndpoint(slotId, PowerSupply)</code> è§£æžè®¾å¤‡ã€é€šé“和资源键。</li><li>PowerSupplyService éªŒè¯èµ„源授权并取得 Operation Lease。</li><li>从 <code>DeviceManager.GetDriver(endpoint.DeviceId)</code> å– Driver，发 SCPI è®¾ç½®å¹¶æŸ¥è¯¢è¯»å›žã€‚</li><li>返回 <code>PowerOperationResult</code>：实测值、原始响应、错误码、耗时。</li></ol><div class="note warn">CAN Facade å½“前申请 <code>deviceId:Generic</code>；电源服务按 Slot æ˜ å°„资源键授权，可能细化到通道。Step ä¸åº”自行猜测 Owner/ResourceKey；需统一 typed API æˆ–通道级 lease åˆçº¦ã€‚</div></section>
<section id="broker"><h2>06　Broker è°ƒç”¨é“¾ï¼šå®¢æˆ·ç«¯ä»£ç†ä¸æŒæœ‰å®žç‰©</h2><div class="cols"><div class="card"><h3>客户端侧</h3><p>Bootstrapper ä¸º Broker é…ç½®åˆ›å»ºè®¾å¤‡ä»£ç† Driver，注入 BrokerRpcTransport；业务层仍调用同一类型化 API。</p></div><div class="card"><h3>Broker å®¿ä¸»</h3><p>BrokerServer æŒæœ‰çœŸå®žé…ç½®å’ŒçœŸå®ž Driver，在设备 gate ä¸­æ‰§è¡Œè¯·æ±‚。物理 socket/串口/SDK ä¼šè¯åªå½’唯一 I/O å®¿ä¸»ã€‚</p></div></div><div class="call"><div class="num">1</div><div><strong>BrokerRpcTransport</strong><p>把 SEND/QUERY ç¼–成操作码和 payload，携带 DeviceId、client instance、配置 Hash。</p></div></div><div class="call"><div class="num">2</div><div><strong>BrokerClientChannel</strong><p>建立/复用命名管道，Hello æ¡æ‰‹ï¼Œç”¨ CorrelationId å…³è”请求响应并设置等待期限。</p></div></div><div class="call"><div class="num">3</div><div><strong>BrokerServer</strong><p>处理 CONNECT/SEND/QUERY/STATUS；按需创建真实 Driver、连接并执行。</p></div></div><div class="call"><div class="num">4</div><div><strong>真实 Driver â†’ ç‰©ç† Transport â†’ ä»ªå™¨</strong><p>Broker è¿”回状态与读回，代理清理传输封装后交回服务层。</p></div></div><div class="note danger">Broker ä¸å¯è¾¾æ—¶ï¼ŒTestStep ä¸å¯è‡ªè¡Œåˆ‡æ¢åˆ° Local ç›´è¿žåŒä¸€ä»ªå™¨ï¼Œå¦åˆ™å¯èƒ½å½¢æˆåŒä¸€ä¸ª PhysicalSessionKey çš„双主控制。写命令已提交但超时，应视为 Unknown，先读回/恢复，不盲目重发。</div></section>
<section id="startup"><h2>07　启动与连接生命周期：接口存在不代表自动执行</h2><table><thead><tr><th>环节</th><th>当前源码事实</th><th>V3.1 ç›®æ ‡ / å·®è·</th></tr></thead><tbody>
<tr><td>基础设施装配</td><td>Bootstrapper åˆ›å»º ResourceManager、DeviceManager、DeviceService、PowerSupplyService、AutoFacade、CanBusService。</td><td>已搜索到的 Bootstrapper è°ƒç”¨ç‚¹åœ¨ Plugin.IntegrationTest；未据此确认生产主程序启动已接入。</td></tr>
<tr><td>Local æ³¨å†Œ</td><td><code>LoadDevicesFromConfig()</code> è¯»å–映射但创建本地 Driver ä»ä¸º TODO。</td><td>按生效配置读取驱动定义、核对唯一宿主后注册。</td></tr>
<tr><td>Driver æ³¨å†Œ</td><td>DeviceManager.RegisterDriver å†™å­—å…¸/初始状态/事件订阅，不执行 Connect。</td><td>注册后由宿主连接本宿主设备并检查 Ready。</td></tr>
<tr><td>CAN è¿žæŽ¥</td><td>CanDeviceDriver é¦–次 Send/Query æ—¶ EnsureConnectedAsync。</td><td>HostReady å‰å»ºè¿žå¹¶å¥åº·æ£€æŸ¥ï¼Œä¸è®©é¦–次测试动作承担连接。</td></tr>
<tr><td>Broker è¿žæŽ¥</td><td>客户端注册代理；BrokerServer åœ¨ CONNECT æˆ–首次操作时可创建/连接真实 Driver。</td><td>真实物理连接留在 Broker å®¿ä¸»ï¼Œä»£ç†åªåš IPC。</td></tr>
<tr><td>SCPI è¿žæŽ¥</td><td>当前 ScpiDriverAdapter.ConnectAsync ä¼šå‘送 <code>*RST</code>。</td><td>自动连接前拆出 Reset；Connect åªå»ºé“¾å¹¶è¿›è¡Œæ— å‰¯ä½œç”¨æŽ¢æµ‹ã€‚</td></tr>
<tr><td>步骤结束</td><td>Dispose é‡Šæ”¾èµ„源预约，不等于 DeviceManager.Disconnect。</td><td>连接由宿主持有，步骤结束不断开。</td></tr>
<tr><td>关闭/重启</td><td>DeviceManager æœ‰å•è®¾å¤‡ Connect/Disconnect；未见完整统一生命周期协调。</td><td>关闭需排空、安全处理、读回后断开；重启进入恢复门禁，再发布 HostReady。</td></tr></tbody></table><div class="note">建议 DeviceManager ç®¡ç†é©±åŠ¨å®žä¾‹å’Œå•è®¾å¤‡è¿žæŽ¥ï¼›å®¿ä¸»çº§ DeviceService æˆ–独立连接协调器负责注册后批量连接、汇总 Connected/Ready、失败隔离、有序关闭。不要在每个 Run() ä¸­ Connect/Disconnect。</div></section>
<section id="result"><h2>08　结果与错误边界</h2><table><thead><tr><th>层</th><th>返回值</th><th>判定边界</th></tr></thead><tbody><tr><td>Driver</td><td>原始响应、状态、异常/连接事件。</td><td>不是 DUT Pass/Fail。</td></tr><tr><td>DeviceService</td><td><code>DeviceCommandResult</code>：成功、读回、错误码/信息、延迟。</td><td>命令交换成功不一定等于工艺合格。</td></tr><tr><td>CanBusService</td><td>发送 bool、接收 CanFrameData。</td><td>生产 Step åº”保留可诊断错误，避免只有 bool。</td></tr><tr><td>PowerSupplyService</td><td>PowerOperationResult：实测值、原始响应、错误、延迟。</td><td>由业务步骤按限值判定。</td></tr><tr><td>TestStep</td><td><span class="tag target">目标</span>记录输入/读数/单位/限值/耗时并设 Verdict。</td><td>设备故障通常为执行 Error；测量超限才是工艺 Fail；结果 Unknown è¦æ¢å¤ï¼Œä¸ç›²ç›®é‡å‘。</td></tr></tbody></table></section>
<section id="gaps"><h2>09　建议优先完善的接口边界</h2><ol><li>给 TestStep æä¾›ç¨³å®š client API ä¸Ž DTO；如 OpenTAP Engine ä¸Ž Aging.Infrastructure æ¡†æž¶ä¸å…¼å®¹ï¼Œç”¨ç‰ˆæœ¬åŒ– IPC。</li><li>把 Bootstrapper æŽ¥å…¥ç”Ÿäº§ç»„合根，加载完整配置、驱动定义及 Local/Broker å½’属。</li><li>实现注册后连接协调、健康检查、HostReady é—¨ç¦ã€æœ‰é™é‡è¯•å’Œæ•…障隔离。</li><li>统一 CAN、电源等服务的 Owner、Slot、Channel、ResourceKey ç”³è¯·æ–¹å¼ã€‚</li><li>把 SCPI <code>*RST</code>、输出设置、安全动作从 Connect æ‹†ä¸ºæ˜¾å¼å—控操作。</li><li>确认共享 PhysicalSession ä¸Šçš„操作锁覆盖完整 I/O ç‰‡æ®µï¼Œå¹¶å®šä¹‰è¶…æ—¶/Unknown è¯­ä¹‰ã€‚</li></ol><div class="note danger">证据边界：本文为源码静态阅读和 V3.1 è®¾è®¡å¯¹ç…§ï¼Œæ²¡æœ‰è¿è¡Œä»ªå™¨ã€æ¨¡æ‹Ÿå™¨æˆ–整站应用。自动连接、HostReady å’Œæ¢å¤é—¨ç¦å‡æ ‡ä¸ºç›®æ ‡ï¼Œä¸æ˜¯å·²éªŒæ”¶äº‹å®žã€‚</div></section>
<section id="sources"><h2>10　源码定位</h2><table><thead><tr><th>类型</th><th>文件</th><th>查看内容</th></tr></thead><tbody>
<tr><td>启动/注册</td><td class="path">D:\TestPlatform\TapProject\Aging.Infrastructure\InfrastructureBootstrapper.cs</td><td>Initialize、LoadDevicesFromConfig、RegisterBrokeredDrivers、RegisterDevice</td></tr>
<tr><td>门面/租约</td><td class="path">D:\TestPlatform\TapProject\Aging.Infrastructure\Services\AutoDeviceFacade.cs</td><td>Execute/Query、Acquire、AutoDeviceLease.Dispose</td></tr>
<tr><td>CAN API</td><td class="path">D:\TestPlatform\TapProject\Aging.Infrastructure\Services\CanBusService.cs</td><td>类型化调用、命令编码、租约重载</td></tr>
<tr><td>执行/管理</td><td class="path">D:\TestPlatform\TapProject\Aging.Infrastructure\Services\DeviceService.cs<br>D:\TestPlatform\TapProject\Aging.Infrastructure\Core\DeviceManager.cs</td><td>权限验证、操作租约、Driver æ³¨å†Œä¸Žè¿žæŽ¥çŠ¶æ€</td></tr>
<tr><td>电源</td><td class="path">D:\TestPlatform\TapProject\Aging.Infrastructure\Services\PowerSupplyService.cs<br>D:\TestPlatform\TapProject\Aging.Infrastructure\Services\SlotDeviceMappingResolver.cs</td><td>Slot æ˜ å°„和电源动作</td></tr>
<tr><td>驱动/传输</td><td class="path">D:\TestPlatform\TapProject\Aging.Infrastructure\Drivers\DriverFactory.cs<br>D:\TestPlatform\TapProject\Aging.Infrastructure\Drivers\CanDeviceDriver.cs<br>D:\TestPlatform\TapProject\Aging.Infrastructure\Drivers\BrokerRpcTransport.cs<br>D:\TestPlatform\TapProject\Aging.Infrastructure\Broker\BrokerClientChannel.cs</td><td>Driver åˆ›å»ºã€æŒ‰éœ€å»ºè¿žã€Broker RPC</td></tr>
<tr><td>Broker å®¿ä¸»</td><td class="path">D:\TestPlatform\TapProject\DeviceBroker\BrokerServer.cs</td><td>真实 Driver åˆ›å»ºã€è¿žæŽ¥å’Œ I/O</td></tr>
<tr><td>当前自动化示例</td><td class="path">D:\TestPlatform\TapProject\Plugin.IntegrationTest\MainWindow.xaml.cs</td><td>InitializeAutoServices、RegisterCanDriver、AutoRunBtn_Click</td></tr>
<tr><td>目标设计</td><td class="path">D:\06-产品开发\18-舱驾控制器老化设备\Local + DeviceBroker æ··åˆæž¶æž„详细设计说明书 V3.1.html</td><td>第 23 ç« ï¼šå¯åŠ¨è¿žæŽ¥ã€HostReady、恢复、关闭与 SCPI</td></tr></tbody></table></section>
<footer style="text-align:center;color:#657987;font-size:12px;padding:17px">仪器调用程序结构与类调用说明 Â· æœ¬åœ°æºç é™æ€æ¢³ç† Â· 2026-11-09</footer></main></div>
<script>const f=document.getElementById('filter'),ss=[...document.querySelectorAll('main section')],c=document.getElementById('count');function go(){let q=f.value.trim().toLowerCase(),n=0;for(const s of ss){let ok=!q||s.innerText.toLowerCase().includes(q);s.hidden=!ok;if(ok)n++}c.textContent=n+' / '+ss.length+' ä¸ªç« èŠ‚'}f.addEventListener('input',go);document.getElementById('reset').onclick=()=>{f.value='';go();f.focus()};</script></body></html>

 docs/³ÌÐò¼Ü¹¹½âÎö±¨¸æ_V3.1_TCPÄ£ÄâÆ÷ÓëͳһÇý¶¯.html

New file
@@ -0,0 +1,342 @@
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="utf-8"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>仪器调试平台 ç¨‹åºæž¶æž„解析报告（V3.1 Â· TCP æ¨¡æ‹Ÿå™¨ + ç»Ÿä¸€é©±åŠ¨ + å¤šè®¾å¤‡å¹¶å‘）</title>
<style>
:root{--bg:#f7f8fa;--card:#fff;--ink:#1f2430;--muted:#5b6472;--line:#e4e8ef;--accent:#2f6fed;--warn:#b7791f;--bad:#c0392b;--ok:#2e8b57;--code:#0d1117;}
*{box-sizing:border-box}
body{margin:0;background:var(--bg);color:var(--ink);font:15px/1.7 "Segoe UI","Microsoft YaHei",Arial,sans-serif}
.wrap{max-width:1080px;margin:0 auto;padding:32px 20px 80px}
h1{font-size:26px;margin:0 0 6px}
h2{font-size:20px;margin:34px 0 12px;padding-bottom:6px;border-bottom:2px solid var(--line)}
h3{font-size:16px;margin:20px 0 8px;color:var(--accent)}
.sub{color:var(--muted);margin:0 0 18px}
.card{background:var(--card);border:1px solid var(--line);border-radius:12px;padding:16px 18px;margin:14px 0;box-shadow:0 1px 2px rgba(0,0,0,.03)}
pre{background:var(--code);color:#e6edf3;border-radius:10px;padding:14px 16px;overflow:auto;font:13px/1.55 "Cascadia Code",Consolas,monospace;margin:10px 0}
code{font-family:"Cascadia Code",Consolas,monospace;background:#eef1f6;padding:1px 5px;border-radius:4px;font-size:13px}
pre code{background:none;padding:0;color:inherit}
table{border-collapse:collapse;width:100%;margin:10px 0;font-size:14px}
th,td{border:1px solid var(--line);padding:7px 10px;text-align:left;vertical-align:top}
th{background:#eef2f8}
.tag{display:inline-block;padding:1px 8px;border-radius:999px;font-size:12px;font-weight:600;margin-right:4px}
.t-local{background:#e6f0ff;color:#1b4fa0}
.t-broker{background:#fdeee0;color:#a35a12}
.t-server{background:#e7f6ec;color:#1f7a3d}
.ok{color:var(--ok);font-weight:600}
.bad{color:var(--bad);font-weight:600}
.warn{color:var(--warn);font-weight:600}
.small{font-size:13px;color:var(--muted)}
.toc{columns:2;font-size:14px}
.toc a{color:var(--accent);text-decoration:none}
.kv{color:#8b949e}
.hl{background:#fff6d6;border-left:4px solid var(--warn);padding:10px 12px;border-radius:6px;margin:10px 0}
.fx{background:#e8f5e9;border-left:4px solid var(--ok);padding:10px 12px;border-radius:6px;margin:10px 0}
</style>
</head>
<body>
<div class="wrap">

<h1>仪器调试平台 Â· ç¨‹åºæž¶æž„解析报告</h1>
<p class="sub">V3.1 ç»“构：CAN æ¨¡æ‹Ÿå™¨ç‹¬ç«‹ TCP æœåŠ¡ + ç»Ÿä¸€ <code>CanDeviceDriver</code> + å¤šè®¾å¤‡å¹¶å‘调试 + æ€»çº¿åº”答器 + ç»´æŠ¤ç§Ÿçº¦å¿ƒè·³ã€‚<br/>
本报告描述<b>最新代码</b>的运行逻辑，与仓库实际实现同步（2026-11-09）。</p>

<div class="card">
<b>目录</b>
<div class="toc">
<div><a href="#s1">1. è¿›ç¨‹ä¸Žæ•°æ®æ‹“扑</a></div>
<div><a href="#s2">2. å·¥ç¨‹ä¸Žå…³é”®æ–‡ä»¶æ¸…单</a></div>
<div><a href="#s3">3. å¯åŠ¨åˆå§‹åŒ–时序</a></div>
<div><a href="#s4">4. è®¾å¤‡æ³¨å†Œä¸Žç»Ÿä¸€é©±åŠ¨åˆ†æ´¾</a></div>
<div><a href="#s5">5. TCP çº¿åè®®ä¸Žæ¨¡æ‹Ÿå™¨æœåŠ¡ç«¯</a></div>
<div><a href="#s6">6. æ€»çº¿è·¯ç”±ä¸Žåº”答器</a></div>
<div><a href="#s7">7. è°ƒè¯•é¡µå¤šæ ‡ç­¾å¤šä¼šè¯</a></div>
<div><a href="#s8">8. ç»´æŠ¤ä¼šè¯çŠ¶æ€æœºä¸Žç§Ÿçº¦å¿ƒè·³</a></div>
<div><a href="#s9">9. æŠ¥æ–‡æ”¶å‘全链路（Local / Broker）</a></div>
<div><a href="#s10">10. é”™è¯¯å¤„理与不变量</a></div>
<div><a href="#s11">11. ä»£ç ç´¢å¼•</a></div>
<div><a href="#s12">12. å·²çŸ¥é™åˆ¶</a></div>
</div>
</div>

<!-- ============================================================ -->
<h2 id="s1">1　进程与数据拓扑</h2>
<div class="card">
<p>系统由 <b>3 ç±»è¿›ç¨‹ + 1 ä¸ªæœåŠ¡è¿›ç¨‹</b> ç»„成，CAN æ€»çº¿ä¸–界由独立服务进程统一托管：</p>
<pre>
┌───────────────────────────────── CanSimulatorServer.exe（总线权威，独立进程） â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”
│  TcpListener 127.0.0.1:9000                                                                                      â”‚
│   â”œâ”€ TcpSimulatorHost   æŽ¥å—连接，每连接一个 ServerSession                                                        â”‚
│   â”œâ”€ ServerSession      HELLO çŠ¶æ€æœº + ä¸€é—®ä¸€ç­”保序响应 + EV:RECV æŽ¨é€ï¼ˆå†™é”ä¸²è¡Œã€å‘½ä»¤æœŸæš‚存门）                 â”‚
│   â”œâ”€ CanBusManager      æŒ‰åæ‡’建 CanBusSimulator；(bus,nodeIndex) å”¯ä¸€æ€§ä»²è£                                     â”‚
│   â”œâ”€ CanCommandExecutor å‘½ä»¤ä¸²æ‰§è¡Œï¼ˆSEND/QUERY/AUTO_RESPONSE/BUS_ECHO/FILTER/LOG/STATUS…）                       â”‚
│   â””─ CanBusSimulator    å¤ç”¨åŽŸè·¯ç”±/自动响应/总线日志 + <b>总线级应答器 EchoResponderToSender</b>                    â”‚
│  UI：监听状态 Â· èŠ‚点树 Â· å®žæ—¶å¸§è¡¨(TX/RX) Â· ç»Ÿè®¡ Â· æ—¥å¿— Â· åº”答器复选框                                              â”‚
└─────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
        â–² TCP 9000（NodeChannelTransport）              â–² TCP 9000（宿主物理会话）
        â”‚                                               â”‚
┌───────┴───────────────┐   å‘½åç®¡é“ RPC   â”Œâ”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”´â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”
│ Plugin.IntegrationTest â”‚ â—„──────────────► â”‚  DeviceBroker.exe         â”‚
│ ï¼ˆä¸»ç¨‹åºï¼ŒLocal è®¾å¤‡ï¼‰  â”‚  aging.broker-   â”‚ ï¼ˆBroker å…±äº«è®¾å¤‡å®¿ä¸»ï¼‰   â”‚
│  CAN-001/002 â€¦         â”‚  b01.v1          â”‚  CAN-003/004 â€¦            â”‚
└────────────────────────┘                  â””───────────────────────────┘

数据文件（%LOCALAPPDATA%\PluginIntegrationTest）：
  data.db  è®¾å¤‡å®šä¹‰ï¼ˆå« ExecutionMode=Local/Broker、BrokerId、Endpoint、PhysicalSessionKey）
  arb.db   è·¨è¿›ç¨‹ç§Ÿçº¦ä»²è£ï¼ˆresource_state / lease_history / recovery_checkpoint / authority_meta）
  debug.db è°ƒè¯•ä¼šè¯ï¼ˆdebug_session çŠ¶æ€æœºæŒä¹…化 + æ“ä½œæ—¥å¿—）
</pre>
<p><span class="tag t-local">Local ç›´è¿ž</span>客户端进程内 <code>CanDeviceDriver</code> ç» <code>NodeChannelTransport</code> ç›´æŽ¥ TCP è¿žæ¨¡æ‹Ÿå™¨ã€‚<br/>
<span class="tag t-broker">Broker ä»£ç†</span>客户端 <code>CanDeviceDriver</code> ç» <code>BrokerRpcTransport</code> èµ°å‘½åç®¡é“委托宿主，宿主内再用 <code>CanDeviceDriver(NodeChannel)</code> è¿žæ¨¡æ‹Ÿå™¨ã€‚<br/>
<span class="tag t-server">服务</span>CanSimulatorServer æ˜¯å”¯ä¸€çš„总线世界权威，所有进程的同名总线其实是<b>同一个进程内的同一总线对象</b>，因此跨进程设备天然互通。</p>
<p class="small">与旧结构的关键差异：不再有"进程内 static æ€»çº¿å­—å…¸"，跨进程隔离问题从根上消除；CAN é©±åŠ¨åªå‰©ä¸€ä¸ªç±»ã€‚</p>
</div>

<!-- ============================================================ -->
<h2 id="s2">2　工程与关键文件清单</h2>
<div class="card">
<table>
<tr><th>层</th><th>文件</th><th>职责</th></tr>
<tr><td>模拟器类库</td><td>CanSimulator\CanBusSimulator.cs Â· CanNode.cs Â· CanFrame.cs Â· <b>SimulatorFraming.cs</b></td><td>虚拟总线/节点/帧；新增 TCP åˆ†å¸§ç¼–解码（4B å¤§ç«¯é•¿åº¦+UTF8）</td></tr>
<tr><td rowspan="4">模拟器服务端<br/>CanSimulatorServer</td><td>CanSimulatorServer.Core\TcpSimulatorHost.cs</td><td>监听/接受连接/会话登记；port=0 éšæœºç«¯å£ï¼ˆæµ‹è¯•å›žçŽ¯ï¼‰</td></tr>
<tr><td>CanSimulatorServer.Core\ServerSession.cs</td><td>单连接协议状态机、保序响应、EV æŽ¨é€ã€å‘½ä»¤æœŸæŽ¨é€æš‚存门</td></tr>
<tr><td>CanSimulatorServer.Core\CanBusManager.cs</td><td>总线注册表 + (bus,node) å”¯ä¸€ä»²è£ + èŠ‚点↔会话胶水</td></tr>
<tr><td>CanSimulatorServer.Core\CanCommandExecutor.cs</td><td>命令串执行器（含 BUS_ECHO åº”答器、AUTO_RESPONSE、FILTER、LOG、STATUS）</td></tr>
<tr><td>模拟器服务 UI</td><td>CanSimulatorServer.App\App.cs Â· MainWindow.cs</td><td>WPF ç›‘控窗口（节点树/帧表/统计/应答器复选框）</td></tr>
<tr><td rowspan="4">驱动层<br/>Aging.Infrastructure</td><td>Drivers\CanDeviceDriver.cs</td><td><b>唯一 CAN é©±åŠ¨</b>：命令语义、接收缓冲、事件、连接状态机</td></tr>
<tr><td>Drivers\ICanTransport.cs Â· NodeChannelTransport.cs Â· BrokerRpcTransport.cs</td><td>传输后端抽象与两实现（TCP ç›´è¿ž / ç®¡é“ RPC）</td></tr>
<tr><td>Drivers\DriverFactory.cs</td><td>CAN ç»Ÿä¸€äº§å‡º CanDeviceDriver</td></tr>
<tr><td>InfrastructureBootstrapper.cs</td><td>装配服务、Broker è®¾å¤‡æ³¨å†Œä»£ç†é©±åŠ¨ã€å¯åŠ¨å¯¹è´¦</td></tr>
<tr><td>Broker å®¿ä¸»</td><td>DeviceBroker\BrokerServer.cs</td><td>三重关卡 + SessionGate + æŽå¸¦æŽ¨é€ AppendPushes</td></tr>
<tr><td rowspan="5">调试插件<br/>Plugin.DeviceDebug</td><td>DeviceDebug.xaml(.cs)</td><td>多设备壳：设备下拉(过滤已开)+加入/关闭+TabControl</td></tr>
<tr><td>DeviceDebugTab.xaml(.cs)</td><td>单设备工作区：独立会话+面板+操作日志+维护按钮</td></tr>
<tr><td>Model\DebugSessionManager.cs</td><td>会话状态机 + <b>维护租约心跳续期</b> + ä»¤ç‰Œç¼“存复用</td></tr>
<tr><td>Panels\CanDebugPanel.xaml(.cs)</td><td>CAN å¤šé€šé“壳（TabControl）</td></tr>
<tr><td>Panels\CanChannelView.xaml(.cs)</td><td>单通道视图（连接/发送/接收/统计），BeginInvoke æ˜¾ç¤º</td></tr>
</table>
</div>

<!-- ============================================================ -->
<h2 id="s3">3　启动初始化时序</h2>
<div class="card">
<pre class="seq">
① ç”¨æˆ·æ‰‹åŠ¨å¯åŠ¨ CanSimulatorServer.exe（主程序与 Broker éƒ½ä¸æ‹‰èµ·å®ƒï¼‰
   â”” TcpSimulatorHost.StartAsync(9000) ç›‘听；UI å°±ç»ªï¼›åº”答器默认 OFF

② å¯åŠ¨ Plugin.IntegrationTest.exe â†’ MainWindow.InitializePlugins（顺序敏感）
   1. DeviceConfig.InitFinish        â†’ å»ºåº“/迁移 data.db
   2. SeedPresetCanDevices()         â†’ é¢„ç½® CAN è®¾å¤‡ï¼ˆ<b>必须先于基础设施</b>，Bootstrapper æ‰«åº“决定注册）
   3. InitializeAutoServices()
      InfrastructureBootstrapper.Initialize(data.db)
        a. DbLeaseStore(arb.db,"local-main")
        b. <u>ReconcileAfterBoot</u>       â† SweepExpired + ApproveRecovery å›žæ”¶ä¸Šæ¬¡è¿›ç¨‹æ³„漏/过期租约
        c. LayeredResourceManager æ³¨å†Œè¿› UtilContainer（"ResourceManager"/"LeaseCoordinator"）
        d. DeviceManager/DeviceService/AutoDeviceFacade/CanBusService
        e. LoadDevicesFromConfig + RegisterBrokeredDrivers（Broker è®¾å¤‡â†’CanDeviceDriver.CreateBrokerProxy）
   4. è‡ªåŠ¨æ‹‰èµ· DeviceBroker.exe（存在 Broker è®¾å¤‡æ—¶ï¼‰
      â”” BrokerServer æž„造时同样 ReconcileAfterBoot(broker:...)
   5. DeviceDebug.InitFinish          â† æ­¤æ—¶ UtilContainer å°±ç»ªï¼Œèƒ½æ‹¿åˆ°ä»²è£æœåŠ¡
</pre>
<div class="hl"><b>顺序要点</b>：建库→预置设备→基础设施→Broker→DeviceDebug。若 DeviceDebug æ—©äºŽåŸºç¡€è®¾æ–½ï¼ŒUtilContainer å–到 null æœåŠ¡ï¼Œç»´æŠ¤ä»²è£ä¼šè¢«é™é»˜ç»•è¿‡ï¼ˆåŽ†å²ç¼ºé™·ï¼Œå·²ä¿®ï¼‰ã€‚</div>
</div>

<!-- ============================================================ -->
<h2 id="s4">4　设备注册与统一驱动分派</h2>
<div class="card">
<p>全系统只有一个 CAN é©±åŠ¨ç±» <code>CanDeviceDriver</code>，Local/Broker å·®å¼‚下沉到构造时选择的传输后端 <code>ICanTransport</code>，上层（自动化 <code>DeviceManager.GetDriver</code>、调试面板）完全无感知。</p>
<pre>
IDeviceDriver（统一契约）
    â–²
CanDeviceDriver  â† å‘½ä»¤è§£æž / _recvBuffer / DriverFrameReceived äº‹ä»¶ / è¿žæŽ¥çŠ¶æ€æœº
 â”œâ”€ NodeChannelTransport   (Local)  TCP ç›´è¿žæ¨¡æ‹Ÿå™¨ï¼šHELLO→命令一问一答→读循环分流响应/推送→断线重连
 â””─ BrokerRpcTransport     (Broker) å‘½åç®¡é“委托宿主：SubmitBody RPC→ResultBody æ€æ˜ å°„→解析 |PUSHED æŽå¸¦

分派来源：
 Â· DriverFactory.CreateDriver("CAN", endpoint) â†’ new CanDeviceDriver(deviceId, "bus:node")   // Local / å®¿ä¸»ç‰©ç†ä¼šè¯
 Â· InfrastructureBootstrapper.RegisterBrokeredDrivers â†’ CanDeviceDriver.CreateBrokerProxy(...) // Broker å®¢æˆ·ç«¯
</pre>
<table>
<tr><th>场景</th><th>驱动如何产生</th><th>物理会话在哪</th></tr>
<tr><td>Local è®¾å¤‡(CAN-001/002)</td><td>面板/工厂 new CanDeviceDriver(NodeChannel)</td><td>本进程→TCP è¿žæ¨¡æ‹Ÿå™¨</td></tr>
<tr><td>Broker è®¾å¤‡(CAN-003/004) å®¢æˆ·ç«¯</td><td>Bootstrapper æ³¨å†Œ CreateBrokerProxy(BrokerRpc)</td><td>宿主进程</td></tr>
<tr><td>Broker è®¾å¤‡ å®¿ä¸»ä¾§</td><td>BrokerServer.EnsureConnectedAsync→DriverFactory→CanDeviceDriver(NodeChannel)</td><td>宿主→TCP è¿žæ¨¡æ‹Ÿå™¨</td></tr>
</table>
<p class="small">关键：<b>全系统只有一份"节点通道驱动"代码</b>——Broker æ¨¡å¼ä¸‹å®¿ä¸»å†…部的物理会话同样是 CanDeviceDriver(NodeChannel)。</p>
</div>

<!-- ============================================================ -->
<h2 id="s5">5　TCP çº¿åè®®ä¸Žæ¨¡æ‹Ÿå™¨æœåŠ¡ç«¯</h2>
<div class="card">
<h3>5.1 åˆ†å¸§</h3>
<p>4 å­—节<b>大端</b>长度前缀 + UTF8 æ–‡æœ¬è¡Œï¼ˆ<code>SimulatorFraming</code>）。读侧循环读满头部与帧体，天然处理粘包/半包；长度非法抛 <code>InvalidDataException</code>；EOF è¿”回 null è§¦å‘断线感知。</p>
<h3>5.2 æ¶ˆæ¯ç±»åž‹</h3>
<table>
<tr><th>方向</th><th>消息</th><th>含义</th></tr>
<tr><td rowspan="4">C→S</td><td><code>HELLO:{bus}:{nodeIndex}:{tag}</code></td><td>握手并挂载 (bus,nodeIndex)，激活节点、开始收帧</td></tr>
<tr><td><code>SEND:{frameId}:{data}</code></td><td>发帧（命令串透传）</td></tr>
<tr><td><code>QUERY:{命令串}</code></td><td>RECV/RECV_ALL/STATUS/AUTO_RESPONSE/BUS_ECHO/FILTER/LOG/BUS_STATUS…</td></tr>
<tr><td><code>DISCONNECT</code></td><td>注销本连接节点</td></tr>
<tr><td rowspan="3">S→C</td><td><code>OK:{payload}</code> / <code>ERR:{code}:{msg}</code></td><td>对上一条请求的响应（恰好一行，保序）</td></tr>
<tr><td><code>EV:RECV:{id}:{data}:{ts}:{src}</code></td><td>总线路由推送帧（主动推送，src å¯ä¸ºèŠ‚点号或 RESPONDER）</td></tr>
<tr><td><code>EV:STATE:…</code></td><td>预留扩展</td></tr>
</table>
<h3>5.3 ServerSession ä¿åºä¸Žæš‚存门</h3>
<pre>
读循环(单线程): é€è¡Œè¯»è¯·æ±‚ â†’ Process() â†’ å“åº”经"写锁"发出 â†’ FlushHeldPushes()
命令处理期间路由产生的 EV:RECV å…ˆè¿› _heldPushes（满 1000 ä¸¢æœ€è€ï¼‰ï¼Œ
响应写完后再补发 â†’ ä¿è¯å®¢æˆ·ç«¯"首行必为响应、推送随后"。
空闲期推送：写锁串行即发即走。
</pre>
<p class="small">错误码：<code>ERR:NODE_BUSY</code>（同 bus åŒ nodeIndex è¢«å ï¼‰ã€<code>ERR:NOT_HANDSHAKED</code>、<code>ERR:UNKNOWN_CMD</code>、<code>ERR:BAD_FRAME</code>。</p>
</div>

<!-- ============================================================ -->
<h2 id="s6">6　总线路由与应答器</h2>
<div class="card">
<p>两种"自动回复"能力，语义不同、互不干扰：</p>
<table>
<tr><th>能力</th><th>触发者</th><th>回复给谁</th><th>开关</th></tr>
<tr><td>节点自动响应</td><td><b>接收</b>节点（收到帧）</td><td>其它节点 + è‡ªèº«é‚®ç®±</td><td>通道面板"自动响应"（<code>AUTO_RESPONSE:ON</code>，写节点属性）</td></tr>
<tr><td><b>总线应答器</b>（新）</td><td>总线本身</td><td><b>发送者自己</b>（同帧回显，src=RESPONDER）</td><td>服务窗口复选框 / <code>QUERY:BUS_ECHO:ON</code>（写 <code>CanBusSimulator.EchoResponderToSender</code>）</td></tr>
</table>
<pre>
OnNodeFrameSent(frame, src=node0):
  1) è·¯ç”±åˆ°å…¶å®ƒèŠ‚点；每个接收节点若 AutoResponseEnabled â†’ SendAutoResponse(回它收到的帧)
  2) è‹¥ EchoResponderToSender：把 frame å¤åˆ¶ã€SourceNodeId="RESPONDER"，直接投递回<b>发送节点自身</b>
     â†’ å‘送节点 FrameReceived â†’ ServerSession æŽ¨é€ EV:RECV å›žè¯¥è¿žæŽ¥ â†’ å‘送者收到"回显"
</pre>
<div class="fx"><b>意义</b>：单客户端调试时也能"发一条收到一条回复"，无需第二节点在线——这正是把 CAN-003 è¿™ç±»å…±äº«è®¾å¤‡å½“作被测设备验证请求/响应的关键能力。</div>
</div>

<!-- ============================================================ -->
<h2 id="s7">7　调试页多标签多会话</h2>
<div class="card">
<pre>
DeviceDebug（壳，SimpleMaskControl æ’件入口）
 â”œâ”€ é¡¶æ ï¼šè®¾å¤‡ä¸‹æ‹‰(仅列<b>未打开</b>设备) + [加入调试] + [关闭当前页] + åˆ·æ–°
 â””─ TabControl
     â””─ DeviceDebugTab Ã— N（每个 = ä¸€ä¸ªè®¾å¤‡ï¼Œç‹¬ç«‹ä¼šè¯/租约/面板/日志）
          â”œâ”€ ä¿¡æ¯æ (设备ID/型号/连接/版本/预约/会话状态)
          â”œâ”€ [进入维护控制] [退出维护]
          â”œâ”€ panelContainer：LoadPanel(kind)
          â”‚     CanDevice â†’ CanDebugPanel(多通道壳) â†’ CanChannelView(单通道)
          â”‚     PowerSupply / PLC â†’ å¯¹åº”面板
          â””─ æ“ä½œæ—¥å¿—(本会话)
</pre>
<p>规则：<b>一会一设备</b>——加入时若设备已开则聚焦其 Tab；下拉过滤掉已开设备；关闭 Tab è°ƒ <code>CloseSessionSilently()</code> é‡Šæ”¾ä¼šè¯ä¸Žç§Ÿçº¦ï¼Œè®¾å¤‡é‡æ–°å›žåˆ°å¯é€‰ã€‚CAN é€šé“内部再套一层 <code>CanDebugPanel</code> TabControl，可对同设备开多通道。</p>
<div class="hl"><b>接收显示线程模型</b>：CanChannelView å¸§ä¸Šå±ç”¨ <code>Dispatcher.BeginInvoke</code>（异步）。曾因用同步 <code>Invoke</code>，在读循环线程推送骤增时与"UI çº¿ç¨‹é˜»å¡žç­‰ RPC å“åº”"形成环形等待 â†’ å¼€åº”答器即冻结（已修）。</div>
</div>

<!-- ============================================================ -->
<h2 id="s8">8　维护会话状态机与租约心跳</h2>
<div class="card">
<pre class="seq">
OpenSession(deviceId) â†’ ReadOnly
   â”‚ RequestMaintenance：ReserveAsync(复用缓存 ownerToken) æ‹¿ç»´æŠ¤ç§Ÿçº¦(TTL=300s)
   â–¼
AcquiringMaintenance â†’ ActivateMaintenance â†’ <b>MaintenanceActive</b>
   â”‚  â”” å¯åŠ¨ç§Ÿçº¦å¿ƒè·³ Timer：每 120s å¯¹æ¯ä¸ª MaintenanceActive ä¼šè¯
   â”‚        Coordinator.Renew(grant, 300) ç»­æœŸï¼Œé˜² TTL è¿‡æœŸ
   â”‚ é€€å‡ºç»´æŠ¤ / å…³é—­ Tab：CloseSession
   â–¼
Closing â†’ Closed（ReleaseReservationAsync ç”¨åŒä¸€ ownerToken é‡Šæ”¾ç§Ÿçº¦ï¼›æ— ç»´æŠ¤ä¼šè¯åˆ™åœå¿ƒè·³ï¼‰
</pre>
<table>
<tr><th>机制</th><th>解决的问题</th></tr>
<tr><td>ownerToken æŒ‰ sessionId ç¼“存复用</td><td>租约按 TokenId(GUID) ç´¢å¼•ï¼›æ¯æ¬¡ new ä¼šå¯¼è‡´é‡Šæ”¾è½ç©ºâ†’租约泄漏→过期 RecoveryRequired æ°¸ä¹…阻塞</td></tr>
<tr><td><b>维护租约心跳续期</b>（新）</td><td>长时间维护会话到 300s TTL è‡ªç„¶è¿‡æœŸâ†’Broker æ …栏 RECOVERY_REQUIRED ç¦æ­¢ I/O；心跳每 120s ç»­æœŸï¼Œæ°¸ä¸è§¦è¾¾è¿‡æœŸçº¿</td></tr>
<tr><td>启动 ReconcileAfterBoot</td><td>进程重启自动 SweepExpired+ApproveRecovery，清掉上次残留/过期租约（含已卡 RecoveryRequired çš„）</td></tr>
<tr><td>死会话回收</td><td>DB æ‰¾å›žçš„未关闭会话强制标 Closed å†æ–°å»ºï¼Œé¿å… RequestMaintenance"会话不存在"</td></tr>
</table>
</div>

<!-- ============================================================ -->
<h2 id="s9">9　报文收发全链路</h2>
<div class="card">
<h3>9.1 å‘送 â€” Local è®¾å¤‡</h3>
<pre>
CanChannelView.发送 â†’ CanDeviceDriver.SendCommandAsync("SEND:0x300:AA BB")
 â†’ NodeChannelTransport.TransceiveAsync â†’ TCP å†™ "SEND:0x300:AA BB"
 â†’ ServerSession å¤„理 â†’ CanCommandExecutor.HandleSend â†’ CanNode.SendFrame â†’ CanBusSimulator è·¯ç”±
 â†’ å›ž "OK:TX:0x300:2" â†’ é©±åŠ¨è¿”回；面板加 TX è¡Œ
</pre>
<h3>9.2 å‘送 â€” Broker è®¾å¤‡ï¼ˆCAN-003）</h3>
<pre>
面板 â†’ CanDeviceDriver(BrokerRpc).SendCommandAsync("SEND:…")
 â†’ BrokerRpcTransport æ˜ å°„ opCode=SEND,payload=整串 â†’ SubmitBody ç»å‘½åç®¡é“
 â†’ BrokerServer.ExecuteOneShotAsync：
     â‘  ç™½åå•+域内设备  â‘¡ configHash å¯¹è´¦(INV-04)  â‘¢ ç§Ÿçº¦æ …栏(INV-01/03)  â‘£ SessionGate ä¸²è¡Œ
     â‘¤ å®¿ä¸»å†… CanDeviceDriver(NodeChannel).SendCommandAsync â†’ TCP â†’ æ¨¡æ‹Ÿå™¨è·¯ç”±
     â‘¥ ResultBody.Readback æœ«å°¾ <b>AppendPushes</b>：把宿主驱动自上次以来收到的 EV:RECV
        ä»¥ "|PUSHED:n|EV:RECV…" æ‹¼ä¸Š â†’ åŒç®¡é“返回
 â†’ å®¢æˆ·ç«¯ BrokerRpcTransport å‰¥ç¦» |PUSHED æ®µå¹¶è§¦å‘ FramePushed
</pre>
<h3>9.3 æŽ¥æ”¶ â€” ç»Ÿä¸€äº‹ä»¶æ¨¡åž‹</h3>
<pre>
服务端路由/应答器产生帧 â†’ ç›®æ ‡èŠ‚点 FrameReceived â†’ ServerSession æŽ¨é€ EV:RECV
 â”œâ”€ Local：NodeChannel è¯»å¾ªçŽ¯æ”¶åˆ° EV:RECV â†’ CanDeviceDriver.OnFramePushed
 â”‚           â†’ _recvBuffer + _pendingPushLines + <b>DriverFrameReceived</b> â†’ é¢æ¿ BeginInvoke ä¸Šå±
 â””─ Broker：宿主读循环收到 â†’ å®¿ä¸»é©±åŠ¨ _pendingPushLines æš‚å­˜
            å®¢æˆ·ç«¯ä¸‹ä¸€æ¬¡ STATUS/SEND è½®è¯¢æ—¶ï¼Œå®¿ä¸» AppendPushes æŽå¸¦ â†’ å®¢æˆ·ç«¯ FramePushed â†’ äº‹ä»¶ â†’ ä¸Šå±
（面板 PollTimer æ¯ 100ms è°ƒ QueryAsync("STATUS")：既刷新统计，也触发 Broker æŽå¸¦ drain）
</pre>
<div class="fx">结果：Local ä¸Ž Broker è®¾å¤‡å…±äº«åŒä¸€å¥—事件驱动接收，实时且无重复行；应答器开启后 Broker è®¾å¤‡ä¹Ÿèƒ½"发一条收一条回显"（实测 50 æ¬¡è¿žç»­å‘送，每次 1 TX + å›žæ˜¾ RX，无错误无冻结）。</div>
</div>

<!-- ============================================================ -->
<h2 id="s10">10　错误处理与不变量</h2>
<div class="card">
<table>
<tr><th>不变量</th><th>含义</th><th>落点</th></tr>
<tr><td>INV-01</td><td>无租约禁止 I/O</td><td>BrokerServer æ …栏：SEND/写类 QUERY éœ€ Active ç§Ÿçº¦ï¼›CONNECT/DISCONNECT ä¸Žåªè¯» drain(RECV/STATUS/LOG/BUS_STATUS) è±å…</td></tr>
<tr><td>INV-03</td><td>过期不自动让渡</td><td>租约过期→RecoveryRequired，拒绝 I/O，需 ApproveRecovery（心跳续期避免误触）</td></tr>
<tr><td>INV-04</td><td>配置哈希对账</td><td>RPC æºå¸¦ configHash，与宿主生效哈希不符→RejectedConfigMismatch（改配置须先 Apply）</td></tr>
<tr><td>INV-06</td><td>结果未知不得假定未执行</td><td>超时/在途异常→Unknown→客户端抛 TimeoutException，禁止自动重试 SEND</td></tr>
</table>
<table>
<tr><th>故障</th><th>行为</th></tr>
<tr><td>模拟器服务不可达</td><td>NodeChannel.ConnectAsync æŠ›å«"请先启动 CanSimulatorServer.exe"的连接异常</td></tr>
<tr><td>中途断线</td><td>IsConnected=false→指数退避重连(0.5~5s)→重发 HELLO；期间发送快速失败 NOT_CONNECTED</td></tr>
<tr><td>同 (bus,node) å†²çª</td><td>HELLO è¿”回 ERR:NODE_BUSY，驱动抛"节点编号 X å·²è¢«å ç”¨"（属配置错误，引导改端点）</td></tr>
<tr><td>推送暂存满</td><td>丢最老并计数；客户端 STATUS/RECV å…œåº•è¡¥è´¦</td></tr>
<tr><td>维护租约过期</td><td>心跳续期避免；若进程崩溃遗留，重启 ReconcileAfterBoot è‡ªåŠ¨å›žæ”¶</td></tr>
</table>
</div>

<!-- ============================================================ -->
<h2 id="s11">11　代码索引</h2>
<div class="card">
<table>
<tr><th>关注点</th><th>位置</th></tr>
<tr><td>TCP åˆ†å¸§</td><td>CanSimulator\SimulatorFraming.cs（Encode/Decode/ReadFrameAsync）</td></tr>
<tr><td>服务端会话/协议</td><td>CanSimulatorServer.Core\ServerSession.cs（Process/HandleHello/OnNodeFrame/FlushHeldPushes）</td></tr>
<tr><td>命令执行/应答器</td><td>CanSimulatorServer.Core\CanCommandExecutor.cs（HandleSend/HandleQuery/BUS_ECHO/FormatPush）</td></tr>
<tr><td>路由/自动响应/应答器</td><td>CanSimulator\CanBusSimulator.cs（OnNodeFrameSent/SendAutoResponse/EchoResponderToSender）</td></tr>
<tr><td>统一驱动</td><td>Aging.Infrastructure\Drivers\CanDeviceDriver.cs（Connect/Send/Query/OnFramePushed/DrainPendingPushLines）</td></tr>
<tr><td>TCP åŽç«¯</td><td>Drivers\NodeChannelTransport.cs（HandshakeAsync/ReadLoopAsync/重连）</td></tr>
<tr><td>RPC åŽç«¯</td><td>Drivers\BrokerRpcTransport.cs（TransceiveAsync/DrainPiggyback/ThrowForState）</td></tr>
<tr><td>Broker æŽå¸¦</td><td>DeviceBroker\BrokerServer.cs（ExecuteOneShotAsync/RunFragmentAsync/AppendPushes）</td></tr>
<tr><td>多设备壳/工作区</td><td>Plugin.DeviceDebug\DeviceDebug.xaml.cs Â· DeviceDebugTab.xaml.cs</td></tr>
<tr><td>会话状态机/心跳</td><td>Plugin.DeviceDebug\Model\DebugSessionManager.cs（RequestMaintenance/ActivateMaintenance/RenewActiveMaintenance）</td></tr>
<tr><td>通道显示</td><td>Panels\CanDebugPanel.xaml.cs（壳）· Panels\CanChannelView.xaml.cs（AddReceivedFrame/BeginInvoke）</td></tr>
<tr><td>装配/注册</td><td>Aging.Infrastructure\InfrastructureBootstrapper.cs（RegisterBrokeredDrivers）· Drivers\DriverFactory.cs</td></tr>
</table>
</div>

<!-- ============================================================ -->
<h2 id="s12">12　已知限制与后续</h2>
<div class="card">
<ul>
<li><b>Broker æŽ¥æ”¶å®žæ—¶æ€§ä¸º"请求驱动"</b>：靠宿主 STATUS/SEND è½®è¯¢æŽå¸¦ drain，非纯推送；面板 100ms è½®è¯¢ä¿è¯æœ€ç»ˆä¸€è‡´ã€‚真实硬件无此层。</li>
<li><b>owner↔clientInstanceId å¼±å¯¹é½</b>：同机 arb.db ä»…存在性/相位校验，未做签名凭据（V3.0 Â§13 P2）。</li>
<li><b>应答器为总线级</b>：一次开关作用于该总线所有发送者；如需按节点/按帧ID ç²¾ç»†æ˜ å°„为后续项。</li>
<li><b>UI å¾…办</b>：临时诊断日志撤除；RecoveryRequired äººå·¥å®¡æ‰¹ UI（现由启动对账代偿）；App.Success/Warn æ ‡é¢˜æœ¬åœ°åŒ–。</li>
<li><b>构建</b>：WPF é“¾è·¯é¡»ç”¨ VS å®Œæ•´ç‰ˆ MSBuild（不加 /p:Platform=x64）；模拟器核心可 dotnet æž„建/测试。</li>
</ul>
<p class="small">本报告与代码同步于 2026-11-09；实现变更请同步更新本文件。</p>
</div>

</div>
</body>
</html>

 tests/Aging.MvpTests/Aging.MvpTests.csproj

New file
@@ -0,0 +1,32 @@
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net472</TargetFramework>
    <Nullable>enable</Nullable>
    <LangVersion>10.0</LangVersion>
    <ImplicitUsings>disable</ImplicitUsings>
    <IsPackable>false</IsPackable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
    <PackageReference Include="xunit" Version="2.4.2" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
  </ItemGroup>
  <ItemGroup>
    <PackageReference Include="System.Text.Json" Version="6.0.5" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\Aging.ResourceContracts\Aging.ResourceContracts.csproj" />
    <ProjectReference Include="..\..\Aging.Infrastructure\Aging.Infrastructure.csproj" />
    <!-- Broker e2e：引用宿主（net472 Exe äº§ç‰© DeviceBroker.exe å¯ç›´æŽ¥ä½œä¸ºç¨‹åºé›†å¼•ç”¨ï¼‰ -->
    <ProjectReference Include="..\..\DeviceBroker\DeviceBroker.csproj" />
    <!-- CAN æ¨¡æ‹Ÿå™¨æœåŠ¡ç«¯æ ¸å¿ƒï¼šæµ‹è¯•è¿›ç¨‹å†…托管 TcpSimulatorHost èµ°çœŸå®ž TCP å›žçŽ¯ -->
    <ProjectReference Include="..\..\CanSimulatorServer\CanSimulatorServer.Core\CanSimulatorServer.Core.csproj" />
  </ItemGroup>
  <ItemGroup>
    <PackageReference Include="System.Data.SQLite" Version="1.0.118" />
  </ItemGroup>

</Project>

 tests/Aging.MvpTests/App.config

New file
@@ -0,0 +1,8 @@
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <appSettings>
    <!-- Broker e2e：宿主内物理 CAN é©±åŠ¨è¿žæ­¤ç«¯å£ï¼Œæµ‹è¯•å¤¹å…·åœ¨è¿›ç¨‹å†…托管同端口模拟器服务 -->
    <add key="CanSimulator.Host" value="127.0.0.1" />
    <add key="CanSimulator.Port" value="19555" />
  </appSettings>
</configuration>

 tests/Aging.MvpTests/BrokerE2ETests.cs

New file
@@ -0,0 +1,334 @@
using System;
using System.Diagnostics;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Aging.Infrastructure.Broker;
using Aging.Infrastructure.Core;
using Aging.Infrastructure.Drivers;
using Aging.ResourceContracts;
using CanSimulatorServer;
using DeviceBroker;
using Xunit;

namespace Aging.MvpTests
{
    /// <summary>
    /// Broker å…¨é“¾è·¯ e2e：客户端（arb.db ç§Ÿçº¦ + CanDeviceDriver BrokerRpc ä»£ç†ï¼‰â†”
    /// DeviceBroker å®¿ä¸»ï¼ˆå‘½åç®¡é“ + æ …栏再校验 + configHash å¯¹è´¦ + SessionGate åŽŸå­ç‰‡æ®µï¼‰ã€‚
    /// å®¿ä¸»çš„物理 CAN é©±åŠ¨ç» TCP è¿žè¿›ç¨‹å†…托管的模拟器服务（固定端口 19555，与 App.config ä¸€è‡´ï¼‰ã€‚
    /// æ¯ä¸ªæµ‹è¯•ä½¿ç”¨å”¯ä¸€ brokerId â†’ ç‹¬ç«‹ç®¡é“名，避免并行串扰。
    /// </summary>
    public class BrokerE2ETests : IDisposable
    {
        private const string DevId = "CAN-B1";
        private const int SimPort = 19555;

        private readonly string _dir;
        private readonly string _dataDb;
        private readonly string _arbDb;
        private readonly string _brokerId;
        private readonly string _pipeName;
        private readonly CancellationTokenSource _cts = new CancellationTokenSource();
        private readonly Task _serverTask;
        private readonly DbLeaseStore _clientLease;
        private readonly TcpSimulatorHost _sim;

        public BrokerE2ETests()
        {
            _dir = Path.Combine(Path.GetTempPath(), "brk_" + Guid.NewGuid().ToString("N"));
            Directory.CreateDirectory(_dir);
            _dataDb = Path.Combine(_dir, "data.db");
            _arbDb = Path.Combine(_dir, "arb.db");
            _brokerId = "broker-" + Guid.NewGuid().ToString("N").Substring(0, 8);
            _pipeName = BrokerPipeName.For(_brokerId);

            CreateDataDb();

            // æ¨¡æ‹Ÿå™¨æœåŠ¡å…ˆäºŽå®¿ä¸»å°±ä½ï¼ˆå®¿ä¸»é¦–次 CONNECT ä¼šæ‹‰èµ·ç‰©ç† TCP ä¼šè¯ï¼‰
            _sim = new TcpSimulatorHost();
            _sim.StartAsync(SimPort).GetAwaiter().GetResult();

            var server = new BrokerServer(_dataDb, _arbDb, _brokerId);
            server.LoadDevices();
            _serverTask = Task.Run(() => server.RunAsync(_cts.Token));
            _clientLease = new DbLeaseStore(_arbDb, "local-main");

            // ç­‰ç›‘听就位（客户端本身有 3s è¿žæŽ¥è¶…时，另有 BROKER_UNREACHABLE é‡è¯•å…œåº•ï¼‰
            Thread.Sleep(250);
        }

        public void Dispose()
        {
            try { _cts.Cancel(); } catch { }
            try { _serverTask.Wait(1500); } catch { }
            try { _sim?.Dispose(); } catch { }
            _cts.Dispose();
            foreach (var f in Directory.GetFiles(_dir))
            {
                try { File.Delete(f); } catch { }
            }
            try { Directory.Delete(_dir); } catch { }
        }

        // ==================== æ­£å‘链路 ====================

        [Fact]
        public async Task WithLease_Connect_Send_Query_Succeeds()
        {
            var grant = GrabLease();
            var hash = DeviceConfigHash.Compute(_dataDb);
            using var driver = CanDeviceDriver.CreateBrokerProxy(DevId, "CAN_E2E:0", _pipeName, hash);

            await RetryAsync(() => driver.ConnectAsync(CancellationToken.None));

            var tx = await driver.SendCommandAsync("SEND:0x123:11 22", CancellationToken.None);
            Assert.Contains("OK:TX", tx);

            var status = await driver.QueryAsync("STATUS", CancellationToken.None);
            Assert.Contains("STATUS", status);

            // Broker ä¾§æ‰§è¡ŒæˆåŠŸåŽç§Ÿçº¦ä»æœ‰æ•ˆï¼ˆæœªè¢«è¯¯é‡Šæ”¾ï¼‰
            Assert.Equal(LeasePhase.Active, _clientLease.PhaseOf(DevId));
            _clientLease.Release(grant, "test-end");
        }

        [Fact]
        public async Task TwoSequencedFragments_SameSession_ExecuteSerially()
        {
            var grant = GrabLease();
            var hash = DeviceConfigHash.Compute(_dataDb);
            using var driver = CanDeviceDriver.CreateBrokerProxy(DevId, "CAN_E2E:0", _pipeName, hash);
            await RetryAsync(() => driver.ConnectAsync(CancellationToken.None));

            // SessionGate ä¸‹åŒä¼šè¯ç‰‡æ®µä¸¥æ ¼ä¸²è¡Œï¼ˆåŒè¿›ç¨‹å•å®¢æˆ·ç«¯æœ¬å°±ä¸²è¡Œï¼ŒéªŒè¯ä¸äº§ç”Ÿäº¤é”™é”™è¯¯ï¼‰
            var a = await driver.SendCommandAsync("SEND:0x100:01", CancellationToken.None);
            var b = await driver.SendCommandAsync("SEND:0x200:02", CancellationToken.None);
            Assert.Contains("OK:TX", a);
            Assert.Contains("OK:TX", b);
            _clientLease.Release(grant, "test-end");
        }

        // ==================== è´Ÿå‘链路 ====================

        [Fact]
        public async Task NoLease_ConnectAllowed_Send_RejectedStaleLease()
        {
            // CONNECT/DISCONNECT ä»…登记/释放宿主物理会话，豁免租约；
            // SEND æœ‰æ€»çº¿è¾“出，无租约必须拒绝（INV-01 ç¦æ­¢æ— ç§Ÿçº¦ç›´æŽ¥ I/O）
            var hash = DeviceConfigHash.Compute(_dataDb);
            using var driver = CanDeviceDriver.CreateBrokerProxy(DevId, "CAN_E2E:0", _pipeName, hash);

            await RetryAsync(() => driver.ConnectAsync(CancellationToken.None));

            var ex = await Record.ExceptionAsync(
                () => driver.SendCommandAsync("SEND:0x100:01", CancellationToken.None));
            Assert.NotNull(ex);
            Assert.Contains("LEASE_STALE", ex.Message);
        }

        [Fact]
        public async Task ConfigHashMismatch_Rejected()
        {
            GrabLease(); // æœ‰ç§Ÿçº¦ï¼Œä½†å“ˆå¸Œå¯¹ä¸ä¸Š â†’ INV-04 æ‹¦æˆª
            using var driver = CanDeviceDriver.CreateBrokerProxy(DevId, "CAN_E2E:0", _pipeName, "deadbeefdeadbeef");

            var ex = await Record.ExceptionAsync(
                () => RetryConnectAsync(driver, expectThrow: true));
            Assert.NotNull(ex);
            Assert.Contains("CONFIG_MISMATCH", ex.Message);
        }

        [Fact]
        public async Task ReleasedLease_Send_Rejected()
        {
            var grant = GrabLease();
            var hash = DeviceConfigHash.Compute(_dataDb);
            using var driver = CanDeviceDriver.CreateBrokerProxy(DevId, "CAN_E2E:0", _pipeName, hash);
            await RetryAsync(() => driver.ConnectAsync(CancellationToken.None));

            // ç§Ÿçº¦å½’还后再 I/O â†’ æ …栏必须拒绝（禁止无租约直接 I/O）
            _clientLease.Release(grant, "released-by-test");
            var ex = await Record.ExceptionAsync(
                () => driver.SendCommandAsync("SEND:0x100:01", CancellationToken.None));
            Assert.NotNull(ex);
            Assert.Contains("LEASE_STALE", ex.Message);
        }

        [Fact]
        public async Task MaintenanceLease_BrokeredWrite_Succeeds()
        {
            // è°ƒè¯•é¡µç»´æŠ¤å†™æƒé“¾è·¯ï¼šç»´æŠ¤ç§Ÿçº¦å†™å…¥ arb.db（OwnerType=Maintenance）后，
            // Broker æ …栏同样放行（占用可见/拒绝语义已由生产场景用例覆盖）
            var outcome = _clientLease.Acquire(new AcquireRequest
            {
                OwnerId = "maint-session-1",
                OwnerType = OwnerTypeV3.Maintenance,
                ResourceKeys = new[] { DevId },
                TtlSeconds = 30
            });
            Assert.Equal(AcquireResultCode.Acquired, outcome.Code);

            var hash = DeviceConfigHash.Compute(_dataDb);
            using var driver = CanDeviceDriver.CreateBrokerProxy(DevId, "CAN_E2E:0", _pipeName, hash);
            await RetryAsync(() => driver.ConnectAsync(CancellationToken.None));
            var tx = await driver.SendCommandAsync("SEND:0x300:AB", CancellationToken.None);
            Assert.Contains("OK:TX", tx);

            _clientLease.Release(outcome.Grants[0], "maint-end");
        }

        // ==================== è¾…助 ====================

        [Fact]
        public async Task BrokerReceive_PiggybackPush_DeliveredToProxyDriver()
        {
            // éªŒæ”¶ç‚¹ï¼šå…±äº«è®¾å¤‡(Broker)能收到同总线对端发来的帧（经宿主捎带推送）。
            // ä¿®å¤åŽ†å²ä¸Š BrokeredCanDriver æ— æŽ¥æ”¶äº‹ä»¶ã€é¢æ¿æ”¶ä¸åˆ° RX çš„顽症。
            var grant = GrabLease();
            var hash = DeviceConfigHash.Compute(_dataDb);
            using var driver = CanDeviceDriver.CreateBrokerProxy(DevId, "CAN_E2E:0", _pipeName, hash);
            await RetryAsync(() => driver.ConnectAsync(CancellationToken.None));

            CanFrameish received = null;
            driver.DriverFrameReceived += (s, f) => received = new CanFrameish { Id = f.FrameIdHex, Data = f.DataHex };

            // å¯¹ç«¯ï¼šåŒæ¨¡æ‹Ÿå™¨åŒæ€»çº¿ CAN_E2E çš„节点 1，本地直连发帧
            using var peer = new CanDeviceDriver("CAN-PEER", "CAN_E2E:1", "127.0.0.1", SimPort);
            peer.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();
            peer.SendCommandAsync("SEND:0x7E7:EE FF", CancellationToken.None).GetAwaiter().GetResult();

            // è§¦å‘宿主 drain æŽå¸¦ï¼šä»»ä¸€éžæŽ¥æ”¶ç±»æŸ¥è¯¢ï¼ˆSTATUS）即可带回推送
            for (int i = 0; i < 20 && received == null; i++)
            {
                await driver.QueryAsync("STATUS", CancellationToken.None);
                if (received == null) await Task.Delay(50);
            }

            Assert.NotNull(received);
            Assert.Equal("0x7E7", received.Id);
            Assert.Contains("EE FF", received.Data);

            _clientLease.Release(grant, "test-end");
        }

        private sealed class CanFrameish { public string Id; public string Data; public string Src; }

        [Fact]
        public async Task BrokerResponderEcho_ViaBusEcho_DeliveredToProxyDriver()
        {
            // å¤çŽ°ç”¨æˆ·åœºæ™¯ï¼šä»… Broker è®¾å¤‡è‡ªå·±å‘帧 + æ€»çº¿åº”答器开启 â†’ åº”收到 RESPONDER å›žæ˜¾ã€‚
            var grant = GrabLease();
            var hash = DeviceConfigHash.Compute(_dataDb);
            using var driver = CanDeviceDriver.CreateBrokerProxy(DevId, "CAN_E2E:0", _pipeName, hash);
            await RetryAsync(() => driver.ConnectAsync(CancellationToken.None));

            CanFrameish echo = null;
            driver.DriverFrameReceived += (s, f) => echo = new CanFrameish { Id = f.FrameIdHex, Data = f.DataHex, Src = f.SourceNodeId };

            // ç» RPC å¼€å¯æ€»çº¿åº”答器
            var on = await driver.QueryAsync("BUS_ECHO:ON", CancellationToken.None);
            Assert.StartsWith("OK:", on);

            // Broker è®¾å¤‡è‡ªå·±å‘一帧
            await driver.SendCommandAsync("SEND:0x111:AA BB CC", CancellationToken.None);

            // è½®è¯¢ STATUS è§¦å‘宿主 drain æŽå¸¦ï¼Œç­‰å›žæ˜¾é€è¾¾
            for (int i = 0; i < 30 && echo == null; i++)
            {
                await driver.QueryAsync("STATUS", CancellationToken.None);
                if (echo == null) await Task.Delay(50);
            }

            Assert.NotNull(echo);
            Assert.Equal("0x111", echo.Id);
            Assert.Contains("RESPONDER", echo.Src);

            _clientLease.Release(grant, "test-end");
        }

        // ==================== è¾…助（原有） ====================

        private LeaseGrant GrabLease()
        {
            var outcome = _clientLease.Acquire(new AcquireRequest
            {
                OwnerId = "e2e-" + Guid.NewGuid().ToString("N"),
                OwnerType = OwnerTypeV3.Production,
                ResourceKeys = new[] { DevId },
                TtlSeconds = 30
            });
            Assert.Equal(AcquireResultCode.Acquired, outcome.Code);
            return outcome.Grants[0];
        }

        private static async Task RetryAsync(Func<Task> action, int attempts = 4)
        {
            Exception last = null;
            for (int i = 0; i < attempts; i++)
            {
                try { await action().ConfigureAwait(false); return; }
                catch (InvalidOperationException ex) when (ex.Message.Contains("BROKER_UNREACHABLE"))
                {
                    last = ex; // å®¿ä¸»å°šæœªå¼€å§‹ç›‘听，短暂重试
                    await Task.Delay(400).ConfigureAwait(false);
                }
            }
            throw last ?? new InvalidOperationException("重试仍失败");
        }

        /// <summary>负向用例：握手可重试（管道未就位），但栅栏/哈希拒绝属终态应直接上抛。</summary>
        private async Task RetryConnectAsync(CanDeviceDriver driver, bool expectThrow)
        {
            Exception last = null;
            for (int i = 0; i < 4; i++)
            {
                try
                {
                    await driver.ConnectAsync(CancellationToken.None).ConfigureAwait(false);
                    return; // æ„å¤–成功——由外层断言捕捉
                }
                catch (InvalidOperationException ex) when (ex.Message.Contains("BROKER_UNREACHABLE"))
                {
                    last = ex;
                    await Task.Delay(400).ConfigureAwait(false);
                }
                catch (InvalidOperationException)
                {
                    throw; // LEASE_STALE / CONFIG_MISMATCH ç»ˆæ€
                }
            }
            throw last ?? new InvalidOperationException("未获得预期拒绝");
        }

        private void CreateDataDb()
        {
            using var conn = new System.Data.SQLite.SQLiteConnection(
                $"Data Source={_dataDb};Version=3;");
            conn.Open();
            using (var ddl = conn.CreateCommand())
            {
                ddl.CommandText = @"
                CREATE TABLE DeviceDefinition (
                    DeviceId TEXT PRIMARY KEY, Kind TEXT NOT NULL, DriverType TEXT NOT NULL,
                    Transport TEXT NOT NULL, Endpoint TEXT NOT NULL,
                    ExecutionMode TEXT NOT NULL DEFAULT 'Local',
                    AuthorityId TEXT NOT NULL DEFAULT '', BrokerId TEXT NOT NULL DEFAULT '',
                    OwnerProcessId TEXT NOT NULL DEFAULT '', PhysicalSessionKey TEXT NOT NULL DEFAULT '',
                    EffectiveVersion TEXT NOT NULL DEFAULT '', CreatedAt TEXT NOT NULL, UpdatedAt TEXT NOT NULL);";
                ddl.ExecuteNonQuery();
            }
            using (var ins = conn.CreateCommand())
            {
                ins.CommandText = @"
                INSERT INTO DeviceDefinition VALUES (
                    'CAN-B1','CanDevice','CAN','Can','CAN_E2E:0',
                    'Broker',@auth,@broker,'','can/CAN_E2E/main',
                    'V1','2026-11-08 00:00:00','2026-11-08 00:00:00');";
                ins.Parameters.AddWithValue("@auth", _brokerId);
                ins.Parameters.AddWithValue("@broker", _brokerId);
                ins.ExecuteNonQuery();
            }
        }
    }
}

 tests/Aging.MvpTests/CanDeviceDriverTests.cs

New file
@@ -0,0 +1,120 @@
using System;
using System.Threading;
using System.Threading.Tasks;
using Aging.Infrastructure.Drivers;
using CanSimulatorServer;
using Xunit;

namespace Aging.MvpTests
{
    /// <summary>
    /// ç»Ÿä¸€ CAN é©±åŠ¨ï¼ˆCanDeviceDriver, TCP NodeChannel åŽç«¯ï¼‰è¡Œä¸ºæµ‹è¯•ï¼š
    /// åœ¨æµ‹è¯•è¿›ç¨‹å†…托管模拟器服务，验证连接/发送/推送事件/本地缓冲查询/错误语义
    /// ä¸Žè°ƒè¯•é¢æ¿çŽ°æœ‰è§£æžæ ¼å¼ï¼ˆRECV_ALL:n:…、OK:TX…）保持兼容。
    /// </summary>
    public class CanDeviceDriverTests : IDisposable
    {
        private readonly TcpSimulatorHost _host;

        public CanDeviceDriverTests()
        {
            _host = new TcpSimulatorHost();
            _host.StartAsync().GetAwaiter().GetResult();
        }

        public void Dispose() => _host.Dispose();

        private CanDeviceDriver NewDriver(string deviceId, string bus, int node) =>
            new CanDeviceDriver(deviceId, $"{bus}:{node}", hostOverride: "127.0.0.1", portOverride: _host.Port);

        [Fact]
        public void ConnectAsync_OnRunningServer_Succeeds()
        {
            using var drv = NewDriver("CAN-T1", "CAN_BUS_1", 0);
            drv.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();
            Assert.True(drv.IsConnected);
        }

        [Fact]
        public void ConnectAsync_NoServer_ThrowsWithStartupHint()
        {
            // æŒ‡å‘必然空闲的端口：错误文案应引导用户启动模拟器服务
            using var drv = new CanDeviceDriver("CAN-T2", "CAN_BUS_1:0", hostOverride: "127.0.0.1", portOverride: 1);
            var ex = Assert.ThrowsAny<Exception>(() =>
                drv.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult());
            Assert.Contains("模拟器", ex.Message);
        }

        [Fact]
        public void SendCommandAsync_ReturnsOkTx_ReadableByPanel()
        {
            using var drv = NewDriver("CAN-T3", "CAN_BUS_1", 1);
            drv.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();

            string resp = drv.SendCommandAsync("SEND:0x100:AA BB", CancellationToken.None)
                              .GetAwaiter().GetResult();
            Assert.StartsWith("OK:TX", resp);
        }

        [Fact]
        public void Push_FromPeer_TriggersEvent_AndLocalRecvAll()
        {
            using var a = NewDriver("CAN-T4A", "CAN_BUS_1", 2);
            using var b = NewDriver("CAN-T4B", "CAN_BUS_1", 3);
            a.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();
            b.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();

            CanSimulator.CanFrame received = null;
            a.DriverFrameReceived += (s, f) => received = f;

            b.SendCommandAsync("SEND:0x222:11 22 33", CancellationToken.None).GetAwaiter().GetResult();

            // ç­‰å¾…推送事件到达（读循环线程触发）
            SpinWait.SpinUntil(() => received != null, 3000);
            Assert.NotNull(received);
            Assert.Equal("0x222", received.FrameIdHex);

            // RECV_ALL ç”±é©±åŠ¨æœ¬åœ°ç¼“冲应答（不依赖服务端邮箱）
            string all = a.QueryAsync("RECV_ALL", CancellationToken.None).GetAwaiter().GetResult();
            Assert.StartsWith("RECV_ALL:1:", all);
            Assert.Contains("0x222:11 22 33", all);
        }

        [Fact]
        public void Query_AutoResponse_ProxiedToServer_ReturnsOk()
        {
            using var drv = NewDriver("CAN-T5", "CAN_BUS_1", 4);
            drv.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();

            string resp = drv.QueryAsync("AUTO_RESPONSE:ON", CancellationToken.None).GetAwaiter().GetResult();
            Assert.StartsWith("OK:", resp);
            string back = drv.QueryAsync("AUTO_RESPONSE", CancellationToken.None).GetAwaiter().GetResult();
            Assert.Contains("ON", back);
        }

        [Fact]
        public void Query_Status_HasLegacyCompatibleFormat()
        {
            using var drv = NewDriver("CAN-T6", "CAN_BUS_1", 5);
            drv.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();

            // é¢æ¿ GetStatValue è§£æž "STATUS:Node=…, â€¦, Rx=0, Tx=0, â€¦"（逗号等号分隔）
            string resp = drv.QueryAsync("STATUS", CancellationToken.None).GetAwaiter().GetResult();
            Assert.StartsWith("STATUS:Node=", resp);
            Assert.Contains("Tx=", resp);
            Assert.Contains("Rx=", resp);
        }

        [Fact]
        public void Connect_NodeBusy_ThrowsWithNodeIndexHint()
        {
            using var first = NewDriver("CAN-T7A", "CAN_BUS_1", 6);
            first.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();

            using var second = NewDriver("CAN-T7B", "CAN_BUS_1", 6);
            var ex = Assert.ThrowsAny<Exception>(() =>
                second.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult());
            Assert.Contains("节点编号", ex.Message);
        }
    }
}

 tests/Aging.MvpTests/ContractSerializeTests.cs

New file
@@ -0,0 +1,39 @@
using System.Text.Json;
using Aging.ResourceContracts;
using Xunit;

namespace Aging.MvpTests
{
    public class ContractSerializeTests
    {
        [Fact]
        public void LeaseGrant_RoundTrips_Json()
        {
            var g = new LeaseGrant("broker-b01", "can/can02", "lease_abc",
                "W01.RunA", OwnerTypeV3.Maintenance, epoch: 7, generation: 42,
                expiresUtcMs: 1793673600000);
            var json = JsonSerializer.Serialize(g);
            var back = JsonSerializer.Deserialize<LeaseGrant>(json)!;
            Assert.Equal(g.Generation, back.Generation);
            Assert.Equal(g.Epoch, back.Epoch);
            Assert.Equal(g.LeaseId, back.LeaseId);
            Assert.Equal(g.OwnerType, back.OwnerType);
        }

        [Fact]
        public void IpcEnvelope_Carries_BodyAndIdentity()
        {
            var e = new IpcEnvelope
            {
                ProtocolVersion = 1, MessageType = "SubmitTask",
                RequestId = "req-1", ClientInstanceId = "hmi/bootA/123",
                AuthorityId = "broker-b01", ConfigHash = "sha256:x",
                BodyJson = "{\"operationCode\":\"SEND\"}"
            };
            var json = JsonSerializer.Serialize(e);
            var back = JsonSerializer.Deserialize<IpcEnvelope>(json)!;
            Assert.Equal("SubmitTask", back.MessageType);
            Assert.Equal("sha256:x", back.ConfigHash);
        }
    }
}

 tests/Aging.MvpTests/DbLeaseStoreTests.cs

New file
@@ -0,0 +1,160 @@
using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Aging.Infrastructure.Core;
using Aging.ResourceContracts;
using Xunit;

namespace Aging.MvpTests
{
    public class DbLeaseStoreTests : IDisposable
    {
        private readonly string _dbPath;
        private readonly DbLeaseStore _store;

        public DbLeaseStoreTests()
        {
            _dbPath = Path.Combine(Path.GetTempPath(),
                "arb_test_" + Guid.NewGuid().ToString("N") + ".db");
            _store = new DbLeaseStore(_dbPath, "local-main");
        }
        public void Dispose() { try { File.Delete(_dbPath); File.Delete(_dbPath + "-wal"); File.Delete(_dbPath + "-shm"); } catch { } }

        private AcquireRequest Req(string key, OwnerTypeV3 type = OwnerTypeV3.Maintenance,
            int ttl = 30) => new AcquireRequest
        {
            OwnerId = "test-owner", OwnerType = type,
            ProcessInstanceId = Guid.NewGuid().ToString("N"),
            ResourceKeys = new[] { key }, TtlSeconds = ttl
        };

        [Fact]
        public void Acquire_FirstOwner_Succeeds()
        {
            var r = _store.Acquire(Req("can/can02"));
            Assert.Equal(AcquireResultCode.Acquired, r.Code);
            Assert.Equal(1, r.Grants[0].Generation);
        }

        [Fact]
        public void Acquire_WhileActiveByOther_ReturnsConflictWithHolder()
        {
            _store.Acquire(Req("can/can02"));
            var second = new AcquireRequest
            {
                OwnerId = "other-owner", OwnerType = OwnerTypeV3.Production,
                ProcessInstanceId = "x", ResourceKeys = new[] { "can/can02" }
            };
            var r = _store.Acquire(second);
            Assert.Equal(AcquireResultCode.ConflictHeld, r.Code);
            Assert.Equal("test-owner", r.Holder.OwnerId);
        }

        [Fact]
        public void TwoIndependentStores_SameFile_SimulatesTwoProcesses()
        {
            var storeB = new DbLeaseStore(_dbPath, "local-main");
            var a = _store.Acquire(Req("psu/psu01/ch/5"));
            var b = storeB.Acquire(new AcquireRequest
            {
                OwnerId = "W02", OwnerType = OwnerTypeV3.Production,
                ProcessInstanceId = "p2", ResourceKeys = new[] { "psu/psu01/ch/5" }
            });
            Assert.Equal(AcquireResultCode.Acquired, a.Code);
            Assert.Equal(AcquireResultCode.ConflictHeld, b.Code);
        }

        [Fact]
        public void Concurrent_50Threads_OnlyOneWins()
        {
            int winners = 0;
            Parallel.For(0, 50, _ =>
            {
                var s = new DbLeaseStore(_dbPath, "local-main");
                var r = s.Acquire(new AcquireRequest
                {
                    OwnerId = Guid.NewGuid().ToString("N"), OwnerType = OwnerTypeV3.Production,
                    ProcessInstanceId = "p", ResourceKeys = new[] { "can/bus" }, WaitTimeoutMs = 3000
                });
                if (r.Code == AcquireResultCode.Acquired) Interlocked.Increment(ref winners);
            });
            Assert.Equal(1, winners);
        }

        [Fact]
        public void ExpiredLease_EntersRecoveryRequired_NotAutoReclaim()
        {
            _store.Acquire(Req("can/can02", ttl: -1));
            _store.SweepExpired();
            var r = _store.Acquire(Req("can/can02", OwnerTypeV3.Production));
            Assert.Equal(AcquireResultCode.RecoveryBlocked, r.Code);

            Assert.True(_store.ApproveRecovery("can/can02", "{\"output\":\"off\"}", "admin"));
            var again = _store.Acquire(Req("can/can02", OwnerTypeV3.Production));
            Assert.Equal(AcquireResultCode.Acquired, again.Code);
            Assert.Equal(2, again.Grants[0].Generation);
        }

        [Fact]
        public void Renew_WithStaleGeneration_Fails()
        {
            var g = _store.Acquire(Req("can/can02")).Grants[0];
            var stale = new LeaseGrant(g.AuthorityId, g.ResourceKey, g.LeaseId,
                g.OwnerId, g.OwnerType, g.Epoch, 999, g.ExpiresUtcMs);
            Assert.False(_store.Renew(stale, 30));
            Assert.True(_store.Renew(g, 30));
        }

        [Fact]
        public void BumpEpoch_InvalidatesAllActiveGrants()
        {
            var g = _store.Acquire(Req("can/can02")).Grants[0];
            _store.BumpEpochForTest("arb.db é‡å¯æ¨¡æ‹Ÿ");
            Assert.False(_store.Renew(g, 30));
        }

        [Fact]
        public void GroupAcquire_PartialConflict_RollsBackAll()
        {
            _store.Acquire(Req("psu/b"));
            var r = _store.Acquire(new AcquireRequest
            {
                OwnerId = "W09", OwnerType = OwnerTypeV3.Production, ProcessInstanceId = "p",
                ResourceKeys = new[] { "psu/a", "psu/b", "psu/c" }
            });
            Assert.Equal(AcquireResultCode.ConflictHeld, r.Code);
            Assert.Null(_store.ProbeConflict("psu/a"));
        }

        [Fact]
        public void ExpiredLease_ReconcileAfterBoot_FreesResource_ForNewAcquire()
        {
            // æ¨¡æ‹Ÿæ—§ owner è¿›ç¨‹æœªé‡Šæ”¾å°±å¼‚常退出：短 TTL ç§Ÿçº¦æ³„漏后过期
            var leaked = _store.Acquire(Req("can/can99", OwnerTypeV3.Maintenance, ttl: 1));
            Assert.Equal(AcquireResultCode.Acquired, leaked.Code);
            Thread.Sleep(1600);

            // æœªå¯¹è´¦å‰ï¼šè¿‡æœŸç§Ÿçº¦è¿›å…¥ RecoveryBlocked（永久阻塞现状）
            var blocked = _store.Acquire(new AcquireRequest
            {
                OwnerId = "new-owner", OwnerType = OwnerTypeV3.Maintenance,
                ProcessInstanceId = "y", ResourceKeys = new[] { "can/can99" }
            });
            Assert.Equal(AcquireResultCode.RecoveryBlocked, blocked.Code);

            // å¯åŠ¨å¯¹è´¦è‡ªæ„ˆï¼ˆINV-03 è‡ªåŠ¨åŒ–形式，证据落 recovery_checkpoint）
            Assert.True(_store.ReconcileAfterBoot("HOST/999") >= 1);
            Assert.Equal(LeasePhase.Free, _store.PhaseOf("can/can99"));

            // å¯¹è´¦åŽå¯é‡æ–°èŽ·å–，且 Generation åªå‰è¿›ä¸å›žé€€
            var reacquired = _store.Acquire(new AcquireRequest
            {
                OwnerId = "new-owner", OwnerType = OwnerTypeV3.Maintenance,
                ProcessInstanceId = "y", ResourceKeys = new[] { "can/can99" }
            });
            Assert.Equal(AcquireResultCode.Acquired, reacquired.Code);
            Assert.True(reacquired.Grants[0].Generation > leaked.Grants[0].Generation);
        }
    }
}

 tests/Aging.MvpTests/FacadeLeaseLifecycleTests.cs

New file
@@ -0,0 +1,49 @@
using System;
using System.IO;
using System.Threading;
using Aging.Infrastructure.Core;
using Aging.ResourceContracts;
using Xunit;

namespace Aging.MvpTests
{
    public class FacadeLeaseLifecycleTests : IDisposable
    {
        private readonly string _dbPath;
        private readonly DbLeaseStore _store;
        public FacadeLeaseLifecycleTests()
        {
            _dbPath = Path.Combine(Path.GetTempPath(), "arb_" + Guid.NewGuid().ToString("N") + ".db");
            _store = new DbLeaseStore(_dbPath, "local-main");
        }
        public void Dispose() { try { File.Delete(_dbPath); File.Delete(_dbPath + "-wal"); File.Delete(_dbPath + "-shm"); } catch { } }

        private LeaseGrant Grab(string key, int ttl)
            => _store.Acquire(new AcquireRequest
            {
                OwnerId = "f", OwnerType = OwnerTypeV3.Production,
                ResourceKeys = new[] { key }, TtlSeconds = ttl
            }).Grants[0];

        [Fact]
        public void Heartbeat_Renew_Extends_Expiry()
        {
            var g = Grab("can/x", 2);
            long before = g.ExpiresUtcMs;
            Thread.Sleep(1200);
            Assert.True(_store.Renew(g, 2));
            Assert.True(_store.ProbeConflict("can/x").ExpiresUtcMs > before);
        }

        [Fact]
        public void Expired_Sweep_StaleRenew_False_And_RecoveryBlocked()
        {
            var g = Grab("can/y", 1);
            Thread.Sleep(1500);
            Assert.Equal(1, _store.SweepExpired());
            Assert.False(_store.Renew(g, 5));
            Assert.Null(_store.ProbeConflict("can/y"));
            Assert.Equal(LeasePhase.RecoveryRequired, _store.PhaseOf("can/y"));
        }
    }
}

 tests/Aging.MvpTests/LayeredResourceManagerTests.cs

New file
@@ -0,0 +1,82 @@
using System;
using System.IO;
using System.Threading;
using Aging.Infrastructure.Core;
using Aging.Infrastructure.Contracts;
using Xunit;

namespace Aging.MvpTests
{
    public class LayeredResourceManagerTests : IDisposable
    {
        private readonly string _dbPath;
        private readonly LayeredResourceManager _rm;

        public LayeredResourceManagerTests()
        {
            _dbPath = Path.Combine(Path.GetTempPath(),
                "arb_" + Guid.NewGuid().ToString("N") + ".db");
            _rm = new LayeredResourceManager(new DbLeaseStore(_dbPath, "local-main"));
        }

        public void Dispose() { try { File.Delete(_dbPath); File.Delete(_dbPath + "-wal"); File.Delete(_dbPath + "-shm"); } catch { } }

        [Fact]
        public void ReserveAsync_Then_ValidateOwner_True()
        {
            var owner = new ResourceOwnerToken(OwnerType.Maintenance, "W01");
            var key = new ResourceKey("CAN-002", "CAN");
            var res = _rm.ReserveAsync(owner, key, CancellationToken.None)
                         .GetAwaiter().GetResult();
            Assert.Equal(ReservationState.Active, res.State);
            Assert.True(_rm.ValidateOwner(owner, key));
        }

        [Fact]
        public void ReserveAsync_Conflict_ExceptionCarriesHolder()
        {
            var a = new ResourceOwnerToken(OwnerType.Maintenance, "holder-A");
            var b = new ResourceOwnerToken(OwnerType.Production, "requester-B");
            var key = new ResourceKey("CAN-002", "CAN");
            _rm.ReserveAsync(a, key, CancellationToken.None).GetAwaiter().GetResult();
            var ex = Assert.Throws<ResourceConflictException>(() =>
                _rm.ReserveAsync(b, key, CancellationToken.None).GetAwaiter().GetResult());
            Assert.Contains("holder-A", ex.Message);
        }

        [Fact]
        public void ValidateOwner_DoesNotShrinkLease_KeepsFullTtl()
        {
            // å›žå½’：ValidateOwner æ›¾ä»¥ Renew(grant,1) æ ¡éªŒï¼Œä¼šæŠŠç§Ÿçº¦åˆ°æœŸç åˆ° now+1s，
            // å¯¼è‡´ä½œç”¨åŸŸç§Ÿçº¦å¿ƒè·³ Renew å› â€œå·²è¿‡æœŸâ€å¤±è´¥â‰¥2 â†’ è¯¯æŠ¥â€œç§Ÿçº¦å·²å¤±æ•ˆâ€ã€‚
            var owner = new ResourceOwnerToken(OwnerType.Production, "auto_x");
            var key = new ResourceKey("CAN-001", "Generic");
            _rm.ReserveAsync(owner, key, CancellationToken.None).GetAwaiter().GetResult();

            // æ¨¡æ‹Ÿ DeviceService æ¯æ¬¡æ“ä½œå‰çš„栅栏校验
            Assert.True(_rm.ValidateOwner(owner, key));

            var holder = _rm.Coordinator.ProbeConflict(key.ToString());
            Assert.NotNull(holder);
            long nowMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            Assert.True(holder!.ExpiresUtcMs - nowMs > 60_000,
                $"ValidateOwner ä¸åº”砍短租约，剩余应≈TTL，实际剩余 {(holder.ExpiresUtcMs - nowMs) / 1000}s");

            // æ ¡éªŒåŽå¿ƒè·³å¼ç»­æœŸä»åº”成功（租约未过期）
            Assert.True(_rm.TryGetGrants(owner.TokenId, out var grants));
            Assert.True(_rm.Coordinator.Renew(grants![0], 30));
        }

        [Fact]
        public void ReleaseReservationAsync_Then_OtherCanReserve()
        {
            var a = new ResourceOwnerToken(OwnerType.Maintenance, "A");
            var b = new ResourceOwnerToken(OwnerType.Production, "B");
            var key = new ResourceKey("CAN-002", "CAN");
            _rm.ReserveAsync(a, key, CancellationToken.None).GetAwaiter().GetResult();
            _rm.ReleaseReservationAsync(a, key, CancellationToken.None).GetAwaiter().GetResult();
            var ok = _rm.ReserveAsync(b, key, CancellationToken.None).GetAwaiter().GetResult();
            Assert.Equal(ReservationState.Active, ok.State);
        }
    }
}

 tests/Aging.MvpTests/SimulatorFramingTests.cs

New file
@@ -0,0 +1,130 @@
using System;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using CanSimulator;
using Xunit;

namespace Aging.MvpTests
{
    /// <summary>
    /// CAN æ¨¡æ‹Ÿå™¨ TCP çº¿åè®®åˆ†å¸§ç¼–解码器测试。
    /// çº¿æ ¼å¼ï¼š4 å­—节大端长度前缀 + UTF8 æ–‡æœ¬ï¼ˆä¸Ž BrokerIpc åŒæƒ¯ç”¨æ³•ï¼‰ã€‚
    /// </summary>
    public class SimulatorFramingTests
    {
        [Fact]
        public void Encode_RoundTrip_DecodesOriginalText()
        {
            string msg = "HELLO:CAN_BUS_1:0:HOST/PID";
            byte[] frame = SimulatorFraming.Encode(msg);

            Assert.Equal(4 + Encoding.UTF8.GetByteCount(msg), frame.Length);

            var ms = new MemoryStream(frame);
            byte[] all = ms.ToArray();
            var got = SimulatorFraming.Decode(all, SimulatorFraming.HeaderSize, all.Length - SimulatorFraming.HeaderSize);
            Assert.Equal(msg, got);
        }

        [Fact]
        public void ReadFrameAsync_TwoFramesInOneBuffer_DecodesBothInOrder()
        {
            // ç²˜åŒ…：两个完整帧连续写入同一流
            var ms = new MemoryStream();
            byte[] f1 = SimulatorFraming.Encode("OK:TX:0x100:8");
            ms.Write(f1, 0, f1.Length);
            byte[] f2 = SimulatorFraming.Encode("EV:RECV:0x123:AA BB:12:00:00.111:2");
            ms.Write(f2, 0, f2.Length);
            ms.Position = 0;

            string? r1 = SimulatorFraming.ReadFrameAsync(ms, CancellationToken.None).GetAwaiter().GetResult();
            string? r2 = SimulatorFraming.ReadFrameAsync(ms, CancellationToken.None).GetAwaiter().GetResult();

            Assert.Equal("OK:TX:0x100:8", r1);
            Assert.Equal("EV:RECV:0x123:AA BB:12:00:00.111:2", r2);
        }

        [Fact]
        public void ReadFrameAsync_FrameSplitAcrossTwoReads_ReassemblesFullFrame()
        {
            // åŠåŒ…：帧体被拆成两次到达（用分段流模拟）
            byte[] frame = SimulatorFraming.Encode("SEND:0x777:DE AD BE EF");
            var chunked = new ChunkedStream(frame, chunk: 6); // å¤´éƒ¨ 6 å­—节后切断

            string? got = SimulatorFraming.ReadFrameAsync(chunked, CancellationToken.None).GetAwaiter().GetResult();
            Assert.Equal("SEND:0x777:DE AD BE EF", got);
        }

        [Fact]
        public void ReadFrameAsync_LengthExceedsMax_Throws()
        {
            // éžæ³•é•¿åº¦å‰ç¼€ï¼šè¶…过 MaxFrameBytes
            byte[] bad = new byte[4];
            bad[0] = 0x7F; bad[1] = 0xFF; bad[2] = 0xFF; bad[3] = 0xFF; // ~2GB
            var ms = new MemoryStream(bad);

            Assert.Throws<InvalidDataException>(() =>
                SimulatorFraming.ReadFrameAsync(ms, CancellationToken.None).GetAwaiter().GetResult());
        }

        [Fact]
        public void ReadFrameAsync_ZeroLengthPrefix_Throws()
        {
            byte[] bad = new byte[4]; // é•¿åº¦ 0
            var ms = new MemoryStream(bad);

            Assert.Throws<InvalidDataException>(() =>
                SimulatorFraming.ReadFrameAsync(ms, CancellationToken.None).GetAwaiter().GetResult());
        }

        [Fact]
        public void ReadFrameAsync_EmptyStream_ReturnsNull()
        {
            // å¯¹ç«¯æ­£å¸¸å…³é—­ï¼šè¯»ä¸åˆ°ä»»ä½•å­—节时返回 null（断线感知契约）
            var ms = new MemoryStream(new byte[0]);
            string? got = SimulatorFraming.ReadFrameAsync(ms, CancellationToken.None).GetAwaiter().GetResult();
            Assert.Null(got);
        }

        [Fact]
        public void ReadFrameAsync_TruncatedBody_ReturnsNull()
        {
            // å¤´å®Œæ•´ä½†ä½“中途 EOF：返回 null è§¦å‘重连
            byte[] frame = SimulatorFraming.Encode("QUERY:RECV_ALL");
            var truncated = new byte[frame.Length - 3];
            Array.Copy(frame, truncated, truncated.Length);
            var ms = new MemoryStream(truncated);

            string? got = SimulatorFraming.ReadFrameAsync(ms, CancellationToken.None).GetAwaiter().GetResult();
            Assert.Null(got);
        }

        /// <summary>每次 Read åªä»Žå†…部缓冲区取固定片段，模拟网络分片到达</summary>
        private sealed class ChunkedStream : Stream
        {
            private readonly byte[] _data;
            private readonly int _chunk;
            private int _pos;
            public ChunkedStream(byte[] data, int chunk) { _data = data; _chunk = chunk; }
            public override bool CanRead => true;
            public override bool CanSeek => false;
            public override bool CanWrite => false;
            public override long Length => _data.Length;
            public override long Position { get => _pos; set => throw new NotSupportedException(); }
            public override void Flush() { }
            public override int Read(byte[] buffer, int offset, int count)
            {
                if (_pos >= _data.Length) return 0;
                int n = Math.Min(Math.Min(count, _chunk), _data.Length - _pos);
                Array.Copy(_data, _pos, buffer, offset, n);
                _pos += n;
                return n;
            }
            public override long Seek(long o, SeekOrigin s) => throw new NotSupportedException();
            public override void SetLength(long v) => throw new NotSupportedException();
            public override void Write(byte[] b, int o, int c) => throw new NotSupportedException();
        }
    }
}

 tests/Aging.MvpTests/SimulatorServerCoreTests.cs

New file
@@ -0,0 +1,255 @@
using System;
using System.IO;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using CanSimulatorServer;
using Xunit;

namespace Aging.MvpTests
{
    /// <summary>
    /// æ¨¡æ‹Ÿå™¨æœåŠ¡ç«¯æ ¸å¿ƒè¡Œä¸ºæµ‹è¯•ï¼šHELLO çŠ¶æ€æœºã€NODE_BUSY ä»²è£ã€
    /// è·¨èŠ‚点路由推送、自动响应回推、命令串执行（AUTO_RESPONSE/STATUS）。
    /// æµ‹è¯•è¿›ç¨‹å†…托管 TcpSimulatorHost（随机端口），走真实 TCP å›žçŽ¯ã€‚
    /// </summary>
    public class SimulatorServerCoreTests : IDisposable
    {
        private readonly TcpSimulatorHost _host;
        private readonly int _port;

        public SimulatorServerCoreTests()
        {
            _host = new TcpSimulatorHost();
            _host.StartAsync().GetAwaiter().GetResult();
            _port = _host.Port;
        }

        public void Dispose() => _host.Dispose();

        // ==================== å®¢æˆ·ç«¯è¾…助 ====================

        private sealed class FakeClient : IDisposable
        {
            public TcpClient Socket = null!;
            public Stream Stream = null!;

            public async Task ConnectAsync(int port)
            {
                Socket = new TcpClient();
                await Socket.ConnectAsync("127.0.0.1", port);
                Stream = Socket.GetStream();
            }

            public Task SendAsync(string msg)
            {
                byte[] f = CanSimulator.SimulatorFraming.Encode(msg);
                return Stream.WriteAsync(f, 0, f.Length);
            }
            public Task<string> RecvAsync() => ReadFrameBlocking();

            public async Task<string> HelloAsync(string bus, int node, string tag = "t")
            {
                await SendAsync($"HELLO:{bus}:{node}:{tag}");
                return await ReadFrameBlocking();
            }

            private async Task<string> ReadFrameBlocking()
            {
                var s = await CanSimulator.SimulatorFraming.ReadFrameAsync(Stream, CancellationToken.None);
                return s ?? "<EOF>";
            }

            public void Dispose() { try { Stream?.Dispose(); Socket?.Close(); } catch { } }
        }

        // ==================== HELLO çŠ¶æ€æœº ====================

        [Fact]
        public void Hello_FirstClient_AcksOk()
        {
            using var c = new FakeClient();
            c.ConnectAsync(_port).GetAwaiter().GetResult();
            var ack = c.HelloAsync("CAN_BUS_1", 0).GetAwaiter().GetResult();
            Assert.StartsWith("OK:HELLO", ack);
        }

        [Fact]
        public void Query_BeforeHello_ReturnsNotHandshaked()
        {
            using var c = new FakeClient();
            c.ConnectAsync(_port).GetAwaiter().GetResult();
            c.SendAsync("QUERY:STATUS").GetAwaiter().GetResult();
            var resp = c.RecvAsync().GetAwaiter().GetResult();
            Assert.Equal("ERR:NOT_HANDSHAKED", resp);
        }

        [Fact]
        public void UnknownCommand_ReturnsUnknownCmd_WithoutDroppingConnection()
        {
            using var c = new FakeClient();
            c.ConnectAsync(_port).GetAwaiter().GetResult();
            c.HelloAsync("CAN_BUS_1", 0).GetAwaiter().GetResult();

            c.SendAsync("FOO:bar").GetAwaiter().GetResult();
            Assert.Equal("ERR:UNKNOWN_CMD:FOO:bar", c.RecvAsync().GetAwaiter().GetResult());

            // è¿žæŽ¥ä¿æŒå¯ç”¨ï¼šåŽç»­åˆæ³•å‘½ä»¤ä»æœ‰å“åº”
            c.SendAsync("QUERY:STATUS").GetAwaiter().GetResult();
            Assert.StartsWith("OK:", c.RecvAsync().GetAwaiter().GetResult());
        }

        // ==================== NODE_BUSY ä»²è£ ====================

        [Fact]
        public void Hello_SameBusSameNode_SecondRejectedNodeBusy()
        {
            using var a = new FakeClient();
            using var b = new FakeClient();
            a.ConnectAsync(_port).GetAwaiter().GetResult();
            b.ConnectAsync(_port).GetAwaiter().GetResult();

            Assert.StartsWith("OK:HELLO", a.HelloAsync("CAN_BUS_1", 3).GetAwaiter().GetResult());
            Assert.Equal("ERR:NODE_BUSY", b.HelloAsync("CAN_BUS_1", 3).GetAwaiter().GetResult());

            // ä¸åŒæ€»çº¿åŒèŠ‚点编号不冲突
            Assert.StartsWith("OK:HELLO", b.HelloAsync("CAN_BUS_2", 3).GetAwaiter().GetResult());
        }

        [Fact]
        public void Hello_AfterDisconnect_SameNodeCanReattach()
        {
            var a = new FakeClient();
            a.ConnectAsync(_port).GetAwaiter().GetResult();
            a.HelloAsync("CAN_BUS_1", 7).GetAwaiter().GetResult();
            a.Dispose(); // æ¨¡æ‹Ÿè¿žæŽ¥æ–­å¼€

            using var b = new FakeClient();
            b.ConnectAsync(_port).GetAwaiter().GetResult();
            // æœåŠ¡ç«¯æ„ŸçŸ¥ EOF éœ€å°‘许时间，轮询重试
            string ack = "";
            for (int i = 0; i < 50 && !ack.StartsWith("OK"); i++)
            {
                Thread.Sleep(20);
                b.SendAsync($"HELLO:CAN_BUS_1:7:retry{i}").GetAwaiter().GetResult();
                ack = b.RecvAsync().GetAwaiter().GetResult();
            }
            Assert.StartsWith("OK:HELLO", ack);
        }

        // ==================== è·¯ç”±ä¸ŽæŽ¨é€ ====================

        [Fact]
        public void Send_FromOneNode_OtherNodeReceivesEvPush()
        {
            using var a = new FakeClient();
            using var b = new FakeClient();
            a.ConnectAsync(_port).GetAwaiter().GetResult();
            b.ConnectAsync(_port).GetAwaiter().GetResult();
            a.HelloAsync("CAN_BUS_1", 0).GetAwaiter().GetResult();
            b.HelloAsync("CAN_BUS_1", 1).GetAwaiter().GetResult();

            a.SendAsync("SEND:0x123:AA BB CC").GetAwaiter().GetResult();
            var ack = a.RecvAsync().GetAwaiter().GetResult();
            Assert.StartsWith("OK:TX", ack);

            // å¯¹ç«¯èŠ‚点收到服务端主动推送
            var push = b.RecvAsync().GetAwaiter().GetResult();
            Assert.StartsWith("EV:RECV:0x123:AA BB CC", push);
        }

        [Fact]
        public void Send_AutoResponseEnabled_RespondsToPeerAndSelf()
        {
            using var a = new FakeClient();
            using var b = new FakeClient();
            a.ConnectAsync(_port).GetAwaiter().GetResult();
            b.ConnectAsync(_port).GetAwaiter().GetResult();
            a.HelloAsync("CAN_BUS_1", 10).GetAwaiter().GetResult();
            b.HelloAsync("CAN_BUS_1", 11).GetAwaiter().GetResult();

            // b å¼€å¯è‡ªåŠ¨å“åº”（QUERY å†™å‘½ä»¤ï¼Œå“åº”一行）
            b.SendAsync("QUERY:AUTO_RESPONSE:ON").GetAwaiter().GetResult();
            Assert.StartsWith("OK:", b.RecvAsync().GetAwaiter().GetResult());

            // a å‘帧 â†’ b è·¯ç”±æ”¶å¸§(推送) + è‡ªåŠ¨å“åº”帧回 a
            a.SendAsync("SEND:0x500:11 22").GetAwaiter().GetResult();
            Assert.StartsWith("OK:TX", a.RecvAsync().GetAwaiter().GetResult());

            // b è‡ªå·±æ”¶åˆ°æºè·¯ç”±æŽ¨é€
            Assert.StartsWith("EV:RECV:0x500:11 22", b.RecvAsync().GetAwaiter().GetResult());
            // a æ”¶åˆ°è‡ªåŠ¨å“åº”帧（来源=b èŠ‚点 11）
            var respPush = a.RecvAsync().GetAwaiter().GetResult();
            Assert.StartsWith("EV:RECV:0x500:11 22", respPush);
            Assert.EndsWith(":11", respPush); // srcNodeIndex=11
        }

        // ==================== å‘½ä»¤æ‰§è¡Œ ====================

        [Fact]
        public void Query_Status_AfterHello_ReturnsOkStatus()
        {
            using var a = new FakeClient();
            a.ConnectAsync(_port).GetAwaiter().GetResult();
            a.HelloAsync("CAN_BUS_1", 20).GetAwaiter().GetResult();

            a.SendAsync("QUERY:STATUS").GetAwaiter().GetResult();
            var resp = a.RecvAsync().GetAwaiter().GetResult();
            Assert.StartsWith("OK:STATUS:", resp);
            Assert.Contains("Node=20", resp); // èŠ‚点以编号寻址
        }

        [Fact]
        public void GarbageFrame_ClosesSession_ButHostKeepsListening()
        {
            // éžæ³•é•¿åº¦å‰ç¼€ï¼ˆåè®®å¤±æ­¥ï¼‰ï¼šæœåŠ¡ç«¯æ–­å¼€è¯¥ä¼šè¯ï¼Œä½†åŽç»­æ–°è¿žæŽ¥ä»èƒ½ HELLO
            int p = _port;
            using (var raw = new TcpClient("127.0.0.1", p))
            {
                byte[] bad = { 0x00, 0x00, 0x00, 0x00 }; // é•¿åº¦ 0
                raw.GetStream().Write(bad, 0, 4);
            }
            Thread.Sleep(100);

            using var c = new FakeClient();
            c.ConnectAsync(_port).GetAwaiter().GetResult();
            Assert.StartsWith("OK:HELLO", c.HelloAsync("CAN_BUS_9", 0).GetAwaiter().GetResult());
        }

        // ==================== æ€»çº¿çº§åº”答器 ====================

        [Fact]
        public void BusEcho_Enabled_SenderReceivesOwnFrameAsResponder()
        {
            using var a = new FakeClient();
            a.ConnectAsync(_port).GetAwaiter().GetResult();
            a.HelloAsync("CAN_ECHO_ON", 0).GetAwaiter().GetResult();

            a.SendAsync("QUERY:BUS_ECHO:ON").GetAwaiter().GetResult();
            Assert.StartsWith("OK:", a.RecvAsync().GetAwaiter().GetResult());

            // å•èŠ‚点发帧（标准 ID）：应答器应把同帧回显给发送者（无需第二节点）
            a.SendAsync("SEND:0x111:AA BB").GetAwaiter().GetResult();
            Assert.StartsWith("OK:TX", a.RecvAsync().GetAwaiter().GetResult());

            var echo = a.RecvAsync().GetAwaiter().GetResult();
            Assert.StartsWith("EV:RECV:0x111:AA BB", echo);
            Assert.EndsWith(":RESPONDER", echo);
        }

        [Fact]
        public void BusEcho_Disabled_NoEchoDelivered()
        {
            using var a = new FakeClient();
            a.ConnectAsync(_port).GetAwaiter().GetResult();
            a.HelloAsync("CAN_ECHO_OFF", 0).GetAwaiter().GetResult(); // é»˜è®¤å…³

            a.SendAsync("SEND:0x912:11").GetAwaiter().GetResult();
            Assert.StartsWith("OK:TX", a.RecvAsync().GetAwaiter().GetResult());

            // ç´§æŽ¥ç€çš„响应应为查询本身，中间不应插入任何 EV:RECV å›žæ˜¾
            a.SendAsync("QUERY:BUS_ECHO").GetAwaiter().GetResult();
            Assert.Equal("OK:BUS_ECHO:OFF", a.RecvAsync().GetAwaiter().GetResult());
        }
    }
}

 tests/Aging.MvpTests/UnitTest1.cs

New file
@@ -0,0 +1,13 @@
using Xunit;

namespace Aging.MvpTests
{
    public class UnitTest1
    {
        [Fact]
        public void Test1()
        {
            Assert.True(true);
        }
    }
}