From ffa66defe02d512099ac17958859382142e0f274 Mon Sep 17 00:00:00 2001 From: Tyrone CT Date: Sat, 5 Jul 2025 14:45:10 +0800 Subject: [PATCH] =?UTF-8?q?CAN=20FD=E5=A2=9E=E5=8A=A0V1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../DBCParserByFD.cs} | 8 +- .../CanDrive/{ => CanFD}/ToomossCanFD.cs | 323 +++++++++++++-- .../CanDrive/{ => CanFD}/USB2CANFD.cs | 0 .../CanDrive/CanFD/USB_DEVICEByFD.cs | 143 +++++++ CapMachine.Wpf/Services/CanFdDriveService.cs | 382 ++++++++++++++++++ 5 files changed, 823 insertions(+), 33 deletions(-) rename CapMachine.Wpf/CanDrive/{CANFD_DBCParser.cs => CanFD/DBCParserByFD.cs} (92%) rename CapMachine.Wpf/CanDrive/{ => CanFD}/ToomossCanFD.cs (53%) rename CapMachine.Wpf/CanDrive/{ => CanFD}/USB2CANFD.cs (100%) create mode 100644 CapMachine.Wpf/CanDrive/CanFD/USB_DEVICEByFD.cs create mode 100644 CapMachine.Wpf/Services/CanFdDriveService.cs diff --git a/CapMachine.Wpf/CanDrive/CANFD_DBCParser.cs b/CapMachine.Wpf/CanDrive/CanFD/DBCParserByFD.cs similarity index 92% rename from CapMachine.Wpf/CanDrive/CANFD_DBCParser.cs rename to CapMachine.Wpf/CanDrive/CanFD/DBCParserByFD.cs index 1110e58..0967da2 100644 --- a/CapMachine.Wpf/CanDrive/CANFD_DBCParser.cs +++ b/CapMachine.Wpf/CanDrive/CanFD/DBCParserByFD.cs @@ -5,9 +5,13 @@ using System.Runtime.InteropServices; using System.Text; using System.Threading.Tasks; -namespace CapMachine.Wpf.CanDrive +namespace CapMachine.Wpf.CanDrive.CanFD { - public class CANFD_DBCParser + /// + /// 和DBCParser一样，但用于处理USB设备的DBC文件解析。 + /// DBCParserByFD类用于处理USB设备的DBC文件解析。 + /// + public class DBCParserByFD { public const Int32 DBC_PARSER_OK = 0;//没有错误 public const Int32 DBC_PARSER_FILE_OPEN = (-1);//打开文件出错 diff --git a/CapMachine.Wpf/CanDrive/ToomossCanFD.cs b/CapMachine.Wpf/CanDrive/CanFD/ToomossCanFD.cs similarity index 53% rename from CapMachine.Wpf/CanDrive/ToomossCanFD.cs rename to CapMachine.Wpf/CanDrive/CanFD/ToomossCanFD.cs index a84245b..8abde2d 100644 --- a/CapMachine.Wpf/CanDrive/ToomossCanFD.cs +++ b/CapMachine.Wpf/CanDrive/CanFD/ToomossCanFD.cs @@ -1,5 +1,8 @@ -using CapMachine.Wpf.Models.Tag; +using CapMachine.Wpf.CanDrive.CanFD; +using CapMachine.Wpf.Models.Tag; +using CapMachine.Wpf.Services; using NPOI.OpenXmlFormats.Wordprocessing; +using Prism.Ioc; using Prism.Mvvm; using System; using System.Collections.Generic; @@ -16,18 +19,29 @@ using System.Windows.Interop; namespace CapMachine.Wpf.CanDrive { /// - /// Toomoss CAN + /// Toomoss CANFD /// public class ToomossCanFD : BindableBase { + private readonly IContainerProvider ContainerProvider; + /// /// 实例化函数 /// - public ToomossCanFD() + public ToomossCanFD(IContainerProvider containerProvider) { + ContainerProvider = containerProvider; + HighSpeedDataService = ContainerProvider.Resolve(); + //Stopwatch.Frequency表示高精度计时器每秒的计数次数（ticks/秒）每毫秒的ticks数 = 每秒的ticks数 ÷ 1000 + TicksPerMs = Stopwatch.Frequency / 1000.0; } + /// + /// HighSpeedDataService 实例 + /// + public HighSpeedDataService HighSpeedDataService { get; set; } + /// /// 开始CAN的驱动 /// @@ -45,15 +59,16 @@ namespace CapMachine.Wpf.CanDrive /// /// 开始Dbc文件写入 /// - public void StartDbc(string DbcPath) + public ObservableCollection StartDbc(string DbcPath) { DBC_Parser(DbcPath); + return ListCanFdDbcModel; } /// /// Dbc消息集合 /// - public ObservableCollection ListCanDbcModel { get; set; } = new ObservableCollection(); + public ObservableCollection ListCanFdDbcModel { get; set; } = new ObservableCollection(); #region 公共变量 @@ -61,7 +76,7 @@ namespace CapMachine.Wpf.CanDrive /// /// 设备固件信息 /// - public USB_DEVICE.DEVICE_INFO DevInfo = new USB_DEVICE.DEVICE_INFO(); + public USB_DEVICEByFD.DEVICE_INFO DevInfo = new USB_DEVICEByFD.DEVICE_INFO(); /// /// CAN Config @@ -145,7 +160,7 @@ namespace CapMachine.Wpf.CanDrive /// public bool ScanDevice() { - DevNum = USB_DEVICE.USB_ScanDevice(DevHandles); + DevNum = USB_DEVICEByFD.USB_ScanDevice(DevHandles); if (DevNum <= 0) { Console.WriteLine("No device connected!"); @@ -168,7 +183,7 @@ namespace CapMachine.Wpf.CanDrive public bool OpenDevice() { //打开设备 - OpenState = USB_DEVICE.USB_OpenDevice(DevHandle); + OpenState = USB_DEVICEByFD.USB_OpenDevice(DevHandle); if (!OpenState) { Console.WriteLine("Open device error!"); @@ -190,7 +205,7 @@ namespace CapMachine.Wpf.CanDrive { //获取固件信息 StringBuilder FuncStr = new StringBuilder(256); - OpenState = USB_DEVICE.DEV_GetDeviceInfo(DevHandle, ref DevInfo, FuncStr); + OpenState = USB_DEVICEByFD.DEV_GetDeviceInfo(DevHandle, ref DevInfo, FuncStr); if (!OpenState) { Console.WriteLine("Get device infomation error!"); @@ -206,7 +221,7 @@ namespace CapMachine.Wpf.CanDrive Console.WriteLine(" Functions:" + DevInfo.Functions.ToString("X8")); Console.WriteLine(" Functions String:" + FuncStr); StringBuilder DLLBuildDate = new StringBuilder(256); - USB_DEVICE.DEV_GetDllBuildTime(DLLBuildDate); + USB_DEVICEByFD.DEV_GetDllBuildTime(DLLBuildDate); Console.WriteLine(" DLL Build Date:" + DLLBuildDate); return true; @@ -253,7 +268,7 @@ namespace CapMachine.Wpf.CanDrive } ret = USB2CANFD.CANFD_Init(DevHandle, ReadCANIndex, ref CANConfig); - if (ret != USB2CAN.CAN_SUCCESS) + if (ret != USB2CANFD.CANFD_SUCCESS) { Console.WriteLine("Config CAN failed!"); return; @@ -272,7 +287,7 @@ namespace CapMachine.Wpf.CanDrive public void DBC_Parser(string Path) { //解析DBC文件 - DBCHandle = CANFD_DBCParser.DBC_ParserFile(DevHandle, new StringBuilder(Path)); + DBCHandle = DBCParserByFD.DBC_ParserFile(DevHandle, new StringBuilder(Path)); if (DBCHandle == 0) { Console.WriteLine("Parser DBC File error!"); @@ -283,27 +298,27 @@ namespace CapMachine.Wpf.CanDrive Console.WriteLine("Parser DBC File success!"); } - ListCanDbcModel.Clear(); + ListCanFdDbcModel.Clear(); //打印DBC里面报文和信号相关信息 - int DBCMsgNum = CANFD_DBCParser.DBC_GetMsgQuantity(DBCHandle); + int DBCMsgNum = DBCParserByFD.DBC_GetMsgQuantity(DBCHandle); for (int i = 0; i < DBCMsgNum; i++) { StringBuilder MsgName = new StringBuilder(32); - CANFD_DBCParser.DBC_GetMsgName(DBCHandle, i, MsgName); + DBCParserByFD.DBC_GetMsgName(DBCHandle, i, MsgName); Console.WriteLine("Msg.Name = {0}", MsgName); - int DBCSigNum = CANFD_DBCParser.DBC_GetMsgSignalQuantity(DBCHandle, MsgName); + int DBCSigNum = DBCParserByFD.DBC_GetMsgSignalQuantity(DBCHandle, MsgName); StringBuilder Publisher = new StringBuilder(32); - CANFD_DBCParser.DBC_GetMsgPublisher(DBCHandle, MsgName, Publisher); + DBCParserByFD.DBC_GetMsgPublisher(DBCHandle, MsgName, Publisher); Console.Write("Signals:"); for (int j = 0; j < DBCSigNum; j++) { StringBuilder SigName = new StringBuilder(32); - CANFD_DBCParser.DBC_GetMsgSignalName(DBCHandle, MsgName, j, SigName); + DBCParserByFD.DBC_GetMsgSignalName(DBCHandle, MsgName, j, SigName); Console.Write("{0} ", SigName); //增加信息数据 - ListCanDbcModel.Add(new CanDbcModel() + ListCanFdDbcModel.Add(new CanDbcModel() { MsgName = MsgName.ToString(), MsgId = "", @@ -338,9 +353,9 @@ namespace CapMachine.Wpf.CanDrive { foreach (var itemSignal in itemMsg) { - CANFD_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue); + DBCParserByFD.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue); } - CANFD_DBCParser.DBC_SyncValueToCANFDMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPt); + DBCParserByFD.DBC_SyncValueToCANFDMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPt); CanMsg[Index] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPt, typeof(USB2CANFD.CANFD_MSG)); Index++; } @@ -379,16 +394,262 @@ namespace CapMachine.Wpf.CanDrive } } + + #region 精确发送报文数据 + + // 添加取消标记源字段用于停止任务 + private CancellationTokenSource CycleSendCts; + + /// + /// 计算每毫秒对应的ticks数（只需计算一次） + /// + private double TicksPerMs; + + // 类成员变量定义 精确记时用 + private readonly Stopwatch Stopwatcher = new Stopwatch(); + private long NextExecutionTime; + // 计算需要等待的时间 + private long CurrentTime; + private long DelayTicks; + private int DelayMs; + + private static readonly Random _random = new Random(); + + /// + /// 精确周期发送CAN数据 + /// + public void StartPrecisionCycleSendMsg() + { + // 创建取消标记源 用于控制任务的取消 允许在需要时通过取消令牌来优雅停止任务 + var cancellationTokenSource = new CancellationTokenSource(); + var token = cancellationTokenSource.Token; + + // 保存取消标记，以便在停止时使用 + CycleSendCts = cancellationTokenSource;//将取消标记源保存到类的成员变量CycleSendCts，这样在外部调用停止方法时可以访问它 + NextExecutionTime = 0;//初始化NextExecutionTime为0，这个变量用于记录下一次执行的目标时间点 + + CycleSendTask = Task.Factory.StartNew(async () => + { + try + { + // 设置当前线程为高优先级 + Thread.CurrentThread.Priority = ThreadPriority.AboveNormal; + + // 初始化完成后开始计时 + Stopwatcher.Restart(); + // 预先计算固定值 + long CycleInTicks = (long)(SendCycle * TicksPerMs); + //临时测试用 + //long lastTicks = Stopwatcher.ElapsedTicks; + //IsCycleSend + while (IsCycleSend && !token.IsCancellationRequested) + { + try + { + // 计算下一次执行时间点 ，将当前设置的发送周期SendCycle(毫秒)转换为Stopwatch的计时单位(tick)，累加到NextExecutionTime上 + NextExecutionTime += CycleInTicks; // 转换为Stopwatch计时单位 + + // 获取当前时间点，以Stopwatch的tick为单位 + CurrentTime = Stopwatcher.ElapsedTicks; + //计算需要等待的时间，即目标时间点(NextExecutionTime)与当前时间点(CurrentTime)的差值 + DelayTicks = NextExecutionTime - CurrentTime; + + // 如果还有等待时间，则等待，只有在目标时间点还未到达时才执行等待 + if (DelayTicks > 0) + { + ////此时是需要等待的，那么需要等待多久呢， 将需等待的tick数转换回毫秒 + DelayMs = (int)(DelayTicks / TicksPerMs); + //20这个数据是预估和测试的，可能跟Windows抖动误差就是20ms左右，当然可以不用这个IF()判断，直接SpinWait.SpinUntil(() => Stopwatcher.ElapsedTicks >= NextExecutionTime);但是会导致当前独占一个CPU核心线程 + //所以设置一个20的阈值，20ms以下的延迟使用SpinWait.SpinUntil进行自旋等待，20ms以上的延迟使用Task.Delay进行异步等待，让CPU不至于一直的独占 + if (DelayMs <= 20) + { + SpinWait.SpinUntil(() => Stopwatcher.ElapsedTicks >= NextExecutionTime); + } + else + { + ////使用Task.Delay进行异步等待，大部分等待时间通过这种方式完成，避免线程阻塞 + await Task.Delay(DelayMs - 20, token); + //// 使用SpinWait.SpinUntil进行精确的微调等待。自旋等待会占用CPU资源，但能提供更高的定时精度，确保在精确的时间点执行 + ////上面的Task.Delay可能会因为系统调度等原因导致实际执行时间稍晚于预期，因此在这里使用SpinWait.SpinUntil来确保在精确的时间点执行 + SpinWait.SpinUntil(() => Stopwatcher.ElapsedTicks >= NextExecutionTime); + } + } + + // 如果已经超过了计划时间，立即执行并重新校准 + if (Stopwatcher.ElapsedTicks >= NextExecutionTime + CycleInTicks) + { + //检测是否发生了严重延迟(超过一个周期)。如果当前时间已经超过了下一次计划时间，则说明系统负载过高或其他原因导致无法按时执行， + //此时重置NextExecutionTime为当前时间，避免连续的延迟累积 + // 严重延迟，重新校准 + NextExecutionTime = Stopwatcher.ElapsedTicks; + Console.WriteLine("定时发送延迟过大，重新校准时间"); + } + + // 使用Stopwatch记录实际的执行间隔，而不是DateTime + //Console.WriteLine($"--实际间隔(ms): {(Stopwatcher.ElapsedTicks - lastTicks) / TicksPerMs:F3}, 目标: {SendCycle}"); + //lastTicks = Stopwatcher.ElapsedTicks; + + //Console.WriteLine($"--当前时间(毫秒): {DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}"); + + + // 执行发送CAN逻辑 + { + + var GroupMsg = CmdData.GroupBy(x => x.MsgName); + USB2CANFD.CANFD_MSG[] CanMsg = new USB2CANFD.CANFD_MSG[GroupMsg.Count()]; + for (int i = 0; i < GroupMsg.Count(); i++) + { + CanMsg[i] = new USB2CANFD.CANFD_MSG(); + CanMsg[i].Data = new Byte[64]; + } + + IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG))); + int Index = 0; + + //循环给MSG赋值数据 + foreach (var itemMsg in GroupMsg) + { + foreach (var itemSignal in itemMsg) + { + DBCParserByFD.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue); + } + DBCParserByFD.DBC_SyncValueToCANFDMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend); + CanMsg[Index] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CANFD.CANFD_MSG)); + Index++; + } + + //通过DBC写入数据后生成CanMsg + //将信号值填入CAN消息里面 + + //释放申请的临时缓冲区 + Marshal.FreeHGlobal(msgPtSend); + + //发送CAN数据 + int SendedNum = USB2CANFD.CANFD_SendMsg(DevHandle, WriteCANIndex, CanMsg, (Int32)CanMsg.Length); + if (SendedNum >= 0) + { + //Console.WriteLine("Success send frames:{0}", SendedNum); + IsSendOk = true; + } + else + { + //Console.WriteLine("Send CAN data failed! {0}", SendedNum); + IsSendOk = false; + } + + } + + } + catch (TaskCanceledException) + { + // 任务被取消，正常退出 + break; + } + catch (Exception ex) + { + Console.WriteLine($"CAN周期发送异常: {ex.Message}"); + // 短暂暂停避免异常情况下CPU占用过高 + await Task.Delay(10, token); + } + } + } + catch (Exception ex) + { + // 确保在任何情况下（正常退出、异常、取消）都会停止计时器 + Stopwatcher.Stop(); + + // 清理其他可能的资源 + Console.WriteLine("CAN周期发送任务已结束，资源已清理"); + } + finally + { + // 确保在任何情况下（正常退出、异常、取消）都会停止计时器 + Stopwatcher.Stop(); + } + + }, token, TaskCreationOptions.LongRunning, TaskScheduler.Default); + } + + + /// + /// 修改停止发送的方法 + /// + public void StopCycleSendMsg() + { + IsCycleSend = false; + CycleSendCts?.Cancel(); + } + + #endregion + + + private bool _IsCycleRevice; /// /// 是否循环接收数据 /// - public bool IsCycleRevice { get; set; } + public bool IsCycleRevice + { + get { return _IsCycleRevice; } + set { _IsCycleRevice = value; RaisePropertyChanged(); } + } + + + private bool _IsCycleSend; + /// + /// 是否循环发送数据 + /// + public bool IsCycleSend + { + get { return _IsCycleSend; } + set { _IsCycleSend = value; RaisePropertyChanged(); } + } /// - /// CycleRevice扫描Task + /// 循环发送数据 + /// + public ushort SendCycle { get; set; } = 100; + + /// + /// 循环接受数据 + /// + public ushort ReviceCycle { get; set; } = 500; + + + /// + /// CycleRevice 扫描Task /// private static Task CycleReviceTask { get; set; } + /// + /// CycleSend 扫描Task + /// + private static Task CycleSendTask { get; set; } + + StringBuilder ValueSb = new StringBuilder(16); + double[] ValueDouble = new double[5]; + + private bool _IsSendOk; + /// + /// 发送报文是否OK + /// + public bool IsSendOk + { + get { return _IsSendOk; } + set + { + if (_IsSendOk != value) + { + RaisePropertyChanged(); + _IsSendOk = value; + } + } + } + + /// + /// 要发送的数据 + /// + public List CmdData { get; set; } = new List(); + /// /// 循环获取CAN消息 /// @@ -432,12 +693,12 @@ namespace CapMachine.Wpf.CanDrive Console.WriteLine(""); //将CAN消息数据填充到信号里面 - CANFD_DBCParser.DBC_SyncCANFDMsgToValue(DBCHandle, msgPt, CanNum); + DBCParserByFD.DBC_SyncCANFDMsgToValue(DBCHandle, msgPt, CanNum); //获取信号值并打印出来 StringBuilder ValueStr = new StringBuilder(32); - CANFD_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("TX1"), new StringBuilder("COM_current_Power"), ValueStr); + DBCParserByFD.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("TX1"), new StringBuilder("COM_current_Power"), ValueStr); Console.WriteLine("COM_current_Power = {0}", ValueStr); - CANFD_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("TX1"), new StringBuilder("COM_Curr_dc"), ValueStr); + DBCParserByFD.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("TX1"), new StringBuilder("COM_Curr_dc"), ValueStr); Console.WriteLine("COM_Curr_dc = {0}", ValueStr); } catch (Exception ex) @@ -484,14 +745,14 @@ namespace CapMachine.Wpf.CanDrive Console.WriteLine(""); //将CAN消息数据填充到信号里面 - CANFD_DBCParser.DBC_SyncCANFDMsgToValue(DBCHandle, msgPt, CanNum); + DBCParserByFD.DBC_SyncCANFDMsgToValue(DBCHandle, msgPt, CanNum); //获取信号值并打印出来 StringBuilder ValueStr = new StringBuilder(32); - CANFD_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), ValueStr); + DBCParserByFD.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), ValueStr); Console.WriteLine("moto_speed = {0}", ValueStr); - CANFD_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), ValueStr); + DBCParserByFD.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), ValueStr); Console.WriteLine("oil_pressure = {0}", ValueStr); - CANFD_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), ValueStr); + DBCParserByFD.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), ValueStr); Console.WriteLine("speed_can = {0}", ValueStr); } @@ -503,7 +764,7 @@ namespace CapMachine.Wpf.CanDrive public void CloseDevice() { //关闭设备 - USB_DEVICE.USB_CloseDevice(DevHandle); + USB_DEVICEByFD.USB_CloseDevice(DevHandle); OpenState = false; } diff --git a/CapMachine.Wpf/CanDrive/USB2CANFD.cs b/CapMachine.Wpf/CanDrive/CanFD/USB2CANFD.cs similarity index 100% rename from CapMachine.Wpf/CanDrive/USB2CANFD.cs rename to CapMachine.Wpf/CanDrive/CanFD/USB2CANFD.cs diff --git a/CapMachine.Wpf/CanDrive/CanFD/USB_DEVICEByFD.cs b/CapMachine.Wpf/CanDrive/CanFD/USB_DEVICEByFD.cs new file mode 100644 index 0000000..66b11c1 --- /dev/null +++ b/CapMachine.Wpf/CanDrive/CanFD/USB_DEVICEByFD.cs @@ -0,0 +1,143 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; + +namespace CapMachine.Wpf.CanDrive.CanFD +{ + /// + /// 和USB_DEVICE一样，但用于处理USB设备的CAN FD协议。 + /// + public class USB_DEVICEByFD + { + //定义电压输出值 + public const Byte POWER_LEVEL_NONE = 0; //不输出 + public const Byte POWER_LEVEL_1V8 = 1; //输出1.8V + public const Byte POWER_LEVEL_2V5 = 2; //输出2.5V + public const Byte POWER_LEVEL_3V3 = 3; //输出3.3V + public const Byte POWER_LEVEL_5V0 = 4; //输出5.0V + //设备信息定义 + public struct DEVICE_INFO + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] + public Byte[] FirmwareName; //固件名称字符串 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] + public Byte[] BuildDate; //固件编译时间字符串 + public UInt32 HardwareVersion;//硬件版本号 + public UInt32 FirmwareVersion;//固件版本号 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] + public UInt32[] SerialNumber; //适配器序列号 + public UInt32 Functions; //适配器当前具备的功能 + } + //方法定义 + /** + * @brief 初始化USB设备，并扫描设备连接数，必须调用 + * @param pDevHandle 每个设备的设备号存储地址 + * @retval 扫描到的设备数量 + */ + [DllImport("USB2XXX.dll")] + public static extern Int32 USB_ScanDevice(Int32[] pDevHandle); + /** + * @brief 打开设备，必须调用 + * @param DevHandle 设备索引号 + * @retval 打开设备的状态 + */ + [DllImport("USB2XXX.dll")] + public static extern bool USB_OpenDevice(Int32 DevHandle); + /** + * @brief 关闭设备 + * @param DevHandle 设备索引号 + * @retval 关闭设备的状态 + */ + [DllImport("USB2XXX.dll")] + public static extern bool USB_CloseDevice(Int32 DevHandle); + /** + * @brief 复位设备程序，复位后需要重新调用USB_ScanDevice，USB_OpenDevice函数 + * @param DevHandle 设备索引号 + * @retval 复位设备的状态 + */ + [DllImport("USB2XXX.dll")] + public static extern bool USB_ResetDevice(Int32 DevHandle); + + /** + * @brief 检测到USB断开连接后，重新连接设备 + * @param DevHandle 设备号 + * @retval 重连状态 + */ + [DllImport("USB2XXX.dll")] + public static extern bool USB_RetryConnect(Int32 DevHandle); + + /** + * @brief 获取设备信息，比如设备名称，固件版本号，设备序号，设备功能说明字符串等 + * @param DevHandle 设备索引号 + * @param pDevInfo 设备信息存储结构体指针 + * @param pFunctionStr 设备功能说明字符串 + * @retval 获取设备信息的状态 + */ + [DllImport("USB2XXX.dll")] + public static extern bool DEV_GetDeviceInfo(Int32 DevHandle, ref DEVICE_INFO pDevInfo, StringBuilder pFunctionStr); + /** + * @brief 擦出用户区数据 + * @param DevHandle 设备索引号 + * @retval 用户区数据擦出状态 + */ + [DllImport("USB2XXX.dll")] + public static extern bool DEV_EraseUserData(Int32 DevHandle); + + /** + * @brief 向用户区域写入用户自定义数据，写入数据之前需要调用擦出函数将数据擦出 + * @param DevHandle 设备索引号 + * @param OffsetAddr 数据写入偏移地址，起始地址为0x00，用户区总容量为0x10000字节，也就是64KBye + * @param pWriteData 用户数据缓冲区首地址 + * @param DataLen 待写入的数据字节数 + * @retval 写入用户自定义数据状态 + */ + [DllImport("USB2XXX.dll")] + public static extern bool DEV_WriteUserData(Int32 DevHandle, Int32 OffsetAddr, byte[] pWriteData, Int32 DataLen); + + /** + * @brief 从用户自定义数据区读出数据 + * @param DevHandle 设备索引号 + * @param OffsetAddr 数据写入偏移地址，起始地址为0x00，用户区总容量为0x10000字节，也就是64KBye + * @param pReadData 用户数据缓冲区首地址 + * @param DataLen 待读出的数据字节数 + * @retval 读出用户自定义数据的状态 + */ + [DllImport("USB2XXX.dll")] + public static extern bool DEV_ReadUserData(Int32 DevHandle, Int32 OffsetAddr, byte[] pReadData, Int32 DataLen); + + /** + * @brief 设置可变电压输出引脚输出电压值 + * @param DevHandle 设备索引号 + * @param PowerLevel 输出电压值 + * @retval 设置输出电压状态 + */ + [DllImport("USB2XXX.dll")] + public static extern bool DEV_SetPowerLevel(Int32 DevHandle, byte PowerLevel); + /** + * @brief 或者CAN或者LIN的时间戳原始值 + * @param DevHandle 设备索引号 + * @param pTimestamp 时间戳指针 + * @retval 获取时间戳状态 + */ + [DllImport("USB2XXX.dll")] + public static extern bool DEV_GetTimestamp(Int32 DevHandle, byte BusType, Int32[] pTimestamp); + + /** + * @brief 复位CAN/LIN时间戳，需要在初始化CAN/LIN之后调用 + * @param DevHandle 设备索引号 + * @retval 复位时间戳状态 + */ + [DllImport("USB2XXX.dll")] + public static extern bool DEV_ResetTimestamp(Int32 DevHandle); + /** + * @brief 获取dll编译日期 + * @param pDateTime 输出DLL编译日期字符串 + * @retval 获取dll编译日期字符串 + */ + [DllImport("USB2XXX.dll")] + public static extern bool DEV_GetDllBuildTime(StringBuilder pDateTime); + } +} diff --git a/CapMachine.Wpf/Services/CanFdDriveService.cs b/CapMachine.Wpf/Services/CanFdDriveService.cs new file mode 100644 index 0000000..575f04f --- /dev/null +++ b/CapMachine.Wpf/Services/CanFdDriveService.cs @@ -0,0 +1,382 @@ +using CapMachine.Model.CANLIN; +using CapMachine.Wpf.CanDrive; +using ImTools; +using Prism.Ioc; +using Prism.Mvvm; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace CapMachine.Wpf.Services +{ + /// + /// Can FD驱动服务 + /// + public class CanFdDriveService : BindableBase + { + public HighSpeedDataService HighSpeedDataService { get; } + + /// + /// 实例化函数 + /// + public CanFdDriveService(HighSpeedDataService highSpeedDataService, IContainerProvider containerProvider) + { + ToomossCanFDDrive = new ToomossCanFD(containerProvider); + //高速数据服务 + HighSpeedDataService = highSpeedDataService; + + //ToomossCanFDDrive.StartCanDrive(); + } + + /// + /// 当前选中的CanLinConfigPro 程序 + /// + public CanLinConfigPro SelectedCanLinConfigPro { get; set; } + + + /// + /// 图莫斯 CAN Drive + /// ToomossCanFDDrive + /// + public ToomossCanFD ToomossCanFDDrive { get; set; } + + /// + /// Dbc消息集合 + /// 包括读取的实时值和数据 + /// + public ObservableCollection ListCanDbcModel { get; set; } = new ObservableCollection(); + + /// + /// 初始化CAN的配置信息 + /// + public void InitCanConfig(CanLinConfigPro selectedCanLinConfigPro) + { + //赋值配置数据 + SelectedCanLinConfigPro = selectedCanLinConfigPro; + //为DBC实时数据关联配置的名称 + foreach (var item in SelectedCanLinConfigPro.CanLinConfigContents) + { + var FindData = ListCanDbcModel.FindFirst(a => a.SignalName == item.SignalName); + if (FindData != null) + { + FindData.Name = item.Name; + } + } + } + + /// + /// 开始DBC 配置文件 加载 + /// + /// + public ObservableCollection StartDbc(string Path) + { + ListCanDbcModel = ToomossCanFDDrive.StartDbc(Path); + return ListCanDbcModel; + } + + + #region 程序驱动CAN + + /// + /// 转速 指令数据 实例 + /// + private CanCmdData SpeedCanCmdData { get; set; } + + /// + /// 功率限制 指令数据 实例 + /// + private CanCmdData PwLimitCanCmdData { get; set; } + + /// + /// 使能 指令数据 实例 + /// + private CanCmdData EnableCanCmdData { get; set; } + + /// + /// PTC使能 指令数据 实例 + /// + private CanCmdData PTCEnableCanCmdData { get; set; } + + /// + /// PTC功率 指令数据 实例 + /// + private CanCmdData PTCPwCanCmdData { get; set; } + + /// + /// PTC水流量 指令数据 实例 + /// + private CanCmdData PTCFlowCanCmdData { get; set; } + + /// + /// PTC水温 指令数据 实例 + /// + private CanCmdData PTCWaterTempCanCmdData { get; set; } + + + /// + /// 要发送的CAN指令数据 + /// 在程序配置好后就确定要发送哪些数据 + /// + public List CmdData { get; set; } = new List(); + + /// + /// 增加发送的指令数据 + /// + /// + public void AddCmdData(CanCmdData SendCanCmdData) + { + //提取常用的实例数据 + switch (SendCanCmdData.ConfigName) + { + case "转速": + SpeedCanCmdData = SendCanCmdData; + break; + case "功率限制": + PwLimitCanCmdData = SendCanCmdData; + break; + case "使能": + EnableCanCmdData = SendCanCmdData; + break; + case "Anti_Sleep": + //SpeedCanCmdData = SendCanCmdData; + break; + case "PTC使能": + PTCEnableCanCmdData = SendCanCmdData; + break; + case "PTC功率": + PTCPwCanCmdData = SendCanCmdData; + break; + case "PTC水流量": + PTCFlowCanCmdData = SendCanCmdData; + break; + case "PTC水温": + PTCWaterTempCanCmdData = SendCanCmdData; + break; + default: + break; + } + //添加到发送数据集合 + CmdData.Add(SendCanCmdData); + } + + + /// + /// 更新速度信息 + /// 默认是启动 + /// + /// + public void UpdateSpeedCmdData(double SpeedData) + { + if (SpeedCanCmdData != null) + { + SpeedCanCmdData.SignalCmdValue = SpeedData; + } + //if (EnableCanCmdData != null) + //{ + // EnableCanCmdData.SignalCmdValue = 1; + //} + } + + /// + /// 更新压缩机使能数据 + /// + /// + public void UpdateCapEnableCmdData(bool IsEnable) + { + if (EnableCanCmdData != null) + { + EnableCanCmdData.SignalCmdValue = IsEnable ? 1 : 0; + } + } + + + /// + /// 更新压缩机的功率限制 + /// + /// + public void UpdateCapPwLimitCmdData(double PwLimit) + { + if (PwLimitCanCmdData != null) + { + PwLimitCanCmdData.SignalCmdValue = PwLimit; + } + } + + + /// + /// 更新 PTC使能信号 + /// + /// + public void UpdateCapPTCEnableCmdData(bool IsEnable) + { + if (PTCEnableCanCmdData != null) + { + PTCEnableCanCmdData.SignalCmdValue = IsEnable ? 1 : 0; + } + } + + /// + /// 更新 PTC功率 信号 + /// + /// + public void UpdateCapPTCPwCmdData(double PTCPw) + { + if (PTCPwCanCmdData != null) + { + PTCPwCanCmdData.SignalCmdValue = PTCPw; + } + } + + /// + /// 更新 PTC水流量 信号 + /// + /// + public void UpdateCapPTCFlowCmdData(double Flow) + { + if (PTCFlowCanCmdData != null) + { + PTCFlowCanCmdData.SignalCmdValue = Flow; + } + } + + /// + /// 更新 PTC水温 信号 + /// + /// + public void UpdateCapPTCWaterTempCmdData(double WaterTemp) + { + if (PTCWaterTempCanCmdData != null) + { + PTCWaterTempCanCmdData.SignalCmdValue = WaterTemp; + } + } + + /// + /// 发送消息给CAN 驱动 + /// + public void SendMsgToCanDrive(double SpeedData) + { + if (ToomossCanFDDrive.OpenState) + { + if (CmdData.Count > 0) + { + //更新速度信息 + UpdateSpeedCmdData(SpeedData); + + ToomossCanFDDrive.SendCanMsg(CmdData); + } + else + { + System.Windows.MessageBox.Show("未发现配置的数据内容", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand); + } + } + else + { + System.Windows.MessageBox.Show("未打开CAN通信，无法发送数据", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand); + } + } + + + /// + /// 循环发送数据到CAN + /// + public void CycleSendMsg() + { + if (ToomossCanFDDrive.OpenState) + { + if (ToomossCanFDDrive.IsCycleSend == false) + { + if (CmdData.Count > 0) + { + ToomossCanFDDrive.IsCycleSend = true; + ToomossCanFDDrive.CmdData = CmdData; + //ToomossCanFDDrive.StartCycleSendMsg(); + ToomossCanFDDrive.StartPrecisionCycleSendMsg(); + } + else + { + System.Windows.MessageBox.Show("未发现配置的数据内容", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand); + } + } + else + { + ToomossCanFDDrive.IsCycleSend = false; + } + + } + } + + + + /// + ///循环接收数据 + /// + public void CycleReciveMsg() + { + if (ToomossCanFDDrive.OpenState) + { + if (ToomossCanFDDrive.IsCycleRevice == false) + { + if (ListCanDbcModel.Count > 0) + { + ToomossCanFDDrive.IsCycleRevice = true; + ToomossCanFDDrive.StartCycleReviceCanMsg(); + } + else + { + System.Windows.MessageBox.Show("未发现配置的数据内容", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand); + } + } + else + { + ToomossCanFDDrive.IsCycleRevice = false; + } + } + } + + + /// + /// 获取数据值 + /// 从DBC中获取数据给数据中心集合 + /// + /// + /// + public double GetDbcValueByName(string Name) + { + if (!ToomossCanFDDrive.IsCycleRevice) return 0; + + if (ListCanDbcModel.Any(a => a.Name == Name)) + { + //double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue, out double Result1); + return double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue.Split(" ")[0], out double Result) == true ? Result : 0; + } + return 0; + } + + /// + /// 速度的数据的获取 + /// 获取速度数据值 + /// 从DBC中获取Speed数据给数据中心集合 + /// + /// + /// + public double GetDbcSpeedValueBySpeedName(string Name) + { + if (!ToomossCanFDDrive.IsCycleRevice) return 0; + + if (ListCanDbcModel.Any(a => a.Name == Name)) + { + //double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue, out double Result1); + //return double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue.Split(" ")[0], out double Result) == true ? Result : 0; + return double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue.Split(" ")[0], out double Result) == true ? Result : 0; + } + return 0; + } + + #endregion + + } +}