diff --git a/CapMachine.Wpf/CanDrive/CanCmdData.cs b/CapMachine.Wpf/CanDrive/CanCmdData.cs index f9ecfdb..90f9ffb 100644 --- a/CapMachine.Wpf/CanDrive/CanCmdData.cs +++ b/CapMachine.Wpf/CanDrive/CanCmdData.cs @@ -1,9 +1,4 @@ using CapMachine.Wpf.Dtos; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace CapMachine.Wpf.CanDrive { @@ -12,6 +7,12 @@ namespace CapMachine.Wpf.CanDrive /// public class CanCmdData { + /// + /// 指令数据改变Handler + /// 改变发送消息名称 + /// + public event EventHandler? CanCmdDataChangedHandler; + /// /// 配置项名称-比如转速、功率限制等 /// @@ -27,11 +28,38 @@ namespace CapMachine.Wpf.CanDrive /// public string? SignalName { get; set; } + private double _SignalCmdValue; /// /// 指令值 /// 没有的话，则给默认值 /// - public double SignalCmdValue { get; set; } + public double SignalCmdValue + { + get { return _SignalCmdValue; } + set + { + if (_SignalCmdValue != value) + { + _SignalCmdValue = value; + if (CanCmdDataChangedHandler != null) + { + CanCmdDataChangedHandler!.Invoke(this, MsgName!); + } + } + + } + } + + ///// + ///// 指令值 + ///// 没有的话，则给默认值 + ///// + //public double SignalCmdValue { get; set; } + + ///// + ///// 逻辑规则Id + ///// + //public long LogicRuleId { get; set; } /// /// CanLinConfig的逻辑转换规则 diff --git a/CapMachine.Wpf/CanDrive/CanDbcModel.cs b/CapMachine.Wpf/CanDrive/CanDbcModel.cs index fa7f0ea..62a8a2d 100644 --- a/CapMachine.Wpf/CanDrive/CanDbcModel.cs +++ b/CapMachine.Wpf/CanDrive/CanDbcModel.cs @@ -47,8 +47,18 @@ namespace CapMachine.Wpf.CanDrive private string? _SignalRtValue = "--"; /// - /// 信号实时值 + /// 信号实时值（供 UI 绑定显示）。 /// + /// + /// - 仅当文本发生变化时才触发通知，避免无谓 UI 刷新。 + /// - 若期望进一步降低分配开销，建议在调用方（接收循环）先做“数值层去重”， + /// 即：仅在数值变化（可设置容差）时才调用 ToString() 格式化并赋值到本属性。 + /// 这样可以显著减少字符串分配与 GC 压力。 + /// + /// + /// // 示例：数值层去重后再格式化（接收循环中使用） + /// // if (Math.Abs(newVal - lastVal) > 1e-3) { model.SignalRtValue = newVal.ToString("F3"); lastVal = newVal; } + /// public string? SignalRtValue { get { return _SignalRtValue; } @@ -62,21 +72,56 @@ namespace CapMachine.Wpf.CanDrive } } - private StringBuilder _SignalRtValueSb = new StringBuilder(10); + private StringBuilder _SignalRtValueSb = new StringBuilder(16); /// - /// 信号实时值 StringBuilder + /// 信号实时值的可变文本缓冲接口。 + /// 设计目的： + /// - 避免外部传入的 StringBuilder 被直接保存（引用别名问题），统一复制文本到内部缓冲 _SignalRtValueSb； + /// - 仅当文本内容变化时才更新 SignalRtValue 并 RaisePropertyChanged，减少 UI 抖动与无谓刷新； + /// - 对 value == null 做防御：清空内部缓冲并置空显示文本（如需显示 “--” 可按需替换）。 + /// 使用方式： + /// - 接收环路可重复复用同一个外部 StringBuilder 作为临时缓存，调用本属性进行更新不会产生实例共享风险。 /// + /// + /// 注意事项： + /// 1) 本属性会复制文本，不会保存外部 StringBuilder 引用；这可避免多个模型共享同一实例导致的数据串扰和并发问题。 + /// 2) 若你的 UI 需要统一的“空值占位符”，可将 setter 中的空字符串替换为 "--"，与字段初始值保持一致。 + /// 3) 线程模型：建议仍在 UI 线程更新以避免跨线程通知问题；如需后台线程更新，请确保有合适的调度（Dispatcher/同步上下文）。 + /// 4) 性能建议：结合 SignalRtValue 的备注，在进入本 setter 前尽量做数值层去重，进一步减少字符串分配。 + /// + /// + /// // 示例：接收循环中复用临时缓存 + /// // var tmp = new StringBuilder(32); + /// // ... 填充 tmp ... + /// // model.SignalRtValueSb = tmp; // 本属性会复制 tmp 的内容，安全且不会产生实例共享 + /// public StringBuilder SignalRtValueSb { get { return _SignalRtValueSb; } set { - //if (_SignalRtValueSb != value) - //{ - SignalRtValue = value.ToString(); - _SignalRtValueSb = value; - //} + // 防御：若外部传入 null，清空内部状态并复位显示文本 + // 注意：此处将显示文本设为空字符串 ""，如果希望与初始占位符 "--" 一致，可改为 SignalRtValue = "--"。 + if (value == null) + { + if (_SignalRtValue != string.Empty) + { + _SignalRtValueSb.Clear(); + SignalRtValue = string.Empty; + } + return; + } + // 复制策略：不保存外部 StringBuilder 的引用，改为复制其当前文本内容 + // 这样可避免多个模型共享同一 StringBuilder 实例导致的数据串扰与线程安全问题 + var str = value.ToString(); + // 仅当文本内容确实发生变化时，才更新内部缓冲与绑定属性，减少无谓的 UI 刷新与字符串分配 + if (!string.Equals(_SignalRtValue, str, StringComparison.Ordinal)) + { + _SignalRtValueSb.Clear(); + _SignalRtValueSb.Append(str); + SignalRtValue = str; + } } } @@ -88,7 +133,7 @@ namespace CapMachine.Wpf.CanDrive public int IsSeletedInfo { get { return _IsSeletedInfo; } - set { _IsSeletedInfo = value;RaisePropertyChanged(); } + set { _IsSeletedInfo = value; RaisePropertyChanged(); } } diff --git a/CapMachine.Wpf/CanDrive/ToomossCan.cs b/CapMachine.Wpf/CanDrive/ToomossCan.cs index 82ce026..c60b581 100644 --- a/CapMachine.Wpf/CanDrive/ToomossCan.cs +++ b/CapMachine.Wpf/CanDrive/ToomossCan.cs @@ -1,26 +1,14 @@ -using CapMachine.Core; -using CapMachine.Model.CANLIN; -using CapMachine.Wpf.Dtos; -using CapMachine.Wpf.Models.Tag; +using CapMachine.Wpf.Dtos; +using CapMachine.Wpf.Models; using CapMachine.Wpf.Services; -using HslCommunication; using ImTools; -using NLog; -using NPOI.OpenXmlFormats.Wordprocessing; using Prism.Ioc; using Prism.Mvvm; -using System; -using System.Collections.Generic; using System.Collections.ObjectModel; using System.Diagnostics; using System.IO; -using System.Linq; using System.Runtime.InteropServices; using System.Text; -using System.Threading.Tasks; -using System.Windows.Forms; -using System.Windows.Interop; -using static CapMachine.Wpf.CanDrive.USB2CAN; namespace CapMachine.Wpf.CanDrive { @@ -34,11 +22,13 @@ namespace CapMachine.Wpf.CanDrive /// /// 实例化函数 /// - public ToomossCan(IContainerProvider containerProvider) + public ToomossCan(IContainerProvider containerProvider, ILogService logService) { ContainerProvider = containerProvider; HighSpeedDataService = ContainerProvider.Resolve(); - LoggerService = ContainerProvider.Resolve(); + LoggerService = logService; + + //monitorValueLog = new MonitorValueLog(logService, "SetSignalValue", "SyncValueToCanMsg", "ret", "CanNum", "SyncCANMsgToValue"); //Stopwatch.Frequency表示高精度计时器每秒的计数次数（ticks/秒）每毫秒的ticks数 = 每秒的ticks数 ÷ 1000 TicksPerMs = Stopwatch.Frequency / 1000.0; @@ -56,6 +46,7 @@ namespace CapMachine.Wpf.CanDrive GetCANConfig(); InitCAN(); + //LoggerService.Info($"Start CAN Drive"); } /// @@ -500,6 +491,32 @@ namespace CapMachine.Wpf.CanDrive StringBuilder ValueSb = new StringBuilder(16); double[] ValueDouble = new double[5]; + // 接收缓冲池（重用，避免每轮分配） + private IntPtr RecvMsgBufferPtr = IntPtr.Zero; + private int RecvMsgBufferCapacity = 1024; + private readonly int CanMsgSize = Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)); + + // 名称 StringBuilder 缓存（DBC 调用复用，避免频繁分配） + private readonly Dictionary MsgNameSBCache = new Dictionary(StringComparer.Ordinal); + private readonly Dictionary SigNameSBCache = new Dictionary(StringComparer.Ordinal); + + // 控制台调试输出开关（默认关闭，防止日志风暴） + public bool EnableConsoleDebugLog { get; set; } = false; + + // 保护接收缓冲的并发锁（接收读与关闭释放之间的互斥） + private readonly object RecvBufferSync = new object(); + + private StringBuilder GetCachedSB(Dictionary cache, string key) + { + key ??= string.Empty; + if (cache.TryGetValue(key, out var sb)) return sb; + var nsb = new StringBuilder(key); + cache[key] = nsb; + return nsb; + } + private StringBuilder GetMsgSB(string key) => GetCachedSB(MsgNameSBCache, key); + private StringBuilder GetSigSB(string key) => GetCachedSB(SigNameSBCache, key); + private bool _IsSendOk; /// /// 发送报文是否OK @@ -598,6 +615,234 @@ namespace CapMachine.Wpf.CanDrive }); } + #region 定时器发送报文数据 + + // 定时器发送：采用单次触发+校准的方式避免周期漂移，减少长时间运行误差 + // 说明：不修改 StartPrecisionCycleSendMsg 的任何内容；此处仅实现定时器版本 + + // 定时器与资源 + private System.Threading.Timer _sendTimer; + private readonly object _sendTimerSync = new object(); + private volatile int _sendTimerRunningFlag = 0; // 防止回调重入 + private int _sendTimerPeriodMs = 100; // 默认100ms + private readonly Stopwatch _sendTimerWatch = new Stopwatch(); + private long _sendTimerNextTicks; + + // 发送缓冲重用，减少分配 + private USB2CAN.CAN_MSG[] _timerCanMsgBuffer; + private IntPtr _timerMsgPtr = IntPtr.Zero; + + /// + /// 启动基于定时器的周期发送（毫秒）。支持典型的50/100/200ms等周期。 + /// 使用单次触发+绝对时间校准的算法，尽量减少漂移；并使用重用缓冲降低内存分配。 + /// + /// 发送周期（毫秒） + public void StartTimerCycleSendMsg(int periodMs) + { + if (periodMs <= 0) periodMs = 1; + + lock (_sendTimerSync) + { + // 先停止旧的 + StopTimerCycleSendMsg_NoLock(); + + _sendTimerPeriodMs = periodMs; + IsCycleSend = true; + + if (_timerMsgPtr == IntPtr.Zero) + { + _timerMsgPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))); + } + + _sendTimerWatch.Restart(); + _sendTimerNextTicks = _sendTimerWatch.ElapsedTicks + (long)(_sendTimerPeriodMs * TicksPerMs); + + // 使用单次触发模式，每次回调后手动调度下一次，便于按绝对时间校准 + _sendTimer = new System.Threading.Timer(SendTimerCallback, null, 0, System.Threading.Timeout.Infinite); + } + } + + /// + /// 启动基于定时器的周期发送（使用 SendCycle 属性作为周期参数） + /// + public void StartTimerCycleSendMsg() + { + StartTimerCycleSendMsg((int)SendCycle); + } + + /// + /// 便捷方法：启动50ms周期发送 + /// + public void StartTimerCycleSendMsg50ms() => StartTimerCycleSendMsg(50); + + /// + /// 便捷方法：启动100ms周期发送 + /// + public void StartTimerCycleSendMsg100ms() => StartTimerCycleSendMsg(100); + + /// + /// 便捷方法：启动200ms周期发送 + /// + public void StartTimerCycleSendMsg200ms() => StartTimerCycleSendMsg(200); + + /// + /// 停止定时器周期发送并释放资源 + /// + public void StopTimerCycleSendMsg() + { + lock (_sendTimerSync) + { + IsCycleSend = false; + StopTimerCycleSendMsg_NoLock(); + } + } + + private void StopTimerCycleSendMsg_NoLock() + { + var t = _sendTimer; + _sendTimer = null; + if (t != null) + { + try { t.Dispose(); } catch { } + } + + // 等待在途回调结束，避免释放资源时发生竞争 + System.Threading.SpinWait.SpinUntil(() => System.Threading.Interlocked.CompareExchange(ref _sendTimerRunningFlag, 0, 0) == 0, 200); + + _sendTimerWatch.Stop(); + + if (_timerMsgPtr != IntPtr.Zero) + { + try { Marshal.FreeHGlobal(_timerMsgPtr); } catch { } finally { _timerMsgPtr = IntPtr.Zero; } + } + _timerCanMsgBuffer = null; // 让GC回收 + IsSendOk = false; + } + + // 定时器回调（单次触发）；回调结束时会按绝对时间校准下一次触发 + private void SendTimerCallback(object state) + { + try + { + if (!IsCycleSend) return; + + // 防止回调重入（当某次发送耗时超过周期时避免并发） + if (System.Threading.Interlocked.Exchange(ref _sendTimerRunningFlag, 1) == 1) + { + ScheduleNextTick(); + return; + } + + var localCmd = CmdData; // 快照引用，避免枚举时被替换 + if (localCmd == null || localCmd.Count == 0) + { + IsSendOk = false; + return; + } + + // 依据消息名进行分组（与 StartPrecisionCycleSendMsg 的发送逻辑一致） + IEnumerable> groupMsg; + try + { + groupMsg = localCmd.GroupBy(x => x.MsgName).ToList(); // ToList 避免重复枚举 + } + catch + { + // 罕见并发异常，跳过本次 + IsSendOk = false; + return; + } + + int msgCount = groupMsg.Count(); + if (msgCount <= 0) + { + IsSendOk = false; + return; + } + + // 确保发送缓冲容量，尽量复用，减少频繁分配 + if (_timerCanMsgBuffer == null || _timerCanMsgBuffer.Length != msgCount) + { + _timerCanMsgBuffer = new USB2CAN.CAN_MSG[msgCount]; + for (int i = 0; i < msgCount; i++) + { + _timerCanMsgBuffer[i] = new USB2CAN.CAN_MSG(); + _timerCanMsgBuffer[i].Data = new byte[64]; + } + } + + int index = 0; + foreach (var itemMsg in groupMsg) + { + foreach (var itemSignal in itemMsg) + { + // 与 StartPrecisionCycleSendMsg 保持一致的调用形态，避免与其他线程共享缓存的并发问题 + CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue); + } + + // 将信号同步到 CAN 帧 + CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), _timerMsgPtr); + _timerCanMsgBuffer[index] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(_timerMsgPtr, typeof(USB2CAN.CAN_MSG)); + index++; + } + + // 发送 CAN 数据 + int sendedNum = USB2CAN.CAN_SendMsg(DevHandle, WriteCANIndex, _timerCanMsgBuffer, (uint)_timerCanMsgBuffer.Length); + IsSendOk = sendedNum >= 0; + } + catch (Exception ex) + { + IsSendOk = false; + LoggerService?.Info($"定时器周期发送CAN数据异常: {ex.Message}"); + } + finally + { + // 标记回调完成并调度下一次 + System.Threading.Interlocked.Exchange(ref _sendTimerRunningFlag, 0); + ScheduleNextTick(); + } + } + + // 计算并调度下一次触发时间（基于绝对时间进行校准，减少漂移） + private void ScheduleNextTick() + { + try + { + if (!IsCycleSend) return; + var timer = _sendTimer; + if (timer == null) return; + + long now = _sendTimerWatch.ElapsedTicks; + long periodTicks = (long)(_sendTimerPeriodMs * TicksPerMs); + + if (_sendTimerNextTicks == 0) + { + _sendTimerNextTicks = now + periodTicks; + } + else if (now >= _sendTimerNextTicks) + { + // 若已错过计划时间，跳至最近的未来时刻，避免累计漂移 + long missed = (now - _sendTimerNextTicks) / periodTicks + 1; + _sendTimerNextTicks += missed * periodTicks; + } + + long dueTicks = _sendTimerNextTicks - now; + int dueMs = dueTicks <= 0 ? 0 : (int)(dueTicks / TicksPerMs); + + timer.Change(dueMs, System.Threading.Timeout.Infinite); + } + catch (ObjectDisposedException) + { + // 计时器已被释放，忽略 + } + catch (Exception ex) + { + LoggerService?.Info($"定时器调度异常: {ex.Message}"); + } + } + + #endregion + #region 精确发送报文数据 @@ -846,7 +1091,7 @@ namespace CapMachine.Wpf.CanDrive /// /// 定时更新时间 /// - private int UpdateCycle = 100; + private int UpdateCycle { get; set; } = 100; /// /// CNA 调度表的配置信息 @@ -855,6 +1100,12 @@ namespace CapMachine.Wpf.CanDrive Random random = new Random(); + /// + /// 监控数据 + /// 查找问题用，平时不用 + /// + //public MonitorValueLog monitorValueLog { get; set; } + /// /// 更新数据 测试用废弃了 /// @@ -1121,7 +1372,6 @@ namespace CapMachine.Wpf.CanDrive // Console.WriteLine($"Update CAN Schedule Error ret = {ret} -- SchTabIndex：{(byte)itemMsgSchConfig.SchTabIndex} -- MsgIndex：{(byte)(itemMsgSchConfig.MsgIndex)}"); // //return; // } - //} @@ -1138,6 +1388,126 @@ namespace CapMachine.Wpf.CanDrive } + /// + /// 加载要发送的数据 + /// 一般是激活后才注册事件 + /// + /// + public void LoadCmdDataToDrive(List cmdData) + { + // Unsubscribe from events on the old CmdData items + if (CmdData != null && CmdData.Count > 0) + { + foreach (var cmd in CmdData) + { + cmd.CanCmdDataChangedHandler -= CmdData_CanCmdDataChangedHandler; + } + } + + // Set the new data and subscribe to events + CmdData = cmdData; + foreach (var cmd in cmdData) + { + cmd.CanCmdDataChangedHandler += CmdData_CanCmdDataChangedHandler; + } + } + + /// + /// 指令数据发生变化执行方法 + /// + /// + /// + private void CmdData_CanCmdDataChangedHandler(object? sender, string e) + { + UpdateSchDataByCmdDataChanged(); + } + + /// + /// 指令数据发生变化执行更新调度表锁 + /// + private readonly object SchUpdateLock = new object(); + + /// + /// 指令数据发生变化执行方法 + /// + /// + /// + private void UpdateSchDataByCmdDataChanged() + { + try + { + if (!IsCycleSend) return; + if (!SchEnable) return; + + // 基础防御：确保 DBC/ 调度表 / 分组已经初始化 + if (DBCHandle == 0 || SchCanMsg == null || GroupMsg == null) + { + return; + } + + lock (SchUpdateLock) + { + //通过DBC进行对消息赋值 + IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))); + int CycleUpdateIndex = 0; + //循环给MSG赋值数据，顺序是固定的，跟初始时设置是一样的 + foreach (var itemMsg in GroupMsg) + { + foreach (var itemSignal in itemMsg) + { + //itemSignal.SignalCmdValue = random.Next(0, 100); //仿真测试数据使用 + var SetSignalValue = CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue); + //monitorValueLog.UpdateValue1(SetSignalValue); + } + var SyncValueToCanMsg = CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend); + //monitorValueLog.UpdateValue2(SyncValueToCanMsg); + SchCanMsg[CycleUpdateIndex] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CAN.CAN_MSG)); + CycleUpdateIndex++; + } + + //通过DBC写入数据后生成CanMsg + //将信号值填入CAN消息里面 + + //释放申请的临时缓冲区 + Marshal.FreeHGlobal(msgPtSend); + + //CAN_UpdateSchedule 官网解释 + // ---MsgTabIndex CAN调度表索引号 + // ---MsgIndex 开始更新帧起始索引，若起始索引大于调度表帧数，则将帧添加到调度表后面 + // ---pCanMsg 需要更新的CAN帧指针 + // ---MsgNum pCanMsgTab里面包含的有效帧数 + + //CAN_UpdateSchedule中的MsgIndex表示当前的调度器中的帧Index序号 + //因为调度表中的帧集合和控制帧的集合和要更新的帧集合都是同一个集合SchCanMsg + //默认1号调度表，一个更新所有的帧数据 + var ret = USB2CAN.CAN_UpdateSchedule(DevHandle, WriteCANIndex, (byte)0, (byte)(0), SchCanMsg, (byte)SchCanMsg.Count());//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可 + if (ret == USB2CAN.CAN_SUCCESS) + { + IsSendOk = true; + //Console.WriteLine($"Update CAN Schedule Success -- SchTabIndex：{(byte)0} -- MsgIndex：{(byte)(0)} "); + //monitorValueLog.UpdateValue3(ret); + } + else + { + IsSendOk = false; + //Console.WriteLine($"Update CAN Schedule Error ret = {ret} -- SchTabIndex：{(byte)0} -- MsgIndex：{(byte)(0)}"); + //monitorValueLog.UpdateValue3(ret); + LoggerService.Info($"更新调度表失败，错误码：{ret}"); + //return; + } + } + + } + catch (Exception ex) + { + IsSendOk = false; + LoggerService.Info($"时间:{DateTime.Now.ToString()}-【MSG】-{ex.Message}"); + } + + } + + + #endregion /// @@ -1145,101 +1515,121 @@ namespace CapMachine.Wpf.CanDrive /// public void StartCycleReviceCanMsg() { + // 防止重复启动，若已有任务在运行则直接返回 + if (CycleReviceTask != null && !CycleReviceTask.IsCompleted) + { + return; + } + //monitorValueLog CycleReviceTask = Task.Run(async () => { - while (IsCycleRevice) + try { - await Task.Delay(ReviceCycle); - try + while (IsCycleRevice) { - //另外一个CAN通道读取数据 - USB2CAN.CAN_MSG[] CanMsgBuffer = new USB2CAN.CAN_MSG[1024]; - //申请数据缓冲区 - IntPtr msgPtRead = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)) * CanMsgBuffer.Length); - int CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, ReadCANIndex, msgPtRead, CanMsgBuffer.Length); - //int CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, 1, msgPtRead, CanMsgBuffer.Length);//测试用，CAN卡 CAN1和CAN2 短接时测试用 - if (CanNum > 0) + await Task.Delay(ReviceCycle); + try { - IsReviceOk = true; - Console.WriteLine("Read CanMsgNum = {0}", CanNum); - for (int i = 0; i < CanNum; i++) + // 另一个CAN通道读取数据（与 CloseDevice 释放互斥，保护指针安全） + IntPtr msgPtRead; + int CanNum; + lock (RecvBufferSync) { - //CanMsgBuffer[i] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure((IntPtr)((UInt32)msgPtRead + i * Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))), typeof(USB2CAN.CAN_MSG)); //有溢出报错 - CanMsgBuffer[i] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure((IntPtr)(msgPtRead + i * Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))), typeof(USB2CAN.CAN_MSG)); - - Console.WriteLine("CanMsg[{0}].ID = 0x{1}", i, CanMsgBuffer[i].ID.ToString("X8")); - Console.WriteLine("CanMsg[{0}].TimeStamp = {1}", i, CanMsgBuffer[i].TimeStamp); - Console.Write("CanMsg[{0}].Data = ", i); - for (int j = 0; j < CanMsgBuffer[i].DataLen; j++) + if (RecvMsgBufferPtr == IntPtr.Zero) { - Console.Write("{0} ", CanMsgBuffer[i].Data[j].ToString("X2")); + RecvMsgBufferPtr = Marshal.AllocHGlobal(CanMsgSize * RecvMsgBufferCapacity); + LoggerService.Info("申请 RecvMsgBufferPtr"); } - Console.WriteLine(""); - - //报文给高速记录的服务 - HighSpeedDataService.AppendOrUpdateMsg(new Models.HighSpeed.CommMsg() + msgPtRead = RecvMsgBufferPtr; + CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, ReadCANIndex, msgPtRead, RecvMsgBufferCapacity); + //int CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, 1, msgPtRead, RecvMsgBufferCapacity);//测试用，CAN卡 CAN1和CAN2 短接时测试用 + //monitorValueLog.UpdateValue4(CanNum); + if (CanNum > 0) { - Category = "CAN", - MsgInfo = "0x" + CanMsgBuffer[i].ID.ToString("X8"), - MsgData = BitConverter.ToString(CanMsgBuffer[i].Data), - Time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") - }); + IsReviceOk = true; + if (EnableConsoleDebugLog) Console.WriteLine("Read CanMsgNum = {0}", CanNum); + for (int i = 0; i < CanNum; i++) + { + var msgPtr = (IntPtr)(msgPtRead + i * CanMsgSize); + var msg = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtr, typeof(USB2CAN.CAN_MSG)); + + if (EnableConsoleDebugLog) + { + Console.WriteLine("CanMsg[{0}].ID = 0x{1}", i, msg.ID.ToString("X8")); + Console.WriteLine("CanMsg[{0}].TimeStamp = {1}", i, msg.TimeStamp); + Console.Write("CanMsg[{0}].Data = ", i); + for (int j = 0; j < msg.DataLen; j++) + { + Console.Write("{0} ", msg.Data[j].ToString("X2")); + } + Console.WriteLine(""); + } + + // 报文给高速记录的服务 + HighSpeedDataService.AppendOrUpdateMsg(new Models.HighSpeed.CommMsg() + { + Category = "CAN", + MsgInfo = "0x" + msg.ID.ToString("X8"), + MsgData = BitConverter.ToString(msg.Data), + Time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + }); + } + } + else if (CanNum == 0) + { + IsReviceOk = false; + if (EnableConsoleDebugLog) Console.WriteLine("No CAN data!"); + } + else + { + IsReviceOk = false; + if (EnableConsoleDebugLog) Console.WriteLine("Get CAN data error!"); + } + // 将CAN消息数据填充到信号里面，用DBC解析数据（仍在锁内，避免指针被并发释放） + var SyncCANMsgToValue = CAN_DBCParser.DBC_SyncCANMsgToValue(DBCHandle, msgPtRead, CanNum); + //monitorValueLog.UpdateValue5(SyncCANMsgToValue); } + + //循环获取消息的数据 + foreach (var item in ListCanDbcModel) + { + // 复用 StringBuilder 缓存，避免频繁分配 + var msgNameSB = GetMsgSB(item.MsgName); + var sigNameSB = GetSigSB(item.SignalName); + CAN_DBCParser.DBC_GetSignalValue(DBCHandle, msgNameSB, sigNameSB, ValueDouble); + item.SignalRtValue = ValueDouble[0].ToString(); + //Console.Write(ValueSb.ToString()); + } + // 缓冲区在 CloseDevice 或任务退出的 finally 中统一释放，避免频繁申请/释放 + + } - else if (CanNum == 0) + catch (Exception ex) { IsReviceOk = false; - Console.WriteLine("No CAN data!"); + LoggerService.Info($"CAN指令接收出现异常:{ex.Message}"); + } + //finally + //{ + // IsReviceOk = false; + //} + } + } + finally + { + IsReviceOk = false; + LoggerService.Info("CAN指令接收 finally结束"); + // 接收任务退出时释放接收缓冲，避免仅停止接收时的缓冲常驻 + lock (RecvBufferSync) + { + if (RecvMsgBufferPtr != IntPtr.Zero) + { + try { Marshal.FreeHGlobal(RecvMsgBufferPtr); } + catch { } + finally { RecvMsgBufferPtr = IntPtr.Zero; } } - else - { - IsReviceOk = false; - Console.WriteLine("Get CAN data error!"); - } - //Console.WriteLine(""); - - //将CAN消息数据填充到信号里面，用DBC解析数据 - CAN_DBCParser.DBC_SyncCANMsgToValue(DBCHandle, msgPtRead, CanNum); - - //循环获取消息的数据 - foreach (var item in ListCanDbcModel) - { - //有配置的名称的，认为是有用的，则需要读取数据 - //if (!string.IsNullOrEmpty(item.Name)) - //{ - //CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ValueSb); - //double[] ValueDouble; - CAN_DBCParser.DBC_GetSignalValue(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ValueDouble); - //item.SignalRtValueSb = ValueSb; - item.SignalRtValue = ValueDouble[0].ToString(); - //Console.Write(ValueSb.ToString()); - //} - } - - //释放数据缓冲区，必须释放，否则程序运行一段时间后会报内存不足 - Marshal.FreeHGlobal(msgPtRead); - Thread.Sleep(10); - - ////获取信号值并打印出来 - //StringBuilder ValueStr = new StringBuilder(32); - //CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), ValueStr); - //Console.WriteLine("moto_speed = {0}", ValueStr); - //CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), ValueStr); - //Console.WriteLine("oil_pressure = {0}", ValueStr); - //CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), ValueStr); - //Console.WriteLine("speed_can = {0}", ValueStr); } - catch (Exception ex) - { - IsReviceOk = false; - LoggerService.Info("接收出现异常"); - } - //finally - //{ - // IsReviceOk = false; - //} } - IsReviceOk = false; }); } @@ -1251,43 +1641,55 @@ namespace CapMachine.Wpf.CanDrive //另外一个CAN通道读取数据 USB2CAN.CAN_MSG[] CanMsgBuffer = new USB2CAN.CAN_MSG[10]; msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)) * CanMsgBuffer.Length); - int CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, ReadCANIndex, msgPt, CanMsgBuffer.Length); - if (CanNum > 0) + try { - Console.WriteLine("Read CanMsgNum = {0}", CanNum); - for (int i = 0; i < CanNum; i++) + int CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, ReadCANIndex, msgPt, CanMsgBuffer.Length); + if (CanNum > 0) { - CanMsgBuffer[i] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure((IntPtr)((UInt32)msgPt + i * Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))), typeof(USB2CAN.CAN_MSG)); - Console.WriteLine("CanMsg[{0}].ID = 0x{1}", i, CanMsgBuffer[i].ID.ToString("X8")); - //Console.WriteLine("CanMsg[{0}].TimeStamp = {1}",i,CanMsgBuffer[i].TimeStamp); - Console.Write("CanMsg[{0}].Data = ", i); - for (int j = 0; j < CanMsgBuffer[i].DataLen; j++) + Console.WriteLine("Read CanMsgNum = {0}", CanNum); + for (int i = 0; i < CanNum; i++) { - Console.Write("{0} ", CanMsgBuffer[i].Data[j].ToString("X2")); + CanMsgBuffer[i] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure((IntPtr)((UInt32)msgPt + i * Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))), typeof(USB2CAN.CAN_MSG)); + Console.WriteLine("CanMsg[{0}].ID = 0x{1}", i, CanMsgBuffer[i].ID.ToString("X8")); + //Console.WriteLine("CanMsg[{0}].TimeStamp = {1}",i,CanMsgBuffer[i].TimeStamp); + Console.Write("CanMsg[{0}].Data = ", i); + for (int j = 0; j < CanMsgBuffer[i].DataLen; j++) + { + Console.Write("{0} ", CanMsgBuffer[i].Data[j].ToString("X2")); + } + Console.WriteLine(""); } - Console.WriteLine(""); + } + else if (CanNum == 0) + { + Console.WriteLine("No CAN data!"); + } + else + { + Console.WriteLine("Get CAN data error!"); + } + Console.WriteLine(""); + + //将CAN消息数据填充到信号里面 + CAN_DBCParser.DBC_SyncCANMsgToValue(DBCHandle, msgPt, CanNum); + //获取信号值并打印出来 + StringBuilder ValueStr = new StringBuilder(32); + CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), ValueStr); + Console.WriteLine("moto_speed = {0}", ValueStr); + CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), ValueStr); + Console.WriteLine("oil_pressure = {0}", ValueStr); + CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), ValueStr); + Console.WriteLine("speed_can = {0}", ValueStr); + } + finally + { + if (msgPt != IntPtr.Zero) + { + try { Marshal.FreeHGlobal(msgPt); } + catch { } + finally { msgPt = IntPtr.Zero; } } } - else if (CanNum == 0) - { - Console.WriteLine("No CAN data!"); - } - else - { - Console.WriteLine("Get CAN data error!"); - } - Console.WriteLine(""); - - //将CAN消息数据填充到信号里面 - CAN_DBCParser.DBC_SyncCANMsgToValue(DBCHandle, msgPt, CanNum); - //获取信号值并打印出来 - StringBuilder ValueStr = new StringBuilder(32); - CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), ValueStr); - Console.WriteLine("moto_speed = {0}", ValueStr); - CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), ValueStr); - Console.WriteLine("oil_pressure = {0}", ValueStr); - CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), ValueStr); - Console.WriteLine("speed_can = {0}", ValueStr); } @@ -1306,6 +1708,30 @@ namespace CapMachine.Wpf.CanDrive { StopSchedule(); } + + // 确保定时器发送被停止并释放资源 + try { StopTimerCycleSendMsg(); } catch { } + + // 等待接收任务结束后释放非托管缓冲区，避免并发释放 + try + { + var task = CycleReviceTask; + if (task != null && !task.IsCompleted) + { + task.Wait(TimeSpan.FromMilliseconds(ReviceCycle + 500)); + } + } + catch { } + // 在锁内安全释放，避免与接收线程并发访问同一指针 + lock (RecvBufferSync) + { + if (RecvMsgBufferPtr != IntPtr.Zero) + { + try { Marshal.FreeHGlobal(RecvMsgBufferPtr); } + catch { } + finally { RecvMsgBufferPtr = IntPtr.Zero; } + } + } } } diff --git a/CapMachine.Wpf/Services/CanDriveService.cs b/CapMachine.Wpf/Services/CanDriveService.cs index ded2774..441a6d9 100644 --- a/CapMachine.Wpf/Services/CanDriveService.cs +++ b/CapMachine.Wpf/Services/CanDriveService.cs @@ -21,18 +21,21 @@ namespace CapMachine.Wpf.Services { public HighSpeedDataService HighSpeedDataService { get; } + public ILogService LogService { get; } public LogicRuleService LogicRuleService { get; } /// /// 实例化函数 /// - public CanDriveService(HighSpeedDataService highSpeedDataService, IContainerProvider containerProvider, LogicRuleService logicRuleService) + public CanDriveService(HighSpeedDataService highSpeedDataService, IContainerProvider containerProvider, ILogService logService, LogicRuleService logicRuleService) { - ToomossCanDrive = new ToomossCan(containerProvider); + ToomossCanDrive = new ToomossCan(containerProvider, logService); //高速数据服务 HighSpeedDataService = highSpeedDataService; + LogService = logService; LogicRuleService = logicRuleService; + //ToomossCanDrive.StartCanDrive(); } @@ -313,7 +316,7 @@ namespace CapMachine.Wpf.Services { if (CmdData.Count > 0) { - + //把指令数据赋值给CAN 驱动 ToomossCanDrive.CmdData = CmdData; if (ToomossCanDrive.SchEnable) @@ -337,7 +340,7 @@ namespace CapMachine.Wpf.Services } ToomossCanDrive.ListCANScheduleConfig = ListCANScheduleConfig!; ToomossCanDrive.StartSchedule(); - ToomossCanDrive.StartCycleUpdateCmd(); + //ToomossCanDrive.StartCycleUpdateCmd(); } else { diff --git a/CapMachine.Wpf/ViewModels/CANConfigViewModel.cs b/CapMachine.Wpf/ViewModels/CANConfigViewModel.cs index d32eca0..f9fda98 100644 --- a/CapMachine.Wpf/ViewModels/CANConfigViewModel.cs +++ b/CapMachine.Wpf/ViewModels/CANConfigViewModel.cs @@ -489,6 +489,7 @@ namespace CapMachine.Wpf.ViewModels CanDriveService.InitCanConfig(SelectCanLinConfigPro); InitLoadCanConfigPro(); + CanDriveService.ToomossCanDrive.LoadCmdDataToDrive(CanDriveService.CmdData); } else { diff --git a/CapMachine.Wpf/ViewModels/DialogCANSchConfigViewModel.cs b/CapMachine.Wpf/ViewModels/DialogCANSchConfigViewModel.cs new file mode 100644 index 0000000..9313f21 --- /dev/null +++ b/CapMachine.Wpf/ViewModels/DialogCANSchConfigViewModel.cs @@ -0,0 +1,380 @@ +using AutoMapper; +using CapMachine.Core; +using CapMachine.Model; +using CapMachine.Model.CANLIN; +using CapMachine.Wpf.Dtos; +using CapMachine.Wpf.Services; +using ImTools; +using Prism.Commands; +using Prism.Services.Dialogs; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows; + +namespace CapMachine.Wpf.ViewModels +{ + /// + /// CAN 调度表配置 + /// + public class DialogCANSchConfigViewModel : DialogViewModel + { + /// + /// 构造函数 + /// + public DialogCANSchConfigViewModel(IFreeSql freeSql, IMapper mapper) + { + Title = "调度表 CAN 配置"; + FreeSql = freeSql; + Mapper = mapper; + + + SendOrderCbxItems = new ObservableCollection() + { + new CbxItems(){ + Key="0", + Text="并行", + }, + new CbxItems(){ + Key="1", + Text="顺序", + }, + }; + + + //默认只能用1号调度器 + SchTabIndexCbxItems = new ObservableCollection() + { + new CbxItems(){ + Key="0", + Text="0", + }, + //new CbxItems(){ + // Key="1", + // Text="1", + //}, + //new CbxItems(){ + // Key="2", + // Text="2", + //}, + //new CbxItems(){ + // Key="3", + // Text="3", + //}, + //new CbxItems(){ + // Key="4", + // Text="4", + //}, + }; + + } + + public IFreeSql FreeSql { get; } + public IMapper Mapper { get; } + + private string name; + /// + /// 名称 + /// + public string Name + { + get { return name; } + set { name = value; RaisePropertyChanged(); } + } + + private ObservableCollection _ListCANScheduleConfigDto = new ObservableCollection(); + /// + /// CAN 调度表数据集合 + /// + public ObservableCollection ListCANScheduleConfigDto + { + get { return _ListCANScheduleConfigDto; } + set { _ListCANScheduleConfigDto = value; RaisePropertyChanged(); } + } + + /// + /// 消息/帧报文信息集合 + /// + public List ListMsg { get; set; } + + private ObservableCollection _MsgCbxItems; + /// + /// 消息名称 集合信息 + /// + public ObservableCollection MsgCbxItems + { + get { return _MsgCbxItems; } + set { _MsgCbxItems = value; RaisePropertyChanged(); } + } + + /// + /// 选中的程序的Id + /// + public long SelectCanLinConfigProId { get; set; } + + private ObservableCollection _SendOrderCbxItems; + /// + /// 发送方式 集合信息 + /// + public ObservableCollection SendOrderCbxItems + { + get { return _SendOrderCbxItems; } + set { _SendOrderCbxItems = value; RaisePropertyChanged(); } + } + + + private string? _CurSendOrder; + /// + /// 当前发送方式 + /// + public string? CurSendOrder + { + get { return _CurSendOrder; } + set { _CurSendOrder = value; RaisePropertyChanged(); } + } + + + private ObservableCollection _SchTabIndexCbxItems; + /// + /// 调度器序号 集合信息 + /// + public ObservableCollection SchTabIndexCbxItems + { + get { return _SchTabIndexCbxItems; } + set { _SchTabIndexCbxItems = value; RaisePropertyChanged(); } + } + + private CANScheduleConfigDto _CurSelectedItem; + /// + /// 选中的数据 + /// + public CANScheduleConfigDto CurSelectedItem + { + get { return _CurSelectedItem; } + set { _CurSelectedItem = value; RaisePropertyChanged(); } + } + + + private DelegateCommand _GridSelectionChangedCmd; + /// + /// 选中行数据命令 + /// + public DelegateCommand GridSelectionChangedCmd + { + set + { + _GridSelectionChangedCmd = value; + } + get + { + if (_GridSelectionChangedCmd == null) + { + _GridSelectionChangedCmd = new DelegateCommand((par) => GridSelectionChangedCmdMethod(par)); + } + return _GridSelectionChangedCmd; + } + } + private void GridSelectionChangedCmdMethod(object par) + { + //先判断是否是正确的集合数据，防止DataGrid的数据源刷新导致的触发事件 + var Selecteddata = par as CANScheduleConfigDto; + + if (Selecteddata != null) + { + CurSelectedItem = Selecteddata; + } + } + + //OpCmd + private DelegateCommand _OpCmd; + /// + /// 增加方法命令 + /// + public DelegateCommand OpCmd + { + set + { + _OpCmd = value; + } + get + { + if (_OpCmd == null) + { + _OpCmd = new DelegateCommand((Par) => OpCmdCall(Par)); + } + return _OpCmd; + } + } + + private void OpCmdCall(string Par) + { + switch (Par) + { + case "Add": + ListCANScheduleConfigDto.Add(new CANScheduleConfigDto + { + CanLinConfigProId = SelectCanLinConfigProId, + Cycle = 100, + SchTabIndex = 0, + OrderSend = 1, + }); + break; + case "Delete": + if (CurSelectedItem != null) + { + //直接删除掉，如果没有ID的话，这就不需要删除了 + FreeSql.Delete(CurSelectedItem.Id).ExecuteAffrows(); + ListCANScheduleConfigDto.Remove(CurSelectedItem); + + CurSelectedItem = null; + } + else + { + MessageBox.Show("请选中后再进行【删除】操作？", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + } + break; + default: + break; + } + } + + private DelegateCommand saveCmd; + /// + /// 保存命令 + /// + public DelegateCommand SaveCmd + { + set + { + saveCmd = value; + } + get + { + if (saveCmd == null) + { + saveCmd = new DelegateCommand(() => SaveCmdMethod()); + } + return saveCmd; + } + } + + /// + /// 保存命令方法 + /// + /// + private void SaveCmdMethod() + { + //检查空的数据 + foreach (var item in ListCANScheduleConfigDto) + { + //整个的发送方式赋值给每个子项 + item.OrderSend = CurSendOrder == "0" ? 0 : 1; + + if (string.IsNullOrEmpty(item.MsgName)) + { + MessageBox.Show("请确认消息名称是否正确", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + if (item.Cycle == 0) + { + MessageBox.Show("请确认周期是否正确", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + if (item.OrderSend >= 2) + { + MessageBox.Show("请确认发送方式是否正确", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + } + + + //发送的控制帧都放到同一个调度表中，不需要检查了 + ////检查重复设置问题 + //bool isRepeat = ListCANScheduleConfigDto.GroupBy(i => i.MsgName).Any(g => g.Count() > 1); + //if (isRepeat) + //{ + // MessageBox.Show("请确认是否重复设置", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + // return; + //} + + //检查数据是否正常 + foreach (var item in ListCANScheduleConfigDto) + { + FreeSql.InsertOrUpdate() + .SetSource(Mapper.Map(item)). + ExecuteAffrows(); + } + + ListCANScheduleConfigDto = new ObservableCollection(Mapper.Map>(FreeSql.Select().Where(a => a.CanLinConfigProId == SelectCanLinConfigProId).ToList())); + + DialogParameters pars = new DialogParameters + { + { "ReturnValue", ListCANScheduleConfigDto } + }; + + RaiseRequestClose(new DialogResult(ButtonResult.OK, pars)); + } + + private DelegateCommand cancelCmd; + /// + /// 保存命令 + /// + public DelegateCommand CancelCmd + { + set + { + cancelCmd = value; + } + get + { + if (cancelCmd == null) + { + cancelCmd = new DelegateCommand(() => CancelCmdMethod()); + } + return cancelCmd; + } + } + + + /// + /// 取消命令方法 + /// + /// + private void CancelCmdMethod() + { + RaiseRequestClose(new DialogResult(ButtonResult.Cancel)); + } + + /// + /// 窗口打开时的传递的参数 + /// + /// + public override void OnDialogOpened(IDialogParameters parameters) + { + ListMsg = parameters.GetValue>("ListMsg"); + // 转换为CbxItems集合，都是文本内容 + MsgCbxItems = new ObservableCollection( + ListMsg.Select(value => new CbxItems + { + Key = value, + Text = value + })); + + ListCANScheduleConfigDto = parameters.GetValue>("ListCANScheduleConfigDto"); + //防止返回的数据为空，就无法增加了 + if (ListCANScheduleConfigDto == null) ListCANScheduleConfigDto = new ObservableCollection(); + //Name = parameters.GetValue("Name"); + if (ListCANScheduleConfigDto.Count > 0) + { + CurSendOrder = ListCANScheduleConfigDto.FirstOrDefault()!.OrderSend.ToString(); + } + + SelectCanLinConfigProId = parameters.GetValue("SelectCanLinConfigProId"); + } + + + } +} diff --git a/CapMachine.Wpf/Views/DialogCANSchConfigView.xaml b/CapMachine.Wpf/Views/DialogCANSchConfigView.xaml new file mode 100644 index 0000000..bb4b0cd --- /dev/null +++ b/CapMachine.Wpf/Views/DialogCANSchConfigView.xaml @@ -0,0 +1,206 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +