LIN 调度表功能同步 25002

This commit is contained in:
2026-01-05 22:07:54 +08:00
parent cae76745e5
commit 427cdc5305
17 changed files with 2225 additions and 73 deletions

View File

@@ -1,4 +1,6 @@
using CapMachine.Wpf.CanDrive;
using CapMachine.Model.CANLIN;
using CapMachine.Wpf.CanDrive;
using CapMachine.Wpf.Dtos;
using CapMachine.Wpf.Services;
using ImTools;
using Microsoft.VisualBasic;
@@ -26,16 +28,19 @@ namespace CapMachine.Wpf.LinDrive
/// 设备Handles集合
/// </summary>
public Int32[] DevHandles { get; set; } = new Int32[20];
/// <summary>
/// 设备Handles
/// 设备句柄本质为设备序号的低4字节可以通过调用USB_ScanDevice函数获得
/// </summary>
public Int32 DevHandle { get; set; } = 0;
/// <summary>
/// Lin的Index
/// LIN通道索引号填0或者1若只有一个通道LIN则填0.
/// </summary>
public Byte LINIndex { get; set; } = 0;
/// <summary>
/// Lin的连接State
/// </summary>
@@ -55,22 +60,59 @@ namespace CapMachine.Wpf.LinDrive
{
ContainerProvider = containerProvider;
HighSpeedDataService = ContainerProvider.Resolve<HighSpeedDataService>();
LoggerService = ContainerProvider.Resolve<ILogService>();
//Stopwatch.Frequency表示高精度计时器每秒的计数次数ticks/秒每毫秒的ticks数 = 每秒的ticks数 ÷ 1000
TicksPerMs = Stopwatch.Frequency / 1000.0;
}
/// <summary>
/// Logger 实例
/// </summary>
public ILogService LoggerService { get; set; }
/// <summary>
/// HighSpeedDataService 实例
/// </summary>
public HighSpeedDataService HighSpeedDataService { get; set; }
/// <summary>
/// 接收优化上下文:缓存帧与信号的 StringBuilder避免循环中重复分配
/// </summary>
private class SignalReadCtx
{
public string SignalName { get; set; }
public StringBuilder SignalNameSB { get; set; }
public LinLdfModel ModelRef { get; set; }
}
private class FrameReadCtx
{
public string MsgName { get; set; }
public StringBuilder MsgNameSB { get; set; }
public bool IsMasterFrame { get; set; }
public List<SignalReadCtx> Signals { get; set; } = new List<SignalReadCtx>();
}
private List<FrameReadCtx> RecvFrameCtxs = new List<FrameReadCtx>();
// 接收缓冲池(重用,避免每轮分配)
private IntPtr RecvMsgBufferPtr = IntPtr.Zero;
private int RecvMsgBufferCapacity = 1024;
private readonly int LinMsgSize = Marshal.SizeOf(typeof(USB2LIN_EX.LIN_EX_MSG));
// 控制台调试输出开关(默认关闭,防止日志风暴)
public bool EnableConsoleDebugLog { get; set; } = false;
// 保护接收缓冲的并发锁(接收读与关闭释放之间的互斥)
private readonly object RecvBufferSync = new object();
/// <summary>
/// 开始LDF文件写入
/// </summary>
public ObservableCollection<LinLdfModel> StartLdf(string LdfPath)
{
LDF_Parser(LdfPath);
BuildRecvFrameCtxs();
return ListLinLdfModel;
}
@@ -152,6 +194,17 @@ namespace CapMachine.Wpf.LinDrive
/// </summary>
public UInt64 LDFHandle { get; set; }
/// <summary>
/// LIN波特率从LDF读取
/// </summary>
public int LINBaudRate { get; private set; }
/// <summary>
/// 当前正在适配器中运行的调度表名称(用于增量刷新)
/// 同一个时刻只能运行一个调度表
/// </summary>
public string ActiveSchName { get; private set; }
/// <summary>
/// LDF消息集合
/// 包括读取的实时值和数据
@@ -163,6 +216,36 @@ namespace CapMachine.Wpf.LinDrive
/// </summary>
public List<LinCmdData> CmdData { get; set; } = new List<LinCmdData>();
/// <summary>
/// 加载要发送的数据(订阅数据变化事件)
/// 一般是激活后才注册事件
/// </summary>
/// <param name="cmdData"></param>
public void LoadCmdDataToDrive(List<LinCmdData> cmdData)
{
// 取消订阅旧数据源事件
if (CmdData != null && CmdData.Count > 0)
{
foreach (var cmd in CmdData)
{
cmd.LinCmdDataChangedHandler -= CmdData_LinCmdDataChangedHandler;
}
}
// 设置新数据源并订阅事件
CmdData = cmdData ?? new List<LinCmdData>();
foreach (var cmd in CmdData)
{
cmd.LinCmdDataChangedHandler += CmdData_LinCmdDataChangedHandler;
}
}
/// <summary>
/// 当前激活调度表下,启用的帧/报文名称集合(来自 ListLINScheduleConfig 的 IsMsgActived
/// 为空(null) 表示不过滤,使用所有 CmdData 中的帧;非空则仅对包含在集合内的帧做信号更新与下发。
/// </summary>
private HashSet<string>? ActiveMsgNames;
/// <summary>
/// ******************【1】*********************
/// 是否存在Dll文件
@@ -240,7 +323,23 @@ namespace CapMachine.Wpf.LinDrive
//读取LDF文件信息
Console.WriteLine("ProtocolVersion = {0}", LDFParser.LDF_GetProtocolVersion(LDFHandle));
Console.WriteLine("LINSpeed = {0}", LDFParser.LDF_GetLINSpeed(LDFHandle));
LINBaudRate = LDFParser.LDF_GetLINSpeed(LDFHandle);
Console.WriteLine("LINSpeed = {0}", LINBaudRate);
// 使用LDF中的波特率初始化LIN通道主机模式
var initRet = USB2LIN_EX.LIN_EX_Init(DevHandle, LINIndex, LINBaudRate, USB2LIN_EX.LIN_EX_MASTER);
if (initRet < USB2LIN_EX.LIN_EX_SUCCESS)
{
Console.WriteLine("LIN通道初始化失败!");
LdfParserState = false;
return;
}
else
{
Console.WriteLine("LIN通道初始化成功");
// 可选:开启适配器供电以驱动从节点(若硬件支持)
try { USB2LIN_EX.LIN_EX_CtrlPowerOut(DevHandle, LINIndex, 1); } catch { }
}
//读取主机名称
StringBuilder MasterName = new StringBuilder(64);
@@ -292,10 +391,49 @@ namespace CapMachine.Wpf.LinDrive
}
}
// 构建接收优化上下文,避免每次循环 GroupBy 与临时对象分配
BuildRecvFrameCtxs();
//解析成功
LdfParserState = true;
}
/// <summary>
/// 构建接收优化上下文
/// </summary>
private void BuildRecvFrameCtxs()
{
if (ListLinLdfModel == null || ListLinLdfModel.Count == 0)
{
RecvFrameCtxs = new List<FrameReadCtx>();
return;
}
var grouped = ListLinLdfModel.GroupBy(x => x.MsgName);
var list = new List<FrameReadCtx>();
foreach (var g in grouped)
{
var first = g.First();
var frame = new FrameReadCtx
{
MsgName = g.Key,
MsgNameSB = new StringBuilder(g.Key),
IsMasterFrame = (first.IsMasterFrame != null && first.IsMasterFrame.Contains("是"))
};
foreach (var model in g)
{
frame.Signals.Add(new SignalReadCtx
{
SignalName = model.SignalName,
SignalNameSB = new StringBuilder(model.SignalName),
ModelRef = model
});
}
list.Add(frame);
}
RecvFrameCtxs = list;
}
/// <summary>
/// 发送LIN数据
@@ -343,42 +481,79 @@ namespace CapMachine.Wpf.LinDrive
await Task.Delay(ReviceCycle);
try
{
var GroupMsg = ListLinLdfModel.GroupBy(x => x.MsgName);
foreach (var itemMsg in GroupMsg)
var frames = RecvFrameCtxs;
if (frames == null || frames.Count == 0)
{
var data = itemMsg.FirstOrDefault();
//非主机发送的指令帧就可以读取数据,因为函数 LDF_ExeFrameToBus【执行帧到总线若该帧的发布者是主机那么就是主机写数据否则就是主机读数据】
//那么主机发送和读取都是同一个函数。会导致跟Master主机也会在这里执行写入导致冲突出现错误。所以做一个排出
if (data != null && !data.IsMasterFrame!.Contains("是"))
IsReviceOk = true;
continue;
}
foreach (var frame in frames)
{
// 仅对从机发布的帧执行读取
if (frame.IsMasterFrame)
continue;
// 主机读操作,读取从机返回的数据值
LDFParser.LDF_ExeFrameToBus(LDFHandle, frame.MsgNameSB, 1);
foreach (var sig in frame.Signals)
{
//主机读操作,读取从机返回的数据值
LDFParser.LDF_ExeFrameToBus(LDFHandle, new StringBuilder(itemMsg.Key), 1);
foreach (var itemSignal in itemMsg)
LDFParser.LDF_GetSignalValueStr(LDFHandle, frame.MsgNameSB, sig.SignalNameSB, ReadValueStr);
sig.ModelRef.SignalRtValueSb = ReadValueStr;
}
}
// 从适配器读取原始LIN报文并写入高速记录服务
lock (RecvBufferSync)
{
if (RecvMsgBufferPtr == IntPtr.Zero)
{
RecvMsgBufferPtr = Marshal.AllocHGlobal(LinMsgSize * RecvMsgBufferCapacity);
if (EnableConsoleDebugLog) LoggerService?.Info("申请 LIN RecvMsgBufferPtr");
}
var msgPtRead = RecvMsgBufferPtr;
int linNum = LDFParser.LDF_GetRawMsg(LDFHandle, msgPtRead, RecvMsgBufferCapacity);
if (linNum > 0)
{
for (int i = 0; i < linNum; i++)
{
//LDFParser.LDF_ExeFrameToBus(LDFHandle, new StringBuilder(itemMsg.Key), 1);
LDFParser.LDF_GetSignalValueStr(LDFHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), ReadValueStr);
itemSignal.SignalRtValueSb = ReadValueStr;
var msgPtr = (IntPtr)(msgPtRead + i * LinMsgSize);
var linMsg = (USB2LIN_EX.LIN_EX_MSG)Marshal.PtrToStructure(msgPtr, typeof(USB2LIN_EX.LIN_EX_MSG));
// 仅使用有效数据长度
int dataLen = linMsg.DataLen <= 0 ? 0 : Math.Min(linMsg.Data?.Length ?? 0, linMsg.DataLen);
string dataHex = dataLen > 0 ? BitConverter.ToString(linMsg.Data, 0, dataLen) : string.Empty;
if (EnableConsoleDebugLog)
{
Console.WriteLine($"LINMsg[{i}] PID=0x{linMsg.PID:X2} Type={linMsg.MsgType} CheckType={linMsg.CheckType} DataLen={linMsg.DataLen} Data={dataHex}");
}
// 推送到高速数据记录服务
HighSpeedDataService.AppendOrUpdateMsg(new Models.HighSpeed.CommMsg()
{
Category = "LIN",
MsgInfo = "0x" + linMsg.PID.ToString("X2"),
MsgData = dataHex,
Time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")
});
}
}
else if (linNum < 0 && EnableConsoleDebugLog)
{
Console.WriteLine("Get LIN raw data error!");
}
}
//StringBuilder ValueStr = new StringBuilder(64);
//LDFParser.LDF_ExeFrameToBus(LDFHandle, new StringBuilder("ID_DATA"), 1);
//LDFParser.LDF_GetSignalValueStr(LDFHandle, new StringBuilder("ID_DATA"), new StringBuilder("Supplier_ID"), ValueStr);
//Console.WriteLine("ID_DATA.Supplier_ID={0}", ValueStr);
//LDFParser.LDF_GetSignalValueStr(LDFHandle, new StringBuilder("ID_DATA"), new StringBuilder("Machine_ID"), ValueStr);
//Console.WriteLine("ID_DATA.Machine_ID={0}", ValueStr);
//LDFParser.LDF_GetSignalValueStr(LDFHandle, new StringBuilder("ID_DATA"), new StringBuilder("Chip_ID"), ValueStr);
//Console.WriteLine("ID_DATA.Chip_ID={0}", ValueStr);
IsReviceOk = true;
}
catch (Exception ex)
{
//LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
IsReviceOk = false;
LoggerService.Info($"{ex.Message}");
}
}
IsReviceOk = false;
});
}
@@ -454,6 +629,23 @@ namespace CapMachine.Wpf.LinDrive
}
private bool _IsReviceOk;
/// <summary>
/// 接收报文是否OK
/// </summary>
public bool IsReviceOk
{
get { return _IsReviceOk; }
set
{
if (_IsReviceOk != value)
{
RaisePropertyChanged();
_IsReviceOk = value;
}
}
}
#region
@@ -543,6 +735,8 @@ namespace CapMachine.Wpf.LinDrive
// 严重延迟,重新校准
NextExecutionTime = Stopwatcher.ElapsedTicks;
Console.WriteLine("定时发送延迟过大,重新校准时间");
LoggerService.Info("定时发送延迟过大,重新校准时间");
}
// 使用Stopwatch记录实际的执行间隔而不是DateTime
@@ -551,7 +745,6 @@ namespace CapMachine.Wpf.LinDrive
//Console.WriteLine($"--当前时间(毫秒): {DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}");
// 执行发送CAN逻辑
{
@@ -578,33 +771,39 @@ namespace CapMachine.Wpf.LinDrive
}
}
IsSendOk = true;
}
}
catch (TaskCanceledException)
{
IsSendOk = false;
// 任务被取消,正常退出
break;
}
catch (Exception ex)
{
IsSendOk = false;
Console.WriteLine($"LIN周期发送异常: {ex.Message}");
// 短暂暂停避免异常情况下CPU占用过高
await Task.Delay(10, token);
}
}
IsSendOk = false;
}
catch (Exception ex)
{
IsSendOk = false;
// 确保在任何情况下(正常退出、异常、取消)都会停止计时器
Stopwatcher.Stop();
LoggerService.Info("接收出现异常");
// 清理其他可能的资源
Console.WriteLine("LIN周期发送任务已结束资源已清理");
}
finally
{
IsSendOk = false;
// 确保在任何情况下(正常退出、异常、取消)都会停止计时器
Stopwatcher.Stop();
}
@@ -625,6 +824,372 @@ namespace CapMachine.Wpf.LinDrive
#endregion
#region
/// <summary>
/// 指令数据变化时,更新调度表的线程锁
/// </summary>
private readonly object SchUpdateLock = new object();
private bool _SchEnable;
/// <summary>
/// 调度表使能
/// </summary>
public bool SchEnable
{
get { return _SchEnable; }
set
{
_SchEnable = value;
RaisePropertyChanged();
}
}
/// <summary>
/// 定时扫描更新数据 扫描Task
/// </summary>
private static Task CycleUpdateCmdTask { get; set; }
/// <summary>
/// 定时更新时间
/// 定时更新调度表的周期
/// </summary>
private int UpdateCycle { get; set; } = 5000;
/// <summary>
/// 调度表数量
/// </summary>
public int SchCount { get; set; }
/// <summary>
/// LIN 调度表的配置信息
/// </summary>
public List<LINScheduleConfigDto> ListLINScheduleConfig { get; set; }
/// <summary>
/// 获取LIN的LINScheduleConfig
/// </summary>
/// <returns></returns>
public List<LINScheduleConfig> GetLINScheduleConfigs()
{
List<LINScheduleConfig> LINScheduleConfigs = new List<LINScheduleConfig>();
SchCount = GetSchCount();
for (int i = 0; i < SchCount; i++)
{
var SchName = GetSchName(i);
var FrameCount = GetSchFrameCount(SchName);
for (int j = 0; j < FrameCount; j++)
{
LINScheduleConfigs.Add(new LINScheduleConfig()
{
SchTabName = GetSchName(i),
SchTabIndex = i,
MsgName = GetSchFrameName(SchName, j),
MsgNameIndex = j,
Cycle = 100,
IsActive = false,
});
}
}
return LINScheduleConfigs;
}
/// <summary>
/// 获取调度的帧的信号个数
/// 消息/报文的个数
/// 一个调度表包含多个帧/消息/报文
/// </summary>
/// <returns></returns>
public int GetSchFrameCount(string SchName)
{
return LDFParser.LDF_GetSchFrameQuantity(LDFHandle, new StringBuilder(SchName));
}
/// <summary>
/// 获取调度的帧的名称
/// </summary>
/// <returns></returns>
public string GetSchFrameName(string SchName, int FrameIndex)
{
StringBuilder FrameName = new StringBuilder();
LDFParser.LDF_GetSchFrameName(LDFHandle, new StringBuilder(SchName), FrameIndex, FrameName);
return FrameName.ToString();
}
/// <summary>
/// 获取调度表数量
/// </summary>
/// <returns></returns>
public int GetSchCount()
{
SchCount = LDFParser.LDF_GetSchQuantity(LDFHandle);
return SchCount;
}
/// <summary>
/// 获取调度表数量
/// </summary>
/// <returns></returns>
public string GetSchName(int index)
{
StringBuilder pSchName = new StringBuilder();
var SchResult = LDFParser.LDF_GetSchName(LDFHandle, index, pSchName);
return pSchName.ToString();
}
Random Random = new Random();
/// <summary>
/// 开始调度表执行
/// 同一个时刻只能运行一个调度表,如果有多个调度表,只能选择一个运行,
/// ********** 如果控制指令分布在不同的调度表中需要更改LDF文件的配置把控制的报文放在同一个调度表中 **********
/// </summary>
public void StartSchedule()
{
if (LDFHandle == 0)
return;
// 1) 将要执行的调度表烧入适配器并自动运行(若不指定,则启动全部调度表)
// 优先使用 ListLINScheduleConfig 指定的调度表名;否则默认取第一个
string selectedSch = string.Empty;
if (ListLINScheduleConfig != null && ListLINScheduleConfig.Count > 0)
{
selectedSch = ListLINScheduleConfig.FirstOrDefault(a => a.IsActive && !string.IsNullOrEmpty(a.SchTabName))?.SchTabName
?? ListLINScheduleConfig.FirstOrDefault(a => !string.IsNullOrEmpty(a.SchTabName))?.SchTabName;
}
if (string.IsNullOrEmpty(selectedSch))
{
// 回退为索引0的调度表
if (GetSchCount() > 0)
{
selectedSch = GetSchName(0);
LoggerService?.Info($"未指定调度表,默认启动调度表[{selectedSch}],注意当前调度表可能需要的调度表");
}
}
//当前激活的调度表
ActiveSchName = selectedSch;
// 计算当前激活调度表下的“被选中帧”集合IsMsgActived=true
if (!string.IsNullOrEmpty(ActiveSchName) && ListLINScheduleConfig != null)
{
var actives = ListLINScheduleConfig
.Where(d => d.IsActive && d.IsMsgActived && string.Equals(d.SchTabName ?? string.Empty, ActiveSchName ?? string.Empty, StringComparison.Ordinal))
.Select(d => d.MsgName)
.Where(n => !string.IsNullOrEmpty(n))
.Distinct()
.ToList();
ActiveMsgNames = actives.Count > 0 ? new HashSet<string>(actives) : new HashSet<string>();
}
else
{
ActiveMsgNames = null; // 不过滤
}
// 2) 先将当前指令值写入对应帧(可选,用于初始化,仅对被选中的帧)
if (CmdData != null && CmdData.Count > 0)
{
var groupMsg = CmdData.GroupBy(x => x.MsgName);
foreach (var itemMsg in groupMsg)
{
// 若设置了激活的帧集合,则进行过滤
if (ActiveMsgNames != null && !ActiveMsgNames.Contains(itemMsg.Key))
continue;
foreach (var itemSignal in itemMsg)
{
LDFParser.LDF_SetSignalValue(LDFHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
}
}
}
// 3) 下发选中调度表到表格并自动执行
var ret = LDFParser.LDF_SetSchToTable(LDFHandle, new StringBuilder(ActiveSchName), 0);
if (ret < 0)
{
LoggerService?.Info($"启动调度表[{ActiveSchName}]失败, 返回:{ret}");
}
else
{
Console.WriteLine($"调度表[{ActiveSchName}]已启动(自动执行)");
LoggerService?.Info($"调度表[{ActiveSchName}]已启动(自动执行)");
}
// 4) 置位调度更新开关(事件驱动刷新,不再自动启动周期刷新任务)
//SchEnable = true;
// 不再自动启动周期更新任务,改为数据变化事件驱动刷新
// if (CycleUpdateCmdTask == null || CycleUpdateCmdTask.IsCompleted) { StartCycleUpdateCmd(); }
}
/// <summary>
/// 循环更新调度表的指令数据
/// 定时更新数据到调度表中
/// 被数值更新事件驱动的方法取代了
/// </summary>
public void StartCycleUpdateCmd()
{
CycleUpdateCmdTask = Task.Run(async () =>
{
while (IsCycleSend)
{
await Task.Delay(UpdateCycle);
try
{
if (CmdData.Count() == 0) return;
//防止有多个不同的消息名称/帧,每个帧单独处理发送
var GroupMsg = CmdData.GroupBy(x => x.MsgName);
foreach (var itemMsg in GroupMsg)
{
// 若设置了激活的帧集合,则进行过滤
if (ActiveMsgNames != null && !ActiveMsgNames.Contains(itemMsg.Key))
continue;
foreach (var itemSignal in itemMsg)
{
if (itemSignal.ConfigName.Contains("速"))
{
itemSignal.SignalCmdValue = 1250 + Random.NextDouble() * 1000;
}
//主机写操作,发送数据给从机
LDFParser.LDF_SetSignalValue(LDFHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
}
////【0】参数注意
//LDFParser.LDF_ExeFrameToBus(LDFHandle, new StringBuilder(itemMsg.Key), 0);
//读取当前的指令帧数据LDF_ExeFrameToBus执行后就可以读取本身的数据
foreach (var item in ListLinLdfModel)
{
if (CmdData.Any(a => a.MsgName == item.MsgName)
&& (ActiveMsgNames == null || ActiveMsgNames.Contains(item.MsgName)))
{
LDFParser.LDF_GetSignalValueStr(LDFHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ReadValueStr);
item.SignalRtValueSb = ReadValueStr;
}
}
// 调度表已在适配器中自动执行,这里仅更新信号值即可
}
// 将更新后的信号值下发到适配器的自动调度表(刷新离线表的数据)
if (!string.IsNullOrEmpty(ActiveSchName))
{
var retPush = LDFParser.LDF_SetSchToTable(LDFHandle, new StringBuilder(ActiveSchName), 0);
if (retPush < 0)
{
LoggerService?.Info($"刷新调度表[{ActiveSchName}]失败, 返回:{retPush}");
}
}
IsSendOk = true;
}
catch (Exception ex)
{
IsSendOk = false;
LoggerService.Info($"时间:{DateTime.Now.ToString()}-【MSG】-{ex.Message}");
}
}
IsSendOk = false;
});
}
/// <summary>
/// 指令数据发生变化事件回调
/// </summary>
/// <param name="sender"></param>
/// <param name="e">消息/帧名称</param>
private void CmdData_LinCmdDataChangedHandler(object? sender, string e)
{
UpdateSchDataByCmdDataChanged(e);
}
/// <summary>
/// 指令数据变化时,按消息名增量刷新调度表数据
/// </summary>
/// <param name="changedMsgName">发生变化的帧名称</param>
private void UpdateSchDataByCmdDataChanged(string changedMsgName)
{
try
{
// 与CAN保持一致仅在循环发送开启且调度表使能时才更新
if (!IsCycleSend) return;
if (!SchEnable) return;
// 基础防御
if (LDFHandle == 0) return;
if (string.IsNullOrEmpty(ActiveSchName)) return;
if (string.IsNullOrEmpty(changedMsgName)) return;
// 若配置了激活帧过滤,则不在集合内的帧不更新
if (ActiveMsgNames != null && ActiveMsgNames.Count > 0 && !ActiveMsgNames.Contains(changedMsgName))
return;
lock (SchUpdateLock)
{
// 仅更新对应消息/帧的信号值
var relatedCmds = CmdData.Where(x => string.Equals(x.MsgName, changedMsgName, StringComparison.Ordinal));
foreach (var cmd in relatedCmds)
{
LDFParser.LDF_SetSignalValue(LDFHandle, new StringBuilder(changedMsgName), new StringBuilder(cmd.SignalName), cmd.SignalCmdValue);
}
//读取当前的指令帧数据,执行后就可以读取本身的数据
foreach (var item in ListLinLdfModel)
{
if (CmdData.Any(a => a.MsgName == item.MsgName))
{
LDFParser.LDF_GetSignalValueStr(LDFHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ReadValueStr);
item.SignalRtValueSb = ReadValueStr;
}
}
// 将更新后的信号值推送到适配器当前运行的调度表(离线表刷新)
var retPush = LDFParser.LDF_SetSchToTable(LDFHandle, new StringBuilder(ActiveSchName), 0);
if (retPush < 0)
{
IsSendOk = false;
LoggerService?.Info($"刷新调度表[{ActiveSchName}]失败, 返回:{retPush}");
}
else
{
IsSendOk = true;
//Console.WriteLine($"Update LIN Schedule Success -- Sch:[{ActiveSchName}] Msg:[{changedMsgName}]");
}
}
}
catch (Exception ex)
{
IsSendOk = false;
LoggerService?.Info($"时间:{DateTime.Now.ToString()}-【LIN_SCH】-{ex.Message}");
}
}
/// <summary>
/// 停止调度表自动执行
/// </summary>
public void StopSchedule()
{
try
{
IsCycleSend = false;
SchEnable = false;
ActiveMsgNames = null; // 清空激活帧过滤集合
if (LDFHandle != 0)
{
LDFParser.LDF_StopSchTable(LDFHandle);
}
}
catch (Exception ex)
{
LoggerService?.Info($"停止调度表异常: {ex.Message}");
}
}
#endregion
/// <summary>
/// 关闭设备
@@ -632,6 +1197,27 @@ namespace CapMachine.Wpf.LinDrive
public void CloseDevice()
{
//关闭设备
try
{
// 停止调度并释放LDF资源
if (LDFHandle != 0)
{
try { LDFParser.LDF_StopSchTable(LDFHandle); } catch { }
try { LDFParser.LDF_Release(LDFHandle); } catch { }
LDFHandle = 0;
}
// 释放接收缓冲区
lock (RecvBufferSync)
{
if (RecvMsgBufferPtr != IntPtr.Zero)
{
try { Marshal.FreeHGlobal(RecvMsgBufferPtr); }
catch { }
finally { RecvMsgBufferPtr = IntPtr.Zero; }
}
}
}
catch { }
USB_DEVICE.USB_CloseDevice(DevHandle);
OpenState = false;
LdfParserState = false;