1315 lines
50 KiB
C#
1315 lines
50 KiB
C#
using CapMachine.Model.CANLIN;
|
||
using CapMachine.Wpf.LinDrive;
|
||
using CapMachine.Wpf.Dtos;
|
||
using Prism.Mvvm;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Collections.ObjectModel;
|
||
using System.Diagnostics;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Text;
|
||
using System.Text.RegularExpressions;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
using System.Windows;
|
||
|
||
namespace CapMachine.Wpf.Services
|
||
{
|
||
/// <summary>
|
||
/// ZLG LIN 驱动服务（共享设备句柄）。
|
||
/// 说明：
|
||
/// - 该服务不直接持有/管理底层原生句柄，而是复用 <see cref="ZlgCanDriveService"/> 中的 <c>Driver</c>（设备级句柄与接收线程均由 Driver 统一管理）。
|
||
/// - LIN 的“调度表/循环发送”在当前实现中使用软件精确定时（<see cref="Stopwatch"/> + <see cref="SpinWait"/>）完成；
|
||
/// 与 ZLG CAN/CANFD 的硬件 <c>auto_send</c> 不同，LIN 侧没有调用硬件调度表能力。
|
||
/// - LDF 解析：此处实现了一个尽量容错的轻量解析器，用于建立“帧/信号 -> 位定义”的运行时索引，供 LIN 收发编解码使用。
|
||
/// 线程与绑定：
|
||
/// - LIN 接收回调通常来自 Driver 的接收线程；更新 WPF 绑定对象时会切换到 UI 线程（见 <see cref="UpdateSignalRtValue"/>）。
|
||
/// - CmdData / LDF 索引 / 调度表快照均通过独立锁对象保护，避免 UI 线程与后台线程并发修改引发的竞态。
|
||
/// </summary>
|
||
public sealed class ZlgLinDriveService : BindableBase
|
||
{
|
||
/// <summary>
|
||
/// LIN 信号定义（运行时索引条目）。
|
||
/// 说明：目前仅使用 StartBit/BitLength 做 bit 级读写；Factor/Offset/IsSigned 预留用于后续扩展（物理量换算）。
|
||
/// </summary>
|
||
private sealed class LinSignalDef
|
||
{
|
||
public string SignalName { get; set; } = string.Empty;
|
||
public int StartBit { get; set; }
|
||
public int BitLength { get; set; }
|
||
public bool IsSigned { get; set; }
|
||
public double Factor { get; set; } = 1;
|
||
public double Offset { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// LIN 帧定义（运行时索引条目）。
|
||
/// 说明：
|
||
/// - 同时缓存裸 FrameId（0-63）与受保护 PID（含奇偶校验位）。
|
||
/// - Signals 字典仅包含在 LDF 的 Frames 里声明且在 Signals 区能找到 bit 定义的信号。
|
||
/// </summary>
|
||
private sealed class LinFrameDef
|
||
{
|
||
public string FrameName { get; set; } = string.Empty;
|
||
public byte FrameId { get; set; }
|
||
public byte Pid { get; set; }
|
||
public int DataLen { get; set; } = 8;
|
||
public string? Publisher { get; set; }
|
||
public bool IsMasterFrame { get; set; }
|
||
public Dictionary<string, LinSignalDef> Signals { get; } = new Dictionary<string, LinSignalDef>(StringComparer.Ordinal);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 软件调度项（以 ticks 为最小单位进行精确定时）。
|
||
/// 说明：
|
||
/// - NextDueTicks/LastWarnTicks 会在调度线程中更新，因此不对外暴露，仅在调度线程内使用。
|
||
/// - PeriodTicks 是基于 <see cref="Stopwatch.Frequency"/> 换算而来，与系统时间无关，抗时间跳变。
|
||
/// </summary>
|
||
private sealed class SoftwareScheduleItem
|
||
{
|
||
public SoftwareScheduleItem(string msgName, long periodTicks)
|
||
{
|
||
MsgName = msgName;
|
||
PeriodTicks = periodTicks;
|
||
}
|
||
|
||
public string MsgName { get; }
|
||
public long PeriodTicks { get; }
|
||
public long NextDueTicks;
|
||
public long LastWarnTicks;
|
||
}
|
||
|
||
private readonly ILogService _log;
|
||
private readonly ZlgCanDriveService _zlgCanDriveService;
|
||
|
||
/// <summary>
|
||
/// LDF 索引锁：保护帧/信号定义索引与 UI 绑定模型映射（_framesByName/_framesByPid/_modelIndex 等）。
|
||
/// </summary>
|
||
private readonly object _ldfLock = new object();
|
||
|
||
/// <summary>
|
||
/// CmdData 锁：保护 <see cref="CmdData"/> 的替换与事件订阅关系，避免并发枚举/修改。
|
||
/// </summary>
|
||
private readonly object _cmdLock = new object();
|
||
|
||
/// <summary>
|
||
/// 调度锁：保护调度配置快照与调度线程的启动/停止（_scheduleCts/_scheduleTask/_scheduleRunning）。
|
||
/// </summary>
|
||
private readonly object _scheduleLock = new object();
|
||
|
||
/// <summary>
|
||
/// 帧名 -> 帧定义索引（用于发送：按 MsgName 找到 PID/信号位定义）。
|
||
/// </summary>
|
||
private Dictionary<string, LinFrameDef> _framesByName = new Dictionary<string, LinFrameDef>(StringComparer.Ordinal);
|
||
|
||
/// <summary>
|
||
/// PID/ID -> 帧定义索引（用于接收：按 pid/6bit id 回查帧定义并解码信号）。
|
||
/// </summary>
|
||
private Dictionary<byte, LinFrameDef> _framesByPid = new Dictionary<byte, LinFrameDef>();
|
||
|
||
/// <summary>
|
||
/// “帧名+信号名” -> UI 模型索引，用于接收线程快速定位绑定对象并更新实时值。
|
||
/// </summary>
|
||
private Dictionary<string, LinLdfModel> _modelIndex = new Dictionary<string, LinLdfModel>(StringComparer.Ordinal);
|
||
|
||
/// <summary>
|
||
/// 未知 PID 的日志节流表：避免接收线程在 LDF 缺失时刷屏。
|
||
/// </summary>
|
||
private readonly Dictionary<byte, long> _unknownPidLastLogTicks = new Dictionary<byte, long>();
|
||
|
||
/// <summary>
|
||
/// 调度取消源（置空表示未运行）。
|
||
/// </summary>
|
||
private CancellationTokenSource? _scheduleCts;
|
||
|
||
/// <summary>
|
||
/// 调度后台任务（LongRunning）。
|
||
/// </summary>
|
||
private Task? _scheduleTask;
|
||
|
||
/// <summary>
|
||
/// 调度运行标记（与 _scheduleCts 配合；主要用于可读性与状态表达）。
|
||
/// </summary>
|
||
private bool _scheduleRunning;
|
||
|
||
/// <summary>
|
||
/// LIN 调度表 DTO 缓存（由 ViewModel/上层写入；启动调度时会取快照）。
|
||
/// </summary>
|
||
private List<LINScheduleConfigDto> _linScheduleConfigs = new List<LINScheduleConfigDto>();
|
||
|
||
/// <summary>
|
||
/// 当前选中的配置程序（沿用原有 FreeSql 模型）。
|
||
/// </summary>
|
||
public CanLinConfigPro? SelectedCanLinConfigPro { get; set; }
|
||
|
||
private bool _openState;
|
||
/// <summary>
|
||
/// LIN 打开状态。
|
||
/// </summary>
|
||
public bool OpenState
|
||
{
|
||
get { return _openState; }
|
||
private set { _openState = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 解析 LDF 文本，提取 Frames/Signals/Nodes（Master）信息。
|
||
/// 说明：这是一个轻量解析器：
|
||
/// - 目标是构建“帧-信号位定义”的索引，并支持 UI 展示；
|
||
/// - 不追求覆盖所有 LDF 语法，仅尽量兼容常见格式。
|
||
/// </summary>
|
||
/// <param name="ldfText">LDF 原始文本（建议已剔除注释）。</param>
|
||
/// <returns>Frames 列表、Signals 位定义字典、Master 节点名（可能为空）。</returns>
|
||
private static (List<(string FrameName, int FrameId, int DataLen, string? Publisher, List<string> Signals)>, Dictionary<string, (int StartBit, int BitLen)>, string? MasterNodeName) ParseLdf(string ldfText)
|
||
{
|
||
var master = TryExtractMasterNodeName(ldfText);
|
||
|
||
var framesBlock = TryExtractNamedBlock(ldfText, "Frames");
|
||
var signalsBlock = TryExtractNamedBlock(ldfText, "Signals");
|
||
|
||
var signals = ParseSignalsBlock(signalsBlock);
|
||
var frames = ParseFramesBlock(framesBlock);
|
||
return (frames, signals, master);
|
||
}
|
||
|
||
private static string? TryExtractMasterNodeName(string ldfText)
|
||
{
|
||
var nodesBlock = TryExtractNamedBlock(ldfText, "Nodes");
|
||
if (string.IsNullOrWhiteSpace(nodesBlock)) return null;
|
||
|
||
// 常见格式：Master: MasterName;
|
||
var m = Regex.Match(nodesBlock, @"(?im)^\s*Master\s*:\s*(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*;", RegexOptions.Compiled);
|
||
if (m.Success)
|
||
{
|
||
return m.Groups["name"].Value;
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
private static Dictionary<string, (int StartBit, int BitLen)> ParseSignalsBlock(string? signalsBlock)
|
||
{
|
||
var dict = new Dictionary<string, (int StartBit, int BitLen)>(StringComparer.Ordinal);
|
||
if (string.IsNullOrWhiteSpace(signalsBlock))
|
||
{
|
||
return dict;
|
||
}
|
||
|
||
// 兼容常见格式：SigName: 0, 8;
|
||
var sigRegex = new Regex(@"(?im)^\s*(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*:\s*(?<start>\d+)\s*,\s*(?<len>\d+)", RegexOptions.Compiled);
|
||
foreach (Match m in sigRegex.Matches(signalsBlock))
|
||
{
|
||
var name = m.Groups["name"].Value;
|
||
if (string.IsNullOrWhiteSpace(name))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!int.TryParse(m.Groups["start"].Value, out var startBit))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!int.TryParse(m.Groups["len"].Value, out var bitLen))
|
||
{
|
||
bitLen = 1;
|
||
}
|
||
|
||
if (bitLen <= 0)
|
||
{
|
||
bitLen = 1;
|
||
}
|
||
|
||
dict[name] = (startBit, bitLen);
|
||
}
|
||
|
||
return dict;
|
||
}
|
||
|
||
private static List<(string FrameName, int FrameId, int DataLen, string? Publisher, List<string> Signals)> ParseFramesBlock(string? framesBlock)
|
||
{
|
||
var list = new List<(string FrameName, int FrameId, int DataLen, string? Publisher, List<string> Signals)>();
|
||
if (string.IsNullOrWhiteSpace(framesBlock))
|
||
{
|
||
return list;
|
||
}
|
||
|
||
// 常见格式：FrameName : 0x10, Publisher, 8 { SigA, SigB };
|
||
var frameRegex = new Regex(@"(?s)(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*:\s*(?<id>0x[0-9A-Fa-f]+|\d+)\s*,\s*(?<pub>[A-Za-z_][A-Za-z0-9_]*)\s*,\s*(?<len>\d+)\s*\{(?<body>.*?)\}\s*;?", RegexOptions.Compiled);
|
||
var sigRegex = new Regex(@"(?m)^[\s\t]*(?<sig>[A-Za-z_][A-Za-z0-9_]*)\s*[,;]", RegexOptions.Compiled);
|
||
|
||
foreach (Match fm in frameRegex.Matches(framesBlock))
|
||
{
|
||
var frameName = fm.Groups["name"].Value;
|
||
var idText = fm.Groups["id"].Value;
|
||
var pub = fm.Groups["pub"].Value;
|
||
var lenText = fm.Groups["len"].Value;
|
||
var body = fm.Groups["body"].Value;
|
||
|
||
if (string.IsNullOrWhiteSpace(frameName) || string.IsNullOrWhiteSpace(idText) || string.IsNullOrWhiteSpace(lenText))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!TryParseIntAuto(idText, out var frameId))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!int.TryParse(lenText, out var dataLen))
|
||
{
|
||
dataLen = 8;
|
||
}
|
||
|
||
dataLen = Math.Max(1, Math.Min(8, dataLen));
|
||
|
||
var sigs = new List<string>();
|
||
foreach (Match sm in sigRegex.Matches(body))
|
||
{
|
||
var sigName = sm.Groups["sig"].Value;
|
||
if (string.IsNullOrWhiteSpace(sigName))
|
||
{
|
||
continue;
|
||
}
|
||
if (IsReservedKeyword(sigName))
|
||
{
|
||
continue;
|
||
}
|
||
sigs.Add(sigName);
|
||
}
|
||
|
||
list.Add((frameName, frameId, dataLen, string.IsNullOrWhiteSpace(pub) ? null : pub, sigs));
|
||
}
|
||
|
||
// 兜底：若正则未匹配到帧（格式差异），退回到只提取 frameName 与 signals
|
||
if (list.Count == 0)
|
||
{
|
||
var fallbackFrameRegex = new Regex(@"(?s)(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*:\s*.*?\{(?<body>.*?)\}\s*;?", RegexOptions.Compiled);
|
||
foreach (Match fm in fallbackFrameRegex.Matches(framesBlock))
|
||
{
|
||
var frameName = fm.Groups["name"].Value;
|
||
var body = fm.Groups["body"].Value;
|
||
if (string.IsNullOrWhiteSpace(frameName) || string.IsNullOrWhiteSpace(body))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
var sigs = new List<string>();
|
||
foreach (Match sm in sigRegex.Matches(body))
|
||
{
|
||
var sigName = sm.Groups["sig"].Value;
|
||
if (string.IsNullOrWhiteSpace(sigName))
|
||
{
|
||
continue;
|
||
}
|
||
if (IsReservedKeyword(sigName))
|
||
{
|
||
continue;
|
||
}
|
||
sigs.Add(sigName);
|
||
}
|
||
|
||
list.Add((frameName, 0, 8, null, sigs));
|
||
}
|
||
}
|
||
|
||
return list;
|
||
}
|
||
|
||
private static bool TryParseIntAuto(string s, out int value)
|
||
{
|
||
s = s.Trim();
|
||
if (s.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
return int.TryParse(s.Substring(2), System.Globalization.NumberStyles.HexNumber, null, out value);
|
||
}
|
||
return int.TryParse(s, out value);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 基于解析结果构建运行时索引：
|
||
/// - _framesByName/_framesByPid：用于发送与接收定位帧定义；
|
||
/// - ListLinLdfModel/_modelIndex：用于 UI 展示与实时值更新。
|
||
/// </summary>
|
||
/// <param name="frames">帧定义集合。</param>
|
||
/// <param name="signals">信号位定义字典。</param>
|
||
/// <param name="masterNodeName">Master 节点名（可能为空）。</param>
|
||
private void BuildRuntimeIndex(
|
||
List<(string FrameName, int FrameId, int DataLen, string? Publisher, List<string> Signals)> frames,
|
||
Dictionary<string, (int StartBit, int BitLen)> signals,
|
||
string? masterNodeName)
|
||
{
|
||
lock (_ldfLock)
|
||
{
|
||
_framesByName = new Dictionary<string, LinFrameDef>(StringComparer.Ordinal);
|
||
_framesByPid = new Dictionary<byte, LinFrameDef>();
|
||
_unknownPidLastLogTicks.Clear();
|
||
|
||
foreach (var f in frames)
|
||
{
|
||
var pid = BuildProtectedId((byte)f.FrameId);
|
||
var isMasterFrame = !string.IsNullOrWhiteSpace(masterNodeName) && string.Equals(f.Publisher, masterNodeName, StringComparison.Ordinal);
|
||
var frame = new LinFrameDef
|
||
{
|
||
FrameName = f.FrameName,
|
||
FrameId = (byte)f.FrameId,
|
||
Pid = pid,
|
||
DataLen = f.DataLen,
|
||
Publisher = f.Publisher,
|
||
IsMasterFrame = isMasterFrame,
|
||
};
|
||
|
||
foreach (var sigName in f.Signals)
|
||
{
|
||
if (!signals.TryGetValue(sigName, out var def))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
frame.Signals[sigName] = new LinSignalDef
|
||
{
|
||
SignalName = sigName,
|
||
StartBit = def.StartBit,
|
||
BitLength = def.BitLen,
|
||
IsSigned = false,
|
||
Factor = 1,
|
||
Offset = 0,
|
||
};
|
||
}
|
||
|
||
_framesByName[frame.FrameName] = frame;
|
||
// 兼容：
|
||
// - 有些设备/固件回传 pid 为“受保护 PID（含奇偶校验位）”
|
||
// - 有些回传 pid 为“裸 ID（0-63，仅 6bit）”
|
||
// 因此两种 key 都建立索引，确保接收解码稳定。
|
||
_framesByPid[frame.Pid] = frame;
|
||
_framesByPid[(byte)(frame.FrameId & 0x3F)] = frame;
|
||
}
|
||
|
||
ListLinLdfModel.Clear();
|
||
_modelIndex = new Dictionary<string, LinLdfModel>(StringComparer.Ordinal);
|
||
|
||
foreach (var frame in _framesByName.Values.OrderBy(a => a.FrameName, StringComparer.Ordinal))
|
||
{
|
||
foreach (var sig in frame.Signals.Values.OrderBy(a => a.SignalName, StringComparer.Ordinal))
|
||
{
|
||
var model = new LinLdfModel
|
||
{
|
||
MsgName = frame.FrameName,
|
||
SignalName = sig.SignalName,
|
||
Publisher = frame.Publisher,
|
||
IsMasterFrame = frame.IsMasterFrame ? "是" : "否",
|
||
SignalDesc = null,
|
||
SignalUnit = null,
|
||
Name = null,
|
||
IsSeletedInfo = 0,
|
||
};
|
||
ListLinLdfModel.Add(model);
|
||
_modelIndex[BuildMsgSigKey(frame.FrameName, sig.SignalName)] = model;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 处理一帧 LIN 接收数据：按 pid 匹配帧定义，按信号位定义解码并更新 UI 实时值。
|
||
/// 说明：
|
||
/// - 该方法可能在 Driver 的接收线程中被调用；
|
||
/// - 不做阻塞操作（如 IO/长时间锁持有），避免拖慢接收线程。
|
||
/// </summary>
|
||
/// <param name="frame">原始 LIN 接收帧。</param>
|
||
private void HandleLinFrame(CanDrive.ZlgCan.ZlgLinRxFrame frame)
|
||
{
|
||
if (!LdfParserState)
|
||
{
|
||
return;
|
||
}
|
||
|
||
LinFrameDef? def;
|
||
lock (_ldfLock)
|
||
{
|
||
if (!_framesByPid.TryGetValue(frame.Pid, out def))
|
||
{
|
||
// pid 可能是 6bit ID 或 8bit PID，做回退匹配
|
||
var id6 = (byte)(frame.Pid & 0x3F);
|
||
if (!_framesByPid.TryGetValue(id6, out def))
|
||
{
|
||
var pidProtected = BuildProtectedId(id6);
|
||
_framesByPid.TryGetValue(pidProtected, out def);
|
||
}
|
||
|
||
if (def == null)
|
||
{
|
||
// 节流日志：每个 pid 至少间隔 5s 输出一次，避免刷屏
|
||
var now = Environment.TickCount64;
|
||
if (!_unknownPidLastLogTicks.TryGetValue(frame.Pid, out var last) || now - last >= 5000)
|
||
{
|
||
_unknownPidLastLogTicks[frame.Pid] = now;
|
||
_log.Debug($"ZLG LIN 收到未知 PID=0x{frame.Pid:X2}（id6=0x{id6:X2}），LDF 中未找到对应帧，已忽略。DataLen={frame.Data?.Length ?? 0}。");
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (def == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var bytes = frame.Data;
|
||
foreach (var sig in def.Signals.Values)
|
||
{
|
||
// LIN 信号位序按 Intel/Little-Endian 方式读取（与现有 CmdData 写入一致）。
|
||
var raw = ReadBitsIntel(bytes, sig.StartBit, sig.BitLength, sig.IsSigned);
|
||
UpdateSignalRtValue(def.FrameName, sig.SignalName, raw.ToString());
|
||
}
|
||
}
|
||
|
||
private void UpdateSignalRtValue(string msgName, string signalName, string value)
|
||
{
|
||
var key = BuildMsgSigKey(msgName, signalName);
|
||
LinLdfModel? model;
|
||
lock (_ldfLock)
|
||
{
|
||
_modelIndex.TryGetValue(key, out model);
|
||
}
|
||
|
||
if (model == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// WPF：从接收线程更新 UI 绑定对象时，尽量切到 UI 线程。
|
||
var app = Application.Current;
|
||
if (app != null && !app.Dispatcher.CheckAccess())
|
||
{
|
||
app.Dispatcher.BeginInvoke(new Action(() => model.SignalRtValue = value));
|
||
return;
|
||
}
|
||
|
||
model.SignalRtValue = value;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 发送一帧（按当前 CmdData 聚合编码）。
|
||
/// </summary>
|
||
/// <param name="msgName">帧名。</param>
|
||
public void SendOneFrameByMsgName(string msgName)
|
||
{
|
||
if (!OpenState)
|
||
{
|
||
throw new InvalidOperationException("设备未连接，无法发送。");
|
||
}
|
||
|
||
LinFrameDef? def;
|
||
lock (_ldfLock)
|
||
{
|
||
if (!_framesByName.TryGetValue(msgName, out def))
|
||
{
|
||
throw new InvalidOperationException($"未找到帧定义：{msgName}。请先解析 LDF。");
|
||
}
|
||
}
|
||
|
||
if (def == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var data = new byte[8];
|
||
|
||
List<LinCmdData> cmds;
|
||
lock (_cmdLock)
|
||
{
|
||
cmds = CmdData.Where(a => string.Equals(a.MsgName, msgName, StringComparison.Ordinal) && !string.IsNullOrWhiteSpace(a.SignalName)).ToList();
|
||
}
|
||
|
||
foreach (var cmd in cmds)
|
||
{
|
||
if (cmd.SignalName == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!def.Signals.TryGetValue(cmd.SignalName, out var sigDef))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
var raw = ConvertPhysicalToRaw(cmd.SignalCmdValue, sigDef);
|
||
WriteBitsIntel(data, sigDef.StartBit, sigDef.BitLength, raw);
|
||
}
|
||
|
||
// LIN 发送：复用 CAN Service 中的 Driver 发送接口。
|
||
// 说明：
|
||
// - channelIndex 当前固定为 0（项目约定）。
|
||
// - dataLen 取 LDF 帧定义中的长度，避免发送多余填充字节。
|
||
_zlgCanDriveService.Driver.TransmitLin(0, def.Pid, data.AsSpan(0, def.DataLen), 0);
|
||
}
|
||
|
||
private static ulong ConvertPhysicalToRaw(double physical, LinSignalDef sigDef)
|
||
{
|
||
var v = (physical - sigDef.Offset) / (Math.Abs(sigDef.Factor) < double.Epsilon ? 1 : sigDef.Factor);
|
||
if (sigDef.IsSigned)
|
||
{
|
||
var max = (1L << (sigDef.BitLength - 1)) - 1;
|
||
var min = -(1L << (sigDef.BitLength - 1));
|
||
var val = (long)Math.Round(v);
|
||
if (val > max) val = max;
|
||
if (val < min) val = min;
|
||
unchecked
|
||
{
|
||
return (ulong)val;
|
||
}
|
||
}
|
||
|
||
var umax = sigDef.BitLength >= 64 ? ulong.MaxValue : ((1UL << sigDef.BitLength) - 1UL);
|
||
var uval = (ulong)Math.Max(0, Math.Round(v));
|
||
if (uval > umax) uval = umax;
|
||
return uval;
|
||
}
|
||
|
||
private static void WriteBitsIntel(byte[] data, int startBit, int bitLen, ulong value)
|
||
{
|
||
if (data == null || data.Length == 0) return;
|
||
if (bitLen <= 0) return;
|
||
|
||
for (int i = 0; i < bitLen; i++)
|
||
{
|
||
var bitPos = startBit + i;
|
||
var byteIndex = bitPos / 8;
|
||
var bitIndex = bitPos % 8;
|
||
if (byteIndex < 0 || byteIndex >= data.Length) break;
|
||
|
||
var mask = (byte)(1 << bitIndex);
|
||
if (((value >> i) & 0x1) == 1)
|
||
{
|
||
data[byteIndex] |= mask;
|
||
}
|
||
else
|
||
{
|
||
data[byteIndex] &= (byte)~mask;
|
||
}
|
||
}
|
||
}
|
||
|
||
private static long ReadBitsIntel(byte[] data, int startBit, int bitLen, bool isSigned)
|
||
{
|
||
if (data == null || data.Length == 0) return 0;
|
||
if (bitLen <= 0) return 0;
|
||
|
||
ulong raw = 0;
|
||
for (int i = 0; i < bitLen; i++)
|
||
{
|
||
var bitPos = startBit + i;
|
||
var byteIndex = bitPos / 8;
|
||
var bitIndex = bitPos % 8;
|
||
if (byteIndex < 0 || byteIndex >= data.Length) break;
|
||
var bit = (data[byteIndex] >> bitIndex) & 0x1;
|
||
raw |= ((ulong)bit << i);
|
||
}
|
||
|
||
if (!isSigned)
|
||
{
|
||
return (long)raw;
|
||
}
|
||
|
||
if (bitLen >= 64)
|
||
{
|
||
unchecked
|
||
{
|
||
return (long)raw;
|
||
}
|
||
}
|
||
|
||
var signBit = 1UL << (bitLen - 1);
|
||
if ((raw & signBit) == 0)
|
||
{
|
||
return (long)raw;
|
||
}
|
||
|
||
var mask = (1UL << bitLen) - 1;
|
||
var twos = (~raw + 1) & mask;
|
||
return -(long)twos;
|
||
}
|
||
|
||
private static byte BuildProtectedId(byte frameId)
|
||
{
|
||
var id = (byte)(frameId & 0x3F);
|
||
var id0 = (id >> 0) & 1;
|
||
var id1 = (id >> 1) & 1;
|
||
var id2 = (id >> 2) & 1;
|
||
var id3 = (id >> 3) & 1;
|
||
var id4 = (id >> 4) & 1;
|
||
var id5 = (id >> 5) & 1;
|
||
|
||
var p0 = (id0 ^ id1 ^ id2 ^ id4) & 1;
|
||
var p1 = (~(id1 ^ id3 ^ id4 ^ id5)) & 1;
|
||
|
||
return (byte)(id | (p0 << 6) | (p1 << 7));
|
||
}
|
||
|
||
private static string BuildMsgSigKey(string msgName, string signalName)
|
||
{
|
||
return $"{msgName}\0{signalName}";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 启动软件精确定时循环发送（按统一周期发送当前 CmdData 中出现的帧）。
|
||
/// </summary>
|
||
/// <param name="cycleMs">周期（ms）。</param>
|
||
public void StartPrecisionCycleSend(int cycleMs)
|
||
{
|
||
if (!OpenState)
|
||
{
|
||
throw new InvalidOperationException("设备未连接，无法启动循环发送。");
|
||
}
|
||
|
||
var ms = Math.Max(1, cycleMs);
|
||
List<string> msgNames;
|
||
lock (_cmdLock)
|
||
{
|
||
msgNames = CmdData.Where(a => !string.IsNullOrWhiteSpace(a.MsgName)).Select(a => a.MsgName!).Distinct(StringComparer.Ordinal).ToList();
|
||
}
|
||
|
||
if (msgNames.Count == 0)
|
||
{
|
||
throw new InvalidOperationException("CmdData 为空，无法启动循环发送。");
|
||
}
|
||
|
||
var sw = Stopwatch.StartNew();
|
||
var freq = Stopwatch.Frequency;
|
||
var periodTicks = (long)(ms * (double)freq / 1000);
|
||
if (periodTicks <= 0) periodTicks = 1;
|
||
|
||
var items = msgNames.Select(n => new SoftwareScheduleItem(n, periodTicks)).ToArray();
|
||
var now = sw.ElapsedTicks;
|
||
for (int i = 0; i < items.Length; i++)
|
||
{
|
||
items[i].NextDueTicks = now + items[i].PeriodTicks;
|
||
}
|
||
|
||
lock (_scheduleLock)
|
||
{
|
||
StopSchedule();
|
||
_scheduleRunning = true;
|
||
_scheduleCts = new CancellationTokenSource();
|
||
var token = _scheduleCts.Token;
|
||
|
||
_scheduleTask = Task.Factory.StartNew(
|
||
() => RunSoftwareScheduler(sw, items, token, freq),
|
||
token,
|
||
TaskCreationOptions.LongRunning,
|
||
TaskScheduler.Default);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 停止循环发送。
|
||
/// </summary>
|
||
public void StopSchedule()
|
||
{
|
||
lock (_scheduleLock)
|
||
{
|
||
_scheduleRunning = false;
|
||
try
|
||
{
|
||
_scheduleCts?.Cancel();
|
||
}
|
||
catch
|
||
{
|
||
// ignore
|
||
}
|
||
|
||
_scheduleCts = null;
|
||
_scheduleTask = null;
|
||
}
|
||
}
|
||
|
||
private void RunSoftwareScheduler(Stopwatch sw, SoftwareScheduleItem[] items, CancellationToken token, long frequency)
|
||
{
|
||
// 说明：
|
||
// - 采用“下一次到期 ticks”驱动调度，避免 Thread.Sleep 累积误差。
|
||
// - waitMs>5 时先 WaitOne 较长时间以降低 CPU；临近触发时用 1ms 等待+SpinWait 降低抖动。
|
||
// - 对单帧发送失败做节流告警，避免循环中刷屏。
|
||
var warnIntervalTicks = frequency * 10;
|
||
var spin = new SpinWait();
|
||
|
||
while (!token.IsCancellationRequested)
|
||
{
|
||
if (!OpenState)
|
||
{
|
||
if (token.WaitHandle.WaitOne(50))
|
||
{
|
||
break;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
var nowTicks = sw.ElapsedTicks;
|
||
long minDue = long.MaxValue;
|
||
for (var i = 0; i < items.Length; i++)
|
||
{
|
||
var d = items[i].NextDueTicks;
|
||
if (d < minDue)
|
||
{
|
||
minDue = d;
|
||
}
|
||
}
|
||
|
||
var waitTicks = minDue - nowTicks;
|
||
if (waitTicks > 0)
|
||
{
|
||
var waitMs = (int)(waitTicks * 1000 / frequency);
|
||
if (waitMs > 5)
|
||
{
|
||
var ms = Math.Min(waitMs - 1, 200);
|
||
if (token.WaitHandle.WaitOne(ms))
|
||
{
|
||
break;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (waitMs > 1)
|
||
{
|
||
if (token.WaitHandle.WaitOne(1))
|
||
{
|
||
break;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
spin.SpinOnce();
|
||
continue;
|
||
}
|
||
|
||
nowTicks = sw.ElapsedTicks;
|
||
for (var i = 0; i < items.Length; i++)
|
||
{
|
||
var it = items[i];
|
||
if (it.NextDueTicks > nowTicks)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
try
|
||
{
|
||
SendOneFrameByMsgName(it.MsgName);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var t = sw.ElapsedTicks;
|
||
if (t - it.LastWarnTicks >= warnIntervalTicks)
|
||
{
|
||
it.LastWarnTicks = t;
|
||
_log.Warn($"LIN 软件循环发送失败：{it.MsgName}，{ex.Message}");
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
// 以“上一次计划时间 + 周期”推进 next，保证周期稳定；
|
||
// 若调度发生严重滞后（next 已过期），则直接以当前时间重新对齐。
|
||
var next = it.NextDueTicks + it.PeriodTicks;
|
||
if (next <= nowTicks)
|
||
{
|
||
next = nowTicks + it.PeriodTicks;
|
||
}
|
||
it.NextDueTicks = next;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private bool _ldfParserState;
|
||
/// <summary>
|
||
/// LDF 解析状态。
|
||
/// 说明：
|
||
/// - 当 <see cref="StartLdf"/> 成功解析并建立运行时索引后为 true；
|
||
/// - 若未解析/解析失败/关闭设备则为 false。
|
||
/// - LIN 收发编解码依赖该状态（未解析时接收帧会被忽略，发送会在找不到帧定义时抛出异常）。
|
||
/// </summary>
|
||
public bool LdfParserState
|
||
{
|
||
get { return _ldfParserState; }
|
||
private set { _ldfParserState = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
/// <summary>
|
||
/// LDF 消息集合（UI 绑定）。
|
||
/// 说明：
|
||
/// - 该集合由 <see cref="StartLdf"/> 解析并构建，用于 UI 展示“帧-信号”全集与实时值；
|
||
/// - 未解析 LDF 时保持为空。
|
||
/// </summary>
|
||
public ObservableCollection<LinLdfModel> ListLinLdfModel { get; private set; } = new ObservableCollection<LinLdfModel>();
|
||
|
||
/// <summary>
|
||
/// 要发送的 LIN 指令集合（来源于配置程序+读写设置）。
|
||
/// </summary>
|
||
public List<LinCmdData> CmdData { get; } = new List<LinCmdData>();
|
||
|
||
/// <summary>
|
||
/// 是否启用调度发送（与 UI 的调度表使能语义对齐）。
|
||
/// </summary>
|
||
public bool SchEnable
|
||
{
|
||
get { return _zlgCanDriveService.Driver.SchEnable; }
|
||
set { _zlgCanDriveService.Driver.SchEnable = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 是否启用事件驱动发送。
|
||
/// </summary>
|
||
public bool IsCycleSend
|
||
{
|
||
get { return _zlgCanDriveService.Driver.IsCycleSend; }
|
||
set { _zlgCanDriveService.Driver.IsCycleSend = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 构造。
|
||
/// </summary>
|
||
/// <param name="zlgCanDriveService">共享 CAN 服务。</param>
|
||
/// <param name="logService">日志服务。</param>
|
||
public ZlgLinDriveService(ZlgCanDriveService zlgCanDriveService, ILogService logService)
|
||
{
|
||
_zlgCanDriveService = zlgCanDriveService;
|
||
_log = logService;
|
||
|
||
// 透传 CAN Service/Driver 的状态指示灯属性（用于 UI 绑定）。
|
||
_zlgCanDriveService.PropertyChanged += (_, __) =>
|
||
{
|
||
RaisePropertyChanged(nameof(IsCycleRevice));
|
||
RaisePropertyChanged(nameof(IsSendOk));
|
||
RaisePropertyChanged(nameof(IsReviceOk));
|
||
};
|
||
|
||
// 订阅 LIN 帧接收事件：回调线程由 Driver 的接收线程决定（通常为后台线程）。
|
||
_zlgCanDriveService.Driver.LinFrameReceived += frame =>
|
||
{
|
||
try
|
||
{
|
||
HandleLinFrame(frame);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_log.Warn($"ZLG LIN 接收处理异常：{ex.Message}");
|
||
}
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 是否正在循环接收（透传底层 Driver 接收线程状态）。
|
||
/// </summary>
|
||
public bool IsCycleRevice
|
||
{
|
||
get { return _zlgCanDriveService.IsCycleRevice; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 发送状态指示（短时间保持 true 后回落，透传 Driver）。
|
||
/// </summary>
|
||
public bool IsSendOk
|
||
{
|
||
get { return _zlgCanDriveService.IsSendOk; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 接收状态指示（短时间保持 true 后回落，透传 Driver）。
|
||
/// </summary>
|
||
public bool IsReviceOk
|
||
{
|
||
get { return _zlgCanDriveService.IsReviceOk; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 开关接收线程（共享设备接收线程）。
|
||
/// </summary>
|
||
/// <param name="enable">是否启用。</param>
|
||
public void SetReceiveEnabled(bool enable)
|
||
{
|
||
_zlgCanDriveService.SetReceiveEnabled(enable);
|
||
RaisePropertyChanged(nameof(IsCycleRevice));
|
||
}
|
||
|
||
/// <summary>
|
||
/// 下发调度表配置（系统层调度表，支持每帧不同周期）。
|
||
/// </summary>
|
||
/// <param name="configs">调度表配置集合。</param>
|
||
public void SetScheduleConfigs(List<LINScheduleConfigDto> configs)
|
||
{
|
||
lock (_scheduleLock)
|
||
{
|
||
// 仅缓存配置快照：真正启动调度时会再取一次快照，避免 UI 边编辑边启动导致的并发问题。
|
||
_linScheduleConfigs = configs ?? new List<LINScheduleConfigDto>();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 启动软件调度（按调度表中每帧的 Cycle 分别调度发送）。
|
||
/// 说明：ZLG LIN 当前未接入硬件调度表/auto_send，因此用软件精确定时实现。
|
||
/// </summary>
|
||
public void StartSchedule()
|
||
{
|
||
if (!OpenState)
|
||
{
|
||
throw new InvalidOperationException("设备未连接，无法启动调度发送。");
|
||
}
|
||
|
||
List<LINScheduleConfigDto> snapshot;
|
||
lock (_scheduleLock)
|
||
{
|
||
snapshot = _linScheduleConfigs?.ToList() ?? new List<LINScheduleConfigDto>();
|
||
}
|
||
|
||
// 仅使用“被激活的调度表”中的“被选中消息”
|
||
var msgItems = snapshot
|
||
.Where(a => a != null)
|
||
.Where(a => a.IsActive)
|
||
.Where(a => a.IsMsgActived)
|
||
.Where(a => !string.IsNullOrWhiteSpace(a.MsgName))
|
||
.GroupBy(a => a.MsgName!, StringComparer.Ordinal)
|
||
.Select(g =>
|
||
{
|
||
// 同一 MsgName 若出现多个周期，以最小周期为准（更安全）
|
||
var cycle = g.Select(x => x.Cycle).Where(x => x > 0).DefaultIfEmpty(100).Min();
|
||
return (MsgName: g.Key, Cycle: cycle);
|
||
})
|
||
.ToList();
|
||
|
||
if (msgItems.Count == 0)
|
||
{
|
||
throw new InvalidOperationException("调度表为空或未选择任何消息帧，无法启动调度。");
|
||
}
|
||
|
||
var sw = Stopwatch.StartNew();
|
||
var freq = Stopwatch.Frequency;
|
||
|
||
var items = msgItems
|
||
.Select(x =>
|
||
{
|
||
var ms = Math.Max(1, x.Cycle);
|
||
var ticks = (long)(ms * (double)freq / 1000);
|
||
if (ticks <= 0) ticks = 1;
|
||
return new SoftwareScheduleItem(x.MsgName, ticks);
|
||
})
|
||
.ToArray();
|
||
|
||
var now = sw.ElapsedTicks;
|
||
for (int i = 0; i < items.Length; i++)
|
||
{
|
||
items[i].NextDueTicks = now + items[i].PeriodTicks;
|
||
}
|
||
|
||
lock (_scheduleLock)
|
||
{
|
||
StopSchedule();
|
||
_scheduleRunning = true;
|
||
_scheduleCts = new CancellationTokenSource();
|
||
var token = _scheduleCts.Token;
|
||
|
||
_scheduleTask = Task.Factory.StartNew(
|
||
() => RunSoftwareScheduler(sw, items, token, freq),
|
||
token,
|
||
TaskCreationOptions.LongRunning,
|
||
TaskScheduler.Default);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设置并订阅要发送的指令集合（事件驱动）。
|
||
/// </summary>
|
||
/// <param name="cmdData">指令集合。</param>
|
||
public void LoadCmdDataToDrive(IEnumerable<LinCmdData> cmdData)
|
||
{
|
||
lock (_cmdLock)
|
||
{
|
||
if (CmdData.Count > 0)
|
||
{
|
||
foreach (var cmd in CmdData)
|
||
{
|
||
// 先退订旧对象事件，避免 UI/服务重复绑定导致“同一变化触发多次发送”。
|
||
cmd.LinCmdDataChangedHandler -= CmdData_LinCmdDataChangedHandler;
|
||
}
|
||
}
|
||
|
||
CmdData.Clear();
|
||
if (cmdData != null)
|
||
{
|
||
CmdData.AddRange(cmdData);
|
||
}
|
||
|
||
foreach (var cmd in CmdData)
|
||
{
|
||
// 订阅变化事件：用于“值变化增量发送”（由 <see cref="IsCycleSend"/> + <see cref="SchEnable"/> 共同控制）。
|
||
cmd.LinCmdDataChangedHandler += CmdData_LinCmdDataChangedHandler;
|
||
}
|
||
}
|
||
}
|
||
|
||
private void CmdData_LinCmdDataChangedHandler(object? sender, string msgName)
|
||
{
|
||
if (!OpenState)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (!IsCycleSend || !SchEnable)
|
||
{
|
||
// 语义：
|
||
// - IsCycleSend：是否允许“事件驱动发送”；
|
||
// - SchEnable：是否启用发送（与 UI 的调度表使能开关对齐）。
|
||
return;
|
||
}
|
||
|
||
if (string.IsNullOrWhiteSpace(msgName))
|
||
{
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
// 事件触发只发送当前 MsgName 对应帧，避免每次改动都全量发送。
|
||
SendOneFrameByMsgName(msgName.Trim());
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_log.Warn($"ZLG LIN 事件驱动发送失败：{msgName}，{ex.Message}");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 初始化 LIN 配置信息（目前仅缓存）。
|
||
/// </summary>
|
||
/// <param name="selectedLinConfigPro">选中的配置。</param>
|
||
public void InitLinConfig(CanLinConfigPro selectedLinConfigPro)
|
||
{
|
||
SelectedCanLinConfigPro = selectedLinConfigPro;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 打开 LIN（共享设备句柄）。
|
||
/// </summary>
|
||
/// <param name="deviceIndex">设备索引。</param>
|
||
/// <param name="baudRate">波特率。</param>
|
||
/// <param name="isMaster">是否主节点。</param>
|
||
public void StartLinDrive(uint deviceIndex, uint baudRate, bool isMaster)
|
||
{
|
||
if (OpenState)
|
||
{
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
// 先确保设备打开（不影响 CAN 后续 Init）
|
||
_zlgCanDriveService.Driver.OpenDevice(deviceIndex);
|
||
|
||
// 初始化 LIN 通道
|
||
_zlgCanDriveService.Driver.OpenAndInitLin(0, new CanDrive.ZlgCan.ZlgLinChannelOptions
|
||
{
|
||
BaudRate = baudRate,
|
||
IsMaster = isMaster,
|
||
MaxLength = 8,
|
||
ChecksumMode = 3
|
||
});
|
||
|
||
// 统一由 CAN 服务侧启动接收线程（设备级 merge 接收可以同时收 CAN/LIN）
|
||
if (!_zlgCanDriveService.Driver.IsReceiving)
|
||
{
|
||
// mergeReceive=true：走合并接收，减少线程与句柄数量（与 CAN 侧默认策略一致）。
|
||
_zlgCanDriveService.Driver.StartReceiveLoop(mergeReceive: true, bufferFrames: 200);
|
||
}
|
||
|
||
OpenState = true;
|
||
LdfParserState = false;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_log.Error($"ZLG LIN 打开失败：{ex.Message}");
|
||
OpenState = false;
|
||
throw;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 关闭 LIN（共享设备句柄下，当前实现以 CloseDevice 为准：关闭将同时关闭 CAN/LIN）。
|
||
/// </summary>
|
||
public void CloseDevice()
|
||
{
|
||
// ZLG 的通道句柄都在 Driver 内部；当前 Close 会关闭所有通道，保持与旧系统“同一时刻只有一种驱动工作”的原则一致。
|
||
_zlgCanDriveService.CloseDevice();
|
||
OpenState = false;
|
||
LdfParserState = false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 加载并解析 LDF 文件，建立“帧/信号”的运行时索引，并生成 UI 可绑定的 <see cref="LinLdfModel"/> 集合。
|
||
/// 说明：
|
||
/// - 这里使用轻量解析器解析常见 LDF 结构（Frames/Signals/Nodes），目的是满足当前项目的 LIN 编解码与 UI 展示需求。
|
||
/// - 若 LDF 格式差异较大，解析可能失败并抛出异常；调用方（通常为 ViewModel）应捕获并提示。
|
||
/// </summary>
|
||
/// <param name="path">LDF 路径。</param>
|
||
public ObservableCollection<LinLdfModel> StartLdf(string path)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(path))
|
||
{
|
||
throw new ArgumentException("LDF 路径为空", nameof(path));
|
||
}
|
||
|
||
if (!File.Exists(path))
|
||
{
|
||
throw new FileNotFoundException($"LDF 文件不存在：{path}", path);
|
||
}
|
||
|
||
try
|
||
{
|
||
// 读取文本：项目约定 UTF-8；若现场文件是 ANSI/GBK，可能需要外部统一转码。
|
||
var text = File.ReadAllText(path, Encoding.UTF8);
|
||
|
||
// 去除单行注释，简化解析
|
||
text = Regex.Replace(text, @"//.*?$", string.Empty, RegexOptions.Multiline);
|
||
|
||
// 解析并构建索引（在 _ldfLock 下更新全量索引，避免并发读到半更新状态）。
|
||
var (frames, signals, masterNodeName) = ParseLdf(text);
|
||
BuildRuntimeIndex(frames, signals, masterNodeName);
|
||
|
||
LdfParserState = true;
|
||
return ListLinLdfModel;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_log.Error($"ZLG LIN 解析 LDF 失败：{ex.Message}");
|
||
LdfParserState = false;
|
||
throw;
|
||
}
|
||
}
|
||
|
||
private static List<LinLdfModel> ParseLdfFramesAndSignals(string ldfText)
|
||
{
|
||
// 说明：此解析器只用于生成“帧-信号全集池”，不做位宽/缩放等语义解析。
|
||
// 目标：尽可能容错地从 Frames 区域提取 FrameName 与其包含的 SignalName 列表。
|
||
|
||
var framesBlock = TryExtractNamedBlock(ldfText, "Frames");
|
||
if (string.IsNullOrWhiteSpace(framesBlock))
|
||
{
|
||
return new List<LinLdfModel>();
|
||
}
|
||
|
||
var result = new List<LinLdfModel>();
|
||
var exists = new HashSet<string>(StringComparer.Ordinal);
|
||
|
||
// Frame 定义一般形式：FrameName : ... { ... }
|
||
// 这里以非贪婪匹配提取每个 Frame 的 body
|
||
var frameRegex = new Regex(@"(?s)(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*:\s*.*?\{(?<body>.*?)\}\s*;?", RegexOptions.Compiled);
|
||
var sigRegex = new Regex(@"(?m)^\s*(?<sig>[A-Za-z_][A-Za-z0-9_]*)\s*[,;]", RegexOptions.Compiled);
|
||
|
||
foreach (Match fm in frameRegex.Matches(framesBlock))
|
||
{
|
||
var frameName = fm.Groups["name"].Value;
|
||
var body = fm.Groups["body"].Value;
|
||
if (string.IsNullOrWhiteSpace(frameName) || string.IsNullOrWhiteSpace(body))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
foreach (Match sm in sigRegex.Matches(body))
|
||
{
|
||
var sigName = sm.Groups["sig"].Value;
|
||
if (string.IsNullOrWhiteSpace(sigName))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 排除明显的关键字（避免误采集）
|
||
if (IsReservedKeyword(sigName))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
var key = $"{frameName}:{sigName}";
|
||
if (!exists.Add(key))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
result.Add(new LinLdfModel
|
||
{
|
||
MsgName = frameName,
|
||
SignalName = sigName,
|
||
Name = null,
|
||
SignalDesc = null,
|
||
SignalUnit = null,
|
||
IsSeletedInfo = 0,
|
||
});
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
private static string? TryExtractNamedBlock(string text, string blockName)
|
||
{
|
||
// 提取形如：blockName { ... } 的块内容（不包含外层大括号）。
|
||
// 基于括号深度扫描，避免正则在嵌套结构上失效。
|
||
var idx = CultureInvariantIndexOf(text, blockName);
|
||
if (idx < 0) return null;
|
||
|
||
var braceIdx = text.IndexOf('{', idx);
|
||
if (braceIdx < 0) return null;
|
||
|
||
int depth = 0;
|
||
for (int i = braceIdx; i < text.Length; i++)
|
||
{
|
||
var ch = text[i];
|
||
if (ch == '{') depth++;
|
||
else if (ch == '}')
|
||
{
|
||
depth--;
|
||
if (depth == 0)
|
||
{
|
||
return text.Substring(braceIdx + 1, i - braceIdx - 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
private static int CultureInvariantIndexOf(string text, string value)
|
||
{
|
||
return text.IndexOf(value, StringComparison.OrdinalIgnoreCase);
|
||
}
|
||
|
||
private static bool IsReservedKeyword(string token)
|
||
{
|
||
// LDF 常见关键字/区块名（用于降低误匹配概率）
|
||
switch (token)
|
||
{
|
||
case "Frames":
|
||
case "Signals":
|
||
case "Signal":
|
||
case "Nodes":
|
||
case "Master":
|
||
case "Slaves":
|
||
case "Diagnostic":
|
||
case "Diagnostics":
|
||
case "Checksum":
|
||
case "Event_triggered_frames":
|
||
case "Sporadic_frames":
|
||
case "Schedule_tables":
|
||
case "Node_attributes":
|
||
case "Node_composition":
|
||
case "LIN_protocol":
|
||
case "LIN_protocol_version":
|
||
case "LIN_speed":
|
||
case "Protocol_version":
|
||
return true;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
}
|