Third_Dev_Dept/StandardSence
18
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

新增信号交互进程插件

Browse Source
This commit is contained in:
ykkokluo
2026-08-17 15:20:27 +08:00
parent 12c7c1d518
commit cacc5fea5c
25 changed files with 937 additions and 369 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Directory.Build.targets
+2 -10
View File
@@ -31,22 +31,14 @@
Condition="Exists('$(TargetDir)leegKeys-sdk.dll')" />
<StandardScenePluginCopyFile Include="$(TargetDir)IoTClient.dll"
Condition="Exists('$(TargetDir)IoTClient.dll')" />
<StandardScenePluginCopyFile Include="$(NuGetPackageRoot)iotclient\1.0.40\lib\netstandard2.0\IoTClient.dll"
Condition="'$(MSBuildProjectName)' == 'StandardScene.Signal' and Exists('$(NuGetPackageRoot)iotclient\1.0.40\lib\netstandard2.0\IoTClient.dll')" />
</ItemGroup>
<Copy SourceFiles="@(StandardScenePluginCopyFile)"
DestinationFolder="$(StandardScenePluginsDir)"
SkipUnchangedFiles="true" />
<ItemGroup Condition="'$(MSBuildProjectName)' == 'StandardScene.Signal'">
<StandardSceneSignalConfig Include="$(TargetDir)Config\Signal\*.json" />
</ItemGroup>
<MakeDir Directories="$(StandardScenePluginsDir)\Config\Signal"
Condition="'@(StandardSceneSignalConfig)' != ''" />
<Copy SourceFiles="@(StandardSceneSignalConfig)"
DestinationFolder="$(StandardScenePluginsDir)\Config\Signal"
SkipUnchangedFiles="true"
Condition="'@(StandardSceneSignalConfig)' != ''" />
<Message Importance="high"
Text="[StandardScene] 已复制 $(MSBuildProjectName) 插件产物到 $(StandardScenePluginsDir)" />
</Target>
StandardScene.Signal/Logic/CarScanWorker.cs
+46 -1
View File
@@ -9,17 +9,43 @@ using StandardScene.Signal.Plc;
namespace StandardScene.Signal.Logic
{
/// <summary>1s 扫全场车，对齐反编译 DefaultPlugin.ExcuteThreadMethod + StarSignManage。</summary>
/// <summary>
/// 1s 扫全场车，对齐反编译 <c>DefaultPlugin.ExcuteThreadMethod</c> + <c>StarSignManage</c>。
/// </summary>
/// <remarks>
/// 每辆车每拍只看当前站点：
/// <list type="number">
/// <item>停稳：先按握手点类型分发 Handler，再执行放行点（放行点不读 PLC，可能把还在等允许进入的车开走，站点不要两边都配）。</item>
/// <item>行驶中：仅 JGControl + RequestIn 调用 <c>RequestInJudge</c>，PLC 未允许进入则停车。</item>
/// </list>
/// 握手点解析优先站点 fields（<see cref="SignalCarAdapter.TryReadSignalStop"/>），没有再查 JSON。
/// </remarks>
public sealed class CarScanWorker : IDisposable
{
/// <summary>取当前全部机构运行态；由 Mission 提供，内部会拷贝列表。</summary>
private readonly Func<IReadOnlyList<PlcStationRuntime>> _runtimes;
/// <summary>扫车间隔，下限 100ms，默认跟进程 TickMs=1000。</summary>
private readonly int _tickMs;
/// <summary>保护握手点 / 放行点字典，热替换配置时与扫车拍互斥。</summary>
private readonly object _configLock = new object();
/// <summary>站点 → 握手点。同一站点多条配置只留第一条。</summary>
private Dictionary<int, HandshakePointModel> _handshake = new Dictionary<int, HandshakePointModel>();
/// <summary>站点 → 放行点。同一站点多条配置只留第一条。</summary>
private Dictionary<int, ReleasePointModel> _release = new Dictionary<int, ReleasePointModel>();
/// <summary>限流区域上次记日志的车号，避免同一区域每秒刷屏。</summary>
private readonly Dictionary<string, int> _rateFlowLog = new Dictionary<string, int>();
/// <summary>车辆没有 GetChargeTime 时，用首次看到「充电中」的时刻估算秒数。</summary>
private readonly Dictionary<int, DateTime> _chargeStarted = new Dictionary<int, DateTime>();
/// <summary>未知 SignalType 的日志节流（同站点 10s 一次）。</summary>
private readonly Dictionary<int, DateTime> _unknownTypeLog = new Dictionary<int, DateTime>();
private CancellationTokenSource _cts;
private Thread _thread;
private int _tickCount;
@@ -30,8 +56,13 @@ namespace StandardScene.Signal.Logic
_tickMs = Math.Max(100, tickMs);
}
/// <summary>已完成的扫车拍数，写入进程 status 供监视。</summary>
public int TickCount => _tickCount;
/// <summary>
/// 热替换握手点 / 放行点。过滤掉站点号无效或信号类型为空的握手点。
/// 不中断线程，下一拍生效。
/// </summary>
public void ReplaceConfig(IEnumerable<HandshakePointModel> handshake, IEnumerable<ReleasePointModel> release)
{
lock (_configLock)
@@ -47,6 +78,7 @@ namespace StandardScene.Signal.Logic
}
}
/// <summary>启动后台扫车线程。重复 Start 若线程仍活则忽略。</summary>
public void Start()
{
if (_thread != null && _thread.IsAlive) return;
@@ -60,6 +92,7 @@ namespace StandardScene.Signal.Logic
Diagnosis.Log("扫车握手线程已启动", "Signal", true);
}
/// <summary>取消令牌并最多等 2s 退出。不抛异常，供进程停止时调用。</summary>
public void Stop()
{
try { _cts?.Cancel(); }
@@ -92,6 +125,10 @@ namespace StandardScene.Signal.Logic
}
}
/// <summary>
/// 一拍：拷贝配置字典 → 按机构名查找闭包 → 遍历全部车。
/// 查找机构时忽略大小写，与 JSON 里 JgName 对齐。
/// </summary>
internal void ScanOnce()
{
Dictionary<int, HandshakePointModel> handshake;
@@ -130,6 +167,10 @@ namespace StandardScene.Signal.Logic
}
}
/// <summary>
/// 站点 fields 有 SignalType 则用地图点配置（老 SignalStop）；
/// 否则用 handshake-points.json。fields 存在但类型为空视为本站不握手。
/// </summary>
private SignalStopSpec ResolveSpec(int sit, IReadOnlyDictionary<int, HandshakePointModel> handshake)
{
if (sit <= 0) return null;
@@ -147,6 +188,10 @@ namespace StandardScene.Signal.Logic
return null;
}
/// <summary>
/// 停稳分发。TimedCharging 优先：充电点不应再走机构逻辑。
/// 未识别的 SignalType 按站点节流打日志，避免刷屏。
/// </summary>
private void DispatchStopped(Car car, SignalStopSpec spec, Func<string, PlcStationRuntime> find)
{
if (spec.Is("TimedCharging"))
StandardScene.Signal/Logic/JgControlHandler.cs
+29 -1
View File
@@ -8,9 +8,28 @@ using StandardScene.Signal.Plc;
namespace StandardScene.Signal.Logic
{
/// <summary>对齐反编译 DefaultPlugin.JGControl / JGJudge / RequestIn / Arrived。</summary>
/// <summary>
/// 机构进出站握手。对齐反编译 <c>DefaultPlugin.JGControl</c> / <c>JGJudge</c> / <c>RequestIn</c> / <c>Arrived</c>。
/// </summary>
/// <remarks>
/// <para>
/// <c>SignalParams</c> 分号三段：<c>机构名;动作;限流</c>。
/// 动作 <c>RequestIn</c>（请求进入，配在机构口外等待点）或 <c>Arrived</c>（到位，配在机构内地标）。
/// 第三段可选，格式与独立限流不同：<c>区域-车组-限额-点1,点2</c>（短横分隔，见 <see cref="RateFlowHandler"/>）。
/// </para>
/// <para>
/// RequestIn 放行条件（需同时满足）：PLC 读字节=允许进入、尚无请求进入车、写字节=无状态。
/// 下线机构额外要求 <c>JgPointId</c> 上没有其它车。通过后写「进入中」、记下 RequestInAgvNo、停充并启动。
/// </para>
/// <para>
/// 车已在跑但本车不是请求进入车、且 PLC 不是允许进入时，立即停车（停稳拍与行驶拍都会判）。
/// Arrived：若 InAgvNo 还不是本车，写「到位」、登记 InAgvNo、清空 RequestInAgvNo。
/// 之后的「离开中 / 已离开」由 PLC Worker 的 <see cref="PlcStationLogic.AutoLeave"/> 推进。
/// </para>
/// </remarks>
public static class JgControlHandler
{
/// <summary>停稳：可选限流 → RequestIn 或 Arrived。</summary>
public static void OnStopped(Car car, SignalStopSpec spec, Func<string, PlcStationRuntime> find, IDictionary<string, int> rateFlowLog)
{
var jgName = spec.Part(0).Trim();
@@ -34,6 +53,7 @@ namespace StandardScene.Signal.Logic
Arrived(jgName, car, find);
}
/// <summary>行驶中只做 RequestIn 安全闸：未允许进入且不是本车占用请求槽则停车。</summary>
public static void OnMoving(Car car, SignalStopSpec spec, Func<string, PlcStationRuntime> find)
{
var jgName = spec.Part(0).Trim();
@@ -44,6 +64,10 @@ namespace StandardScene.Signal.Logic
RequestInJudge(jgName, car, find);
}
/// <summary>
/// 请求进入。锁机构运行态，避免与 PLC Worker 同时改写字节 / 车号。
/// 后半段与 <see cref="RequestInJudge"/> 相同，覆盖「刚放行后又被调度层启动」的竞态。
/// </summary>
private static void RequestIn(string jgName, Car car, Func<string, PlcStationRuntime> find)
{
var rt = find(jgName);
@@ -89,6 +113,7 @@ namespace StandardScene.Signal.Logic
}
}
/// <summary>行驶中的 RequestIn 安全闸，条件与 RequestIn 后半段一致。</summary>
private static void RequestInJudge(string jgName, Car car, Func<string, PlcStationRuntime> find)
{
var rt = find(jgName);
@@ -110,6 +135,9 @@ namespace StandardScene.Signal.Logic
}
}
/// <summary>
/// 到位。InAgvNo 已是本车则认为已报到，避免每秒重复写「到位」把 WriteSuccess 清掉。
/// </summary>
private static void Arrived(string jgName, Car car, Func<string, PlcStationRuntime> find)
{
var rt = find(jgName);
StandardScene.Signal/Logic/PointControlHandler.cs
+14 -1
View File
@@ -6,9 +6,18 @@ using StandardScene.Signal.Plc;
namespace StandardScene.Signal.Logic
{
/// <summary>对齐反编译 DefaultPlugin.PointControl：牵引棒升/降到位后再放行。</summary>
/// <summary>
/// 销钉 / 牵引棒升降后再放行。对齐反编译 <c>DefaultPlugin.PointControl</c>。
/// </summary>
/// <remarks>
/// <c>SignalParams</c>：<c>动作;机构名</c>。
/// 动作：<c>UP1</c> 升销钉1，<c>UP2</c> 升销钉1+2，<c>Down1</c> / <c>Down2</c> 对应下降。
/// 机构名可选：填了则必须等该机构读字节=允许离开才启动；空则只等销钉动作完成。
/// 销钉指令通过 <see cref="SignalCarAdapter.Control"/> 反射调用车体 MethodMember（如 SetPin1Up）。
/// </remarks>
public static class PointControlHandler
{
/// <summary>停稳：先判机构是否允许离开，再下发销钉，全部到位后启动。</summary>
public static void OnStopped(Car car, SignalStopSpec spec, Func<string, PlcStationRuntime> find)
{
var action = spec.Part(0).Trim();
@@ -48,6 +57,10 @@ namespace StandardScene.Signal.Logic
}
}
/// <summary>
/// 任一销钉未完成则本拍只下发指令、不启动；
/// 全部完成且（无需等离开 或 已允许离开）才 Start。
/// </summary>
private static void PinThenGo(Car car, int pos, bool waitLeave, string jgName, params string[] actions)
{
var done = true;
StandardScene.Signal/Logic/RateFlowHandler.cs
+11 -2
View File
@@ -8,11 +8,17 @@ using StandardScene.Signal.Plc;
namespace StandardScene.Signal.Logic
{
/// <summary>
/// 对齐反编译 DefaultPlugin.RateFlowControl。
/// 独立类型用分号：区域;车组;限额;点1,点2。JGControl 第三段用短横：区域-车组-限额-点1,点2。
/// 区域车组限流。对齐反编译 <c>DefaultPlugin.RateFlowControl</c>。
/// </summary>
/// <remarks>
/// 独立握手类型 <c>RateFlowControl</c> 用分号：<c>区域;车组;限额;点1,点2</c>。
/// 挂在 JGControl 第三段时用短横：<c>区域-车组-限额-点1,点2</c>（因为前两段机构名/动作已经占用分号）。
/// 统计「站点列表上、同车组、且不是本车」的数量，小于限额才放行。
/// 解析异常时放行（return true），避免配错把产线卡死。
/// </remarks>
public static class RateFlowHandler
{
/// <summary>独立限流点：通过则停充并启动。</summary>
public static void OnStopped(Car car, SignalStopSpec spec, IDictionary<string, int> logByArea)
{
if (AllowPass(car, spec.SignalParams, logByArea, sep: ';'))
@@ -22,9 +28,11 @@ namespace StandardScene.Signal.Logic
}
}
/// <summary>JGControl 第三段限流，短横分隔。不通过时调用方应直接 return，不启动。</summary>
public static bool AllowPass(Car car, string rateFlowString, IDictionary<string, int> logByArea) =>
AllowPass(car, rateFlowString, logByArea, sep: '-');
/// <param name="sep">独立类型用 ';'，JGControl 挂载用 '-'。</param>
private static bool AllowPass(Car car, string raw, IDictionary<string, int> logByArea, char sep)
{
try
@@ -71,6 +79,7 @@ namespace StandardScene.Signal.Logic
}
}
/// <summary>同一限流区域仅在「决策车号变化」时再打一条带原始参数的日志。</summary>
private static void Note(IDictionary<string, int> logByArea, string area, Car car, string raw)
{
if (logByArea == null) return;
StandardScene.Signal/Logic/ReleasePointHandler.cs
+9 -1
View File
@@ -5,9 +5,17 @@ using StandardScene.Signal.Plc;
namespace StandardScene.Signal.Logic
{
/// <summary>对齐反编译 StarSignManage：配置点停稳则停充并放行。</summary>
/// <summary>
/// 无条件放行点。对齐反编译 <c>StarSignManage</c> / <c>StartSignModel</c>。
/// </summary>
/// <remarks>
/// 车在配置站点停稳且 <see cref="ReleasePointModel.IsUse"/> 为 true 时：停充并启动，不读 PLC。
/// 用于任务在某点停住、充完电或人工暂停后需要自动续跑的站点。
/// 机构口应配握手点，不要同时配放行点——扫车线程在握手 Handler 之后仍会执行本方法，可能提前开走。
/// </remarks>
public static class ReleasePointHandler
{
/// <summary>按当前站点号查放行表；未配置或未启用则什么都不做。</summary>
public static void OnStopped(Car car, int sit, IReadOnlyDictionary<int, ReleasePointModel> points)
{
if (points == null || !points.TryGetValue(sit, out var p) || p == null || !p.IsUse)
StandardScene.Signal/Logic/SignalStopSpec.cs
+22 -1
View File
@@ -3,13 +3,31 @@ using StandardScene.Signal.Model;
namespace StandardScene.Signal.Logic
{
/// <summary>握手点解析结果。参数格式与反编译 SignalStop.SignalParams 一致。</summary>
/// <summary>
/// 一条握手点配置的解析结果。参数格式与反编译 <c>SignalStop.SignalParams</c> 一致。
/// </summary>
/// <remarks>
/// <see cref="SignalParams"/> 按分号切成 <see cref="Parts"/>，缺段时 <see cref="Part"/> 返回空串。
/// 各类型约定：
/// <list type="bullet">
/// <item><c>JGControl</c>：机构名;RequestIn|Arrived;[区域-车组-限额-点列表]</item>
/// <item><c>PointControl</c>：UP1|UP2|Down1|Down2;机构名</item>
/// <item><c>TimedCharging</c>：最长秒数;上限电量;下限电量</item>
/// <item><c>RateFlowControl</c>：区域;车组;限额;点1,点2</item>
/// </list>
/// </remarks>
public sealed class SignalStopSpec
{
/// <summary>握手类型名，与 Handler 的 <see cref="Is"/> 比较时忽略大小写。</summary>
public string SignalType { get; init; } = "";
/// <summary>原始参数串，限流独立类型会整段交给 <see cref="RateFlowHandler"/>。</summary>
public string SignalParams { get; init; } = "";
/// <summary>按 ';' 切分，保留空段（与 Split None 一致，方便 Part(n) 按下标取）。</summary>
public string[] Parts { get; init; } = Array.Empty<string>();
/// <summary>取第 <paramref name="index"/> 段；越界或 null 返回空串。</summary>
public string Part(int index)
{
if (index < 0 || index >= Parts.Length)
@@ -17,6 +35,7 @@ namespace StandardScene.Signal.Logic
return Parts[index] ?? "";
}
/// <summary>从类型名和参数串构造；类型会 Trim，参数保持原样以便日志对照现场 JSON。</summary>
public static SignalStopSpec Parse(string signalType, string signalParams)
{
var type = (signalType ?? "").Trim();
@@ -29,6 +48,7 @@ namespace StandardScene.Signal.Logic
};
}
/// <summary>从握手点 Model 构造；model 为 null 时返回 null。</summary>
public static SignalStopSpec From(HandshakePointModel model)
{
if (model == null)
@@ -36,6 +56,7 @@ namespace StandardScene.Signal.Logic
return Parse(model.SignalType, model.SignalParams);
}
/// <summary>类型名是否匹配（忽略大小写）。</summary>
public bool Is(string type) =>
string.Equals(SignalType, type, StringComparison.OrdinalIgnoreCase);
}
StandardScene.Signal/Logic/TimedChargeHandler.cs
+10 -1
View File
@@ -6,9 +6,18 @@ using StandardScene.Signal.Plc;
namespace StandardScene.Signal.Logic
{
/// <summary>对齐反编译 DefaultPlugin.TimedCharging：时长 / 上限电量 / 下限电量。</summary>
/// <summary>
/// 站点定时充电。对齐反编译 <c>DefaultPlugin.TimedCharging</c>。
/// </summary>
/// <remarks>
/// <c>SignalParams</c>：<c>最长秒数;上限电量;下限电量</c>，某段填 0 表示该条件不启用。
/// 正在充电：电量 ≥ 上限则停充；时长到且电量已过下限则停充；时长到但电量仍 ≤ 下限则继续充。
/// 已停充且车仍停着：视为充电流程结束，启动放行。
/// 充电秒数优先反射 <c>GetChargeTime</c>，没有则用 <paramref name="chargeStarted"/> 字典估算。
/// </remarks>
public static class TimedChargeHandler
{
/// <summary>停稳且本站是 TimedCharging 时由扫车线程调用。</summary>
public static void OnStopped(Car car, SignalStopSpec spec, IDictionary<int, DateTime> chargeStarted)
{
int.TryParse(spec.Part(0), out var maxSeconds);
StandardScene.Signal/Mission/SignalInteractMission.cs
+100 -1
View File
@@ -16,51 +16,129 @@ using StandardScene.Utils;
namespace StandardScene.Signal
{
/// <summary>
/// 第三方信号交互进程：PLC Worker（200ms）+ 扫车握手（1s）。
/// 第三方信号交互进程（场景 <c>scene.signal</c> 的唯一 Mission）。
/// </summary>
/// <remarks>
/// <para>
/// 对齐梅山吉利反编译插件 <c>CoreClass30.A20050.Plugin.DefaultPlugin</c>：
/// 一边用西门子 S7 和机构 PLC 交换进出站字节，一边按站点对停稳 AGV 做握手 / 放行。
/// </para>
/// <para>
/// 两条独立循环，不要合成一次 HTTP 或任务编排节点：
/// </para>
/// <list type="bullet">
/// <item>
/// <term>PLC Worker</term>
/// <description>
/// 每个机构一条后台线程，默认 200ms：心跳翻转、读「允许进入/离开」、回读写字节、按需写入、
/// <see cref="PlcStationLogic.AutoLeave"/> 推进离站状态机。
/// </description>
/// </item>
/// <item>
/// <term>扫车线程</term>
/// <description>
/// <see cref="CarScanWorker"/> 默认 1s 扫全场车。停稳则按握手点类型分发给
/// JGControl / PointControl / TimedCharging / RateFlowControl，再执行放行点；
/// 行驶中仅对 JGControl 的 RequestIn 做「未允许进入则急停」。
/// </description>
/// </item>
/// </list>
/// <para>
/// 配置三张 JSON（工作目录 <c>Config/Signal/</c>，可由迷毂数据中心改，保存后点「重新加载配置」）：
/// 机构 <c>stations.json</c>、握手点 <c>handshake-points.json</c>、放行点 <c>release-points.json</c>。
/// 站点 fields 若已写 <c>SignalType</c>/<c>SignalParams</c>，优先于握手点表。
/// </para>
/// <para>
/// CycleGUI 进程工具栏必须点「信号交互进程」，不要打开开放泛型编辑器。
/// 列表窗体只改 JSON，不经过本进程的 HTTP；改完需本进程已启动才会重启 Worker。
/// </para>
/// </remarks>
[MissionType(Name = "信号交互进程", editor = typeof(SignalInteractMission))]
[I18N.DocumentTranslation(Name = "Signal Interact Mission", locale = "en")]
public class SignalInteractMission : Mission
{
/// <summary>扫车周期（毫秒）。对齐反编译 DefaultPlugin 主循环，现场一般保持 1000。</summary>
[FieldMember] public int TickMs = 1000;
/// <summary>单机构 PLC 轮询周期（毫秒）。对齐 PLCManager，现场一般保持 200。</summary>
[FieldMember] public int PlcPollMs = 200;
/// <summary>
/// 西门子系列，传给 IoTClient <c>SiemensVersion</c>。
/// 常用 <c>S7_1500</c> / <c>S7_1200</c> / <c>S7_300</c>；连字符会当成下划线解析。
/// </summary>
[FieldMember] public string PlcVersion = "S7_1500";
/// <summary>机构未单独填 Port 时使用的 S7 端口，默认 102。</summary>
[FieldMember] public int PlcPort = 102;
/// <summary>S7 机架槽号，S7-1500 常见为 1；写入 <see cref="SiemensPlcSession"/>。</summary>
[FieldMember] public int PlcSlot = 1;
/// <summary>机构表路径。相对路径只解析工作目录 <c>Config/Signal</c>，不读插件目录。</summary>
[FieldMember] public string StationsPath = @"Config\Signal\stations.json";
/// <summary>放行点表路径。车停在这些站点且启用时，无条件停充并启动，不读 PLC。</summary>
[FieldMember] public string ReleasePointsPath = @"Config\Signal\release-points.json";
/// <summary>握手点表路径。按站点配置 JGControl / PointControl / TimedCharging / RateFlowControl。</summary>
[FieldMember] public string HandshakePointsPath = @"Config\Signal\handshake-points.json";
/// <summary>Execute 成功后为 true；ReloadConfig 仅在已启动时重启 Worker / 扫车。</summary>
[JsonIgnore] private bool _started;
/// <summary>保护 <see cref="_workers"/>：启动、停止、状态快照、扫车查找机构时共用。</summary>
[JsonIgnore] private readonly object _workerLock = new object();
/// <summary>当前在跑的机构 Worker，与 stations.json 一一对应（空名称的机构不会创建）。</summary>
[JsonIgnore] private readonly List<PlcStationWorker> _workers = new List<PlcStationWorker>();
/// <summary>全场扫车握手线程；停止进程时置空。</summary>
[JsonIgnore] private CarScanWorker _scan;
/// <summary>PLC 每 tick 都会回调刷新状态；用计数把 UI 刷新降到约每 5 个 poll 一次。</summary>
[JsonIgnore] private int _statusTick;
/// <summary>进程监视面板展示的运行摘要（机构连接数、扫车次数、各站读写字节）。</summary>
public class SignalInteractMissionStatus : MissionStatus
{
/// <summary>当前 Worker 数量，等于已加载且名称非空的机构数。</summary>
public int StationCount { get; set; }
/// <summary>最近一次快照里 <c>IsConnected == true</c> 的机构数。</summary>
public int ConnectedCount { get; set; }
/// <summary>放行点 JSON 条数（含未启用）。</summary>
public int ReleasePointCount { get; set; }
/// <summary>握手点 JSON 条数。</summary>
public int HandshakePointCount { get; set; }
/// <summary><see cref="CarScanWorker.TickCount"/>，用于确认扫车线程是否在跑。</summary>
public int ScanTickCount { get; set; }
/// <summary>实际解析到的机构文件绝对路径。</summary>
public string StationsFile { get; set; }
/// <summary>实际解析到的放行点文件绝对路径。</summary>
public string ReleasePointsFile { get; set; }
/// <summary>实际解析到的握手点文件绝对路径。</summary>
public string HandshakePointsFile { get; set; }
/// <summary>各机构运行态快照，供监视列表展示。</summary>
public List<PlcStationSnapshot> Stations { get; set; } = new List<PlcStationSnapshot>();
}
public override MissionStatus status { get; set; } = new SignalInteractMissionStatus();
/// <summary>SimpleLite 按 MissionType 反射创建实例时调用。</summary>
public static Mission Create() => new SignalInteractMission();
/// <summary>
/// 加载三张 JSON，拉起全部 PLC Worker 和扫车线程。
/// 重复点击会先停再建；失败时 status 为「启动失败」并记诊断。
/// </summary>
[MethodMember(Name = "启动进程", Description = "加载配置，启动 PLC Worker 与扫车握手")]
public override void Execute()
{
@@ -83,6 +161,11 @@ namespace StandardScene.Signal
}
}
/// <summary>
/// 重新读 JSON 并刷新 status 里的路径/条数。
/// 进程已启动时：重建 PLC Worker，并向扫车线程热替换握手点/放行点（不必停进程）。
/// 迷毂数据中心改完文件后应调本方法，否则内存里仍是旧表。
/// </summary>
[MethodMember(Name = "重新加载配置", Description = "重新读取 JSON；若进程已启动则重启 Worker/扫车")]
public void ReloadConfig()
{
@@ -113,6 +196,7 @@ namespace StandardScene.Signal
}
}
/// <summary>停扫车、停全部 PLC 连接。隐藏了基类 Stop，工具栏显示本方法。</summary>
[MethodMember(Name = "停止进程")]
public new void Stop()
{
@@ -125,6 +209,7 @@ namespace StandardScene.Signal
Diagnosis.Post("信号交互进程已停止", "Signal", true);
}
/// <summary>CycleGUI 独立窗体编辑机构表；保存立刻写 JSON，需「重新加载配置」才进 Worker。</summary>
[MethodMember(Name = "打开机构列表", Description = "按 PlcStationModel 增删改机构配置")]
public void OpenStations()
{
@@ -139,6 +224,7 @@ namespace StandardScene.Signal
}
}
/// <summary>CycleGUI 独立窗体编辑握手点；主键展示为「站点号 + 信号类型」。</summary>
[MethodMember(Name = "打开握手点列表", Description = "按站点配置 JGControl / PointControl / TimedCharging / RateFlowControl")]
public void OpenHandshakePoints()
{
@@ -156,6 +242,7 @@ namespace StandardScene.Signal
}
}
/// <summary>CycleGUI 独立窗体编辑放行点；主键为站点号。</summary>
[MethodMember(Name = "打开放行点列表", Description = "按 ReleasePointModel 增删改放行点")]
public void OpenReleasePoints()
{
@@ -170,6 +257,10 @@ namespace StandardScene.Signal
}
}
/// <summary>
/// 扫车 Handler 用机构名查找运行态。返回拷贝列表，避免长时间持锁；
/// 运行态对象本身仍由各 Worker 持有，读写需 <see cref="PlcStationRuntime.Sync"/>。
/// </summary>
internal IReadOnlyList<PlcStationRuntime> Runtimes
{
get
@@ -179,6 +270,7 @@ namespace StandardScene.Signal
}
}
/// <summary>停旧扫车线程，按当前 JSON 新建并启动。</summary>
private void RestartScan()
{
try { _scan?.Stop(); }
@@ -191,6 +283,10 @@ namespace StandardScene.Signal
_scan.Start();
}
/// <summary>
/// 先停全部旧连接，再按机构表为每个非空名称建 <see cref="PlcStationWorker"/>。
/// 机构 Port&lt;=0 时回退进程级 <see cref="PlcPort"/>。
/// </summary>
private void RestartWorkers()
{
StopWorkers();
@@ -219,6 +315,7 @@ namespace StandardScene.Signal
PushStatus();
}
/// <summary>清空列表后再 Stop，避免扫车在停连接过程中仍拿到旧 Runtime。</summary>
private void StopWorkers()
{
List<PlcStationWorker> copy;
@@ -235,6 +332,7 @@ namespace StandardScene.Signal
}
}
/// <summary>PLC Worker 每周期回调；约每 5 次才刷一次监视面板，避免 200ms 打满 UI。</summary>
private void RefreshStatus()
{
if (Interlocked.Increment(ref _statusTick) % 5 != 0)
@@ -242,6 +340,7 @@ namespace StandardScene.Signal
PushStatus();
}
/// <summary>把各机构快照和扫车次数写进 MissionStatus，供 SimpleLite 进程监视。</summary>
private void PushStatus()
{
List<PlcStationSnapshot> snaps;
StandardScene.Signal/Model/HandshakePointModel.cs
+22 -1
View File
@@ -4,16 +4,37 @@ namespace StandardScene.Signal.Model
{
/// <summary>
/// 握手点配置。对应老地图点上的 <c>SignalStop</c>（SignalType + SignalParams）。
/// 站点 fields 若已填写同名键，优先用站点字段。
/// </summary>
/// <remarks>
/// 站点 fields 若已填写同名键，扫车优先用站点字段，本表该站点不再生效。
/// SignalParams 按分号切分，各类型格式见 <see cref="StandardScene.Signal.Logic.SignalStopSpec"/>。
/// 列表主键展示为「站点号 + 类型」，同一站点建议只配一条。
/// </remarks>
[Category("握手点数据管理")]
[DisplayName("握手点配置列表")]
public class HandshakePointModel
{
/// <summary>地图站点号，与车 PositionId（siteID / GetLastSite）对应。</summary>
[DisplayName("站点")]
public int Sit { get; set; }
/// <summary>
/// 握手类型：<c>JGControl</c> 机构进出、
/// <c>PointControl</c> 销钉升降、
/// <c>TimedCharging</c> 定时充电、
/// <c>RateFlowControl</c> 区域限流。
/// 其它字符串会每 10s 打一次「未找到业务模块」日志。
/// </summary>
[DisplayName("信号类型")]
public string SignalType { get; set; } = "JGControl";
/// <summary>
/// 类型参数。示例：
/// JGControl <c>上线机构1;RequestIn</c> / <c>上线机构1;Arrived</c> / 第三段限流 <c>缓存区-A-2-60,61</c>；
/// PointControl <c>UP1;下线机构1</c>；
/// TimedCharging <c>300;95;20</c>；
/// RateFlowControl <c>缓存区;A;2;60,61,62</c>。
/// </summary>
[DisplayName("信号参数")]
public string SignalParams { get; set; } = "";
}
StandardScene.Signal/Model/PlcStationModel.cs
+33 -1
View File
@@ -3,40 +3,72 @@ using System.ComponentModel;
namespace StandardScene.Signal.Model
{
/// <summary>
/// PLC 机构配置。对应反编译 <c>PLCModel</c> 的可存档字段；读写运行态不进本类。
/// PLC 机构静态配置，对应反编译 <c>PLCModel</c> 可存档字段。
/// 读写运行态（当前字节、机构内车号）在 <see cref="StandardScene.Signal.Plc.PlcStationRuntime"/>，不进本类、不进 JSON。
/// 机构名称不能重复，列表编辑器用 JgName 做主键。
/// </summary>
[Category("PLC数据管理")]
[DisplayName("PLC配置列表(机构名称不能重复)")]
public class PlcStationModel
{
/// <summary>逻辑名，握手点 SignalParams 第一段、Worker 线程名都用它。不能空、不能重复。</summary>
[DisplayName("机构名称")]
public string JgName { get; set; } = "";
/// <summary>西门子 PLC IP。</summary>
[DisplayName("机构IP")]
public string Ip { get; set; } = "127.0.0.1";
/// <summary>S7 端口。填 0 则用进程字段 PlcPort（默认 102）。</summary>
[DisplayName("端口")]
public int Port { get; set; } = 102;
/// <summary>
/// 读字节地址（PLC→调度：允许进入/离开）。
/// 支持 <c>DB1.DBB0</c> 或 Hsl 风格 <c>DB1.0</c>。空则跳过读取。
/// </summary>
[DisplayName("读地址")]
public string ReadDb { get; set; } = "";
/// <summary>
/// 写字节地址（调度→PLC：进入中/到位/离开中/已离开）。
/// Worker 会先回读再按需写入。空则跳过写和回读。
/// </summary>
[DisplayName("写地址")]
public string WriteDb { get; set; } = "";
/// <summary>
/// 心跳位地址，如 <c>DB1.DBX2.0</c>。
/// Worker 每拍读当前值再写反码，让 PLC 判断调度进程存活。空则不做心跳。
/// </summary>
[DisplayName("写心跳地址")]
public string HeartDb { get; set; } = "";
/// <summary>机构进入地标（预留，与老 PLCModel 字段对齐；上线跟车主要用 JgInContains）。</summary>
[DisplayName("机构进入地标")]
public int JgInPointId { get; set; }
/// <summary>
/// 进入过程包含的站点列表（逗号/分号/空格分隔）。
/// 上线：写字节=进入中 且车已不在此列表 → 视为到位。
/// </summary>
[DisplayName("机构进入包含地标")]
public string JgInContains { get; set; } = "";
/// <summary>
/// 机构工作地标。下线 RequestIn 用它查「机构内是否已有车」；
/// 下线/等待通行离站时，车必须停在此点才响应允许离开。
/// </summary>
[DisplayName("机构地标")]
public int JgPointId { get; set; }
/// <summary>
/// 机构占用包含的站点列表。车已不在此列表且写字节还不是已离开 → 写已离开。
/// </summary>
[DisplayName("机构包含地标")]
public string JgContains { get; set; } = "";
/// <summary>上线 / 单牵引下线 / 双牵引下线 / 等待通行，决定 AutoLeave 分支。</summary>
[DisplayName("上下机构")]
public SignalLineType LineType { get; set; } = SignalLineType.未知;
}
StandardScene.Signal/Model/PlcStationSnapshot.cs
+23 -1
View File
@@ -2,18 +2,40 @@ using System.ComponentModel;
namespace StandardScene.Signal.Model
{
/// <summary>单个机构运行态快照，供 MissionStatus / 监视面板展示。</summary>
/// <summary>
/// 单个机构运行态快照，供 MissionStatus / 监视面板展示。
/// 由 <see cref="StandardScene.Signal.Plc.PlcStationRuntime.ToSnapshot"/> 拷贝，UI 不要直接绑 Runtime。
/// </summary>
public class PlcStationSnapshot
{
/// <summary>机构逻辑名。</summary>
[DisplayName("机构")] public string JgName { get; set; } = "";
/// <summary>最近一拍 PLC 读写是否成功。</summary>
[DisplayName("连接")] public bool IsConnected { get; set; }
/// <summary>PLC→调度读字节的枚举名（允许进入 / 允许离开 / 无状态）。</summary>
[DisplayName("读信号")] public string ReadSignal { get; set; } = "";
/// <summary>调度目标写字节的枚举名。</summary>
[DisplayName("写信号")] public string WriteSignal { get; set; } = "";
/// <summary>从写地址回读到的枚举名，用于确认 PLC 是否已吃进目标值。</summary>
[DisplayName("回读写值")] public string ReadWriteSignal { get; set; } = "";
/// <summary>已报到在机构内的 AGV 号，0 表示没有。</summary>
[DisplayName("机构内车")] public int InAgvNo { get; set; }
/// <summary>已获准进入、正在往机构开的 AGV 号，0 表示没有。</summary>
[DisplayName("请求进入车")] public int RequestInAgvNo { get; set; }
/// <summary>目标写字节是否已与回读一致。</summary>
[DisplayName("写入成功")] public bool WriteSuccess { get; set; }
/// <summary>Worker 内存心跳翻转，表示线程在跑。</summary>
[DisplayName("心跳")] public bool Heart { get; set; }
/// <summary>最近一次断线或周期异常原因。</summary>
[DisplayName("最近错误")] public string LastError { get; set; } = "";
}
}
StandardScene.Signal/Model/ReleasePointModel.cs
+12 -1
View File
@@ -2,12 +2,23 @@ using System.ComponentModel;
namespace StandardScene.Signal.Model
{
/// <summary>放行点配置。对应反编译 <c>StartSignModel</c>。</summary>
/// <summary>
/// 放行点配置。对应反编译 <c>StartSignModel</c>。
/// </summary>
/// <remarks>
/// 车停在 <see cref="Sit"/> 且 <see cref="IsUse"/> 为 true 时，进程停充并启动，不读 PLC。
/// 同一站点不要同时配握手点：扫车先握手再放行，可能把还在等允许进入的车开走。
/// 站点号不能重复，列表编辑器用 Sit 做主键。
/// </remarks>
[Category("放行点数据管理")]
[DisplayName("放行点配置列表")]
public class ReleasePointModel
{
/// <summary>要自动放行的地图站点号。</summary>
[DisplayName("放行站点")]
public int Sit { get; set; }
/// <summary>false 时该条保留在 JSON 里但不生效，方便现场临时关掉某个点。</summary>
[DisplayName("启用")]
public bool IsUse { get; set; } = true;
}
StandardScene.Signal/Model/SignalEnums.cs
+35 -3
View File
@@ -1,30 +1,62 @@
namespace StandardScene.Signal.Model
{
/// <summary>PLC → 调度：读字节含义（与反编译 ENUM_READ_SIGNAL 对齐）。</summary>
/// <summary>
/// PLC → 调度：读字节含义。对齐反编译 <c>ENUM_READ_SIGNAL</c>。
/// 机构用这一个字节告诉 AGV 现在能不能进、能不能出。
/// </summary>
public enum SignalReadValue : byte
{
/// <summary>0：空闲 / 未允许。RequestIn 必须看到写字节也是无状态才放行。</summary>
无状态 = 0,
/// <summary>1：允许进入机构。扫车 RequestIn 的放行条件之一。</summary>
允许进入 = 1,
/// <summary>2：允许离开机构。下线升销钉、等待通行机构、PointControl 等会等这个值。</summary>
允许离开 = 2
}
/// <summary>调度 → PLC：写字节含义（与反编译 ENUM_WRITE_SIGNAL 对齐）。</summary>
/// <summary>
/// 调度 → PLC：写字节含义。对齐反编译 <c>ENUM_WRITE_SIGNAL</c>。
/// AGV 用这一个字节向机构汇报当前处于进站流程的哪一步。
/// </summary>
public enum SignalWriteValue : byte
{
/// <summary>0：空闲。离站清空后回到此值，下一辆才能 RequestIn。</summary>
无状态 = 0,
/// <summary>1：已获准进入、正在往机构开。RequestIn 成功时写入。</summary>
进入中 = 1,
/// <summary>2：已到达机构内地标。Arrived 或上线 AutoLeave 检测到离开进入包含区时写入。</summary>
到位 = 2,
/// <summary>3：正在离开机构。上线看到车在跑、下线/等待通行启动后写入。</summary>
离开中 = 3,
/// <summary>4：已离开包含地标。PLC 确认后调度清零写字节和车号。</summary>
已离开 = 4
}
/// <summary>机构类型（与反编译 ENUM_JGTYPE 对齐）。</summary>
/// <summary>
/// 机构类型。对齐反编译 <c>ENUM_JGTYPE</c>。
/// 决定 <see cref="StandardScene.Signal.Plc.PlcStationLogic.AutoLeave"/> 走哪套离站，以及 RequestIn 要不要查机构内是否有车。
/// </summary>
public enum SignalLineType : byte
{
/// <summary>0：未配置，AutoLeave 不处理。</summary>
未知 = 0,
/// <summary>1：上线。进站靠扫车 RequestIn/Arrived，离站跟车位自动推进到位/离开中/已离开。</summary>
上线机构 = 1,
/// <summary>2：单牵引下线。RequestIn 时若 JgPointId 上已有车则不放行；离站要升销钉1。</summary>
单牵引下线机构 = 2,
/// <summary>3：双牵引下线。同单牵引，离站还需销钉2到位。</summary>
双牵引下线机构 = 3,
/// <summary>4：等待通行。无销钉，允许离开后停充启动即可。</summary>
等待通行机构 = 4
}
}
StandardScene.Signal/Plc/PlcStationLogic.cs
+34 -1
View File
@@ -5,9 +5,17 @@ using StandardScene.Signal.Model;
namespace StandardScene.Signal.Plc
{
/// <summary>读写字节转换与四套自动离站，对齐反编译 PLCManager。</summary>
/// <summary>
/// PLC 字节含义转换，以及按机构类型自动推进离站状态机。对齐反编译 <c>PLCManager</c>。
/// </summary>
/// <remarks>
/// 由 <see cref="PlcStationWorker"/> 每 200ms 在已持有 <see cref="PlcStationRuntime.Sync"/> 时调用。
/// 写字节含义见 <see cref="SignalWriteValue"/>：无状态 → 进入中 → 到位 → 离开中 → 已离开 → 清零。
/// 「已离开」可由本侧写成功，或 PLC 回读写值变成已离开（对方清过）触发清空。
/// </remarks>
public static class PlcStationLogic
{
/// <summary>PLC 读字节 → 调度侧枚举。仅 1=允许进入、2=允许离开，其余当无状态。</summary>
public static SignalReadValue ConvertRead(byte val) => val switch
{
1 => SignalReadValue.允许进入,
@@ -15,6 +23,7 @@ namespace StandardScene.Signal.Plc
_ => SignalReadValue.无状态
};
/// <summary>PLC 写地址回读字节 → 调度侧枚举。1~4 对应进入中/到位/离开中/已离开。</summary>
public static SignalWriteValue ConvertWrite(byte val) => val switch
{
1 => SignalWriteValue.进入中,
@@ -24,6 +33,10 @@ namespace StandardScene.Signal.Plc
_ => SignalWriteValue.无状态
};
/// <summary>
/// 判断站点是否落在机构配置的包含列表里。
/// 列表支持逗号、分号、空格分隔，与 JSON 里 <c>JgInContains</c> / <c>JgContains</c> 一致。
/// </summary>
public static bool ContainsSite(string csv, int siteId)
{
if (string.IsNullOrWhiteSpace(csv) || siteId <= 0)
@@ -32,6 +45,7 @@ namespace StandardScene.Signal.Plc
.Any(s => int.TryParse(s.Trim(), out var n) && n == siteId);
}
/// <summary>按 <see cref="PlcStationModel.LineType"/> 分发四套离站逻辑；未知类型不处理。</summary>
public static void AutoLeave(PlcStationRuntime rt)
{
if (rt?.Config == null) return;
@@ -52,6 +66,10 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>
/// 离站完成：写字节清无状态、清空机构内车号。
/// 若仍挂着 RequestInAgvNo（上线途中 PLC 已报已离开），一并清掉以免卡死下一辆。
/// </summary>
private static void ClearLeft(PlcStationRuntime rt, bool fromReadback)
{
rt.WriteSignal = SignalWriteValue.无状态;
@@ -67,6 +85,12 @@ namespace StandardScene.Signal.Plc
Diagnosis.Log($"{rt.Config.JgName} 已离开，清空信号", "JGControl", true);
}
/// <summary>
/// 上线机构：进站过程由扫车 RequestIn/Arrived 启动，离站由本方法跟车位推进。
/// 进入中且车已离开 JgInContains → 视为到位；
/// 到位且车在跑 → 离开中；
/// 离开中且车已不在 JgContains → 已离开。
/// </summary>
private static void AutoLeaveUpLine(PlcStationRuntime rt)
{
if (rt.WriteSuccess && rt.WriteSignal == SignalWriteValue.已离开)
@@ -100,6 +124,11 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>
/// 下线机构：车已在机构内（InAgvNo），等允许离开后升销钉、停充、启动，写离开中；
/// 车离开 JgContains 后写已离开。
/// <paramref name="pin2"/> 为 true 时双牵引，需销钉1+2都到位。
/// </summary>
private static void AutoLeaveDownLine(PlcStationRuntime rt, bool pin2)
{
if (rt.WriteSuccess && rt.WriteSignal == SignalWriteValue.已离开)
@@ -144,6 +173,10 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>
/// 等待通行机构：无销钉，允许离开且停在 JgPointId 时停充并启动，写离开中；
/// 离开包含地标后写已离开。
/// </summary>
private static void AutoLeaveWaitSit(PlcStationRuntime rt)
{
if (rt.WriteSuccess && rt.WriteSignal == SignalWriteValue.已离开)
StandardScene.Signal/Plc/PlcStationRuntime.cs
+26 -1
View File
@@ -4,7 +4,14 @@ using StandardScene.Signal.Model;
namespace StandardScene.Signal.Plc
{
/// <summary>机构运行态。写信号赋值会清 WriteSuccess，驱动 Worker 重写 PLC。</summary>
/// <summary>
/// 单个机构的运行态（不进 JSON）。扫车线程改写目标写字节，PLC Worker 负责真正下发。
/// </summary>
/// <remarks>
/// 赋值 <see cref="WriteSignal"/> 会把 <see cref="WriteSuccess"/> 置 false，下一拍 Worker 发现
/// 目标与回读不一致就会重写 PLC。回读与目标一致后再标成功，AutoLeave 才继续往下一状态走。
/// 所有读写应在 <see cref="Sync"/> 内进行。
/// </remarks>
public sealed class PlcStationRuntime
{
private SignalWriteValue _writeSignal;
@@ -16,11 +23,13 @@ namespace StandardScene.Signal.Plc
Config = config ?? throw new ArgumentNullException(nameof(config));
}
/// <summary>本机构静态配置（IP、DB 地址、地标、机构类型）。</summary>
public PlcStationModel Config { get; }
/// <summary>扫车线程与 PLC Worker 共用运行态，写入时加此锁。</summary>
public object Sync { get; } = new object();
/// <summary>PLC→调度：允许进入 / 允许离开 / 无状态。变化时打诊断。</summary>
public SignalReadValue ReadSignal
{
get => _readSignal;
@@ -32,6 +41,9 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>
/// 调度→PLC 的目标写字节。赋值即视为尚未写成功，驱动 Worker 重写。
/// </summary>
public SignalWriteValue WriteSignal
{
get => _writeSignal;
@@ -44,6 +56,7 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>从写地址回读到的当前值，用来确认 PLC 是否已吃进目标字节。</summary>
public SignalWriteValue ReadWriteSignal
{
get => _readWriteSignal;
@@ -55,13 +68,25 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>已报到在机构内的 AGV 号；0 表示没有。Arrived / 上线自动到位 时写入。</summary>
public int InAgvNo { get; set; }
/// <summary>已获准进入、正在往机构开的 AGV 号；到位或离站清空后为 0。</summary>
public int RequestInAgvNo { get; set; }
/// <summary>最近一拍 PLC 读写是否成功。心跳或读写失败会立刻变 false。</summary>
public bool IsConnected { get; set; }
/// <summary>目标写字节是否已与 PLC 回读一致。改 WriteSignal 时自动清掉。</summary>
public bool WriteSuccess { get; set; }
/// <summary>内存侧心跳翻转标志，供监视面板看到 Worker 在跑；真正写 PLC 的是 HeartDb 位翻转。</summary>
public bool Heart { get; set; }
/// <summary>最近一次断线或周期异常原因，连接正常时清空。</summary>
public string LastError { get; set; } = "";
/// <summary>拷贝一份给 MissionStatus / 监视列表，避免 UI 直接绑运行态。</summary>
public PlcStationSnapshot ToSnapshot() => new PlcStationSnapshot
{
JgName = Config.JgName,
StandardScene.Signal/Plc/PlcStationWorker.cs
+16
View File
@@ -9,6 +9,15 @@ namespace StandardScene.Signal.Plc
/// 单机构 200ms 循环：心跳、读允许进出、回读写值、按需写入、自动离站。
/// 对齐反编译 <c>PLCManager.ExcuteThreadMethod</c>。
/// </summary>
/// <remarks>
/// 一拍顺序固定，失败则本拍标断线并 return，避免用脏数据推进状态机：
/// 1. 翻转内存心跳标志；若配置了 HeartDb，读当前位再写反码（PLC 侧看翻转判断调度活着）。
/// 2. 读 ReadDb → <see cref="PlcStationRuntime.ReadSignal"/>。
/// 3. 回读 WriteDb → ReadWriteSignal；与目标 WriteSignal 一致则 WriteSuccess=true。
/// 4. 目标与回读不一致且尚未成功时写入目标字节。
/// 5. <see cref="PlcStationLogic.AutoLeave"/>。
/// 读写均在 <see cref="PlcStationRuntime.Sync"/> 内，与扫车 Handler 互斥。
/// </remarks>
public sealed class PlcStationWorker : IDisposable
{
private readonly SiemensPlcSession _session;
@@ -16,6 +25,8 @@ namespace StandardScene.Signal.Plc
private readonly Action _onTick;
private CancellationTokenSource _cts;
private Thread _thread;
/// <summary>断线日志节流起点，避免 200ms 打满诊断。</summary>
private DateTime _lastFailLog = DateTime.MinValue;
public PlcStationWorker(PlcStationRuntime runtime, SiemensPlcSession session, int pollMs, Action onTick = null)
@@ -26,8 +37,10 @@ namespace StandardScene.Signal.Plc
_onTick = onTick;
}
/// <summary>本机构运行态，扫车线程按 JgName 查找后加 Sync 读写。</summary>
public PlcStationRuntime Runtime { get; }
/// <summary>启动后台线程。重复 Start 若仍存活则忽略。</summary>
public void Start()
{
if (_thread != null && _thread.IsAlive) return;
@@ -41,6 +54,7 @@ namespace StandardScene.Signal.Plc
Diagnosis.Log($"{Runtime.Config.JgName} Worker 已启动 → {Runtime.Config.Ip}:{Runtime.Config.Port}", "PLC", true);
}
/// <summary>取消循环、最多等 2s、关闭 S7 连接并标断线。</summary>
public void Stop()
{
try { _cts?.Cancel(); }
@@ -80,6 +94,7 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>单拍 PLC 交互。心跳地址为空则跳过心跳；读写地址为空则跳过对应步骤。</summary>
internal void Tick()
{
var cfg = Runtime.Config;
@@ -145,6 +160,7 @@ namespace StandardScene.Signal.Plc
LogFail($"{Runtime.Config.JgName} {reason}");
}
/// <summary>同一机构失败日志最少间隔 5 秒。</summary>
private void LogFail(string msg)
{
if ((DateTime.Now - _lastFailLog).TotalSeconds < 5) return;
StandardScene.Signal/Plc/SiemensPlcSession.cs
+24 -1
View File
@@ -5,9 +5,17 @@ using IoTClient.Common.Enums;
namespace StandardScene.Signal.Plc
{
/// <summary>西门子 S7 长连接。地址兼容 Hsl 的 DB1.0 与 IoTClient 的 DB1.DBB0。</summary>
/// <summary>
/// 西门子 S7 长连接封装（IoTClient）。一个机构一个实例，由对应 Worker 独占。
/// </summary>
/// <remarks>
/// 字节地址兼容老 Hsl 写法 <c>DB1.0</c> 与 IoTClient 写法 <c>DB1.DBB0</c>；
/// 心跳位地址保持原样（如 <c>DB1.DBX2.0</c>），不做 DBB 转换。
/// 连接失败时读/写返回 false，由 Worker 标断线，不在这里抛给扫车线程。
/// </remarks>
public sealed class SiemensPlcSession : IDisposable
{
/// <summary>匹配 Hsl 风格「DB块号.字节偏移」，捕获组 1=DB，2=偏移。</summary>
private static readonly Regex BareDbByte = new Regex(@"^DB(\d+)\.(\d+)$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
private readonly SiemensVersion _version;
@@ -17,6 +25,10 @@ namespace StandardScene.Signal.Plc
private SiemensClient _client;
private readonly object _sync = new object();
/// <param name="version">进程字段 PlcVersion，如 S7_1500。</param>
/// <param name="ip">机构 IP。</param>
/// <param name="port">S7 端口，通常 102。</param>
/// <param name="slot">机架槽号，S7-1500 常见 1。</param>
public SiemensPlcSession(string version, string ip, int port, int slot)
{
_version = ParseVersion(version);
@@ -25,6 +37,7 @@ namespace StandardScene.Signal.Plc
_slot = (byte)Math.Max(0, slot);
}
/// <summary>当前客户端是否已 Open 成功。未创建客户端时为 false。</summary>
public bool Connected
{
get
@@ -33,6 +46,7 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>惰性创建客户端并 Open。已连接则直接 true；失败返回 false 不抛。</summary>
public bool EnsureOpen()
{
lock (_sync)
@@ -53,6 +67,7 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>读一字节。地址会先规范化；未连接或失败时 value=0 且返回 false。</summary>
public bool TryReadByte(string address, out byte value)
{
value = 0;
@@ -72,6 +87,7 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>写一字节（进入中/到位等）。失败返回 false。</summary>
public bool TryWriteByte(string address, byte value)
{
if (string.IsNullOrWhiteSpace(address) || !EnsureOpen())
@@ -87,6 +103,7 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>读心跳位。地址不做 DBB 转换。</summary>
public bool TryReadBool(string address, out bool value)
{
value = false;
@@ -106,6 +123,7 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>写心跳位（通常写当前值的反码，让 PLC 看到翻转）。</summary>
public bool TryWriteBool(string address, bool value)
{
if (string.IsNullOrWhiteSpace(address) || !EnsureOpen())
@@ -121,6 +139,7 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>关闭并丢弃客户端，下次 EnsureOpen 会新建。</summary>
public void Close()
{
lock (_sync)
@@ -133,6 +152,9 @@ namespace StandardScene.Signal.Plc
public void Dispose() => Close();
/// <summary>
/// <c>DB1.0</c> → <c>DB1.DBB0</c>；已是 DBB/DBW/DBX 的地址原样返回。
/// </summary>
internal static string NormalizeByteAddress(string address)
{
var addr = address.Trim();
@@ -140,6 +162,7 @@ namespace StandardScene.Signal.Plc
return m.Success ? $"DB{m.Groups[1].Value}.DBB{m.Groups[2].Value}" : addr;
}
/// <summary>空或无法解析时默认 S7_1500。允许把 S7-1500 写成带连字符。</summary>
internal static SiemensVersion ParseVersion(string version)
{
if (string.IsNullOrWhiteSpace(version))
StandardScene.Signal/Plc/SignalCarAdapter.cs
+48 -3
View File
@@ -12,11 +12,16 @@ using StandardScene.Signal.Site;
namespace StandardScene.Signal.Plc
{
/// <summary>
/// 不引用 Magnetic.dll：按方法名反射 Start/Stop/牵引棒。
/// MagCar / Mag2Car 有对应 MethodMember 时生效；没有则视为动作已完成。
/// 信号插件访问 AGV / 站点的适配层。不引用 Magnetic.dll，按方法名反射启停和牵引棒。
/// </summary>
/// <remarks>
/// MagCar / Mag2Car 上有对应 MethodMember（StartMag2Car、SetPin1Up 等）时生效；
/// 没有 <c>IsActionFinish</c> 则视为动作已完成，避免非磁导航车卡在销钉等待。
/// 启停回退顺序：StartMag2Car / StartMagCar → SendStart(0)。
/// </remarks>
public static class SignalCarAdapter
{
/// <summary>当前内核里的全部车；SimpleLib 异常时返回空，避免扫车线程崩掉。</summary>
public static IEnumerable<Car> All()
{
try
@@ -29,12 +34,17 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>按车号取车；id≤0 返回 null。</summary>
public static Car Find(int id)
{
if (id <= 0) return null;
return SimpleLib.GetCar(id) as Car;
}
/// <summary>
/// 当前站点：优先 <c>siteID</c>，否则 <c>GetLastSite()</c>。
/// 握手 / 放行 / 限流都用这个号去对 JSON 里的 Sit。
/// </summary>
public static int PositionId(Car car)
{
if (car == null) return 0;
@@ -50,6 +60,7 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>读车 status.enums["State"]，没有则空串。</summary>
public static string GetState(Car car)
{
if (car?.status?.enums != null &&
@@ -59,6 +70,7 @@ namespace StandardScene.Signal.Plc
return "";
}
/// <summary>State 为「运行中」或 Running。</summary>
public static bool IsMoving(Car car)
{
var state = GetState(car);
@@ -66,7 +78,10 @@ namespace StandardScene.Signal.Plc
string.Equals(state, "Running", StringComparison.OrdinalIgnoreCase);
}
/// <summary>对齐反编译 RunStatus==停止：非运行中即视为停稳，含充电中。</summary>
/// <summary>
/// 对齐反编译 <c>RunStatus==停止</c>：非运行中即视为可握手，含充电中 / 停止中 / WaitPass。
/// 充电点必须把「充电中」算停稳，否则 TimedCharging 不会进 Handler。
/// </summary>
public static bool IsStopped(Car car)
{
if (car == null) return false;
@@ -80,6 +95,7 @@ namespace StandardScene.Signal.Plc
return !IsRunning(car);
}
/// <summary>正在充电（中英文 State）。</summary>
public static bool IsCharging(Car car)
{
var state = GetState(car);
@@ -87,6 +103,10 @@ namespace StandardScene.Signal.Plc
string.Equals(state, "Charging", StringComparison.OrdinalIgnoreCase);
}
/// <summary>
/// 车仍占资源：运行中，或有 pendingLocks，或 tags 含 occupied。
/// 上线机构「到位后开始离开」用这个判断，比单纯看 State 更早切到离开中。
/// </summary>
public static bool IsRunning(Car car)
{
if (car == null) return false;
@@ -98,6 +118,7 @@ namespace StandardScene.Signal.Plc
return false;
}
/// <summary>电量百分比，读 enums["Soc"]；解析失败当 0。</summary>
public static double Soc(Car car)
{
if (car?.status?.enums != null &&
@@ -107,6 +128,7 @@ namespace StandardScene.Signal.Plc
return 0;
}
/// <summary>限流用的车组：fields["group"] 或 ["GroupID"]。</summary>
public static string GroupId(Car car)
{
if (car?.fields == null) return "";
@@ -117,6 +139,7 @@ namespace StandardScene.Signal.Plc
return "";
}
/// <summary>当前停在给定站点集合上的全部车（按 PositionId）。</summary>
public static IReadOnlyList<Car> CarsAt(IEnumerable<int> siteIds)
{
var set = new HashSet<int>(siteIds ?? Array.Empty<int>());
@@ -125,12 +148,14 @@ namespace StandardScene.Signal.Plc
return All().Where(c => set.Contains(PositionId(c))).ToList();
}
/// <summary>当前停在单个站点上的车。下线 RequestIn 用 JgPointId 查机构内是否已有车。</summary>
public static IReadOnlyList<Car> CarsAt(int siteId)
{
if (siteId <= 0) return Array.Empty<Car>();
return CarsAt(new[] { siteId });
}
/// <summary>读站点 fields 指定键。站点不存在或值为空返回 false。</summary>
public static bool TryReadSiteField(int siteId, string key, out string value)
{
value = "";
@@ -152,6 +177,10 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>
/// 地图点是否自带 SignalStop（SignalType 字段存在且非空）。
/// SignalParams 可缺省。有类型则扫车不再查 handshake-points.json。
/// </summary>
public static bool TryReadSignalStop(int siteId, out string signalType, out string signalParams)
{
signalType = "";
@@ -162,6 +191,10 @@ namespace StandardScene.Signal.Plc
return true;
}
/// <summary>
/// 已充电秒数。优先反射 GetChargeTime（int/double/TimeSpan）；
/// 没有则从首次看到充电中的时刻算，离开充电态时清字典。
/// </summary>
public static int ChargeSeconds(Car car, IDictionary<int, DateTime> startedAt)
{
if (car == null) return 0;
@@ -191,6 +224,7 @@ namespace StandardScene.Signal.Plc
return 0;
}
/// <summary>放行：Mag2 → Mag → SendStart(0)。</summary>
public static void Start(Car car)
{
if (car == null) return;
@@ -199,6 +233,7 @@ namespace StandardScene.Signal.Plc
TryInvoke(car, "SendStart", new object[] { (ushort)0 });
}
/// <summary>急停：Mag2 → Mag → SendStop(0)。机构未允许进入时调用。</summary>
public static void Stop(Car car)
{
if (car == null) return;
@@ -207,12 +242,17 @@ namespace StandardScene.Signal.Plc
TryInvoke(car, "SendStop", new object[] { (ushort)0 });
}
/// <summary>停充。握手放行前通常先停充再启动。</summary>
public static void StopCharge(Car car)
{
if (car == null) return;
TryInvoke(car, "StopCharge");
}
/// <summary>
/// 销钉/停充等动作是否完成。车类型没有 IsActionFinish 时返回 true（非磁导航不阻塞）。
/// 反射异常也当完成，避免把产线卡死。
/// </summary>
public static bool IsActionFinish(Car car, string action)
{
if (car == null) return false;
@@ -231,6 +271,7 @@ namespace StandardScene.Signal.Plc
}
}
/// <summary>下发动作：先按动作名直接调 MethodMember，没有再 ImmediateCommand(action)。</summary>
public static void Control(Car car, string action)
{
if (car == null || string.IsNullOrWhiteSpace(action)) return;
@@ -238,6 +279,10 @@ namespace StandardScene.Signal.Plc
TryInvoke(car, "ImmediateCommand", new object[] { action });
}
/// <summary>
/// 按名称找实例方法。无参与带参分开匹配，重载参数个数不对就跳过。
/// 调用抛错返回 false，让上层试下一个名字。
/// </summary>
private static bool TryInvoke(object target, string name, object[] args = null)
{
var type = target.GetType();
StandardScene.Signal/SignalConfigStore.cs
+17 -26
View File
@@ -6,9 +6,18 @@ using Newtonsoft.Json.Converters;
namespace StandardScene.Signal
{
/// <summary>信号插件 JSON 配置的路径解析、种子拷贝与读写。</summary>
/// <summary>
/// 信号插件三张 JSON 的路径解析与读写。
/// </summary>
/// <remarks>
/// 只使用 SimpleLite 工作目录 <c>Config/Signal/*.json</c>，不读、不拷 <c>plugins/Config/Signal</c>。
/// 文件不存在时 Load 返回空表；Save 会创建目录。
/// 迷毂数据中心走同一套文件；保存后需在本进程点「重新加载配置」。
/// 枚举按名字序列化（<see cref="StringEnumConverter"/>），与样例里 <c>"上线机构"</c> 一致。
/// </remarks>
public static class SignalConfigStore
{
/// <summary>保存时串行写盘，避免 CycleGUI 与迷毂 API 同时 Save 互相覆盖一半。</summary>
private static readonly object FileLock = new object();
private static readonly JsonSerializerSettings JsonSettings = new JsonSerializerSettings
@@ -19,8 +28,8 @@ namespace StandardScene.Signal
};
/// <summary>
/// 相对路径依次尝试：工作目录、插件目录旁的 Config。
/// 工作目录文件不存在时，若插件目录有样例则拷过去。
/// 相对路径固定落到工作目录（SimpleLite.exe 所在目录）下的 <c>Config/Signal</c>。
/// 已是绝对路径则原样返回。文件不存在也返回该路径，不回退插件目录。
/// </summary>
public static string Resolve(string configuredPath)
{
@@ -30,31 +39,12 @@ namespace StandardScene.Signal
if (Path.IsPathRooted(configuredPath))
return configuredPath;
var working = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, configuredPath);
if (File.Exists(working))
return working;
var sample = Path.Combine(
Path.GetDirectoryName(typeof(SignalConfigStore).Assembly.Location) ?? "",
configuredPath);
if (File.Exists(sample))
{
try
{
var dir = Path.GetDirectoryName(working);
if (!string.IsNullOrEmpty(dir))
Directory.CreateDirectory(dir);
File.Copy(sample, working, overwrite: false);
}
catch
{
return File.Exists(working) ? working : sample;
}
}
return working;
return Path.Combine(AppDomain.CurrentDomain.BaseDirectory, configuredPath);
}
/// <summary>
/// 反序列化为列表。文件不存在、空、或 JSON 损坏时返回空列表，不抛给启动流程。
/// </summary>
public static List<T> Load<T>(string path) where T : class
{
try
@@ -72,6 +62,7 @@ namespace StandardScene.Signal
}
}
/// <summary>缩进写入；自动建目录。与 Load 共用枚举按名序列化。</summary>
public static void Save<T>(string path, IReadOnlyList<T> items)
{
var json = JsonConvert.SerializeObject(items ?? Array.Empty<T>(), JsonSettings);
StandardScene.Signal/Site/SignalSiteFields.cs
+9 -2
View File
@@ -1,12 +1,19 @@
namespace StandardScene.Signal.Site
{
/// <summary>
/// 站点 fields 键名，替代老地图 <c>SignalStop</c>。
/// 地图编辑器若未挂字段袋，仍可手工写入这两个键；未写则回退 handshake-points.json。
/// 站点 fields 键名，替代老地图 <c>SignalStop</c> 对象。
/// </summary>
/// <remarks>
/// 地图编辑器若未挂字段袋，仍可手工在站点 fields 写入这两个键。
/// 扫车解析顺序：站点有非空 SignalType → 用地图点；否则回退 <c>handshake-points.json</c>。
/// 键名必须与迷毂/地图侧约定完全一致，改这里要同步改地图字段袋。
/// </remarks>
public static class SignalSiteFields
{
/// <summary>握手类型，取值同 <see cref="StandardScene.Signal.Model.HandshakePointModel.SignalType"/>。</summary>
public const string SignalType = "SignalType";
/// <summary>握手参数，取值同 <see cref="StandardScene.Signal.Model.HandshakePointModel.SignalParams"/>。</summary>
public const string SignalParams = "SignalParams";
}
}
StandardScene.Signal/StandardScene.Signal.csproj
+8 -1
View File
@@ -1,3 +1,9 @@
<!--
scene.signal：第三方 PLC 信号交互插件。
产物 StandardScene.Signal.dll + StandardScene.Signal.scene.json，拷到 SimpleLite/plugins。
运行时由「信号交互进程」拉起：每机构 200ms S7 轮询 + 1s 扫车握手。
Config/Signal/*.json 仅留在工程内作样例，运行时读写 SimpleLite 工作目录 Config/Signal，不部署到 plugins。
-->
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
@@ -20,7 +26,8 @@
<ItemGroup>
<None Update="StandardScene.Signal.scene.json" CopyToOutputDirectory="PreserveNewest" />
<None Update="Config\Signal\*.json" CopyToOutputDirectory="PreserveNewest" />
<!-- 样例 JSON 只留源码树，不复制到输出/plugins；运行时读写工作目录 Config/Signal -->
<None Update="Config\Signal\*.json" CopyToOutputDirectory="Never" />
</ItemGroup>
<ItemGroup>
StandardScene.Signal/Ui/ModelListPanel.cs
+14 -308
View File
@@ -1,51 +1,36 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using CycleGUI;
using Newtonsoft.Json;
using StandardScene.Utils;
namespace StandardScene.Signal.Ui
{
/// <summary>
/// 按 Model 的 <see cref="DisplayNameAttribute"/> 反射生成可增删改列表（CycleGUI）。
/// 跳过 <see cref="BrowsableAttribute.Browsable"/> = false 与 <see cref="JsonIgnoreAttribute"/>。
/// CycleGUI 独立窗口打开某一类 Model 列表（进程工具栏「打开机构/握手点/放行点列表」触发）。
/// </summary>
/// <remarks>
/// 每种 T 共用一个静态窗口：已打开则前置，关掉后下次再 DeclarePanel。
/// 真正的增删改在 <see cref="ModelTableEditor{T}"/>，保存直接写 JSON，
/// 不自动 Reload 进程内 Worker，需再到进程上点「重新加载配置」。
/// </remarks>
public static class ModelListPanel<T> where T : class, new()
{
/// <summary>当前已声明的面板；关闭或异常后置 null，允许再次 Open。</summary>
private static Panel _panel;
private static List<T> _items = new List<T>();
private static int _selected = -1;
private static string _status = "";
private static string _title = "";
private static string _path = "";
private static Func<T, string> _keySelector = _ => "";
private static readonly Dictionary<string, string> Text = new Dictionary<string, string>();
private static readonly Dictionary<string, bool> Bools = new Dictionary<string, bool>();
private static readonly Dictionary<string, int> EnumIdx = new Dictionary<string, int>();
private static PropertyInfo[] Props => _props ??= Discover();
private static PropertyInfo[] _props;
private static readonly ModelTableEditor<T> Editor = new ModelTableEditor<T>();
/// <param name="title">窗口标题。</param>
/// <param name="path">JSON 绝对路径（应先经 SignalConfigStore.Resolve）。</param>
/// <param name="keySelector">主键，添加/保存时查重（机构名、站点号等）。</param>
public static void Open(string title, string path, Func<T, string> keySelector)
{
Editor.Bind(path, keySelector ?? (_ => ""), typeof(T).Name);
if (_panel != null)
{
try { _panel.BringToFront(); return; }
catch { _panel = null; }
}
_title = title;
_path = path;
_keySelector = keySelector ?? (_ => "");
_items = SignalConfigStore.Load<T>(path);
_selected = -1;
_status = $"已加载 {_items.Count} 条 · {_path}";
ClearEditor();
var typeKey = typeof(T).Name;
var panel = GUI.DeclarePanel()
.ShowTitle(title)
.SetDefaultDocking(Panel.Docking.None)
@@ -58,291 +43,12 @@ namespace StandardScene.Signal.Ui
{
if (pb.Closing())
{
SignalConfigStore.Save(_path, _items);
panel.Exit();
_panel = null;
return;
}
var headers = Props.Select(DisplayOf).Concat(new[] { "行操作" }).ToArray();
pb.SeparatorText($"列表（{_items.Count}）");
pb.Table($"model-list-{typeKey}", headers, _items.Count, (row, i) =>
{
var item = _items[i];
foreach (var p in Props)
row.Label(FormatCell(p.GetValue(item)));
if (row.ButtonGroup(new[] { "选择" }, new[] { "选择该行" }) == 0)
{
_selected = i;
LoadEditor(item);
}
}, height: 10, enableSearch: true);
pb.SeparatorText(_selected >= 0 ? $"编辑第 {_selected + 1} 行" : "编辑（未选中则「添加」写入新行）");
DrawEditor(pb);
if (pb.Button("添加", distinct: $"ml-{typeKey}-add")) Add();
pb.SameLine(8);
if (pb.Button("保存当前行", distinct: $"ml-{typeKey}-save")) SaveRow();
pb.SameLine(8);
if (pb.Button("删除当前行", distinct: $"ml-{typeKey}-del")) ConfirmDelete();
pb.SameLine(8);
if (pb.Button("清空编辑区", distinct: $"ml-{typeKey}-clear"))
{
_selected = -1;
ClearEditor();
_status = "已清空编辑区，可添加新行";
}
if (!string.IsNullOrEmpty(_status))
{
pb.Separator();
pb.Label(_status);
}
});
}
private static PropertyInfo[] Discover()
{
return typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => p.CanRead && p.CanWrite && p.GetIndexParameters().Length == 0)
.Where(p => p.GetCustomAttribute<BrowsableAttribute>()?.Browsable != false)
.Where(p => p.GetCustomAttribute<JsonIgnoreAttribute>() == null)
.OrderBy(p => p.MetadataToken)
.ToArray();
}
private static string DisplayOf(PropertyInfo p) =>
p.GetCustomAttribute<DisplayNameAttribute>()?.DisplayName ?? p.Name;
private static string FormatCell(object value)
{
if (value == null) return "";
if (value is bool b) return b ? "是" : "否";
return Convert.ToString(value) ?? "";
}
private static void DrawEditor(PanelBuilder pb)
{
for (var i = 0; i < Props.Length; i++)
{
var p = Props[i];
var label = $"{i + 1}. {DisplayOf(p)}";
var type = p.PropertyType;
if (type == typeof(bool))
{
if (!Bools.ContainsKey(p.Name)) Bools[p.Name] = false;
var v = Bools[p.Name];
pb.CheckBox(label, ref v);
Bools[p.Name] = v;
}
else if (type.IsEnum)
{
var names = Enum.GetNames(type);
if (names.Length == 0) continue;
if (!EnumIdx.ContainsKey(p.Name)) EnumIdx[p.Name] = 0;
var idx = EnumIdx[p.Name];
if (idx < 0 || idx >= names.Length) idx = 0;
pb.DropdownBox(label, names, ref idx);
EnumIdx[p.Name] = idx;
}
else
{
if (!Text.ContainsKey(p.Name)) Text[p.Name] = "";
var (text, _) = pb.TextInput(label, Text[p.Name], alwaysReturnString: true);
Text[p.Name] = text ?? "";
}
}
}
private static void LoadEditor(T item)
{
foreach (var p in Props)
{
var value = p.GetValue(item);
if (p.PropertyType == typeof(bool))
Bools[p.Name] = value is true;
else if (p.PropertyType.IsEnum)
{
var names = Enum.GetNames(p.PropertyType);
var name = value?.ToString() ?? names.FirstOrDefault() ?? "";
var idx = Array.IndexOf(names, name);
EnumIdx[p.Name] = idx >= 0 ? idx : 0;
}
else
Text[p.Name] = value == null ? "" : Convert.ToString(value) ?? "";
}
}
private static void ClearEditor()
{
Text.Clear();
Bools.Clear();
EnumIdx.Clear();
foreach (var p in Props)
{
if (p.PropertyType == typeof(bool))
Bools[p.Name] = false;
else if (p.PropertyType.IsEnum)
EnumIdx[p.Name] = 0;
else if (p.PropertyType == typeof(int) || p.PropertyType == typeof(byte) || p.PropertyType == typeof(ushort))
Text[p.Name] = "0";
else
Text[p.Name] = DefaultText(p);
}
}
private static string DefaultText(PropertyInfo p)
{
try
{
var fresh = new T();
var v = p.GetValue(fresh);
return v == null ? "" : Convert.ToString(v) ?? "";
}
catch
{
return "";
}
}
private static bool TryBuild(out T item, out string err)
{
item = new T();
err = "";
foreach (var p in Props)
{
try
{
object boxed;
if (p.PropertyType == typeof(bool))
boxed = Bools.TryGetValue(p.Name, out var b) && b;
else if (p.PropertyType.IsEnum)
{
var names = Enum.GetNames(p.PropertyType);
var idx = EnumIdx.TryGetValue(p.Name, out var e) ? e : 0;
if (idx < 0 || idx >= names.Length) idx = 0;
boxed = Enum.Parse(p.PropertyType, names[idx]);
}
else if (p.PropertyType == typeof(int))
{
var raw = Text.TryGetValue(p.Name, out var t) ? t : "0";
if (!int.TryParse(string.IsNullOrWhiteSpace(raw) ? "0" : raw.Trim(), out var n))
{
err = $"{DisplayOf(p)} 必须是整数";
return false;
}
boxed = n;
}
else if (p.PropertyType == typeof(ushort))
{
var raw = Text.TryGetValue(p.Name, out var t) ? t : "0";
if (!ushort.TryParse(string.IsNullOrWhiteSpace(raw) ? "0" : raw.Trim(), out var n))
{
err = $"{DisplayOf(p)} 必须是 0-65535";
return false;
}
boxed = n;
}
else if (p.PropertyType == typeof(byte))
{
var raw = Text.TryGetValue(p.Name, out var t) ? t : "0";
if (!byte.TryParse(string.IsNullOrWhiteSpace(raw) ? "0" : raw.Trim(), out var n))
{
err = $"{DisplayOf(p)} 必须是 0-255";
return false;
}
boxed = n;
}
else
boxed = Text.TryGetValue(p.Name, out var s) ? s ?? "" : "";
p.SetValue(item, boxed);
}
catch (Exception ex)
{
err = $"{DisplayOf(p)} 写入失败：{ex.Message}";
return false;
}
}
var key = (_keySelector(item) ?? "").Trim();
if (string.IsNullOrEmpty(key))
{
err = "主键不能为空";
return false;
}
return true;
}
private static void Add()
{
if (!TryBuild(out var item, out var err))
{
CycleUiHelper.Alert("错误", err);
return;
}
var key = _keySelector(item);
if (_items.Any(x => string.Equals(_keySelector(x), key, StringComparison.OrdinalIgnoreCase)))
{
CycleUiHelper.Alert("错误", $"主键「{key}」已存在");
return;
}
_items.Add(item);
_selected = _items.Count - 1;
SignalConfigStore.Save(_path, _items);
_status = $"已添加 {key}";
_panel?.Repaint();
}
private static void SaveRow()
{
if (_selected < 0 || _selected >= _items.Count)
{
CycleUiHelper.Alert("提示", "请先选择要保存的行，或用「添加」写入新行");
return;
}
if (!TryBuild(out var item, out var err))
{
CycleUiHelper.Alert("错误", err);
return;
}
var key = _keySelector(item);
if (_items.Where((_, i) => i != _selected)
.Any(x => string.Equals(_keySelector(x), key, StringComparison.OrdinalIgnoreCase)))
{
CycleUiHelper.Alert("错误", $"主键「{key}」已存在");
return;
}
_items[_selected] = item;
SignalConfigStore.Save(_path, _items);
_status = $"已保存 {key}";
CycleUiHelper.Alert("提示", "保存成功");
_panel?.Repaint();
}
private static void ConfirmDelete()
{
if (_selected < 0 || _selected >= _items.Count)
{
CycleUiHelper.Alert("提示", "请先选择要删除的行");
return;
}
var key = _keySelector(_items[_selected]);
CycleUiHelper.ConfirmThen($"删除「{key}」？", () =>
{
_items.RemoveAt(_selected);
_selected = -1;
ClearEditor();
SignalConfigStore.Save(_path, _items);
_status = $"已删除 {key}";
_panel?.Repaint();
Editor.Render(pb);
});
}
}
StandardScene.Signal/Ui/ModelTableEditor.cs
+355
View File
@@ -0,0 +1,355 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using CycleGUI;
using Newtonsoft.Json;
using StandardScene.Utils;
namespace StandardScene.Signal.Ui
{
/// <summary>
/// 按 Model 的 <see cref="DisplayNameAttribute"/> 反射生成可增删改表格。
/// </summary>
/// <remarks>
/// 列顺序取属性 MetadataToken（源码声明顺序）。
/// 跳过不可写、索引器、<see cref="BrowsableAttribute"/> 为 false、<see cref="JsonIgnoreAttribute"/> 的属性。
/// 编辑区用独立字典暂存，点「添加」或「保存当前行」才反写对象并 <see cref="SignalConfigStore.Save"/>。
/// CycleGUI 控件 id 带 <c>_idPrefix</c>，三种表同时开窗时不会抢同一组控件状态。
/// </remarks>
public sealed class ModelTableEditor<T> where T : class, new()
{
private static PropertyInfo[] Props => _props ??= Discover();
private static PropertyInfo[] _props;
private List<T> _items = new List<T>();
/// <summary>-1 表示未选中，此时「保存/删除」会提示先选行，「添加」写入新行。</summary>
private int _selected = -1;
private string _status = "";
private string _path = "";
private string _idPrefix = typeof(T).Name;
private Func<T, string> _keySelector = _ => "";
/// <summary>字符串/数值编辑缓存，键为属性名。</summary>
private readonly Dictionary<string, string> _text = new Dictionary<string, string>();
private readonly Dictionary<string, bool> _bools = new Dictionary<string, bool>();
/// <summary>枚举下拉当前下标，写入时按 Enum.GetNames 转回枚举值。</summary>
private readonly Dictionary<string, int> _enumIdx = new Dictionary<string, int>();
public int Count => _items.Count;
public string Status => _status;
/// <summary>绑定 JSON 路径并立即 Reload。同一编辑器换文件时调用。</summary>
public void Bind(string path, Func<T, string> keySelector, string idPrefix)
{
_path = path ?? "";
_keySelector = keySelector ?? (_ => "");
_idPrefix = string.IsNullOrWhiteSpace(idPrefix) ? typeof(T).Name : idPrefix;
Reload();
}
/// <summary>从磁盘重读，丢弃未保存的编辑区内容。</summary>
public void Reload()
{
_items = SignalConfigStore.Load<T>(_path);
_selected = -1;
_status = $"已加载 {_items.Count} 条 · {_path}";
ClearEditor();
}
/// <summary>列表 + 编辑区 + 添加/保存/删除/清空/刷新。每帧由面板 Define 调用。</summary>
public void Render(PanelBuilder pb)
{
var headers = Props.Select(DisplayOf).Concat(new[] { "行操作" }).ToArray();
pb.SeparatorText($"列表（{_items.Count}）");
pb.Table($"dc-list-{_idPrefix}", headers, _items.Count, (row, i) =>
{
var item = _items[i];
foreach (var p in Props)
row.Label(FormatCell(p.GetValue(item)));
if (row.ButtonGroup(new[] { "选择" }, new[] { "选择该行" }) == 0)
{
_selected = i;
LoadEditor(item);
}
}, height: 10, enableSearch: true);
pb.SeparatorText(_selected >= 0 ? $"编辑第 {_selected + 1} 行" : "编辑（未选中则「添加」写入新行）");
DrawEditor(pb);
if (pb.Button("添加", distinct: $"dc-{_idPrefix}-add")) Add();
pb.SameLine(8);
if (pb.Button("保存当前行", distinct: $"dc-{_idPrefix}-save")) SaveRow();
pb.SameLine(8);
if (pb.Button("删除当前行", distinct: $"dc-{_idPrefix}-del")) ConfirmDelete();
pb.SameLine(8);
if (pb.Button("清空编辑区", distinct: $"dc-{_idPrefix}-clear"))
{
_selected = -1;
ClearEditor();
_status = "已清空编辑区，可添加新行";
}
pb.SameLine(8);
if (pb.Button("从文件刷新", distinct: $"dc-{_idPrefix}-reload"))
Reload();
if (!string.IsNullOrEmpty(_status))
{
pb.Separator();
pb.Label(_status);
}
}
/// <summary>发现可编辑列。Browsable=false 或 JsonIgnore 的运行态字段不会进表。</summary>
private static PropertyInfo[] Discover()
{
return typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => p.CanRead && p.CanWrite && p.GetIndexParameters().Length == 0)
.Where(p => p.GetCustomAttribute<BrowsableAttribute>()?.Browsable != false)
.Where(p => p.GetCustomAttribute<JsonIgnoreAttribute>() == null)
.OrderBy(p => p.MetadataToken)
.ToArray();
}
private static string DisplayOf(PropertyInfo p) =>
p.GetCustomAttribute<DisplayNameAttribute>()?.DisplayName ?? p.Name;
private static string FormatCell(object value)
{
if (value == null) return "";
if (value is bool b) return b ? "是" : "否";
return Convert.ToString(value) ?? "";
}
private void DrawEditor(PanelBuilder pb)
{
for (var i = 0; i < Props.Length; i++)
{
var p = Props[i];
var label = $"{_idPrefix}-{i + 1}. {DisplayOf(p)}";
var type = p.PropertyType;
if (type == typeof(bool))
{
if (!_bools.ContainsKey(p.Name)) _bools[p.Name] = false;
var v = _bools[p.Name];
pb.CheckBox(label, ref v);
_bools[p.Name] = v;
}
else if (type.IsEnum)
{
var names = Enum.GetNames(type);
if (names.Length == 0) continue;
if (!_enumIdx.ContainsKey(p.Name)) _enumIdx[p.Name] = 0;
var idx = _enumIdx[p.Name];
if (idx < 0 || idx >= names.Length) idx = 0;
pb.DropdownBox(label, names, ref idx);
_enumIdx[p.Name] = idx;
}
else
{
if (!_text.ContainsKey(p.Name)) _text[p.Name] = "";
var (text, _) = pb.TextInput(label, _text[p.Name], alwaysReturnString: true);
_text[p.Name] = text ?? "";
}
}
}
private void LoadEditor(T item)
{
foreach (var p in Props)
{
var value = p.GetValue(item);
if (p.PropertyType == typeof(bool))
_bools[p.Name] = value is true;
else if (p.PropertyType.IsEnum)
{
var names = Enum.GetNames(p.PropertyType);
var name = value?.ToString() ?? names.FirstOrDefault() ?? "";
var idx = Array.IndexOf(names, name);
_enumIdx[p.Name] = idx >= 0 ? idx : 0;
}
else
_text[p.Name] = value == null ? "" : Convert.ToString(value) ?? "";
}
}
private void ClearEditor()
{
_text.Clear();
_bools.Clear();
_enumIdx.Clear();
foreach (var p in Props)
{
if (p.PropertyType == typeof(bool))
_bools[p.Name] = false;
else if (p.PropertyType.IsEnum)
_enumIdx[p.Name] = 0;
else if (p.PropertyType == typeof(int) || p.PropertyType == typeof(byte) || p.PropertyType == typeof(ushort))
_text[p.Name] = "0";
else
_text[p.Name] = DefaultText(p);
}
}
private static string DefaultText(PropertyInfo p)
{
try
{
var fresh = new T();
var v = p.GetValue(fresh);
return v == null ? "" : Convert.ToString(v) ?? "";
}
catch
{
return "";
}
}
/// <summary>把编辑区打成对象。主键空、整数解析失败时返回 false 并给出中文 err。</summary>
private bool TryBuild(out T item, out string err)
{
item = new T();
err = "";
foreach (var p in Props)
{
try
{
object boxed;
if (p.PropertyType == typeof(bool))
boxed = _bools.TryGetValue(p.Name, out var b) && b;
else if (p.PropertyType.IsEnum)
{
var names = Enum.GetNames(p.PropertyType);
var idx = _enumIdx.TryGetValue(p.Name, out var e) ? e : 0;
if (idx < 0 || idx >= names.Length) idx = 0;
boxed = Enum.Parse(p.PropertyType, names[idx]);
}
else if (p.PropertyType == typeof(int))
{
var raw = _text.TryGetValue(p.Name, out var t) ? t : "0";
if (!int.TryParse(string.IsNullOrWhiteSpace(raw) ? "0" : raw.Trim(), out var n))
{
err = $"{DisplayOf(p)} 必须是整数";
return false;
}
boxed = n;
}
else if (p.PropertyType == typeof(ushort))
{
var raw = _text.TryGetValue(p.Name, out var t) ? t : "0";
if (!ushort.TryParse(string.IsNullOrWhiteSpace(raw) ? "0" : raw.Trim(), out var n))
{
err = $"{DisplayOf(p)} 必须是 0-65535";
return false;
}
boxed = n;
}
else if (p.PropertyType == typeof(byte))
{
var raw = _text.TryGetValue(p.Name, out var t) ? t : "0";
if (!byte.TryParse(string.IsNullOrWhiteSpace(raw) ? "0" : raw.Trim(), out var n))
{
err = $"{DisplayOf(p)} 必须是 0-255";
return false;
}
boxed = n;
}
else
boxed = _text.TryGetValue(p.Name, out var s) ? s ?? "" : "";
p.SetValue(item, boxed);
}
catch (Exception ex)
{
err = $"{DisplayOf(p)} 写入失败：{ex.Message}";
return false;
}
}
var key = (_keySelector(item) ?? "").Trim();
if (string.IsNullOrEmpty(key))
{
err = "主键不能为空";
return false;
}
return true;
}
/// <summary>主键已存在则拒绝。成功后立刻写盘并把选中行指到新行。</summary>
private void Add()
{
if (!TryBuild(out var item, out var err))
{
CycleUiHelper.Alert("错误", err);
return;
}
var key = _keySelector(item);
if (_items.Any(x => string.Equals(_keySelector(x), key, StringComparison.OrdinalIgnoreCase)))
{
CycleUiHelper.Alert("错误", $"主键「{key}」已存在");
return;
}
_items.Add(item);
_selected = _items.Count - 1;
SignalConfigStore.Save(_path, _items);
_status = $"已添加 {key}";
}
/// <summary>覆盖当前选中行。主键与其它行冲突则拒绝。</summary>
private void SaveRow()
{
if (_selected < 0 || _selected >= _items.Count)
{
CycleUiHelper.Alert("提示", "请先选择要保存的行，或用「添加」写入新行");
return;
}
if (!TryBuild(out var item, out var err))
{
CycleUiHelper.Alert("错误", err);
return;
}
var key = _keySelector(item);
if (_items.Where((_, i) => i != _selected)
.Any(x => string.Equals(_keySelector(x), key, StringComparison.OrdinalIgnoreCase)))
{
CycleUiHelper.Alert("错误", $"主键「{key}」已存在");
return;
}
_items[_selected] = item;
SignalConfigStore.Save(_path, _items);
_status = $"已保存 {key}";
CycleUiHelper.Alert("提示", "保存成功");
}
/// <summary>确认框通过后删除选中行并写盘。</summary>
private void ConfirmDelete()
{
if (_selected < 0 || _selected >= _items.Count)
{
CycleUiHelper.Alert("提示", "请先选择要删除的行");
return;
}
var key = _keySelector(_items[_selected]);
CycleUiHelper.ConfirmThen($"删除「{key}」？", () =>
{
_items.RemoveAt(_selected);
_selected = -1;
ClearEditor();
SignalConfigStore.Save(_path, _items);
_status = $"已删除 {key}";
});
}
}
}
_inspect_datacenter.csx
+18
View File
@@ -0,0 +1,18 @@
#r "D:\工作\stand\SimpleLite\SimpleLite.dll"
using System;
using System.Linq;
using System.Reflection;
var asm = typeof(SimpleLite.RCS.Mission).Assembly;
Console.WriteLine("asm=" + asm.FullName);
foreach (var t in asm.GetTypes().OrderBy(x => x.FullName))
{
var n = t.FullName ?? "";
if (n.IndexOf("Data", StringComparison.OrdinalIgnoreCase) >= 0
|| n.IndexOf("Json", StringComparison.OrdinalIgnoreCase) >= 0
|| n.IndexOf("Table", StringComparison.OrdinalIgnoreCase) >= 0
|| n.IndexOf("Center", StringComparison.OrdinalIgnoreCase) >= 0
|| n.IndexOf("Store", StringComparison.OrdinalIgnoreCase) >= 0
|| n.Contains("UI"))
Console.WriteLine(n);
}