From 532374d1c465f7c464aba8550cb16199afce575c Mon Sep 17 00:00:00 2001 From: Tyrone CT Date: Thu, 9 Apr 2026 21:56:22 +0800 Subject: [PATCH] =?UTF-8?q?CAN/LIN=20=E5=AF=BC=E5=85=A5=E5=92=8C=E5=AF=BC?= =?UTF-8?q?=E5=87=BA=E5=8A=9F=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .windsurf/rules/zlgcan.md | 36 + CapMachine.Model/CANLIN/CANFdConfigExd.cs | 6 + .../CANLIN/CANFdScheduleConfig.cs | 60 + CapMachine.Model/CANLIN/CanLinConfigPro.cs | 6 + CapMachine.Wpf/CanDrive/CanFD/ToomossCanFD.cs | 602 +++- CapMachine.Wpf/CanDrive/ZlgCan/ZLGAPI.cs | 1250 ++++++++ .../CanDrive/ZlgCan/ZlgCanChannelOptions.cs | 82 + .../CanDrive/ZlgCan/ZlgCanFd200uDriver.cs | 2593 ++++++++++++++++ .../CanDrive/ZlgCan/ZlgCanIdHelper.cs | 62 + .../CanDrive/ZlgCan/ZlgDbcDatabase.cs | 728 +++++ .../CanDrive/ZlgCan/ZlgNativeFrames.cs | 103 + .../CanDrive/ZlgCan/接口函数使用手册.pdf | Bin 0 -> 1666099 bytes CapMachine.Wpf/Dtos/CANFdConfigExdDto.cs | 11 + CapMachine.Wpf/Dtos/CANFdScheduleConfigDto.cs | 83 + CapMachine.Wpf/Services/CanFdDriveService.cs | 59 +- CapMachine.Wpf/Services/ComActionService.cs | 4 +- .../Services/NavigationMenuService.cs | 10 +- CapMachine.Wpf/Services/ZlgCanDriveService.cs | 1008 +++++++ CapMachine.Wpf/Services/ZlgLinDriveService.cs | 1314 ++++++++ .../ViewModels/CANConfigViewModel.cs | 47 +- .../ViewModels/CANFDConfigViewModel.cs | 159 +- .../DialogCANFdSchConfigViewModel.cs | 377 +++ .../DialogCanLinConfigImExportViewModel.cs | 2 +- .../DialogZlgCANFDSchConfigViewModel.cs | 358 +++ .../DialogZlgCANSchConfigViewModel.cs | 402 +++ .../DialogZlgCanLinRwConfigViewModel.cs | 904 ++++++ .../ViewModels/LinConfigViewModel.cs | 12 +- .../ViewModels/ZlgCanDriveConfigViewModel.cs | 2684 +++++++++++++++++ .../ViewModels/ZlgLinDriveConfigViewModel.cs | 1171 +++++++ .../Views/DialogCANFdSchConfigView.xaml | 206 ++ .../Views/DialogCANFdSchConfigView.xaml.cs | 28 + .../Views/DialogCanLinConfigImExportView.xaml | 2 +- .../DialogCanLinConfigImExportView.xaml.cs | 2 +- .../Views/DialogZlgCANFDSchConfigView.xaml | 143 + .../Views/DialogZlgCANFDSchConfigView.xaml.cs | 18 + .../Views/DialogZlgCANSchConfigView.xaml | 180 ++ .../Views/DialogZlgCANSchConfigView.xaml.cs | 28 + .../Views/DialogZlgCanLinRwConfigView.xaml | 373 +++ .../Views/DialogZlgCanLinRwConfigView.xaml.cs | 15 + .../Views/ZlgCanDriveConfigView.xaml | 842 ++++++ .../Views/ZlgCanDriveConfigView.xaml.cs | 28 + .../Views/ZlgLinDriveConfigView.xaml | 741 +++++ .../Views/ZlgLinDriveConfigView.xaml.cs | 28 + Sample/C#_USBCANFD_251215/USBCANFD/ZLGAPI.cs | 1236 ++++++++ Sample/zdbc_c#_251106/DBC/ZLGAPI.cs | 1169 +++++++ .../zdbc_c#_251106/DBC/ZLGAPI.cs | 1169 +++++++ 46 files changed, 20232 insertions(+), 109 deletions(-) create mode 100644 .windsurf/rules/zlgcan.md create mode 100644 CapMachine.Model/CANLIN/CANFdScheduleConfig.cs create mode 100644 CapMachine.Wpf/CanDrive/ZlgCan/ZLGAPI.cs create mode 100644 CapMachine.Wpf/CanDrive/ZlgCan/ZlgCanChannelOptions.cs create mode 100644 CapMachine.Wpf/CanDrive/ZlgCan/ZlgCanFd200uDriver.cs create mode 100644 CapMachine.Wpf/CanDrive/ZlgCan/ZlgCanIdHelper.cs create mode 100644 CapMachine.Wpf/CanDrive/ZlgCan/ZlgDbcDatabase.cs create mode 100644 CapMachine.Wpf/CanDrive/ZlgCan/ZlgNativeFrames.cs create mode 100644 CapMachine.Wpf/CanDrive/ZlgCan/接口函数使用手册.pdf create mode 100644 CapMachine.Wpf/Dtos/CANFdScheduleConfigDto.cs create mode 100644 CapMachine.Wpf/Services/ZlgCanDriveService.cs create mode 100644 CapMachine.Wpf/Services/ZlgLinDriveService.cs create mode 100644 CapMachine.Wpf/ViewModels/DialogCANFdSchConfigViewModel.cs create mode 100644 CapMachine.Wpf/ViewModels/DialogZlgCANFDSchConfigViewModel.cs create mode 100644 CapMachine.Wpf/ViewModels/DialogZlgCANSchConfigViewModel.cs create mode 100644 CapMachine.Wpf/ViewModels/DialogZlgCanLinRwConfigViewModel.cs create mode 100644 CapMachine.Wpf/ViewModels/ZlgCanDriveConfigViewModel.cs create mode 100644 CapMachine.Wpf/ViewModels/ZlgLinDriveConfigViewModel.cs create mode 100644 CapMachine.Wpf/Views/DialogCANFdSchConfigView.xaml create mode 100644 CapMachine.Wpf/Views/DialogCANFdSchConfigView.xaml.cs create mode 100644 CapMachine.Wpf/Views/DialogZlgCANFDSchConfigView.xaml create mode 100644 CapMachine.Wpf/Views/DialogZlgCANFDSchConfigView.xaml.cs create mode 100644 CapMachine.Wpf/Views/DialogZlgCANSchConfigView.xaml create mode 100644 CapMachine.Wpf/Views/DialogZlgCANSchConfigView.xaml.cs create mode 100644 CapMachine.Wpf/Views/DialogZlgCanLinRwConfigView.xaml create mode 100644 CapMachine.Wpf/Views/DialogZlgCanLinRwConfigView.xaml.cs create mode 100644 CapMachine.Wpf/Views/ZlgCanDriveConfigView.xaml create mode 100644 CapMachine.Wpf/Views/ZlgCanDriveConfigView.xaml.cs create mode 100644 CapMachine.Wpf/Views/ZlgLinDriveConfigView.xaml create mode 100644 CapMachine.Wpf/Views/ZlgLinDriveConfigView.xaml.cs create mode 100644 Sample/C#_USBCANFD_251215/USBCANFD/ZLGAPI.cs create mode 100644 Sample/zdbc_c#_251106/DBC/ZLGAPI.cs create mode 100644 Sample/zdbc_c#_251106/zdbc_c#_251106/DBC/ZLGAPI.cs diff --git a/.windsurf/rules/zlgcan.md b/.windsurf/rules/zlgcan.md new file mode 100644 index 0000000..1861d74 --- /dev/null +++ b/.windsurf/rules/zlgcan.md @@ -0,0 +1,36 @@ +--- +（））trigger: manual +--- +### 目标：根据周立功的CAN卡提供的官方资料，进行封装成C#类库供使用，主要是CAN，CAN FD，LIN三个通信，其中CAN和CAN FD使用DBC配置，LIN使用LDF配置， + +### 周立功CAN卡型号：USBCANFD 200U + +### 官网网络资源地址 + +函数库简介：https://manual.zlg.cn/web/#/152/5333 +开发流程：https://manual.zlg.cn/web/#/152/5334 +数据结构定义：https://manual.zlg.cn/web/#/152/5335 +函数说明：https://manual.zlg.cn/web/#/152/5336 +设备类型号：https://manual.zlg.cn/web/#/152/6361 + +### 官方ZLGAPI + +CapMachine.Wpf\CanDrive\ZlgCan\ZLGAPI.cs + +### 官方接口函数使用方法： + +CapMachine.Wpf\CanDrive\ZlgCan\接口函数使用手册.pdf + +### 要求： + +相关的封装内容放到CapMachine.Wpf\CanDrive\ZlgCan下，封装要体现工程化能力，需要考虑性能，后期长时间运行 + +功能要全面，我之前用的图莫斯的CAN卡，是另外一套函数，在CapMachine.Wpf\CanDrive 和CapMachine.Wpf\LinDrive 中封装实现，你可以查看 + +官方的样例在\CapMachine\Sample\C#_USBCANFD_251215，可借鉴使用 + +可以联网查询信息 + +需要详细的注释分析过程 + +当前提供的CAN和LIN的基础能力，我最终需要的是使用DBC（CAN/CAN FD）和LDF（LIN）配置文件进行读取数据和控制发送 diff --git a/CapMachine.Model/CANLIN/CANFdConfigExd.cs b/CapMachine.Model/CANLIN/CANFdConfigExd.cs index 4425e27..bbb670d 100644 --- a/CapMachine.Model/CANLIN/CANFdConfigExd.cs +++ b/CapMachine.Model/CANLIN/CANFdConfigExd.cs @@ -49,5 +49,11 @@ namespace CapMachine.Model.CANLIN /// [Column(Name = "DbcPath", IsNullable = false, StringLength = 500)] public string? DbcPath { get; set; } + + /// + /// 调度表是否启用 + /// + [Column(Name = "SchEnable")] + public bool SchEnable { get; set; } } } diff --git a/CapMachine.Model/CANLIN/CANFdScheduleConfig.cs b/CapMachine.Model/CANLIN/CANFdScheduleConfig.cs new file mode 100644 index 0000000..5789e15 --- /dev/null +++ b/CapMachine.Model/CANLIN/CANFdScheduleConfig.cs @@ -0,0 +1,60 @@ +using FreeSql.DataAnnotations; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace CapMachine.Model.CANLIN +{ + /// + /// 调度表的配置 + /// 其实这些调度表是在DBC中有的，但是图莫斯的驱动没有读取到这些信息 + /// 那么我们在系统层面进行操作和保存这些信息 + /// + [Table(Name = "CANFdScheduleConfig")] + public class CANFdScheduleConfig + { + /// + /// 主键 + /// + [Column(IsPrimary = true, IsIdentity = true)] + public long Id { get; set; } + + /// + /// 消息名称 + /// + [Column(Name = "MsgName")] + public string? MsgName { get; set; } + + /// + /// 消息的周期 + /// + [Column(Name = "Cycle")] + public int Cycle { get; set; } + + /// + /// 发送方式 + /// + [Column(Name = "OrderSend")] + public int OrderSend { get; set; } + + /// + /// 调度表的Index + /// //约定每帧对应一个调度表，预设5个调度表，每个调度表对应一个帧 + /// 0-4这个范围的设置Index + /// + [Column(Name = "SchTabIndex")] + public int SchTabIndex { get; set; } + + + + + /// + /// ///////////////////////////////////////////导航属性/////////////////////////////////////////////////////// + /// + + public long CanLinConfigProId { get; set; } + public CanLinConfigPro? CanLinConfigPro { get; set; } + } +} diff --git a/CapMachine.Model/CANLIN/CanLinConfigPro.cs b/CapMachine.Model/CANLIN/CanLinConfigPro.cs index 48f1f48..1756c75 100644 --- a/CapMachine.Model/CANLIN/CanLinConfigPro.cs +++ b/CapMachine.Model/CANLIN/CanLinConfigPro.cs @@ -50,6 +50,12 @@ namespace CapMachine.Model.CANLIN ///CAN 的调度表配置模式 public List? CanScheduleConfigs { get; set; } + /// + /// ///////////////////////////////////////////导航属性/////////////////////////////////////////////////////// + /// + ///CAN 的调度表配置模式 + public List? CanFdScheduleConfigs { get; set; } + /// /// ///////////////////////////////////////////导航属性/////////////////////////////////////////////////////// /// diff --git a/CapMachine.Wpf/CanDrive/CanFD/ToomossCanFD.cs b/CapMachine.Wpf/CanDrive/CanFD/ToomossCanFD.cs index 2e3dce0..281b631 100644 --- a/CapMachine.Wpf/CanDrive/CanFD/ToomossCanFD.cs +++ b/CapMachine.Wpf/CanDrive/CanFD/ToomossCanFD.cs @@ -1,6 +1,8 @@ using CapMachine.Wpf.CanDrive.CanFD; +using CapMachine.Wpf.Dtos; using CapMachine.Wpf.Models.Tag; using CapMachine.Wpf.Services; +using ImTools; using NPOI.OpenXmlFormats.Wordprocessing; using Prism.Ioc; using Prism.Mvvm; @@ -20,20 +22,41 @@ using System.Windows.Interop; namespace CapMachine.Wpf.CanDrive { /// - /// Toomoss CANFD + /// 图莫斯（Toomoss）CAN FD 驱动封装。 /// + /// + /// 职责边界： + /// - 负责图莫斯 USB2XXX（CANFD）SDK 的设备扫描/打开/初始化/关闭； + /// - 负责 DBC 文件解析，并提供“信号值 <-> CANFD 帧”的互转（通过 SDK 的 DBCParserByFD 接口）； + /// - 提供三类发送能力： + /// - 单次发送（）； + /// - 软件侧精确周期发送（，以及并行版本 ）； + /// - 硬件侧调度表发送（ / ，以及 增量更新）； + /// - 提供接收能力：后台轮询读取报文并同步到 DBC 信号实时值（）。 + /// + /// 线程与资源： + /// - 发送/接收/调度表更新均可能在后台线程运行； + /// - 多处使用 分配非托管内存，必须在 finally 中释放，避免长期运行内存上涨。 + /// + /// 重要约束： + /// - 为 0 表示 DBC 未解析成功，任何 DBC_* 调用都应视为不可用； + /// - / 表示 CANFD 通道索引（0=CAN1,1=CAN2）。 + /// public class ToomossCanFD : BindableBase { private readonly IContainerProvider ContainerProvider; /// - /// 实例化函数 + /// 构造函数。 /// - public ToomossCanFD(IContainerProvider containerProvider) + /// DI 容器。 + /// 日志服务。 + public ToomossCanFD(IContainerProvider containerProvider, ILogService logService) { ContainerProvider = containerProvider; + LoggerService = logService; HighSpeedDataService = ContainerProvider.Resolve(); - LogService = ContainerProvider.Resolve(); + //LogService = ContainerProvider.Resolve(); //Stopwatch.Frequency表示高精度计时器每秒的计数次数（ticks/秒）每毫秒的ticks数 = 每秒的ticks数 ÷ 1000 TicksPerMs = Stopwatch.Frequency / 1000.0; } @@ -43,11 +66,22 @@ namespace CapMachine.Wpf.CanDrive /// public HighSpeedDataService HighSpeedDataService { get; set; } - public ILogService LogService { get; set; } + public ILogService LoggerService { get; set; } /// - /// 开始CAN的驱动 + /// 启动 CANFD 驱动（设备准备流程）。 /// + /// + /// 执行顺序与 SDK 依赖一致： + /// 1) 校验 DLL 是否存在； + /// 2) 扫描设备并选取句柄； + /// 3) 打开设备； + /// 4) 读取设备信息； + /// 5) 获取 CANFD 初始化配置（仲裁/数据波特率）； + /// 6) 初始化 CANFD。 + /// + /// 注意：该方法不解析 DBC；DBC 解析由 显式触发。 + /// public void StartCanDrive() { try @@ -61,14 +95,16 @@ namespace CapMachine.Wpf.CanDrive } catch (Exception ex) { - LogService.Error(ex.Message); + LoggerService.Error(ex.Message); System.Windows.MessageBox.Show($"{ex.Message}", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand); } } /// - /// 开始Dbc文件写入 + /// 解析并加载 DBC 文件。 /// + /// DBC 文件路径。 + /// 解析得到的信号列表（用于 UI 展示与实时值刷新）。 public ObservableCollection StartDbc(string DbcPath) { DBC_Parser(DbcPath); @@ -76,43 +112,51 @@ namespace CapMachine.Wpf.CanDrive } /// - /// Dbc消息集合 + /// DBC 解析得到的信号集合。 /// + /// + /// 接收线程会持续更新 。 + /// public ObservableCollection ListCanFdDbcModel { get; set; } = new ObservableCollection(); #region 公共变量 /// - /// 仲裁波特率 + /// 仲裁波特率（Arbitration Bit Rate）。 /// public uint ArbBaudRate { get; set; } = 500000; /// - /// 数据波特率 + /// 数据波特率（Data Bit Rate）。 /// public uint DataBaudRate { get; set; } = 2000000; /// - /// CAN FD标准 ISO是否启用 + /// 是否启用 ISO CRC（CAN FD ISO 标准）。 /// public bool ISOEnable { get; set; } = true; /// - /// 终端电阻 是否启用 + /// 终端电阻是否启用。 /// public bool ResEnable { get; set; } = true; /// - /// 更新配置 + /// 更新 CANFD 参数配置（仅更新内存变量，实际生效需重新 InitCAN）。 /// - public void UpdateConfig(uint arbBaudRate, uint dataBaudRate, bool iSOEnable, bool resEnable,ushort sendCycle) + /// 仲裁波特率。 + /// 数据波特率。 + /// ISO CRC 使能。 + /// 终端电阻使能。 + /// 软件循环发送周期（ms）。 + public void UpdateConfig(uint arbBaudRate, uint dataBaudRate, bool iSOEnable, bool resEnable, ushort sendCycle) { ArbBaudRate = arbBaudRate; DataBaudRate = dataBaudRate; ISOEnable = iSOEnable; ResEnable = resEnable; - SendCycle=sendCycle; + SendCycle = sendCycle; } /// @@ -136,8 +180,11 @@ namespace CapMachine.Wpf.CanDrive public USB2CANFD.CANFD_BUS_ERROR CurCANFD_BUS_ERROR = new USB2CANFD.CANFD_BUS_ERROR(); /// - /// DBC Handle + /// DBC 解析成功后得到的句柄。 /// + /// + /// 为 0 表示 DBC 未解析/解析失败。 + /// public UInt64 DBCHandle { get; set; } /// @@ -151,19 +198,19 @@ namespace CapMachine.Wpf.CanDrive public Int32 DevHandle { get; set; } = 0; /// - /// Write CAN Index + /// 发送通道索引（0=CAN1,1=CAN2）。 /// public Byte WriteCANIndex { get; set; } = 0; /// - /// Read CAN Index + /// 接收通道索引（0=CAN1,1=CAN2）。 /// public Byte ReadCANIndex { get; set; } = 0; private bool _OpenState; /// - /// 打开设备的状态 + /// 设备打开状态。 /// public bool OpenState { @@ -173,7 +220,7 @@ namespace CapMachine.Wpf.CanDrive private bool _DbcParserState; /// - /// DBC解析的状态 + /// DBC 解析状态。 /// public bool DbcParserState { @@ -402,8 +449,12 @@ namespace CapMachine.Wpf.CanDrive } /// - /// 发送CAN数据 + /// 单次发送：根据 CmdData 中的信号值构建 CANFD 报文并发送。 /// + /// 待发送的信号指令集合（按 MsgName 分组后组成帧）。 + /// + /// 注意：该方法会分配临时非托管内存 msgPt，并在结束前释放。 + /// public void SendCanMsg(List CmdData) { var GroupMsg = CmdData.GroupBy(x => x.MsgName); @@ -414,6 +465,7 @@ namespace CapMachine.Wpf.CanDrive CanMsg[i].Data = new Byte[64]; } + // 非托管缓冲：SDK API 以指针形式写入帧结构体 IntPtr msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG))); int Index = 0; //循环给MSG赋值数据 @@ -447,7 +499,7 @@ namespace CapMachine.Wpf.CanDrive //DBCParser.DBC_SyncValueToCANFDMsg(DBCHandle, new StringBuilder("msg_speed_can"), msgPt); //CanMsg[2] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPt, typeof(USB2CANFD.CANFD_MSG)); - //释放申请的临时缓冲区 + // 释放临时非托管缓冲区，避免内存泄漏 Marshal.FreeHGlobal(msgPt); Console.WriteLine(""); //发送CAN数据 @@ -484,8 +536,18 @@ namespace CapMachine.Wpf.CanDrive private static readonly Random _random = new Random(); /// - /// 精确周期发送CAN数据 + /// 定时扫描更新数据 扫描Task /// + private static Task CycleUpdateCmdTask { get; set; } + + /// + /// 软件侧精确周期发送 CANFD 数据。 + /// + /// + /// - 使用 tick 作为时间基准，减少 DateTime 抖动； + /// - 使用 Task.Delay + SpinWait 组合等待； + /// - 使用 支持外部取消。 + /// public void StartPrecisionCycleSendMsg() { // 创建取消标记源 用于控制任务的取消 允许在需要时通过取消令牌来优雅停止任务 @@ -550,7 +612,7 @@ namespace CapMachine.Wpf.CanDrive //此时重置NextExecutionTime为当前时间，避免连续的延迟累积 // 严重延迟，重新校准 NextExecutionTime = Stopwatcher.ElapsedTicks; - LogService.Info("定时发送延迟过大，重新校准时间"); + LoggerService.Info("定时发送延迟过大，重新校准时间"); Console.WriteLine("定时发送延迟过大，重新校准时间"); } @@ -572,6 +634,7 @@ namespace CapMachine.Wpf.CanDrive CanMsg[i].Data = new Byte[64]; } + // 发送构帧临时缓冲：每轮申请/释放，避免与其他线程共享同一指针导致并发问题 IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG))); int Index = 0; @@ -590,7 +653,7 @@ namespace CapMachine.Wpf.CanDrive //通过DBC写入数据后生成CanMsg //将信号值填入CAN消息里面 - //释放申请的临时缓冲区 + // 释放非托管缓冲区（务必释放，否则长时间运行会造成内存泄漏） Marshal.FreeHGlobal(msgPtSend); //CanMsg[0].Flags = 5; @@ -618,7 +681,7 @@ namespace CapMachine.Wpf.CanDrive } catch (Exception ex) { - LogService.Error(ex.Message); + LoggerService.Error(ex.Message); Console.WriteLine($"CAN周期发送异常: {ex.Message}"); // 短暂暂停避免异常情况下CPU占用过高 IsSendOk = false; @@ -632,7 +695,7 @@ namespace CapMachine.Wpf.CanDrive { // 确保在任何情况下（正常退出、异常、取消）都会停止计时器 Stopwatcher.Stop(); - LogService.Error(ex.Message); + LoggerService.Error(ex.Message); // 清理其他可能的资源 Console.WriteLine("CAN周期发送任务已结束，资源已清理"); IsSendOk = false; @@ -674,8 +737,12 @@ namespace CapMachine.Wpf.CanDrive } /// - /// 修改停止发送的方法 + /// 停止软件循环发送。 /// + /// + /// - 置 为 false，循环自然退出； + /// - 触发 取消，用于尽快唤醒 Delay 并退出。 + /// public void StopCycleSendMsg() { IsCycleSend = false; @@ -765,7 +832,7 @@ namespace CapMachine.Wpf.CanDrive if (messageStopwatch.ElapsedTicks >= nextExecutionTime + cycleInTicks) { nextExecutionTime = messageStopwatch.ElapsedTicks; - LogService.Info($"消息{msgName}定时发送延迟过大，重新校准时间"); + LoggerService.Info($"消息{msgName}定时发送延迟过大，重新校准时间"); } // 使用锁确保DBC操作和发送的线程安全 @@ -779,12 +846,12 @@ namespace CapMachine.Wpf.CanDrive // 为信号赋值 foreach (var signal in signals) { - CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(msgName), + DBCParserByFD.DBC_SetSignalValue(DBCHandle, new StringBuilder(msgName), new StringBuilder(signal.SignalName), signal.SignalCmdValue); } // 同步值到CAN消息 - CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(msgName), msgPtSend); + DBCParserByFD.DBC_SyncValueToCANFDMsg(DBCHandle, new StringBuilder(msgName), msgPtSend); var canMsg = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CAN.CAN_MSG)); // 直接发送此消息，无需通过队列 @@ -800,7 +867,7 @@ namespace CapMachine.Wpf.CanDrive else { IsSendOk = false; - LogService.Info($"消息{msgName}发送失败: {sendedNum}"); + LoggerService.Info($"消息{msgName}发送失败: {sendedNum}"); } } finally @@ -812,23 +879,23 @@ namespace CapMachine.Wpf.CanDrive } catch (TaskCanceledException) { - LogService.Info($"消息{msgName}发送任务被取消"); + LoggerService.Info($"消息{msgName}发送任务被取消"); break; } catch (Exception ex) { - LogService.Info($"消息{msgName}发送异常: {ex.Message}"); + LoggerService.Info($"消息{msgName}发送异常: {ex.Message}"); await Task.Delay(10, token); } } } catch (Exception ex) { - LogService.Info($"消息{msgName}发送线程异常: {ex.Message}"); + LoggerService.Info($"消息{msgName}发送线程异常: {ex.Message}"); } finally { - LogService.Info($"消息{msgName}发送线程已退出"); + LoggerService.Info($"消息{msgName}发送线程已退出"); } }, token, TaskCreationOptions.LongRunning, TaskScheduler.Default); @@ -845,11 +912,11 @@ namespace CapMachine.Wpf.CanDrive } catch (Exception ex) { - LogService.Info($"并行发送监控任务异常: {ex.Message}"); + LoggerService.Info($"并行发送监控任务异常: {ex.Message}"); } finally { - LogService.Info("并行发送任务已全部结束"); + LoggerService.Info("并行发送任务已全部结束"); IsSendOk = false; } }, token, TaskCreationOptions.LongRunning, TaskScheduler.Default); @@ -859,9 +926,405 @@ namespace CapMachine.Wpf.CanDrive + #region 调度表发送报文 + + private bool _SchEnable; + /// + /// 调度表使能开关。 + /// + /// + /// 该开关用于控制“硬件调度表发送”及“CmdData 变化时是否增量更新调度表”。 + /// + public bool SchEnable + { + get { return _SchEnable; } + set + { + _SchEnable = value; + RaisePropertyChanged(); + } + } + + + /// + /// 调度表的发送的报文数据 + /// + private USB2CANFD.CANFD_MSG[] SchCanMsg { get; set; } + + /// + /// 依据消息的分组 + /// + private IEnumerable> GroupMsg { get; set; } + + /// + /// 调度表集合数据 + /// 总共3个调度表，第一个表里面包含3帧数据，第二个调度表包含6帧数据，第三个调度表包含11帧数据 + /// Byte[] MsgTabNum = new Byte[3] { 3, 6, 11 }; + /// + private Byte[] MsgTabNum { get; set; } + + /// + /// 调度表发送的次数集合 + /// 第一个调度表循环发送数据，第二个调度表循环发送数据，第三个调度表只发送3次 + /// UInt16[] SendTimes = new UInt16[3] { 0xFFFF, 0xFFFF, 3 }; + /// + private UInt16[] SendTimes { get; set; } + + /// + /// 预设的调度表的个数 常值 + /// + private const int MsgTabCount = 5; + + /// + /// 定时更新时间 + /// + private int UpdateCycle { get; set; } = 100; + + /// + /// CNA 调度表的配置信息 + /// + public List ListCANScheduleConfig { get; set; } + + Random random = new Random(); + + /// + /// 监控数据 + /// 查找问题用，平时不用 + /// + //public MonitorValueLog monitorValueLog { get; set; } + + /// + /// 更新数据 测试用废弃了 + /// + public void UpdateValue() + { + //通过DBC进行对消息赋值 + IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG))); + int Index = 0; + //循环给MSG赋值数据 + foreach (var itemMsg in GroupMsg) + { + foreach (var itemSignal in itemMsg) + { + itemSignal.SignalCmdValue = random.Next(0, 100); + DBCParserByFD.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue); + } + DBCParserByFD.DBC_SyncValueToCANFDMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend); + SchCanMsg[Index] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CANFD.CANFD_MSG)); + Index++; + } + + //通过DBC写入数据后生成CanMsg + //将信号值填入CAN消息里面 + + //释放申请的临时缓冲区 + Marshal.FreeHGlobal(msgPtSend); + + + ////总共3个调度表，第一个表里面包含3帧数据，第二个调度表包含6帧数据，第三个调度表包含11帧数据 + //MsgTabNum = new Byte[1] { 1 }; + ////第一个调度表循环发送数据，第二个调度表循环发送数据，第三个调度表只发送3次 + //SendTimes = new UInt16[1] { 0xFFFF }; + //var ret = USB2CANFD.CAN_SetSchedule(DevHandle, WriteCANIndex, SchCanMsg, MsgTabNum, SendTimes, 1);//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可 + var ret = USB2CANFD.CANFD_UpdateSchedule(DevHandle, WriteCANIndex, 0, 0, SchCanMsg, 1);//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可 + if (ret == USB2CANFD.CANFD_SUCCESS) + { + Console.WriteLine("Update CAN Schedule Success"); + } + else + { + Console.WriteLine("Update CAN Schedule Error ret = {0}", ret); + return; + } + } + + /// + /// 启动硬件调度表（CANFD）。 + /// + /// + /// 流程与 CAN 类似： + /// 1) 基于 分组构建帧数组； + /// 2) 使用 DBC 将信号值同步到帧； + /// 3) 将调度周期写入帧 ； + /// 4) 调用 CANFD_SetSchedule 下发； + /// 5) 调用 CANFD_StartSchedule 启动调度器 0。 + /// + public void StartSchedule() + { + if (CmdData.Count() == 0) return; + + //依据报文进行分组 + GroupMsg = CmdData.GroupBy(x => x.MsgName)!; + //初始化调度表要发送的消息结构 + SchCanMsg = new USB2CANFD.CANFD_MSG[GroupMsg.Count()]; + for (int i = 0; i < GroupMsg.Count(); i++) + { + SchCanMsg[i] = new USB2CANFD.CANFD_MSG(); + SchCanMsg[i].Data = new Byte[64]; + } + + //通过DBC进行对消息赋值 + 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); + //每个分组就是一个帧指令/消息数据 + SchCanMsg[Index] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CANFD.CANFD_MSG)); + // 将“MsgName -> 帧 index”的映射写回调度表配置，用于调试/定位（当前更新实现是全量更新，不依赖 MsgIndex） + if (ListCANScheduleConfig.Any(a => a.MsgName == itemMsg.Key)) + { + //把帧的位置给ListCANScheduleConfig，方便更新时定位数据 + ListCANScheduleConfig.FindFirst(a => a.MsgName == itemMsg.Key).MsgIndex = Index; + + // 设备 SDK 约定：TimeStamp 字段用于调度表发送周期（单位毫秒） + SchCanMsg[Index].TimeStamp = (uint)ListCANScheduleConfig.FindFirst(a => a.MsgName == itemMsg.Key).Cycle; + } + Index++; + } + //通过DBC写入数据后生成CanMsg + //将信号值填入CAN消息里面 + //释放申请的临时缓冲区 + Marshal.FreeHGlobal(msgPtSend); + + //********就是可以设置多个调度表放那里，但是运行时同一个时刻只能运行调度表其中的一个 ******** + //****** 控制报文SchCanMsg和调度器中第一个调度器中的报文集合和要更新的报文集合都是同一个变量SchCanMsg， ******** + // *** SchCanMsg的Index序号和ListCANScheduleConfig的MsgIndex是一样的 *** + + //图莫斯的Sample：总共3个调度表，第一个表里面包含3帧数据，第二个调度表包含6帧数据，第三个调度表包含11帧数据 + //预设5个调度表，但是我们只用其中第一个调度表，第一个调度表中包括多少消息帧，由系统的控制指令的帧的分布决定，SchCanMsg.Count()是所需要的控制发送的帧，都放到第一个调度表中 + + MsgTabNum = new Byte[MsgTabCount] { (byte)SchCanMsg.Count(), 1, 1, 1, 1 }; + //0xFFFF：调度表循环发送数据，X：调度表循环发送的次数 + //设置每个调度表的发送方式，约定全部为循环发送 + SendTimes = new UInt16[MsgTabCount] { 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF }; + + //SchCanMsg:需要发送的消息集合；MsgTabNum：调度表集合数据；SendTimes：发送次数集合数据；调度表个数：MsgTabCount + var ret = USB2CANFD.CANFD_SetSchedule(DevHandle, WriteCANIndex, SchCanMsg, MsgTabNum, SendTimes, MsgTabCount);//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可 + if (ret == USB2CANFD.CANFD_SUCCESS) + { + Console.WriteLine("Set CAN Schedule Success"); + } + else + { + Console.WriteLine("Set CAN Schedule Error ret = {0}", ret); + LoggerService.Info($"Set CAN Schedule Error; 返回错误代码：{ret}"); + return; + } + + // 约定使用调度器索引 0：同一时刻只能运行一个调度器，且本项目把所有控制帧都集中在同一个调度器里 + //CAN_MSG的TimeStamp就是这个报文发送的周期，由调度器协调 + ret = USB2CANFD.CANFD_StartSchedule(DevHandle, WriteCANIndex, (byte)0, (byte)100, (byte)ListCANScheduleConfig.FirstOrDefault()!.OrderSend); + if (ret == USB2CANFD.CANFD_SUCCESS) + { + Console.WriteLine($"Start CAN Schedule 1 Success，SchTabIndex：{(byte)0} - Cycle：{(byte)100} - OrderSend：{(byte)1}"); + } + else + { + Console.WriteLine("Start CAN Schedule 1 Error ret = {0}", ret); + LoggerService.Info($"Start CAN Schedule 1 Error;"); + return; + } + + + //foreach (var itemGroupMsg in GroupMsg) + //{ + // if (itemGroupMsg == null) continue; + // if (ListCANScheduleConfig.Any(a => a.MsgName!.Contains(itemGroupMsg.Key))) + // { + // var CANScheduleConfig = ListCANScheduleConfig.FindFirst(a => a.MsgName!.Contains(itemGroupMsg.Key)); + // //配置表里面包括这个报文消息内容 + // ret = USB2CANFD.CAN_StartSchedule(DevHandle, WriteCANIndex, (byte)CANScheduleConfig.SchTabIndex, (byte)CANScheduleConfig.Cycle, (byte)CANScheduleConfig.OrderSend); + // if (ret == USB2CANFD.CAN_SUCCESS) + // { + // Console.WriteLine($"Start CAN Schedule 1 Success，SchTabIndex：{(byte)CANScheduleConfig.SchTabIndex} - Cycle：{(byte)CANScheduleConfig.Cycle} - OrderSend：{(byte)CANScheduleConfig.OrderSend}"); + // } + // else + // { + // Console.WriteLine("Start CAN Schedule 1 Error ret = {0}", ret); + // LoggerService.Info($"Start CAN Schedule 1 Error;消息名称：{CANScheduleConfig.MsgName}"); + // return; + // } + // } + // else + // { + // LoggerService.Info($"调度表配置未发现对应的消息报文信息；报文信息{itemGroupMsg.Key}"); + // } + //} + + //走到这里说明调度表执行的是OK的 + //IsSendOk = true; + + } + + + /// + /// 停止硬件调度表。 + /// + /// + /// 停止后设备侧将不再按周期自动发送。 + /// + public void StopSchedule() + { + ret = USB2CANFD.CANFD_StopSchedule(DevHandle, WriteCANIndex);//启动第一个调度表,表里面的CAN帧并行发送 + if (ret == USB2CANFD.CANFD_SUCCESS) + { + IsSendOk = false; + Console.WriteLine("Stop CAN Schedule"); + LoggerService.Info($"Stop CAN Schedule"); + } + else + { + Console.WriteLine("Start CAN Schedule Error ret = {0}", ret); + LoggerService.Info($"Stop CAN Schedule"); + return; + } + + + } + + /// + /// 循环使用的 + /// + private int CycleUpdateIndex = 0; + + /// + /// 绑定/刷新驱动侧要发送的 CmdData，并自动维护“值变化事件”的订阅。 + /// + /// 新的指令集合。 + /// + /// 注意：必须先对旧集合取消订阅，否则会造成重复触发和内存泄漏。 + /// + 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; + } + } + + /// + /// CmdData 中任意信号值变化事件处理。 + /// + /// 事件源。 + /// 变化的 MsgName（约定为报文名）。 + private void CmdData_CanCmdDataChangedHandler(object? sender, string e) + { + UpdateSchDataByCmdDataChanged(); + } + + /// + /// 调度表更新互斥锁。 + /// + private readonly object SchUpdateLock = new object(); + + /// + /// 当 CmdData 中信号值变化时，增量刷新调度表的帧数据。 + /// + /// + /// 触发条件： 与 同时为 true。 + /// 当前实现为“全量覆盖更新”（CANFD_UpdateSchedule）。 + /// + public void UpdateSchDataByCmdDataChanged() + { + try + { + if (!IsCycleSend) return; + if (!SchEnable) return; + + // 基础防御：确保 DBC/ 调度表 / 分组已经初始化 + if (DBCHandle == 0 || SchCanMsg == null || GroupMsg == null) + { + return; + } + + lock (SchUpdateLock) + { + // 重新构建每一帧的 Data，并覆盖更新到设备调度表 + IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG))); + int CycleUpdateIndex = 0; + //循环给MSG赋值数据，顺序是固定的，跟初始时设置是一样的 + foreach (var itemMsg in GroupMsg) + { + foreach (var itemSignal in itemMsg) + { + //itemSignal.SignalCmdValue = random.Next(0, 100); //仿真测试数据使用 + var SetSignalValue = DBCParserByFD.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue); + //monitorValueLog.UpdateValue1(SetSignalValue); + } + var SyncValueToCanMsg = DBCParserByFD.DBC_SyncValueToCANFDMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend); + //monitorValueLog.UpdateValue2(SyncValueToCanMsg); + SchCanMsg[CycleUpdateIndex] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CANFD.CANFD_MSG)); + CycleUpdateIndex++; + } + + //通过DBC写入数据后生成CanMsg + //将信号值填入CAN消息里面 + + // 释放非托管缓冲 + Marshal.FreeHGlobal(msgPtSend); + + //CAN_UpdateSchedule 官网解释 + // ---MsgTabIndex CAN调度表索引号 + // ---MsgIndex 开始更新帧起始索引，若起始索引大于调度表帧数，则将帧添加到调度表后面 + // ---pCanMsg 需要更新的CAN帧指针 + // ---MsgNum pCanMsgTab里面包含的有效帧数 + + //CAN_UpdateSchedule中的MsgIndex表示当前的调度器中的帧Index序号 + //因为调度表中的帧集合和控制帧的集合和要更新的帧集合都是同一个集合SchCanMsg + // 默认调度表索引 0：一次性覆盖更新所有帧（MsgIndex=0, MsgNum=帧数） + var ret = USB2CANFD.CANFD_UpdateSchedule(DevHandle, WriteCANIndex, (byte)0, (byte)(0), SchCanMsg, (byte)SchCanMsg.Count());//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可 + if (ret == USB2CANFD.CANFD_SUCCESS) + { + IsSendOk = true; + Console.WriteLine($"Update CAN Schedule Success -- SchTabIndex：{(byte)0} -- MsgIndex：{(byte)(0)}-- SchCanMsg.Count()：{(SchCanMsg.Count())} "); + //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 + + + + private bool _IsCycleRevice; /// - /// 是否循环接收数据 + /// 是否循环接收数据。 /// public bool IsCycleRevice { @@ -872,7 +1335,7 @@ namespace CapMachine.Wpf.CanDrive private bool _IsCycleSend; /// - /// 是否循环发送数据 + /// 是否循环发送数据。 /// public bool IsCycleSend { @@ -881,12 +1344,12 @@ namespace CapMachine.Wpf.CanDrive } /// - /// 循环发送数据 + /// 软件循环发送周期（毫秒）。 /// public ushort SendCycle { get; set; } = 200; /// - /// 循环接受数据 + /// 接收轮询周期（毫秒）。 /// public ushort ReviceCycle { get; set; } = 200; @@ -906,7 +1369,7 @@ namespace CapMachine.Wpf.CanDrive private bool _IsSendOk; /// - /// 发送报文是否OK + /// 最近一次发送是否成功。 /// public bool IsSendOk { @@ -924,7 +1387,7 @@ namespace CapMachine.Wpf.CanDrive private bool _IsReviceOk; /// - /// 接收报文是否OK + /// 最近一次接收是否成功。 /// public bool IsReviceOk { @@ -941,18 +1404,22 @@ namespace CapMachine.Wpf.CanDrive /// - /// 要发送的数据 + /// 当前激活的指令集合（由 Service/UI 下发）。 /// public List CmdData { get; set; } = new List(); /// - /// 循环获取CAN消息 + /// 启动后台循环接收 CANFD 报文，并同步到 DBC 信号实时值。 /// + /// + /// 注意：当前实现每轮接收都会分配 msgPtRead 并释放，长时间运行会造成 GC 压力和潜在碎片； + /// 若后续需要优化，可参考 CAN 版本的“接收缓冲池复用 + CloseDevice 互斥释放”。 + /// public void StartCycleReviceCanMsg() { CycleReviceTask = Task.Run(async () => { - //var ret = USB2CANFD.CANFD_StartGetMsg(DevHandle, ReadCANIndex); + //var ret = USB2CANFDFD.CANFD_StartGetMsg(DevHandle, ReadCANIndex); while (IsCycleRevice) { await Task.Delay(ReviceCycle); @@ -990,14 +1457,14 @@ namespace CapMachine.Wpf.CanDrive else if (CanNum == 0) { IsReviceOk = false; - Console.WriteLine("No CAN data!"); + //Console.WriteLine("No CAN data!"); } else { IsReviceOk = false; Console.WriteLine("Get CAN data error!"); } - Console.WriteLine(""); + //Console.WriteLine(""); //将CAN消息数据填充到信号里面 DBCParserByFD.DBC_SyncCANFDMsgToValue(DBCHandle, msgPtRead, CanNum); @@ -1008,7 +1475,7 @@ namespace CapMachine.Wpf.CanDrive //有配置的名称的，认为是有用的，则需要读取数据 //if (!string.IsNullOrEmpty(item.Name)) //{ - //CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ValueSb); + //DBCParserByFD.DBC_GetSignalValueStr(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ValueSb); //double[] ValueDouble; DBCParserByFD.DBC_GetSignalValue(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ValueDouble); //item.SignalRtValueSb = ValueSb; @@ -1017,7 +1484,7 @@ namespace CapMachine.Wpf.CanDrive //} } - //释放数据缓冲区，必须释放，否则程序运行一段时间后会报内存不足 + // 释放数据缓冲区，必须释放，否则程序运行一段时间后会报内存不足 Marshal.FreeHGlobal(msgPtRead); Thread.Sleep(10); @@ -1031,8 +1498,8 @@ namespace CapMachine.Wpf.CanDrive catch (Exception ex) { IsReviceOk = false; - LogService.Error(ex.Message); - //LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}"); + LoggerService.Error(ex.Message); + //LoggerService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}"); } } @@ -1091,8 +1558,14 @@ namespace CapMachine.Wpf.CanDrive /// - /// 关闭设备 + /// 关闭设备并释放资源。 /// + /// + /// 释放顺序要点： + /// - 关闭设备并下置状态位； + /// - 若启用调度表则先停止； + /// - 等待接收任务退出（短等待，避免 UI 卡死）。 + /// public void CloseDevice() { //关闭设备 @@ -1101,6 +1574,25 @@ namespace CapMachine.Wpf.CanDrive DbcParserState = false; IsCycleRevice = false; IsCycleSend = false; + if (SchEnable) + { + StopSchedule(); + } + + // 确保定时器发送被停止并释放资源 + //try { StopTimerCycleSendMsg(); } catch { } + + // 等待接收任务结束后释放非托管缓冲区，避免并发释放 + try + { + var task = CycleReviceTask; + if (task != null && !task.IsCompleted) + { + task.Wait(TimeSpan.FromMilliseconds(ReviceCycle + 500)); + } + } + catch { } + } } diff --git a/CapMachine.Wpf/CanDrive/ZlgCan/ZLGAPI.cs b/CapMachine.Wpf/CanDrive/ZlgCan/ZLGAPI.cs new file mode 100644 index 0000000..90e2d76 --- /dev/null +++ b/CapMachine.Wpf/CanDrive/ZlgCan/ZLGAPI.cs @@ -0,0 +1,1250 @@ +using System.Runtime.InteropServices; + +namespace CapMachine.Wpf.CanDrive.ZlgCan +{ + /// + /// ZLG 原生驱动（zlgcan.dll）P/Invoke 映射层。 + /// 说明： + /// - 本类仅负责将厂商 SDK 的函数/常量/结构体映射到 C#，不包含任何业务逻辑；上层 Driver/Service 会对这些 API 进行封装并提供线程安全与资源管理。 + /// - 互操作注意事项： + /// 1) zlgcan.dll 必须随程序部署且位数与进程一致（x86/x64），否则会在加载/调用时失败。 + /// 2) 结构体需严格按 SDK 定义设置 与 Pack；字段顺序与大小必须一致。 + /// 3) DllImport 的 CallingConvention 与 SetLastError 需与 SDK 匹配，否则可能出现栈不平衡或错误码不可用。 + /// - 约定：当前工程中通常由 ZlgCanFd200uDriver 负责检查 DLL 存在与架构匹配，并在打开设备前完成预检查。 + /// + public class ZLGCAN + { + + #region 设备类型 + // 设备类型常量：用于 ZCAN_OpenDevice/ZCAN_OpenDeviceByName。 + // 说明：常量值来自厂商 SDK；此处保持原值以便与文档/示例对照。 + public static UInt32 ZCAN_PCI9810 = 2; + public static UInt32 ZCAN_USBCAN1 = 3; + public static UInt32 ZCAN_USBCAN2 = 4; + public static UInt32 ZCAN_PCI9820 = 5; + public static UInt32 ZCAN_CANETUDP = 12; + public static UInt32 ZCAN_PCI9840 = 14; + public static UInt32 ZCAN_PCI9820I = 16; + public static UInt32 ZCAN_CANETTCP = 17; + public static UInt32 ZCAN_PCI5010U = 19; + public static UInt32 ZCAN_USBCAN_E_U = 20; + public static UInt32 ZCAN_USBCAN_2E_U = 21; + public static UInt32 ZCAN_PCI5020U = 22; + public static UInt32 ZCAN_PCIE9221 = 24; + public static UInt32 ZCAN_WIFICAN_TCP = 25; + public static UInt32 ZCAN_WIFICAN_UDP = 26; + public static UInt32 ZCAN_PCIe9120 = 27; + public static UInt32 ZCAN_PCIe9110 = 28; + public static UInt32 ZCAN_PCIe9140 = 29; + public static UInt32 ZCAN_USBCAN_4E_U = 31; + public static UInt32 ZCAN_CANDTU_200UR = 32; + public static UInt32 ZCAN_USBCAN_8E_U = 34; + public static UInt32 ZCAN_CANDTU_NET = 36; + public static UInt32 ZCAN_CANDTU_100UR = 37; + public static UInt32 ZCAN_PCIE_CANFD_200U = 39; + public static UInt32 ZCAN_PCIE_CANFD_400U = 40; + public static UInt32 ZCAN_USBCANFD_200U = 41; + public static UInt32 ZCAN_USBCANFD_100U = 42; + public static UInt32 ZCAN_USBCANFD_MINI = 43; + public static UInt32 ZCAN_CANSCOPE = 45; + public static UInt32 ZCAN_CLOUD = 46; + public static UInt32 ZCAN_CANDTU_NET_400 = 47; + public static UInt32 ZCAN_CANFDNET_TCP = 48; + public static UInt32 ZCAN_CANFDNET_200U_TCP = 48; + public static UInt32 ZCAN_CANFDNET_UDP = 49; + public static UInt32 ZCAN_CANFDNET_200U_UDP = 49; + public static UInt32 ZCAN_CANFDWIFI_TCP = 50; + public static UInt32 ZCAN_CANFDWIFI_100U_TCP = 50; + public static UInt32 ZCAN_CANFDWIFI_UDP = 51; + public static UInt32 ZCAN_CANFDWIFI_100U_UDP = 51; + public static UInt32 ZCAN_CANFDNET_400U_TCP = 52; + public static UInt32 ZCAN_CANFDNET_400U_UDP = 53; + public static UInt32 ZCAN_CANFDNET_100U_TCP = 55; + public static UInt32 ZCAN_CANFDNET_100U_UDP = 56; + public static UInt32 ZCAN_CANFDNET_800U_TCP = 57; + public static UInt32 ZCAN_CANFDNET_800U_UDP = 58; + public static UInt32 ZCAN_USBCANFD_800U = 59; + public static UInt32 ZCAN_PCIE_CANFD_100U_EX = 60; + public static UInt32 ZCAN_PCIE_CANFD_400U_EX = 61; + public static UInt32 ZCAN_PCIE_CANFD_200U_MINI = 62; + public static UInt32 ZCAN_PCIE_CANFD_200U_EX = 63; + public static UInt32 ZCAN_PCIE_CANFD_200U_M2 = 63; + public static UInt32 ZCAN_CANFDDTU_400_TCP = 64; + public static UInt32 ZCAN_CANFDDTU_400_UDP = 65; + public static UInt32 ZCAN_CANFDWIFI_200U_TCP = 66; + public static UInt32 ZCAN_CANFDWIFI_200U_UDP = 67; + public static UInt32 ZCAN_CANFDDTU_800ER_TCP = 68; + public static UInt32 ZCAN_CANFDDTU_800ER_UDP = 69; + public static UInt32 ZCAN_CANFDDTU_800EWGR_TCP = 70; + public static UInt32 ZCAN_CANFDDTU_800EWGR_UDP = 71; + public static UInt32 ZCAN_CANFDDTU_600EWGR_TCP = 72; + public static UInt32 ZCAN_CANFDDTU_600EWGR_UDP = 73; + public static UInt32 ZCAN_CANFDDTU_CASCADE_TCP = 74; + public static UInt32 ZCAN_CANFDDTU_CASCADE_UDP = 75; + public static UInt32 ZCAN_USBCANFD_400U = 76; + public static UInt32 ZCAN_CANFDDTU_200U = 77; + public static UInt32 ZCAN_ZPSCANFD_TCP = 78; + public static UInt32 ZCAN_ZPSCANFD_USB = 79; + public static UInt32 ZCAN_CANFDBRIDGE_PLUS = 80; + public static UInt32 ZCAN_CANFDDTU_300U = 81; + public static UInt32 ZCAN_PCIE_CANFD_800U = 82; + public static UInt32 ZCAN_PCIE_CANFD_1200U = 83; + public static UInt32 ZCAN_MINI_PCIE_CANFD = 84; + public static UInt32 ZCAN_USBCANFD_800H = 85; + #endregion + + #region LIN事件 + // LIN 事件常量：用于接收/状态通知。 + public static UInt32 ZCAN_LIN_WAKE_UP = 1; + public static UInt32 ZCAN_LIN_ENTERED_SLEEP_MODE = 2; + public static UInt32 ZCAN_LIN_EXITED_SLEEP_MODE = 3; + #endregion + + #region 函数 + // 原生函数导入： + // - 这里不逐个函数详注，具体语义以 SDK 文档为准； + // - 上层 Driver 会封装为更易用的 C# API，并处理错误码、重试、线程模型等。 + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall, SetLastError = true)] + public static extern IntPtr ZCAN_OpenDevice(uint device_type, uint device_index, uint reserved); + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall, SetLastError = true)] + public static extern IntPtr ZCAN_OpenDeviceByName(uint device_type, string name); + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_CloseDevice(IntPtr device_handle); + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_IsDeviceOnLine(IntPtr device_handle); + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_GetDeviceInf(IntPtr device_handle, IntPtr pInfo); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_InitCAN(IntPtr device_handle, uint can_index, IntPtr pInitConfig); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_InitCAN(IntPtr device_handle, uint can_index, ref ZCAN_CHANNEL_INIT_CONFIG config); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_StartCAN(IntPtr chn_handle); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ResetCAN(IntPtr chn_handle); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ClearBuffer(IntPtr chn_handle); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReadChannelErrInfo(IntPtr chn_handle, ref ZCAN_CHANNEL_ERR_INFO pErrInfo); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_GetReceiveNum(IntPtr channel_handle, byte type); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_Transmit(IntPtr channel_handle, IntPtr pTransmit, uint len); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_TransmitFD(IntPtr channel_handle, IntPtr pTransmit, uint len); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_TransmitData(IntPtr device_handle, IntPtr pTransmit, uint len); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_Receive(IntPtr channel_handle, IntPtr pReceive, uint len, int wait_time = -1); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReceiveFD(IntPtr channel_handle, IntPtr pReceive, uint len, int wait_time = -1); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReceiveData(IntPtr device_handle, IntPtr pReceive, uint len, int wait_time); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetValue(IntPtr device_handle, string path, string value); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetValue(IntPtr device_handle, string path, IntPtr value); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetValue(IntPtr device_handle, string path, ref ZCAN_AUTO_TRANSMIT_OBJ value); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetValue(IntPtr device_handle, string path, ref ZCANFD_AUTO_TRANSMIT_OBJ value); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_GetValue(IntPtr device_handle, string path); + + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_InitLIN(IntPtr device_handle, uint lin_index, IntPtr pLINInitConfig); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_StartLIN(IntPtr channel_handle); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ResetLIN(IntPtr channel_handle); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_TransmitLIN(IntPtr channel_handle, IntPtr pSend, uint Len); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_GetLINReceiveNum(IntPtr channel_handle); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReceiveLIN(IntPtr channel_handle, IntPtr pReceive, uint Len, int WaitTime); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetLINPublish(IntPtr channel_handle, IntPtr pSend, uint nPublishCount); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetLINSubscribe(IntPtr channel_handle, IntPtr pSend, uint nSubscribeCount); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_WakeUpLIN(IntPtr channel_handle); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_Request(IntPtr device_handle, IntPtr req, IntPtr resp, IntPtr dataBuf, uint dataBufSize); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_Control(IntPtr device_handle, IntPtr ctrl, IntPtr resp); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_RequestEX(IntPtr device_handle, IntPtr requestData, IntPtr resp, IntPtr dataBuf, uint dataBufSize); + + + [DllImport("zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_ControlEX(IntPtr device_handle, uint dataType, IntPtr ctrl, IntPtr resp); + #endregion + + #region 结构体 + // SDK 结构体定义：用于与原生内存布局一致地传参/收参。 + // 说明：字段注释多数来自 SDK 示例或历史代码；这里主要保证布局与 Pack 正确。 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_DEVICE_INFO + { + public ushort hw_Version; + public ushort fw_Version; + public ushort dr_Version; + public ushort in_Version; + public ushort irq_Num; + public byte can_Num; + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)] + public char[] str_Serial_Num; + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 40)] + public char[] str_hw_Type; + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] + public byte[] reserved; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_CHANNEL_INIT_CONFIG + { + public uint can_type; + public _ZCAN_CHANNEL_INIT_CONFIG config; + } + + + [StructLayout(LayoutKind.Explicit, Pack = 1)] + public struct _ZCAN_CHANNEL_INIT_CONFIG + { + [FieldOffset(0)] + public _ZCAN_CHANNEL_CAN_INIT_CONFIG can; + [FieldOffset(0)] + public _ZCAN_CHANNEL_CANFD_INIT_CONFIG canfd; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZCAN_CHANNEL_CAN_INIT_CONFIG + { + public uint acc_code; + public uint acc_mask; + public uint reserved; + public byte filter; + public byte timing0; + public byte timing1; + public byte mode; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZCAN_CHANNEL_CANFD_INIT_CONFIG + { + public uint acc_code; + public uint acc_mask; + public uint abit_timing; + public uint dbit_timing; + public uint brp; + public byte filter; + public byte mode; + public ushort pad; + public uint reserved; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_CHANNEL_ERR_INFO + { + public uint error_code; + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] + public byte[] passive_ErrData; + public byte arLost_ErrData; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_Transmit_Data + { + public can_frame frame; + public uint transmit_type; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class can_frame + { + public uint can_id; + public byte can_dlc; // frame payload length in byte (0 .. CAN_MAX_DLEN) + public byte __pad; // padding + public byte __res0; // reserved / padding + public byte __res1; // reserved / padding + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] data; // frame data + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class canfd_frame + { + public uint can_id; + public byte len; + public byte flags; + public byte __res0; + public byte __res1; /* reserved / padding */ + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public byte[] data; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZCAN_Receive_Data + { + public can_frame frame; + public UInt64 timestamp; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZCAN_ReceiveFD_Data + { + public canfd_frame frame; + public UInt64 timestamp; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_AUTO_TRANSMIT_OBJ //CANFD定时发送帧结构体 + { + public ushort enable; //0-禁用，1-使能 + public ushort index; //定时报文索引 + public uint interval; //定时周期 + public ZCAN_Transmit_Data obj; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANFD_AUTO_TRANSMIT_OBJ //CANFD定时发送帧结构体 + { + public ushort enable; //0-禁用，1-使能 + public ushort index; //定时报文索引 + public uint interval; //定时周期 + public ZCAN_TransmitFD_Data obj; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_TransmitFD_Data + { + public canfd_frame frame; // 报文数据信息，详见 canfd_frame 结构说明。 + public uint transmit_type; // 发送方式，0=正常发送，1=单次发送，2=自发自收，3=单次自发自收。 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANCANFDData + { + public UInt64 timeStamp; + public UInt32 flag; // flag用于设置一些参数，内部结构可以通过以下函数实现设置和取值 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] + public byte[] extraData; //未使用 + public canfd_frame frame; //实际报文结构体 + + // frameType 帧类型 0-CAN 1-CANFD + public uint frameType + { + get { return (flag & 0x03); } + set { flag = (uint)((flag & ~0x03) | (value & 0x03)); } + } + + // txDelay队列发送延时，延时时间存放在 timeStamp 字段；0-不启用延时，1-启用延时，单位1ms，2-启用延时，单位100us + public uint txDelay + { + get { return ((flag >> 2) & 0x03); } + set { flag = (uint)((flag & ~0x0C) | (value & 0x03) << 2); } + } + + public uint transmitType + { + get { return ((flag >> 4) & 0x0F); } + set { flag = (uint)((flag & ~0x0F) | (value & 0x0F) << 4); } + } + + public uint txEchoRequest + { + get { return ((flag >> 8) & 0x01); } + set { flag = (uint)(flag | (value & 0x01) << 8); } + } + + public uint txEchoed + { + get { return ((flag >> 9) & 0x01); } // bit9 + set { flag = (uint)((flag & ~0x200) | (value & 0x01) << 9); } + } + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct PID + { + public byte rawVal; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct RxData + { + public UInt64 timeStamp; + public byte datalen; + public byte dir; + public byte chkSum; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 13)] + public byte[] reserved; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] data; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANDataObj + { + public byte dataType; // 1-CAN/CANFD数据, 4-LIN数据 + public byte chnl; // 数据通道 + public UInt16 flag; // 未使用 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] + public byte[] extraData; // 未使用 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 92)] + public byte[] data; // 报文结构体 + } + + + // LIN + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINData + { + public PID pid; // 受保护的ID + public RxData rxData; // 数据 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINErrData + { + public UInt64 timeStamp; // 时间戳，单位微秒(us) + public PID pid; // 受保护的ID + + public byte dataLen; // 数据长度 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] data; // 数据 + + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] + public byte[] errData; // 错误信息 + + public byte dir; // 传输方向 + public byte chkSum; // 数据校验，部分设备不支持校验数据的获取 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINEventData + { + public UInt64 timeStamp; // 时间戳，单位微秒(us) + public byte type; // 数据长度 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_MSG + { + public byte chnl; // 数据通道 + public byte dataType; // 0-LIN，1-ErrLIN + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 46)] + public byte[] data; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_INIT_CONFIG + { + public byte linMode; // 0-slave,1-master + public byte chkSumMode; // 1-经典校验，2-增强校验 3-自动(对应eZLINChkSumMode的模式) + public byte maxLength; // 最大数据长度，8~64 + public byte reserved; + public uint libBaud; // 波特率，取值1000~20000 + + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_PUBLISH_CFG + { + public byte ID; // 受保护的ID（ID取值范围为0-63） + public byte datelen; // 范围1~8 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] // 数据段内容 + public byte[] data; + public byte chkSumMode; // 校验方式：0-默认，启动时配置 1-经典校验 2-增强校验(对应eZLINChkSumMode的模式) + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] + public byte[] reserved; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_SUBSCIBE_CFG + { + public byte ID; // 受保护的ID（ID取值范围为0-63） + public byte datelen; // dataLen范围为1-8 当为255（0xff）则表示设备自动识别报文长度 + public byte chkSumMode; // 校验方式：0-默认，启动时配置 1-经典校验 2-增强校验(对应eZLINChkSumMode的模式) + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] + public byte[] reserved; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct SESSION_PARAM + { + public uint timeout; // 响应超时时间(ms)。因PC定时器误差，建议设置不小于200ms + public uint enhanced_timeout; // 收到消极响应错误码为0x78后的超时时间(ms)。因PC定时器误差，建议设置不小于200ms + public byte threeInOne; //三合一，把下面三个变量写进这一个变量 + + // threeInOne 包含以下三个变量 + // BYTE check_any_negative_response : 1; // 接收到非本次请求服务的消极响应时是否需要判定为响应错误 + // BYTE wait_if_suppress_response : 1; // 抑制响应时是否需要等待消极响应，等待时长为响应超时时间 + // BYTE flag : 6; // 保留 + public byte check_any_negative_response + { + get { return (byte)(threeInOne & 0x0001); } + set { threeInOne = (byte)((threeInOne & ~0x0001) | (value & 0x0001)); } + } + public byte wait_if_suppress_response + { + get { return (byte)((threeInOne & 0x0002) >> 1); } + set { threeInOne = (byte)((threeInOne & ~0x0002) | (value & 0x0002)); } + } + public byte flag + { + get { return (byte)((threeInOne & 0x00FC) >> 2); } + set { threeInOne = (byte)((threeInOne & ~0x00FC) | (value & 0x00FC)); } + } + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] + public byte[] reserved0; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct TRANS_PARAM + { + public byte version; // 传输协议版本，VERSION_0，VERSION_1 + public byte max_data_len; // 单帧最大数据长度，can:8，canfd:64 + public byte local_st_min; // 本程序发送流控时用，连续帧之间的最小间隔，0x00-0x7F(0ms~127ms)，0xF1-0xF9(100us~900us) + public byte block_size; // 流控帧的块大小 + public byte fill_byte; // 无效字节的填充数据 + public byte ext_frame; // 0:标准帧 1:扩展帧 + public byte is_modify_ecu_st_min; // 是否忽略ECU 返回流控的STmin，强制使用本程序设置的remote_st_min 参数代替 + public byte remote_st_min; // 发送多帧时用, is_modify_ecu_st_min = 1 时有效，0x00 - 0x7F(0ms~127ms), 0xF1 - 0xF9(100us~900us) + public uint fc_timeout; // 接收流控超时时间(ms)，如发送首帧后需要等待回应流控帧 + public byte fill_mode; // 数据长度填充模式 0-就近填充 1-不填充 2-最大填充 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] + public byte[] reserved0; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct TRANS_PARAM_LIN + { + public byte fill_byte; // 无效字节的填充数据 + public byte st_min; // 从节点准备接收诊断请求的下一帧或传输诊断响应的下一帧所需的最小时间 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] + public byte[] reserved0; + }; + + + // CAN UDS请求数据 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_UDS_REQUEST // 硬件UDS接口构体 + { + public uint req_id; // 请求事务索引ID，范围0~65535 + public byte channel; // 设备通道索引 + public byte frame_type; // 帧类型 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] + public byte[] reserved0; + public uint src_addr; // 请求地址 + public uint dst_addr; // 响应地址 + public byte suppress_response; // 1-抑制响应 + public byte sid; // 请求服务id + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] + public byte[] reserved1; + + public SESSION_PARAM session_param; + public TRANS_PARAM trans_param; + public IntPtr data; // 数据数组(不包含SID) + public uint data_len; // 数据数组的长度 + public uint reserved2; + } + + + // LIN UDS请求数据 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZLIN_UDS_REQUEST // 硬件UDS接口构体 + { + public uint req_id; // 请求事务索引ID，范围0~65535 + public byte channel; // 设备通道索引 + public byte suppress_response; // 1:抑制响应 0:不抑制 + public byte sid; // 请求服务id + public byte Nad; // 节点地址 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] reserved1; + + + public SESSION_PARAM session_param; + public TRANS_PARAM_LIN trans_param; + public IntPtr data; // 数据数组(不包含SID) + public uint data_len; // 数据数组的长度 + public uint reserved2; + } + + + // UDS响应数据 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_UDS_RESPONSE + { + public byte status; // 响应状态 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] + public byte[] reserved; + public byte type; // 响应类型 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] // 大小为8 + public byte[] raw; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct UDS_RESPONSE_Positive + { + public byte sid; // 响应服务id + public uint data_len; // 数据长度(不包含SID), 数据存放在接口传入的dataBuf中 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct UDS_RESPONSE_Negative + { + public byte neg_code; // 固定为0x7F + public byte sid; // 请求服务id + public byte error_code; // 错误码 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct UDS_RESPONSE_raw + { + public ulong raw; + } + + + [StructLayout(LayoutKind.Explicit)] + public struct _UDS_RESPONSE_union + { + [FieldOffset(0)] + public UDS_RESPONSE_Positive zudsPositive; + + [FieldOffset(0)] + public UDS_RESPONSE_Negative zudsNegative; + + [FieldOffset(0)] + public UDS_RESPONSE_raw raw; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANCANFDUdsData + { + public IntPtr req; // 请求信息 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 24)] + public byte[] reserved; // 保留位 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINUdsData + { + public IntPtr req; // 请求信息 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 24)] + public byte[] reserved; // 保留位 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANUdsRequestDataObj + { + public uint dataType; // 数据类型 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 63)] + public byte[] data; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] + public byte[] reserved; // 保留位 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_DYNAMIC_CONFIG_DATA + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public char[] key; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public char[] value; + } + + [StructLayout(LayoutKind.Sequential)] + public struct BusUsage + { + public ulong nTimeStampBegin; // 测量起始时间戳，单位us + public ulong nTimeStampEnd; // 测量结束时间戳，单位us + public byte nChnl; // 通道 + public byte nReserved; // 保留 + public ushort nBusUsage; // 总线利用率(%)，总线利用率*100展示。取值0~10000，如8050表示80.50% + public uint nFrameCount; // 帧数量 + } + #endregion + } + + + public class ZDBC + { + #region 常量定义 + public const int _MAX_FILE_PATH_ = 260; // 最长文件路径 + public const int _DBC_NAME_LENGTH_ = 127; // 名称最长长度 + public const int _DBC_COMMENT_MAX_LENGTH_ = 127; // 注释最长长度 + public const int _DBC_UNIT_MAX_LENGTH_ = 23; // 单位最长长度 + public const int _DBC_SIGNAL_MAX_COUNT_ = 256; // 一个消息含有的信号的最大数目 + + public const int MUTIPLEXER_NONE = 0; // 不使用复用器 + public const int MUTIPLEXER_M_VALUE = 1; // 复用信号，当复用器开关的值为multiplexer_value时，该信号有效 + public const int MUTIPLEXER_M_SWITCH = 2; // 复用器开关，一个DBC消息只能有一个信号为开关 + + public const int FT_CAN = 0; // CAN + public const int FT_CANFD = 1; // CANFD + + public const int PROTOCOL_J1939 = 0; + public const int PROTOCOL_OTHER = 1; + public const uint INVALID_DBC_HANDLE = 0xffffffff; // 无效的DBC句柄 + #endregion + + #region 函数部分 + + // ZDBC.dll + public delegate bool OnSend(IntPtr ctx, IntPtr pObj); + public delegate void OnMultiTransDone(IntPtr ctx, IntPtr pMsg, IntPtr data, UInt16 nLen, byte nDirection); + public static OnSend onSend; + public static OnMultiTransDone onMultiTransDone; + + /// + /// 此函数用于初始化解析模块，只需要初始化一次。 + /// + /// 是否关闭多帧发送，为 1 时不支持多帧的消息发送。 + /// 是否开启异步解析；0-不启动，ZDBC_AsyncAnalyse 接口无效；1-启动, 独立线程解析出消息。 + /// 为 INVALID_DBC_HANDLE 表示初始化失败，其他表示初始化成功，保存该返回值，之后的函数调用都要用到该句柄。 + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZDBC_Init(byte disableMultiSend = 0, byte enableAsyncAnalyse = 1); + + /// + /// 释放资源, 与DBC_Init配对使用 + /// + /// hDBC-句柄, ZDBC_Init的返回值 + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_Release(uint DBCHandle); + + /// + /// 此函数用以加载 DBC 格式文件。 + /// + /// 句柄；ZDBC_Init的返回值 + /// 结构体 FileInfo的指针 + /// 为 true 表示加载成功，false 表示失败。 + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_LoadFile(uint DBCHandle, IntPtr pFileInfo); + + /// + /// 从字符串加载DBC + /// + /// hDBC-句柄, DBC_Load的返回值 + /// pFileContent-文件内容字符串 + /// merge-是否合并到当前数据库; 1:不清除现有的数据, 即支持加载多个文件;0：清除原来的数据 + /// + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_LoadContent(uint DBCHandle, IntPtr pFileContent, uint merge); + + /// + /// 获取文件的第一条消息。 + /// + /// hDBC-句柄, DBC_Load的返回值 + /// pMsg 存储消息的信息 + /// true表示成功 + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetFirstMessage(uint DBCHandle, IntPtr pMsg); + + /// + /// 获取下一条消息。 + /// + /// hDBC-句柄, DBC_Load的返回值 + /// pMsg 存储消息的信息 + /// true表示成功 + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetNextMessage(uint DBCHandle, IntPtr pMsg); + + /// + /// 此函数用以根据 ID 获取消息数据。 + /// + /// 句柄； + /// 帧 ID； + /// 消息信息结构体 + /// + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetMessageById(uint DBCHandle, uint nID, IntPtr pMsg); + + /// + /// 此函数用以获取 DBC 文件中含有的消息数目。 + /// + /// DBC句柄 + /// DBC 文件中含有的消息数目 + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZDBC_GetMessageCount(uint DBCHandle); + + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_Analyse(uint DBCHandle, IntPtr pObj, IntPtr pMsg); + + + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_AsyncAnalyse(uint DBCHandle, IntPtr pObj, uint frame_type, UInt64 extraData); + + + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_OnReceive(uint DBCHandle, IntPtr pObj, uint frame_type); + + + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_SetSender(uint hDBC, OnSend sender, IntPtr ctx); + + + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_SetOnMultiTransDoneFunc(uint hDBC, OnMultiTransDone func, IntPtr ctx); + + + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern byte ZDBC_Send(uint hDBC, IntPtr pMsg); + + /// + /// 根据原始数据解码为 DBCMessage。 + /// + /// DBC句柄 + /// 输出参数，解析结果。 + /// 帧数据数组, ControlCAN 传入 VCI_CAN_OBJ, zlgcan 传入 can_frame。 + /// 原始帧数据个数, 即数组大小。 + /// frame_type 帧类型, 参考FT_CAN=0、FT_CANFD=1，ControlCAN不支持CANFD。 + /// 是否成功。 + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_Decode(uint DBCHandle, IntPtr P2DBCMessage, IntPtr P2Obj, uint nCount, byte frame_type); + + /// + /// 根据 DBCMessage 编码为原始数据。 + /// + /// DBC句柄； + /// 编码的原始数据缓冲区数组, ControlCAN 传入 VCI_CAN_OBJ, zlgcan 传入 can_frame。 + /// 输出参数，pObj 缓冲区大小, 返回时为实际原始数据个数。 + /// 输入参数，DBC 消息。 + /// frame_type 帧类型, FT_CAN=0、FT_CANFD=1，ControlCAN不支持CANFD。 + /// 是否成功。 + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_Encode(uint DBCHandle, IntPtr P2Obj, IntPtr P2nCount, IntPtr pMsg, byte frame_type); + + /// + /// 信号原始值转换为实际值 + /// + /// sgl 信号 + /// rawVal 原始值, 如果该值超出信号长度可表示范围，会被截断。 + /// 实际值 + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern double ZDBC_CalcActualValue(IntPtr sgl, IntPtr rawVal); //原始值通过计算转为实际值,实际值会传入rawVal的地址 + + /// + /// 信号实际值转换为原始值 + /// + /// sgl 信号 + /// actualVal 实际值, 超出可表示范围时会被修正 + /// 原始值 + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt64 ZDBC_CalcRawValue(IntPtr sgl, IntPtr actualVal); + + /// + /// 获取网络节点数量 + /// + /// ZDBC_Init的返回值 + /// 网络节点总数量 + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt32 ZDBC_GetNetworkNodeCount(uint DBCHandle); + + /// + /// + /// + /// ZDBC_Init的返回值 + /// index 位置索引 + /// DBCNetworkNode * node 网络节点信息 + /// + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetNetworkNodeAt(uint DBCHandle, UInt32 index, IntPtr node); + + + /// + /// 获取具体信号的值与含义对个数 + /// + /// ZDBC_Init的返回值 + /// message的ID + /// signal的名字 + /// + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt32 ZDBC_GetValDescPairCount(uint DBCHandle, UInt32 mag_id, string signal_name); + + + /// + /// 获取具体信号的值与含义对 + /// + /// ZDBC_Init的返回值 + /// message的ID + /// signal的名字 + /// ValDescPair结构体类型 + [DllImport("zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_GetValDescPair(uint DBCHandle, UInt32 mag_id, string signal_name, IntPtr pair); + + + #endregion + + #region DBC 结构体部分 + + public struct FileInfo + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _MAX_FILE_PATH_ + 1)] + public byte[] strFilePath; // dbc文件路径 + public byte type; // dbc的协议类型, j1939选择PROTOCOL_J1939, 其他协议选择PROTOCOL_OTHER + public byte merge; // 1:不清除现有的数据, 即支持加载多个文件 0：清除原来的数据 + }; + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct DBCSignal + { + + public UInt32 nStartBit; // 起始位 + public UInt32 nLen; // 位长度 + public double nFactor; // 转换因子 + public double nOffset; // 转换偏移实际值=原始值*nFactor+nOffset + public double nMin; // 最小值 + public double nMax; // 最大值 + public UInt64 nRawvalue; // 原始值 + public byte is_signed; // 1:有符号数据, 0:无符号 + public byte is_motorola; // 是否摩托罗拉格式 + public byte multiplexer_type; // 复用器类型 + public byte val_type; // 0:integer, 1:float, 2:double + public UInt32 multiplexer_value; // 复用器开关值为此值时信号有效 + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_UNIT_MAX_LENGTH_ + 1)] + public byte[] unit; //单位 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strName; //名称 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_COMMENT_MAX_LENGTH_ + 1)] + public byte[] strComment; //注释 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strValDesc; //值描述 + + public double initialValue; // 初始化值（原始值） + public uint initialValueValid; // 初始值是否有效 + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct DBCMessage + { + public UInt32 nSignalCount; // 信号数量 + public UInt32 nID; // ID + public UInt32 nSize; // 消息占的字节数目 + public double nCycleTime; // 发送周期 + public byte nExtend; // 1:扩展帧, 0:标准帧 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_SIGNAL_MAX_COUNT_)] + public DBCSignal[] vSignals; // 信号集合 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strName; // 名称 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_COMMENT_MAX_LENGTH_ + 1)] + public byte[] strComment; // 注释 + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct ValDescPair + { + public double value; // 信号值 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strName; // 对应的值描述 + } + #endregion + } + + + public class ZUDS + { + #region 参数定义 + + public static uint udsRTR = 0x40000000; // Remote Transmission Request + public static uint udsEFF = 0x80000000; // Extend Frame Flag + public static uint udsERR = 0x20000000; // Err flag + + #endregion + + #region 函数部分 + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + public delegate uint OnUDSTransmitDelegate(IntPtr ctx, IntPtr frame, uint count); + + + /// + /// 该函数用于初始化 UDS 函数库，返回操作句柄，用于后续的操作，与 ZUDS_Release + /// 配对使用。 + /// typedef uint32 TP_TYPE; // transport protocol + /// #define DoCAN 0 + /// + /// + /// 操作句柄，= ZUDS_INVALID_HANDLE 为无效句柄，其他值为有效句柄。 + [DllImport("zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt32 ZUDS_Init(uint type); + + + /// + /// 该函数用于释放资源，与 ZUDS_Init 配对使用。 + /// + /// + /// + [DllImport("zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_Release(uint type); + + + /// + /// 该函数用于设置函数库的参数。 + /// + /// + /// 参数类型,= PARAM_TYPE_SESSION 0 用 于 设 置 会 话 层 参 数 ， = + ///PARAM_TYPE_ISO15765 1 用于设置 ISO15765 的通信参数； + /// 参数值,type =PARAM_TYPE_SESSION 0 时为 ZUDS_SESSION_PARAM， + ///type= PARAM_TYPE_ISO15765 1 时为 ZUDS_ISO15765_PARAM。 + [DllImport("zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_SetParam(UInt32 ZUDS_HANDLE, byte type, IntPtr param); + + + /// + /// 该函数用于设置发送回调函数。函数库自身并不发送帧数据，把打包的帧数据通过回调 + ///函数传出给用户发送，用户可通过 zlgcan 函数库进行帧数据发送。 + /// + /// + /// ctx 上下文参数, 在回调函数中传出, 库内部不会处理该参数； + /// ：回调函数原型；typedef uint32 (*OnUDSTransmit)(void* ctx, const ZUDS_FRAME* frame, uint32 count); + [DllImport("zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_SetTransmitHandler(UInt32 ZUDS_HANDLE, IntPtr ctx, OnUDSTransmitDelegate onUDSTransmit); + + + [DllImport("zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_OnReceive(UInt32 ZUDS_HANDLE, IntPtr ZUDS_FRAME); + + + [DllImport("zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_Request(UInt32 ZUDS_HANDLE, IntPtr ZUDS_REQUEST, IntPtr ZUDS_RESPONSE); + + + [DllImport("zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_Stop(UInt32 ZUDS_HANDLE); + + + [DllImport("zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_SetTesterPresent(UInt32 ZUDS_HANDLE, byte enable, IntPtr param); + + #endregion + + #region 结构体部分 + /// + /// 会话层面参数；即一应一答传输时的通讯参数。 + /// + public struct ZUDS_SESSION_PARAM + { + public UInt16 timeout;// ms, timeout to wait the response of the server + public UInt16 enhanced_timeout; // ms,timeout to wait after negative response: error code 0x78 + public UInt32 reserved0; // 保留 + public UInt32 reserved1; // 保留 + } + + + /// + /// 传输数据部分的参数，例如传输时侯每帧报文的字节数。 + /// + public struct ZUDS_ISO15765_PARAM + { + public byte version; // VERSION_0, VERSION_1格式版本，为 VERSION_0 时符合 ISO15765-2 的 2004 版本格式要求；为 + //hVERSION_1 是符合 ISO15765-2 的 2016 版本新增的格式要求，如下图所示 + public byte max_data_len; // max data length, can:8, canfd:64 + public byte local_st_min; // ms, min time between two consecutive frames + public byte block_size; + public byte fill_byte; // fill to invalid byte + public byte frame_type; // 0:std 1:ext + public byte is_modify_ecu_st_min; //是否忽略 ECU 返回流控的 STmin，强制使用本程序设置的 + //remote_st_min 参数代替 + + public byte remote_st_min; //发 送 多 帧 时 用, is_ignore_ecu_st_min = 1 时 有 效 , + //0x00-0x7F(0ms ~127ms), 0xF1-0xF9(100us ~900us) + public UInt16 fc_timeout; //接收流控超时时间(ms), 如发送首帧后需要等待回应流控帧。 + public byte fill_mode;//字节填充模式。FILL_MODE_NONE-不填充0；FILL_MODE_SHORT- 小于 8 字节填充至 8 字节，大于 8 字节时按 DLC 就近填充1；FILL_MODE_MAX- 始终填充至最大数据长度 (不建议)2。 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZUDS_TESTER_PRESENT_PARAM + { + public UInt32 addr;//会话保持的请求地址； + public UInt16 cycle;//发送周期，单位毫秒； + public byte suppress_response; // 1:suppress是否抑制响应，建议设置为 1； + public UInt32 reserved;//：保留，忽略即可。 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZUDS_REQUEST + { + public uint src_addr; // 请求地址 + public uint dst_addr; // 响应地址 + public byte suppress_response; // 1:抑制响应 + public byte sid; //service id of request + public ushort reserve0; + public IntPtr param; //array,params of the service + public uint param_len; //参数数组的长度 + public uint reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZUDS_RESPONSE + { + public byte status; + public byte type; // RT_POSITIVE, RT_NEGATIVE + public _ZUDS_Union union; + public uint reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZUDS_positive + { + public byte sid; // service id of response + public IntPtr param; // array, params of the service, don't free + public uint param_len; + + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZUDS_negative + { + public byte neg_code; // 0x7F + public byte sid; //service id of response + public byte error_code;//消极响应的错误码 + + } + + + [StructLayout(LayoutKind.Explicit)] + public struct _ZUDS_Union + { + [FieldOffset(0)] + public ZUDS_positive zudsPositive; + + [FieldOffset(0)] + public _ZUDS_negative zudsNegative; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZUDS_FRAME + { + public uint id; + public byte extend; + public byte remote; + public byte data_len; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public byte[] data; + public uint reserved; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZUDS_CTX + { + public IntPtr can_type; // 0-CAN 1-CANFD 2-CANFD加速 + public IntPtr chn_handle; // 通道句柄 + } + #endregion + } +} diff --git a/CapMachine.Wpf/CanDrive/ZlgCan/ZlgCanChannelOptions.cs b/CapMachine.Wpf/CanDrive/ZlgCan/ZlgCanChannelOptions.cs new file mode 100644 index 0000000..508084e --- /dev/null +++ b/CapMachine.Wpf/CanDrive/ZlgCan/ZlgCanChannelOptions.cs @@ -0,0 +1,82 @@ +using System; + +namespace CapMachine.Wpf.CanDrive.ZlgCan +{ + /// + /// ZLG CANFD 通道初始化参数。 + /// + public sealed class ZlgCanFdChannelOptions + { + /// + /// 仲裁域波特率（单位：bps）。例如 500000。 + /// + public uint ArbitrationBaudRate { get; set; } = 500000; + + /// + /// 数据域波特率（单位：bps）。例如 2000000。 + /// + public uint DataBaudRate { get; set; } = 2000000; + + /// + /// 终端电阻。 + /// + public bool EnableInternalResistance { get; set; } = true; + + /// + /// 仅监听模式。 + /// + public bool ListenOnly { get; set; } = false; + + /// + /// 是否启用总线利用率上报。 + /// + public bool EnableBusUsage { get; set; } = false; + + /// + /// 总线利用率上报周期（单位：ms）。 + /// + public int BusUsagePeriodMs { get; set; } = 500; + + /// + /// 是否启用设备层“合并接收”（ZCAN_ReceiveData）。 + /// + public bool EnableMergeReceive { get; set; } = false; + + /// + /// 合并接收缓冲区最大帧数量。 + /// + public int MergeReceiveBufferFrames { get; set; } = 100; + } + + /// + /// ZLG LIN 通道初始化参数。 + /// + public sealed class ZlgLinChannelOptions + { + /// + /// LIN 模式：true=主节点，false=从节点。 + /// + public bool IsMaster { get; set; } = true; + + /// + /// 校验模式。 + /// 1-经典校验，2-增强校验，3-自动。 + /// + public byte ChecksumMode { get; set; } = 3; + + /// + /// 最大数据长度（8~64）。 + /// + public byte MaxLength { get; set; } = 8; + + /// + /// 波特率（1000~20000）。 + /// + public uint BaudRate { get; set; } = 19200; + + /// + /// LIN 接收轮询等待时间（ms）。 + /// + public int ReceiveWaitMs { get; set; } = 10; + } +} diff --git a/CapMachine.Wpf/CanDrive/ZlgCan/ZlgCanFd200uDriver.cs b/CapMachine.Wpf/CanDrive/ZlgCan/ZlgCanFd200uDriver.cs new file mode 100644 index 0000000..219e2ff --- /dev/null +++ b/CapMachine.Wpf/CanDrive/ZlgCan/ZlgCanFd200uDriver.cs @@ -0,0 +1,2593 @@ +using CapMachine.Wpf.CanDrive; +using CapMachine.Wpf.Services; +using Prism.Mvvm; +using System; +using System.ComponentModel; +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; +using System.Threading.Tasks; + +namespace CapMachine.Wpf.CanDrive.ZlgCan +{ + /// + /// 周立功 USBCANFD-200U 工程化封装（CAN/CANFD/LIN）。 + /// + /// + /// 设计目标： + /// - 把 ZLG 原生 DLL（zlgcan.dll/zdbc.dll 等）调用封装为可被 WPF/Service 层直接消费的 .NET API； + /// - 统一承载 CAN/CANFD/LIN 三类通道的“打开/初始化/接收/发送/关闭”生命周期； + /// - 支持两类发送： + /// - 普通发送： / / ； + /// - 事件驱动发送：由 订阅 ，在信号值变化时增量下发； + /// - 支持硬件定时发送（调度表）： + /// - 通过 下发 auto_send 列表并 apply； + /// - 运行中通过 MsgName->Index 映射实现“值变化时覆盖更新同 index 的帧数据”（不改变周期）。 + /// + /// 线程与资源（务必理解）： + /// - 接收线程由 创建，回调事件在后台线程触发； + /// - DBC 编码/解码与 CmdData 注入受 保护，避免接收线程与 UI 线程并发访问同一 DBC 对象； + /// - 设备句柄/通道句柄/接收线程生命周期受 保护，避免并发 Open/Close 导致句柄泄漏或 AccessViolation； + /// - auto_send（硬件定时发送）状态受 保护，避免 UI 启停与事件覆盖更新并发冲突。 + /// + public sealed class ZlgCanFd200uDriver : BindableBase, IDisposable + { + /// + /// 驱动全局互斥锁。 + /// + /// + /// 用于保护“设备句柄/通道句柄/接收线程”的生命周期操作： + /// - Open/Init/Start/Reset/Close + /// - StartReceiveLoop/StopReceiveLoop + /// 避免多线程同时开关导致句柄泄漏、AccessViolation 或状态错乱。 + /// + private readonly object _sync = new object(); + + /// + /// 日志服务（用于输出驱动调用、异常、诊断信息）。 + /// + private readonly ILogService _log; + + /// + /// 硬件定时发送(auto_send)相关状态互斥锁。 + /// + /// + /// auto_send 的配置/覆盖更新可能来自不同线程： + /// - UI 线程点击“循环发送/调度表”触发 StartAutoSendSchedule + /// - CmdDataChanged 事件线程触发覆盖更新 + /// 因此必须对“是否启用、映射表、通道/帧类型”等共享状态加锁。 + /// + private readonly object _autoSendSync = new object(); + + /// + /// 当前是否处于硬件定时发送(auto_send)任务运行态。 + /// + private bool _autoSendActive; + + /// + /// 当前硬件定时发送使用的通道索引（0/1）。 + /// + private int _autoSendChannelIndex; + + /// + /// 当前硬件定时发送使用的帧类型（ 或 ）。 + /// + private byte _autoSendFrameType; + + /// + /// MsgName -> auto_send 任务索引列表的映射。 + /// + /// + /// 用于“信号值变化时覆盖更新对应定时发送任务”。 + /// - 一个 MsgName 可能对应多个条目（例如配置了多个相同 MsgName 的调度表行）。 + /// - 覆盖更新时通过 重新写入同 index 的 auto_send 结构体达到更新效果。 + /// + private readonly Dictionary> _autoSendMsgIndex = new Dictionary>(StringComparer.Ordinal); + + /// + /// 预加载的 zlgcan.dll 模块句柄。 + /// + /// + /// 用于在 中强制从输出目录加载指定 DLL，减少被 PATH 中同名 DLL 干扰的风险。 + /// + private static IntPtr _preloadedZlgcanHandle = IntPtr.Zero; + + /// + /// 预加载 zlgcan.dll 失败时记录的错误信息。 + /// + /// + /// - 若预加载失败，后续 OpenDevice 失败时会把该信息拼接到异常提示中，便于定位依赖缺失/位数不匹配等问题。 + /// + private static string? _preloadedZlgcanError; + + /// + /// 设备句柄（ZCAN_OpenDevice 返回）。 + /// + /// + /// - 设备句柄是 CAN/CANFD/LIN 共用的“根句柄”； + /// - auto_send 配置也通过 device_handle + path 进行 SetValue。 + /// + private IntPtr _deviceHandle = IntPtr.Zero; + + /// + /// CAN/CANFD 通道句柄数组（最多 2 通道）。 + /// + private readonly IntPtr[] _canChannelHandles = new IntPtr[2]; + + /// + /// LIN 通道句柄。 + /// + private IntPtr _linChannelHandle = IntPtr.Zero; + + /// + /// 接收线程取消令牌。 + /// + private CancellationTokenSource? _recvCts; + + /// + /// 接收循环任务（后台线程）。 + /// + private Task? _recvTask; + + /// + /// 对象是否已释放。 + /// + private volatile bool _disposed; + + /// + /// DBC 数据结构互斥锁。 + /// + /// + /// 用于保护以下共享状态的并发读写： + /// - 的加载/释放 + /// - 与 的替换 + /// - 的注入与事件订阅/退订 + /// + /// 接收线程在解码时会读取 DBC 与索引，因此这里必须保证读取到的是一致快照。 + /// + private readonly object _dbcSync = new object(); + + /// + /// DBC 数据库实例。 + /// + /// + /// 该对象封装 zdbc.dll 的加载/解析能力，用于： + /// - 接收帧解析为信号值（更新 UI 的 ） + /// - 发送时把 CmdData 的信号值编码为原始帧数据（见 ） + /// + private ZlgDbcDatabase? _dbc; + + /// + /// DBC 解析后的“信号模型集合”（用于 UI 绑定）。 + /// + private ObservableCollection? _dbcModels; + + /// + /// SignalName -> 信号模型的索引，加速更新（接收解码更新时 O(1) 查找）。 + /// + private Dictionary? _dbcModelIndex; + + /// + /// 当前用于发送的指令集合（来源于配置程序+读写设置，外部通过 LoadCmdDataToDrive 注入）。 + /// + /// + /// 该集合的每个元素通常对应一个 Signal（含 MsgName/SignalName/SignalCmdValue）。 + /// - 事件驱动发送：订阅每个元素的 CanCmdDataChangedHandler，在信号变化时增量下发。 + /// - 编码发送：按 MsgName 聚合所有 SignalName/SignalCmdValue，再交给 DBC 编码。 + /// + private List? _cmdData; + + /// + /// CmdData 编码并发送时使用的通道索引。 + /// + private int _cmdSendChannelIndex; + + /// + /// CmdData 编码并发送时使用的帧类型（CAN/CANFD）。 + /// + private byte _cmdSendFrameType; + + /// + /// 构造函数。 + /// + /// 日志服务。 + public ZlgCanFd200uDriver(ILogService logService) + { + _log = logService; + } + + /// + /// 设备打开状态的 backing 字段。 + /// + /// + /// 对外通过 暴露。 + /// - 仅在驱动内部状态切换时写入（例如 /）； + /// - 使用 通知 UI 刷新。 + /// + private bool _openState; + /// + /// 设备打开状态。 + /// + public bool OpenState + { + get { return _openState; } + private set { _openState = value; RaisePropertyChanged(); } + } + + /// + /// 接收线程运行状态的 backing 字段。 + /// + private bool _isReceiving; + /// + /// 是否正在接收。 + /// + public bool IsReceiving + { + get { return _isReceiving; } + private set { _isReceiving = value; RaisePropertyChanged(); } + } + + /// + /// 发送指示灯状态的 backing 字段。 + /// + private bool _isSendOk; + /// + /// 最近是否发生过“发送成功”（用于 UI 指示灯）。 + /// + public bool IsSendOk + { + get { return _isSendOk; } + private set { _isSendOk = value; RaisePropertyChanged(); } + } + + /// + /// 接收指示灯状态的 backing 字段。 + /// + private bool _isReviceOk; + /// + /// 最近是否发生过“接收成功”（用于 UI 指示灯）。 + /// + public bool IsReviceOk + { + get { return _isReviceOk; } + private set { _isReviceOk = value; RaisePropertyChanged(); } + } + + /// + /// 发送指示灯更新 token。 + /// + /// + /// 用于解决“短时间内多次 MarkSendOk 导致的延迟回落互相覆盖”问题： + /// - 每次触发都会递增 token； + /// - 延迟回落时仅当 token 未变化才会把 置回 false。 + /// + private int _sendOkToken; + + /// + /// 接收指示灯更新 token。 + /// + /// + /// 语义同 ，用于 的延迟回落保护。 + /// + private int _reviceOkToken; + + /// + /// 将 置为 true 并在一段时间后自动恢复为 false。 + /// + /// 保持 true 的时间（毫秒）。 + private void MarkSendOk(int holdMs = 800) + { + var token = Interlocked.Increment(ref _sendOkToken); + IsSendOk = true; + Task.Run(async () => + { + await Task.Delay(Math.Max(50, holdMs)); + if (token == _sendOkToken) + { + IsSendOk = false; + } + }); + } + + /// + /// 将 置为 true 并在一段时间后自动恢复为 false。 + /// + /// 保持 true 的时间（毫秒）。 + private void MarkReviceOk(int holdMs = 800) + { + var token = Interlocked.Increment(ref _reviceOkToken); + IsReviceOk = true; + Task.Run(async () => + { + await Task.Delay(Math.Max(50, holdMs)); + if (token == _reviceOkToken) + { + IsReviceOk = false; + } + }); + } + + /// + /// CAN/CANFD 原始帧接收事件。 + /// + /// + /// - 该事件在接收线程中触发（非 UI 线程）； + /// - 订阅方若需要更新 UI，请自行切回 UI 线程； + /// - 即使启用了 DBC 解码，该事件仍会原样抛出原始帧，便于外部做抓包/记录。 + /// + public event Action? CanFrameReceived; + + /// + /// LIN 原始帧接收事件。 + /// + /// + /// 同 ：在接收线程触发，订阅方自行处理线程切换。 + /// + public event Action? LinFrameReceived; + + /// + /// 的 backing 字段。 + /// + private bool _dbcDecodeEnabled; + /// + /// 是否启用 DBC 解码更新（接收帧触发）。 + /// + public bool DbcDecodeEnabled + { + get { return _dbcDecodeEnabled; } + set { _dbcDecodeEnabled = value; RaisePropertyChanged(); } + } + + /// + /// 的 backing 字段。 + /// + private bool _isCycleSend; + /// + /// 是否启用“事件驱动发送”。 + /// + /// + /// 与现有 ToomossCan/ToomossCanFD 行为对齐：只有 IsCycleSend=true 且 SchEnable=true 时， + /// 才会在 CmdDataChanged 事件中触发增量下发。 + /// + public bool IsCycleSend + { + get { return _isCycleSend; } + set { _isCycleSend = value; RaisePropertyChanged(); } + } + + /// + /// 的 backing 字段。 + /// + private bool _schEnable; + /// + /// 发送使能（与 UI 的调度表使能语义对齐）。 + /// + public bool SchEnable + { + get { return _schEnable; } + set { _schEnable = value; RaisePropertyChanged(); } + } + + /// + /// 打开设备（不初始化 CAN/LIN 通道）。 + /// + /// 设备索引（通常 0）。 + /// + /// 说明： + /// - 该方法只负责获取 device_handle（根句柄）；通道初始化由 / 完成； + /// - 若 OpenDevice 失败，为了便于现场定位，代码会输出： + /// - 输出目录 DLL 依赖诊断（是否缺失、位数是否匹配、版本信息）； + /// - 当前进程架构与已加载模块路径； + /// - 该方法是幂等的：若设备已打开则直接返回。 + /// + public void OpenDevice(uint deviceIndex) + { + ThrowIfDisposed(); + + lock (_sync) + { + if (_deviceHandle != IntPtr.Zero) + { + OpenState = true; + return; + } + + EnsureNativeDllExists("zlgcan.dll"); + + // 设备类型固定为 USBCANFD-200U。若后续扩展其它型号，应把 deviceType 抽为配置参数。 + var deviceType = ZLGCAN.ZCAN_USBCANFD_200U; + + try + { + _deviceHandle = ZLGCAN.ZCAN_OpenDevice(deviceType, deviceIndex, 0); + } + catch (Exception ex) + { + var baseDir = AppContext.BaseDirectory; + var dllFullPath = Path.Combine(baseDir, "zlgcan.dll"); + var msg = $"ZCAN_OpenDevice 调用异常。deviceType={deviceType}, deviceIndex={deviceIndex}, " + + $"Is64BitProcess={Environment.Is64BitProcess}, ProcessArch={RuntimeInformation.ProcessArchitecture}, " + + $"DllPath={dllFullPath}, BaseDir={baseDir}。异常：{ex.Message}"; + _log.Error(msg); + throw new InvalidOperationException(msg, ex); + } + + if (_deviceHandle == IntPtr.Zero) + { + var lastError = Marshal.GetLastWin32Error(); + var lastErrorMsg = string.Empty; + try + { + lastErrorMsg = new Win32Exception(lastError).Message; + } + catch + { + } + + var baseDir = AppContext.BaseDirectory; + var dllFullPath = Path.Combine(baseDir, "zlgcan.dll"); + var loadedModulePath = GetLoadedModulePath("zlgcan.dll") ?? string.Empty; + var depDiag = string.Join(" | ", new[] + { + BuildDllDiag(baseDir, "zlgcan.dll"), + BuildDllDiag(baseDir, "USB2XXX.dll"), + BuildDllDiag(baseDir, "libusb-1.0.dll"), + BuildDllDiag(baseDir, "zdbc.dll"), + BuildDllDiag(baseDir, "kerneldlls\\USBCANFD.dll"), + BuildDllDiag(baseDir, "kerneldlls\\CANDevCore.dll"), + BuildDllDiag(baseDir, "kerneldlls\\CANDevice.dll"), + BuildDllDiag(baseDir, "kerneldlls\\CANFDCOM.dll"), + BuildDllDiag(baseDir, "kerneldlls\\CANFDNET.dll"), + BuildDllDiag(baseDir, "kerneldlls\\ZPSCANFD.dll"), + BuildDllDiag(baseDir, "kerneldlls\\USBCANFD800U.dll"), + BuildDllDiag(baseDir, "kerneldlls\\USBCAN.dll"), + BuildDllDiag(baseDir, "kerneldlls\\usbcan.dll"), + }.Where(s => !string.IsNullOrWhiteSpace(s))); + string dllVer = string.Empty; + try + { + if (File.Exists(dllFullPath)) + { + var vi = FileVersionInfo.GetVersionInfo(dllFullPath); + dllVer = vi?.FileVersion ?? string.Empty; + } + } + catch + { + } + + var msg = $"ZCAN_OpenDevice 失败。deviceType={deviceType}, deviceIndex={deviceIndex}。" + + $"Win32LastError={lastError}(0x{lastError:X}){(string.IsNullOrWhiteSpace(lastErrorMsg) ? string.Empty : $"({lastErrorMsg})")}。" + + $"Is64BitProcess={Environment.Is64BitProcess}, ProcessArch={RuntimeInformation.ProcessArchitecture}。" + + $"DllPath={dllFullPath}, DllVersion={dllVer}, LoadedModulePath={loadedModulePath}, BaseDir={baseDir}。" + + $"PreloadError={_preloadedZlgcanError ?? string.Empty}。" + + $"DirDllDiag={depDiag}。" + + "请确认：1) 已安装ZLG驱动；2) 设备已连接且未被其它程序占用；3) 程序位数与 zlgcan.dll 匹配；4) 设备类型/索引正确。"; + + _log.Error(msg); + throw new InvalidOperationException(msg); + } + + OpenState = true; + } + } + + /// + /// 预加载指定路径的原生 DLL，尽量避免被 PATH 中的同名 DLL 干扰。 + /// + /// DLL 完整路径。 + private static void TryPreloadNativeDll(string dllFullPath) + { + try + { + if (_preloadedZlgcanHandle != IntPtr.Zero) + { + return; + } + + if (!string.IsNullOrWhiteSpace(_preloadedZlgcanError)) + { + return; + } + + _preloadedZlgcanHandle = NativeLibrary.Load(dllFullPath); + } + catch (Exception ex) + { + _preloadedZlgcanError = $"{ex.GetType().Name}: {ex.Message}"; + } + } + + /// + /// 构造输出目录下某个 DLL 的诊断信息（架构/大小/版本）。 + /// + /// 输出目录。 + /// DLL 文件名。 + /// 诊断信息字符串；不存在返回 "xxx:not_found"；异常返回 null。 + private static string? BuildDllDiag(string baseDir, string fileName) + { + try + { + if (string.IsNullOrWhiteSpace(baseDir) || string.IsNullOrWhiteSpace(fileName)) + { + return null; + } + + var full = Path.Combine(baseDir, fileName); + if (!File.Exists(full)) + { + return $"{fileName}:not_found"; + } + + var arch = TryGetPeArchitecture(full) ?? string.Empty; + long size = 0; + try + { + size = new FileInfo(full).Length; + } + catch + { + } + + var ver = string.Empty; + try + { + var vi = FileVersionInfo.GetVersionInfo(full); + ver = vi?.FileVersion ?? string.Empty; + } + catch + { + } + + return $"{fileName}:arch={arch},size={size},ver={ver}"; + } + catch + { + return null; + } + } + + /// + /// 获取当前进程中已加载模块的完整路径。 + /// + /// 模块文件名（如 zlgcan.dll）。 + /// 完整路径；获取失败返回 null。 + private static string? GetLoadedModulePath(string moduleFileName) + { + try + { + if (string.IsNullOrWhiteSpace(moduleFileName)) + { + return null; + } + + using var p = Process.GetCurrentProcess(); + foreach (ProcessModule m in p.Modules) + { + if (string.Equals(m.ModuleName, moduleFileName, StringComparison.OrdinalIgnoreCase)) + { + return m.FileName; + } + } + + return null; + } + catch + { + return null; + } + } + + /// + /// 打开设备并初始化 CANFD 通道。 + /// + /// 设备索引（通常 0）。 + /// 通道0配置。 + /// 通道1配置（可为 null 表示不初始化）。 + /// + /// 生命周期语义： + /// - 本方法会执行：OpenDevice -> InitCAN(通道参数) -> StartCAN； + /// - 并根据通道0配置写入“设备级合并接收开关”（0/set_device_recv_merge）； + /// - 初始化过程中如发生异常，会调用 尽量回收已打开的句柄，避免资源泄漏。 + /// + /// 注意： + /// - 合并接收开关属于 device 级能力，因此以通道0配置为准； + /// - 该方法不启动接收线程，接收线程由 单独启动，便于 UI 控制。 + /// + public void OpenAndInitCan(uint deviceIndex, ZlgCanFdChannelOptions channel0, ZlgCanFdChannelOptions? channel1 = null) + { + ThrowIfDisposed(); + + lock (_sync) + { + if (_deviceHandle == IntPtr.Zero) + { + OpenDevice(deviceIndex); + } + + try + { + InitCanChannelInternal(0, channel0); + _canChannelHandles[0] = StartCanChannelInternal(0); + + if (channel1 != null) + { + InitCanChannelInternal(1, channel1); + _canChannelHandles[1] = StartCanChannelInternal(1); + } + + // 合并接收：这是设备级能力，按通道0的配置为准（两通道同时开启/关闭） + var mergeEnable = channel0.EnableMergeReceive; + var mergeRet = ZLGCAN.ZCAN_SetValue(_deviceHandle, "0/set_device_recv_merge", mergeEnable ? "1" : "0"); + if (mergeRet != 1) + { + _log.Warn("设置合并接收失败（0/set_device_recv_merge）。将继续运行，但接收模式可能不符合预期。"); + } + } + catch + { + SafeClose_NoLock(); + throw; + } + } + } + + /// + /// 初始化并启动 LIN 通道。 + /// + /// LIN 通道索引（通常 0）。 + /// LIN 初始化参数。 + /// + /// 说明： + /// - LIN 与 CAN/CANFD 共用同一个 device_handle； + /// - 本工程在 UI/Service 层通常会做 CAN/LIN 互斥校验，避免同时占用同一硬件。 + /// + public void OpenAndInitLin(uint linIndex, ZlgLinChannelOptions options) + { + ThrowIfDisposed(); + + lock (_sync) + { + if (_deviceHandle == IntPtr.Zero) + { + OpenDevice(0); + } + + if (_linChannelHandle != IntPtr.Zero) + { + throw new InvalidOperationException("LIN 通道已初始化。"); + } + + var cfg = new ZLGCAN.ZCAN_LIN_INIT_CONFIG + { + linMode = (byte)(options.IsMaster ? 1 : 0), + chkSumMode = options.ChecksumMode, + maxLength = options.MaxLength, + reserved = 0, + libBaud = options.BaudRate + }; + + IntPtr pCfg = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZLGCAN.ZCAN_LIN_INIT_CONFIG))); + try + { + Marshal.StructureToPtr(cfg, pCfg, false); + _linChannelHandle = ZLGCAN.ZCAN_InitLIN(_deviceHandle, linIndex, pCfg); + } + finally + { + Marshal.FreeHGlobal(pCfg); + } + + if (_linChannelHandle == IntPtr.Zero) + { + throw new InvalidOperationException("ZCAN_InitLIN 失败。"); + } + + var ret = ZLGCAN.ZCAN_StartLIN(_linChannelHandle); + if (ret != 1) + { + throw new InvalidOperationException("ZCAN_StartLIN 失败。"); + } + } + } + + /// + /// 启动后台接收线程。 + /// + /// 是否启用合并接收（ZCAN_ReceiveData）。建议与通道初始化时的 EnableMergeReceive 保持一致。 + /// 接收缓冲最大帧数（合并接收固定数组大小，过小会丢帧）。 + /// + /// 线程与回调说明： + /// - 本方法会创建一个后台 Task 持续读取驱动接收缓冲区； + /// - 收到帧后会触发 / （在后台线程触发，非 UI 线程）； + /// - 若 为 true，会在接收线程中对帧做 DBC 解码并更新 集合。 + /// + /// 注意： + /// - 若你在 UI 层直接绑定 集合并要求线程安全更新，请在订阅事件或更新集合时切回 UI 线程。 + /// + /// 设备未打开或接收线程已启动。 + public void StartReceiveLoop(bool mergeReceive, int bufferFrames = 100) + { + ThrowIfDisposed(); + + lock (_sync) + { + if (_deviceHandle == IntPtr.Zero) + { + throw new InvalidOperationException("设备未打开。"); + } + + if (_recvTask != null) + { + throw new InvalidOperationException("接收线程已启动。"); + } + + if (bufferFrames <= 0) bufferFrames = 1; + + _recvCts = new CancellationTokenSource(); + var token = _recvCts.Token; + + _recvTask = Task.Run(() => + { + IsReceiving = true; + try + { + if (mergeReceive) + { + ReceiveLoop_Merge(token, bufferFrames); + } + else + { + ReceiveLoop_PerChannel(token, bufferFrames); + } + } + catch (Exception ex) + { + _log.Error($"ZLG 接收线程异常退出：{ex.Message}"); + } + finally + { + IsReceiving = false; + } + }, token); + } + } + + /// + /// 加载 DBC 文件，并生成 UI 绑定用的信号集合。 + /// + /// DBC 文件路径。 + /// 是否启用异步解析。 + /// 是否合并加载。 + /// 协议类型。 + /// CanDbcModel 集合。 + /// + /// 成功加载后会： + /// - 重新创建并替换内部 DBC 数据库对象； + /// - 构建用于 UI 展示的 列表； + /// - 建立 SignalName 索引（用于接收线程解码时快速定位模型并更新值）； + /// - 默认开启 ，使接收线程能驱动实时值更新。 + /// + public ObservableCollection StartDbc(string dbcPath, bool enableAsyncAnalyse = true, bool merge = false, byte protocolType = ZDBC.PROTOCOL_OTHER) + { + ThrowIfDisposed(); + + lock (_dbcSync) + { + _dbc?.Dispose(); + _dbc = new ZlgDbcDatabase(_log); + _dbc.Load(dbcPath, enableAsyncAnalyse, merge, protocolType); + + _dbcModels = _dbc.BuildCanDbcModels(); + _dbcModelIndex = BuildDbcModelIndex(_dbcModels); + + DbcDecodeEnabled = true; + + return _dbcModels; + } + } + + /// + /// 设置并订阅要发送的指令集合（事件驱动）。 + /// + /// 指令集合。 + /// 发送通道（0/1）。 + /// 帧类型：ZDBC.FT_CAN 或 ZDBC.FT_CANFD。 + /// + /// 本方法用于建立“信号值变化 => 增量下发”的事件驱动链路： + /// - 会先取消订阅旧集合的变更事件，再订阅新集合； + /// - 仅当 与 同时为 true 时，变更事件才会触发实际发送； + /// - 发送时仍会通过 DBC 对 MsgName 进行编码（见 ）。 + /// + public void LoadCmdDataToDrive(List cmdData, int channelIndex, byte frameType) + { + ThrowIfDisposed(); + + lock (_dbcSync) + { + // 说明：CmdData 的变更事件回调可能与接收线程/调度表线程并发发生。 + // 这里使用 _dbcSync 统一保护： + // - _cmdData 集合引用替换 + // - 事件订阅/退订 + // - _cmdSendChannelIndex/_cmdSendFrameType 写入 + // 以避免事件在“退订一半/替换一半”的中间状态触发导致空引用或错用旧集合。 + if (_cmdData != null) + { + foreach (var old in _cmdData) + { + old.CanCmdDataChangedHandler -= CmdData_CanCmdDataChangedHandler; + } + } + + // 保存最新 CmdData 快照：后续 + // - 事件驱动发送会按 MsgName 聚合信号并编码； + // - 启动硬件调度表也会从 CmdData/DBC 生成原始帧。 + _cmdData = cmdData; + _cmdSendChannelIndex = channelIndex; + _cmdSendFrameType = frameType; + + if (_cmdData != null) + { + foreach (var item in _cmdData) + { + item.CanCmdDataChangedHandler += CmdData_CanCmdDataChangedHandler; + } + } + } + } + + /// + /// 事件驱动回调：某个 MsgName 的信号值变更时，仅增量编码并下发该消息。 + /// + /// 发送方。 + /// 发生变化的消息名称。 + /// + /// 发送策略： + /// - 调度表(硬件 auto_send)运行时：优先覆盖更新设备定时发送列表中的对应条目（见 ）； + /// - 否则：立即编码并发送 1 帧（见 ）。 + /// + /// 说明：该方法由 的变更事件触发，可能不在 UI 线程。 + /// + private void CmdData_CanCmdDataChangedHandler(object? sender, string msgName) + { + try + { + if (!IsCycleSend) return; + if (!SchEnable) return; + + // 注意：该回调可能在非 UI 线程触发，也可能被频繁触发（例如 UI 滑条连续变化）。 + // 这里的实现目标是“尽量少做事”： + // - 若已启用硬件 auto_send：只覆盖更新对应条目帧数据，不做 apply/clear（避免抖动）； + // - 否则直接发送 1 帧，维持信号变化的即时反馈。 + // 调度表使能时：优先使用硬件定时发送（auto_send）进行增量覆盖； + // 若当前未处于 auto_send 任务状态，则回退为直接发送一帧。 + if (TryUpdateAutoSendByMsgName(msgName)) + { + return; + } + + SendOneMsgByCmdData(msgName, _cmdSendChannelIndex, _cmdSendFrameType); + } + catch (Exception ex) + { + _log.Warn($"事件驱动发送异常：{ex.Message}"); + } + } + + /// + /// 按 MsgName 尝试覆盖更新硬件定时发送列表中的对应任务。 + /// + /// 消息名称。 + /// true=已更新 auto_send；false=未更新（可能未启动 auto_send 或未命中任务索引）。 + /// + /// 覆盖更新原理： + /// - auto_send 的每条任务由 index 唯一标识； + /// - 重新对同 index 调用 SetValue 写入新的帧数据，即可实现“后续周期发送新值”； + /// - 本方法仅覆盖帧数据，不改变周期（周期由启动调度表时写入）。 + /// + private bool TryUpdateAutoSendByMsgName(string msgName) + { + if (string.IsNullOrWhiteSpace(msgName)) return false; + + bool active; + int channelIndex; + byte frameType; + List? taskIndexes; + lock (_autoSendSync) + { + // 从 auto_send 运行态读取一个“快照”： + // - active/channelIndex/frameType：当前硬件调度表的运行参数 + // - taskIndexes：该 MsgName 在硬件列表中对应的任务 index（可能映射到多个条目） + // 之所以拷贝 ToList()：避免后续遍历时与 Start/StopSchedule 并发清空集合产生枚举异常。 + active = _autoSendActive; + channelIndex = _autoSendChannelIndex; + frameType = _autoSendFrameType; + if (!_autoSendMsgIndex.TryGetValue(msgName, out taskIndexes)) + { + taskIndexes = null; + } + else + { + taskIndexes = taskIndexes.ToList(); + } + } + + if (!active || taskIndexes == null || taskIndexes.Count == 0) + { + return false; + } + + var built = TryBuildRawFrameFromCmdData(msgName, frameType); + if (built == null) + { + // 常见原因： + // - DBC 未加载/加载失败 + // - CmdData 中不存在该 MsgName 的任何信号 + // - 该 MsgName 在 DBC 中找不到 message 定义，导致编码失败 + return false; + } + + foreach (var idx in taskIndexes) + { + try + { + // intervalMs 传 null：表示“只覆盖帧内容，不修改周期”。 + // 周期由 StartAutoSendSchedule 首次写入，运行中保持不变。 + ConfigureAutoSendRawFrame(channelIndex, idx, enable: true, intervalMs: null, canId: built.Value.CanId, payload: built.Value.Payload, payloadLen: built.Value.PayloadLen, frameType: frameType); + } + catch (Exception ex) + { + _log.Warn($"覆盖定时发送失败：Msg={msgName}, Index={idx}, {ex.Message}"); + } + } + + return true; + } + + /// + /// 根据 MsgName 从当前 CmdData 聚合信号值，并通过 DBC 编码为原始 CAN/CANFD 帧。 + /// + /// 消息名称（DBC Message Name）。 + /// 帧类型（CAN/CANFD）。 + /// + /// 成功返回 (CanId, Payload, PayloadLen)；失败返回 null（如 DBC 未加载、CmdData 为空或该 MsgName 无任何信号值）。 + /// + private (uint CanId, byte[] Payload, int PayloadLen)? TryBuildRawFrameFromCmdData(string msgName, byte frameType) + { + ZlgDbcDatabase? dbc; + List? cmdData; + lock (_dbcSync) + { + // 读取 DBC 与 CmdData 引用快照： + // - 避免在锁内做编码（编码可能较慢，会阻塞接收线程解码等操作）； + // - 允许并发切换 DBC/重载 CmdData：即使快照稍旧，也只会影响一次编码结果。 + dbc = _dbc; + cmdData = _cmdData; + } + + if (dbc == null || !dbc.IsLoaded) return null; + if (cmdData == null || cmdData.Count == 0) return null; + + var dict = new Dictionary(StringComparer.Ordinal); + foreach (var item in cmdData) + { + if (!string.Equals(item.MsgName, msgName, StringComparison.Ordinal)) + { + continue; + } + + if (string.IsNullOrWhiteSpace(item.SignalName)) + { + continue; + } + + // 同一 SignalName 若在 CmdData 中重复出现，这里按“最后一次覆盖”处理。 + dict[item.SignalName] = item.SignalCmdValue; + } + + if (dict.Count == 0) return null; + + var (canId, data, dataLen) = dbc.EncodeToRawFrame(msgName, dict, frameType); + return (canId, data ?? Array.Empty(), dataLen); + } + + /// + /// 清空并按调度表批量配置硬件定时发送列表，然后 apply_auto_send 使能。 + /// + /// 调度表条目集合。 + /// 通道索引（0/1）。 + /// 帧类型（CAN/CANFD）。 + /// + /// 对应周立功定时发送能力： + /// - 通过 {channel}/auto_send 或 {channel}/auto_send_canfd 写入待发送帧与周期； + /// - 再通过 {channel}/apply_auto_send 使能后，由设备侧硬件定时器保证发送周期精度。 + /// + /// 本工程约定： + /// - 调度表中的 MsgName 必须能在 DBC 中找到 message 定义，否则无法编码并会被跳过； + /// - 运行期间信号值变化会触发覆盖更新（不影响周期）。 + /// + public void StartAutoSendSchedule(IEnumerable<(string MsgName, int CycleMs, int OrderSend, int SchTabIndex)> scheduleItems, int channelIndex, byte frameType) + { + ThrowIfDisposed(); + if (_deviceHandle == IntPtr.Zero) throw new InvalidOperationException("设备未打开。"); + + var items = scheduleItems?.Where(a => !string.IsNullOrWhiteSpace(a.MsgName)).ToList() + ?? new List<(string MsgName, int CycleMs, int OrderSend, int SchTabIndex)>(); + + if (items.Count == 0) + { + throw new InvalidOperationException("调度表为空，无法启动硬件定时发送。"); + } + + // 硬件侧列表索引顺序即发送启动顺序：按 SchTabIndex、OrderSend 排序以保持可控。 + items = items + .OrderBy(a => a.SchTabIndex) + .ThenBy(a => a.OrderSend) + .ThenBy(a => a.MsgName, StringComparer.Ordinal) + .ToList(); + + // 周立功说明：每通道最大 100 条（部分型号更小）。这里按 100 做上限保护。 + if (items.Count > 100) + { + throw new InvalidOperationException($"调度表条目过多（{items.Count}），超过硬件定时发送列表上限 100。"); + } + + // 重要：重新配置调度表时必须先 clear_auto_send。 + // - 防止旧条目残留导致“设备仍发送旧帧/旧周期”； + // - 也确保本次配置从 index=0 连续写入，便于 MsgName->index 映射稳定。 + ClearAutoSend(channelIndex); + + var msgIndex = new Dictionary>(StringComparer.Ordinal); + for (ushort i = 0; i < items.Count; i++) + { + var it = items[i]; + var cycle = (uint)Math.Max(1, it.CycleMs); + + var built = TryBuildRawFrameFromCmdData(it.MsgName, frameType); + if (built == null) + { + _log.Warn($"定时发送跳过：MsgName={it.MsgName} 未能从 CmdData/DBC 生成原始帧。"); + continue; + } + + ConfigureAutoSendRawFrame(channelIndex, i, enable: true, intervalMs: cycle, canId: built.Value.CanId, payload: built.Value.Payload, payloadLen: built.Value.PayloadLen, frameType: frameType); + if (!msgIndex.TryGetValue(it.MsgName, out var list)) + { + list = new List(); + msgIndex[it.MsgName] = list; + } + + list.Add(i); + } + + // apply_auto_send：告诉设备“开始执行定时发送列表”。 + // 注意：仅在配置完所有条目后调用一次即可。 + ApplyAutoSend(channelIndex); + + lock (_autoSendSync) + { + // 记录运行态与映射表：供 CmdDataChanged 事件在运行中做“覆盖更新”。 + _autoSendActive = true; + _autoSendChannelIndex = channelIndex; + _autoSendFrameType = frameType; + _autoSendMsgIndex.Clear(); + foreach (var kv in msgIndex) + { + _autoSendMsgIndex[kv.Key] = kv.Value; + } + } + } + + /// + /// 停止硬件定时发送（clear_auto_send）。 + /// + /// 通道索引（0/1）。 + /// + /// - 会清空设备侧定时发送列表并停止发送； + /// - 同时清空内存态 MsgName->Index 映射，避免后续误覆盖写入。 + /// + public void StopAutoSendSchedule(int channelIndex) + { + ThrowIfDisposed(); + + if (_deviceHandle == IntPtr.Zero) + { + lock (_autoSendSync) + { + _autoSendActive = false; + _autoSendMsgIndex.Clear(); + } + return; + } + + // clear_auto_send：停止设备侧定时发送并清空列表。 + // 该调用非常关键：否则即使 PC 侧不再发送，硬件仍会按周期继续发。 + ClearAutoSend(channelIndex); + lock (_autoSendSync) + { + _autoSendActive = false; + _autoSendMsgIndex.Clear(); + } + } + + private void ConfigureAutoSendRawFrame(int channelIndex, ushort taskIndex, bool enable, uint? intervalMs, uint canId, byte[] payload, int payloadLen, byte frameType) + { + var interval = intervalMs ?? 1; + var len = Math.Max(0, payloadLen); + var data = payload ?? Array.Empty(); + + // 根据帧类型选择写入 auto_send 的结构体： + // - CAN：{channel}/auto_send + ZCAN_AUTO_TRANSMIT_OBJ + // - CANFD：{channel}/auto_send_canfd + ZCANFD_AUTO_TRANSMIT_OBJ + // 覆盖更新的关键：对同一 taskIndex 再次 SetValue 会替换设备侧缓存的帧数据。 + if (frameType == ZDBC.FT_CAN) + { + var canBytes = len <= 0 ? Array.Empty() : data.Take(Math.Min(8, len)).ToArray(); + ConfigureAutoSendCan(channelIndex, taskIndex, enable, interval, canId, canBytes); + return; + } + + if (frameType == ZDBC.FT_CANFD) + { + var fdBytes = len <= 0 ? Array.Empty() : data.Take(Math.Min(64, len)).ToArray(); + ConfigureAutoSendCanFd(channelIndex, taskIndex, enable, interval, canId, fdBytes); + return; + } + + throw new ArgumentOutOfRangeException(nameof(frameType), "frameType 仅支持 ZDBC.FT_CAN=0 或 ZDBC.FT_CANFD=1。"); + } + + /// + /// 根据 MsgName，从当前 CmdData 中取出信号值，编码并发送一帧。 + /// + /// 消息名称。 + /// 发送通道。 + /// 帧类型：ZDBC.FT_CAN 或 ZDBC.FT_CANFD。 + public void SendOneMsgByCmdData(string msgName, int channelIndex, byte frameType) + { + ThrowIfDisposed(); + + ZlgDbcDatabase? dbc; + List? cmdData; + lock (_dbcSync) + { + // 仅在锁内拿到 DBC/CmdData 的引用快照，避免编码时长时间占用 _dbcSync。 + // 编码可能会分配内存/做查表，若在锁内执行会阻塞接收线程的 DBC 解码。 + dbc = _dbc; + cmdData = _cmdData; + } + + if (dbc == null || !dbc.IsLoaded) + { + // DBC 未加载时无法做“信号值->原始帧”的编码，因此直接忽略（上层会通过 DbcParserState 提示）。 + return; + } + + if (cmdData == null || cmdData.Count == 0) + { + // 没有 CmdData 也就没有要写入的信号值，直接返回。 + return; + } + + if (string.IsNullOrWhiteSpace(msgName)) + { + return; + } + + var dict = new Dictionary(StringComparer.Ordinal); + foreach (var item in cmdData) + { + if (!string.Equals(item.MsgName, msgName, StringComparison.Ordinal)) + { + continue; + } + + if (string.IsNullOrWhiteSpace(item.SignalName)) + { + continue; + } + + dict[item.SignalName] = item.SignalCmdValue; + } + + if (dict.Count == 0) + { + // MsgName 未命中任何信号：常见于 CmdData 尚未注入或 UI 选择的消息为空。 + return; + } + + // DBC 编码：将“信号名->物理值”转换为可发送的 raw frame。 + // 注意：frameType 决定 payload 长度上限（CAN=8, CANFD=64）。 + var (canId, data, dataLen) = dbc.EncodeToRawFrame(msgName, dict, frameType); + if (frameType == ZDBC.FT_CAN) + { + // requestTxEcho=true：请求设备回传一帧 Tx echo。 + // - merge 接收模式下会以 IsTx 标识； + // - per-channel 接收模式下会走 __pad/flags 判断（见接收循环）。 + SendCan(channelIndex, canId, data, requestTxEcho: true); + return; + } + + if (frameType == ZDBC.FT_CANFD) + { + SendCanFd(channelIndex, canId, data, requestTxEcho: true); + return; + } + + throw new ArgumentOutOfRangeException(nameof(frameType), "frameType 仅支持 ZDBC.FT_CAN=0 或 ZDBC.FT_CANFD=1。"); + } + + /// + /// 停止后台接收线程。 + /// + public void StopReceiveLoop() + { + lock (_sync) + { + // StopReceiveLoop 与 StartReceiveLoop/Open/Close 同受 _sync 保护： + // - 防止接收线程创建/销毁与通道 Reset/Close 并发； + // - 保证 _recvCts/_recvTask 的可见性与一致性。 + if (_recvCts == null || _recvTask == null) + { + return; + } + + try + { + _recvCts.Cancel(); + _recvTask.Wait(TimeSpan.FromSeconds(2)); + } + catch (Exception ex) + { + _log.Warn($"停止接收线程等待超时或异常：{ex.Message}"); + } + finally + { + // 无论等待是否超时，都要清理引用并释放 CTS，避免下次 StartReceiveLoop 认为线程仍在运行。 + _recvCts.Dispose(); + _recvCts = null; + _recvTask = null; + } + } + } + + /// + /// 发送 CAN 报文。 + /// + /// 通道索引（0/1）。 + /// 包含扩展帧标志位的 can_id（可用 ZlgCanIdHelper.MakeCanId 生成）。 + /// 数据（0~8字节）。 + /// 是否请求发送回显。 + /// 发送方式，0=正常发送，1=单次发送，2=自发自收，3=单次自发自收。 + public uint SendCan(int channelIndex, uint canId, byte[] data, bool requestTxEcho = false, uint transmitType = 0) + { + ThrowIfDisposed(); + var chn = GetCanChannelHandleOrThrow(channelIndex); + + var frame = new ZLGCAN.can_frame + { + can_id = canId, + can_dlc = (byte)Math.Min(8, data?.Length ?? 0), + __pad = 0, + __res0 = 0, + __res1 = 0, + data = new byte[8] + }; + + if (data != null && data.Length > 0) + { + Array.Copy(data, frame.data, Math.Min(8, data.Length)); + } + + if (requestTxEcho) + { + frame.__pad |= 0x20; + } + + var tx = new ZLGCAN.ZCAN_Transmit_Data + { + frame = frame, + transmit_type = transmitType + }; + + IntPtr pTx = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZLGCAN.ZCAN_Transmit_Data))); + try + { + Marshal.StructureToPtr(tx, pTx, false); + var ret = ZLGCAN.ZCAN_Transmit(chn, pTx, 1); + if (ret > 0) + { + MarkSendOk(); + } + return ret; + } + finally + { + Marshal.FreeHGlobal(pTx); + } + } + + /// + /// 发送 CANFD 报文。 + /// + /// 通道索引（0/1）。 + /// 包含扩展帧标志位的 can_id（可用 ZlgCanIdHelper.MakeCanId 生成）。 + /// 数据（0~64字节）。 + /// 是否请求发送回显。 + /// 发送方式，0=正常发送，1=单次发送，2=自发自收，3=单次自发自收。 + /// 驱动返回的实际发送帧数（通常为 0 或 1）。 + /// + /// - CANFD 有效长度由 决定，内部会自动截断到 64 字节； + /// - 若 为 true，会在 flags 中设置回显位，使设备回传一帧 Tx 事件。 + /// 在 merge 接收模式下，这种 Tx 回显会以 标识。 + /// + /// 通道未初始化或句柄无效。 + public uint SendCanFd(int channelIndex, uint canId, byte[] data, bool requestTxEcho = false, uint transmitType = 0) + { + ThrowIfDisposed(); + var chn = GetCanChannelHandleOrThrow(channelIndex); + + var len = (byte)Math.Min(64, data?.Length ?? 0); + var frame = new ZLGCAN.canfd_frame + { + can_id = canId, + len = len, + flags = 0, + __res0 = 0, + __res1 = 0, + data = new byte[64] + }; + + if (data != null && data.Length > 0) + { + Array.Copy(data, frame.data, Math.Min(64, data.Length)); + } + + if (requestTxEcho) + { + frame.flags |= 0x20; + } + + var tx = new ZLGCAN.ZCAN_TransmitFD_Data + { + frame = frame, + transmit_type = transmitType + }; + + IntPtr pTx = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZLGCAN.ZCAN_TransmitFD_Data))); + try + { + Marshal.StructureToPtr(tx, pTx, false); + var ret = ZLGCAN.ZCAN_TransmitFD(chn, pTx, 1); + if (ret > 0) + { + MarkSendOk(); + } + return ret; + } + finally + { + Marshal.FreeHGlobal(pTx); + } + } + + /// + /// 设置设备定时发送（CAN）。 + /// + /// 通道索引。 + /// 定时任务索引。 + /// 是否使能。 + /// 周期（ms）。 + /// can_id。 + /// 数据（0~8）。 + /// + /// 对应 ZLG 驱动 SetValue 路径：{channelIndex}/auto_send。 + /// + /// 关键点： + /// - 为设备侧列表索引；同一索引再次写入会“覆盖更新”； + /// - 为周期（毫秒），设备按该周期自动发送； + /// - 本实现默认设置发送回显位（__pad=0x20），便于在接收线程中区分 Tx/Rx 并刷新发送指示灯。 + /// + /// 设备未打开或底层 SetValue 失败。 + public void ConfigureAutoSendCan(int channelIndex, ushort taskIndex, bool enable, uint intervalMs, uint canId, byte[] data) + { + ThrowIfDisposed(); + + if (_deviceHandle == IntPtr.Zero) + { + throw new InvalidOperationException("设备未打开。"); + } + + var frame = new ZLGCAN.can_frame + { + can_id = canId, + can_dlc = (byte)Math.Min(8, data?.Length ?? 0), + __pad = 0x20, // 默认发送回显 + __res0 = 0, + __res1 = 0, + data = new byte[8] + }; + + if (data != null && data.Length > 0) + { + Array.Copy(data, frame.data, Math.Min(8, data.Length)); + } + + var obj = new ZLGCAN.ZCAN_AUTO_TRANSMIT_OBJ + { + enable = (ushort)(enable ? 1 : 0), + index = taskIndex, + interval = intervalMs, + obj = new ZLGCAN.ZCAN_Transmit_Data { frame = frame, transmit_type = 0 } + }; + + var path = string.Format("{0}/auto_send", channelIndex); + var ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, ref obj); + if (ret != 1) + { + throw new InvalidOperationException($"配置定时发送失败：{path}"); + } + } + + /// + /// 设置设备定时发送（CANFD）。 + /// + /// 通道索引。 + /// 定时任务索引。 + /// 是否使能。 + /// 周期（ms）。 + /// can_id。 + /// 数据（0~64）。 + /// + /// 对应 ZLG 驱动 SetValue 路径：{channelIndex}/auto_send_canfd。 + /// + /// 与 一致： + /// - 同 index 写入即覆盖更新； + /// - interval 为周期（ms）； + /// - 默认设置发送回显(flags=0x20)。 + /// + /// 设备未打开或底层 SetValue 失败。 + public void ConfigureAutoSendCanFd(int channelIndex, ushort taskIndex, bool enable, uint intervalMs, uint canId, byte[] data) + { + ThrowIfDisposed(); + + if (_deviceHandle == IntPtr.Zero) + { + throw new InvalidOperationException("设备未打开。"); + } + + var frame = new ZLGCAN.canfd_frame + { + can_id = canId, + len = (byte)Math.Min(64, data?.Length ?? 0), + flags = 0x20, // 默认发送回显 + __res0 = 0, + __res1 = 0, + data = new byte[64] + }; + + if (data != null && data.Length > 0) + { + Array.Copy(data, frame.data, Math.Min(64, data.Length)); + } + + var obj = new ZLGCAN.ZCANFD_AUTO_TRANSMIT_OBJ + { + enable = (ushort)(enable ? 1 : 0), + index = taskIndex, + interval = intervalMs, + obj = new ZLGCAN.ZCAN_TransmitFD_Data { frame = frame, transmit_type = 0 } + }; + + var path = string.Format("{0}/auto_send_canfd", channelIndex); + var ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, ref obj); + if (ret != 1) + { + throw new InvalidOperationException($"配置定时发送失败：{path}"); + } + } + + /// + /// 启动通道定时发送任务（apply_auto_send）。 + /// + /// 通道索引。 + /// + /// 对应 ZLG 驱动 SetValue 路径：{channelIndex}/apply_auto_send。 + /// + /// 调用时机： + /// - 在完成若干条 auto_send/auto_send_canfd 配置后调用； + /// - 设备侧开始按列表条目周期自动发送。 + /// + /// 设备未打开或底层 SetValue 失败。 + public void ApplyAutoSend(int channelIndex) + { + ThrowIfDisposed(); + if (_deviceHandle == IntPtr.Zero) throw new InvalidOperationException("设备未打开。"); + + var path = string.Format("{0}/apply_auto_send", channelIndex); + var ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, "0"); + if (ret != 1) + { + throw new InvalidOperationException($"启动定时发送失败：{path}"); + } + } + + /// + /// 清空通道定时发送任务（clear_auto_send）。 + /// + /// 通道索引。 + /// + /// 对应 ZLG 驱动 SetValue 路径：{channelIndex}/clear_auto_send。 + /// + /// 说明： + /// - clear 会清空硬件列表并停止该通道的定时发送； + /// - 若你要重新配置调度表，建议先 clear，再从 index=0 重新写入并 apply。 + /// + /// 设备未打开或底层 SetValue 失败。 + public void ClearAutoSend(int channelIndex) + { + ThrowIfDisposed(); + if (_deviceHandle == IntPtr.Zero) throw new InvalidOperationException("设备未打开。"); + + var path = string.Format("{0}/clear_auto_send", channelIndex); + var ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, "0"); + if (ret != 1) + { + throw new InvalidOperationException($"清空定时发送失败：{path}"); + } + } + + /// + /// 配置 LIN 发布表。 + /// + /// 发布配置集合。 + /// + /// - LIN 发布表用于“周期性/按条件发布”LIN 数据（由设备侧完成具体发送时机，取决于驱动能力与配置）。 + /// - 本方法会将托管结构体数组拷贝到非托管内存，再调用底层 API。 + /// - 若集合为空则直接返回。 + /// + /// 线程说明： + /// - 该方法为同步调用；建议在设备已初始化 LIN 通道后调用。 + /// + /// LIN 未初始化或底层配置失败。 + public void SetLinPublish(IEnumerable publishCfg) + { + ThrowIfDisposed(); + if (_linChannelHandle == IntPtr.Zero) throw new InvalidOperationException("LIN 未初始化。"); + + var list = publishCfg?.ToList() ?? new List(); + if (list.Count == 0) + { + return; + } + + int size = Marshal.SizeOf(typeof(ZLGCAN.ZCAN_LIN_PUBLISH_CFG)); + IntPtr pArr = Marshal.AllocHGlobal(size * list.Count); + try + { + for (int i = 0; i < list.Count; i++) + { + var item = list[i]; + if (item.data == null || item.data.Length != 8) + { + item.data = new byte[8]; + } + + if (item.reserved == null || item.reserved.Length != 5) + { + item.reserved = new byte[5]; + } + + Marshal.StructureToPtr(item, IntPtr.Add(pArr, i * size), false); + } + + var ret = ZLGCAN.ZCAN_SetLINPublish(_linChannelHandle, pArr, (uint)list.Count); + if (ret != 1) + { + throw new InvalidOperationException("ZCAN_SetLINPublish 失败。"); + } + } + finally + { + Marshal.FreeHGlobal(pArr); + } + } + + /// + /// 配置 LIN 订阅表。 + /// + /// 订阅配置集合。 + /// + /// - LIN 订阅表用于配置希望接收/关注的 LIN 帧。 + /// - 本方法会将托管结构体数组拷贝到非托管内存，再调用底层 API。 + /// - 若集合为空则直接返回。 + /// + /// LIN 未初始化或底层配置失败。 + public void SetLinSubscribe(IEnumerable subscribeCfg) + { + ThrowIfDisposed(); + if (_linChannelHandle == IntPtr.Zero) throw new InvalidOperationException("LIN 未初始化。"); + + var list = subscribeCfg?.ToList() ?? new List(); + if (list.Count == 0) + { + return; + } + + int size = Marshal.SizeOf(typeof(ZLGCAN.ZCAN_LIN_SUBSCIBE_CFG)); + IntPtr pArr = Marshal.AllocHGlobal(size * list.Count); + try + { + for (int i = 0; i < list.Count; i++) + { + var item = list[i]; + if (item.reserved == null || item.reserved.Length != 5) + { + item.reserved = new byte[5]; + } + Marshal.StructureToPtr(item, IntPtr.Add(pArr, i * size), false); + } + + var ret = ZLGCAN.ZCAN_SetLINSubscribe(_linChannelHandle, pArr, (uint)list.Count); + if (ret != 1) + { + throw new InvalidOperationException("ZCAN_SetLINSubscribe 失败。"); + } + } + finally + { + Marshal.FreeHGlobal(pArr); + } + } + + /// + /// 发送一帧 LIN 报文。 + /// + /// 通道号（通常为 0）。 + /// 受保护 ID（PID，包含奇偶校验位）。 + /// 数据区（0-8字节）。 + /// 方向（通常 0；具体含义以 ZLG 文档为准）。 + /// + /// 说明： + /// - 当前工程使用 merge 接收（）读取 LIN 帧，因此这里的发送只负责向设备下发原始帧； + /// - ZLG 的 LIN 发送 API 以 数组形式接收数据；本方法将 PID+数据按 的内存布局写入。 + /// + public void TransmitLin(int channel, byte pid, ReadOnlySpan data, byte dir = 0) + { + ThrowIfDisposed(); + if (_linChannelHandle == IntPtr.Zero) throw new InvalidOperationException("LIN 未初始化。"); + + var len = Math.Min(8, data.Length); + var buf8 = new byte[8]; + if (len > 0) + { + data.Slice(0, len).CopyTo(buf8); + } + + var linData = new ZLGCAN.ZCANLINData + { + pid = new ZLGCAN.PID { rawVal = pid }, + rxData = new ZLGCAN.RxData + { + timeStamp = 0, + datalen = (byte)len, + dir = dir, + chkSum = 0, + reserved = new byte[13], + data = buf8 + }, + reserved = new byte[7] + }; + + var msg = new ZLGCAN.ZCAN_LIN_MSG + { + chnl = (byte)channel, + dataType = 0, + data = new byte[46] + }; + + var linSize = Marshal.SizeOf(typeof(ZLGCAN.ZCANLINData)); + IntPtr pLin = Marshal.AllocHGlobal(linSize); + try + { + Marshal.StructureToPtr(linData, pLin, false); + var copy = Math.Min(msg.data.Length, linSize); + Marshal.Copy(pLin, msg.data, 0, copy); + } + finally + { + Marshal.FreeHGlobal(pLin); + } + + var msgSize = Marshal.SizeOf(typeof(ZLGCAN.ZCAN_LIN_MSG)); + IntPtr pMsg = Marshal.AllocHGlobal(msgSize); + try + { + Marshal.StructureToPtr(msg, pMsg, false); + var ret = ZLGCAN.ZCAN_TransmitLIN(_linChannelHandle, pMsg, 1); + if (ret == 0) + { + throw new InvalidOperationException("ZCAN_TransmitLIN 失败。"); + } + MarkSendOk(); + } + finally + { + Marshal.FreeHGlobal(pMsg); + } + } + + /// + /// 关闭设备。 + /// + /// + /// 资源释放顺序（概览）： + /// - 停止接收线程（）； + /// - Reset LIN/CAN 通道并关闭设备句柄（见 ）； + /// - 取消 CmdData 事件订阅并释放 DBC 资源。 + /// + /// 线程安全： + /// - 该方法通过 与 保护，避免并发 close/load/receive 导致状态错乱。 + /// + public void Close() + { + lock (_sync) + { + // 先停接收线程： + // - 接收线程内部会访问 device_handle/channel_handle； + // - 若不先停线程就 Reset/Close 句柄，极易触发访问已释放句柄导致异常或崩溃。 + StopReceiveLoop(); + + // 再按通道/设备顺序释放句柄： + // - ResetLIN/ResetCAN 让驱动停止通道并回收内部资源 + // - CloseDevice 释放 device_handle + SafeClose_NoLock(); + } + + lock (_dbcSync) + { + // Close 过程同时断开“事件驱动发送”链路： + // - 避免 UI 仍在更新 SignalCmdValue 时触发驱动调用（此时句柄可能已关闭）； + // - 也避免 _cmdData 持有 Driver 事件导致对象无法被 GC 回收。 + if (_cmdData != null) + { + foreach (var item in _cmdData) + { + item.CanCmdDataChangedHandler -= CmdData_CanCmdDataChangedHandler; + } + } + + _cmdData = null; + + _dbcModels = null; + _dbcModelIndex = null; + + _dbc?.Dispose(); + _dbc = null; + } + } + + /// + /// + /// 遵循 .NET Dispose 语义： + /// - 多次调用是安全的（通过 做幂等保护）； + /// - Dispose 内部会调用 释放驱动句柄、停止接收线程并释放 DBC 资源。 + /// + public void Dispose() + { + if (_disposed) return; + _disposed = true; + + try + { + // 说明：Dispose 不抛异常，避免在 using/终结路径打断上层释放流程。 + // Close 内部已经尽量记录日志并吞掉部分关闭异常，保证释放流程走完。 + Close(); + } + catch + { + // ignored + } + } + + /// + /// 关闭设备与通道句柄（不加锁版本）。 + /// + /// + /// 该方法假定调用方已经持有 ： + /// - 用于 Close 流程中按顺序 Reset LIN、Reset CAN、CloseDevice； + /// - 任何异常都会被吞掉并记录 Warn，确保关闭流程尽量走完，避免句柄泄漏。 + /// + private void SafeClose_NoLock() + { + try + { + if (_linChannelHandle != IntPtr.Zero) + { + // ResetLIN 语义：停止 LIN 通道并释放其内部缓存/线程。 + var ret = ZLGCAN.ZCAN_ResetLIN(_linChannelHandle); + if (ret != 1) + { + _log.Warn("ZCAN_ResetLIN 失败。"); + } + } + } + catch (Exception ex) + { + _log.Warn($"关闭 LIN 异常：{ex.Message}"); + } + finally + { + _linChannelHandle = IntPtr.Zero; + } + + for (int i = 0; i < _canChannelHandles.Length; i++) + { + try + { + if (_canChannelHandles[i] != IntPtr.Zero) + { + // ResetCAN 语义：停止 CAN/CANFD 通道。 + // 注意：若硬件 auto_send 正在发送，建议在服务层先调用 StopAutoSendSchedule(clear_auto_send)。 + // 当前 Close 不主动 clear_auto_send 的原因： + // - auto_send 是 per-channel 的“设备侧任务”，通常由上层 Start/StopSchedule 管控； + // - Close 仍会 ResetCAN/CloseDevice，通常也会导致任务失效，但具体行为依赖 SDK/硬件。 + var ret = ZLGCAN.ZCAN_ResetCAN(_canChannelHandles[i]); + if (ret != 1) + { + _log.Warn($"ZCAN_ResetCAN 失败，通道{i}。"); + } + } + } + catch (Exception ex) + { + _log.Warn($"关闭 CAN 通道{i}异常：{ex.Message}"); + } + finally + { + _canChannelHandles[i] = IntPtr.Zero; + } + } + + try + { + if (_deviceHandle != IntPtr.Zero) + { + var ret = ZLGCAN.ZCAN_CloseDevice(_deviceHandle); + if (ret != 1) + { + _log.Warn("ZCAN_CloseDevice 失败。"); + } + } + } + catch (Exception ex) + { + _log.Warn($"关闭设备异常：{ex.Message}"); + } + finally + { + _deviceHandle = IntPtr.Zero; + OpenState = false; + } + } + + /// + /// 初始化指定 CANFD 通道（仅设置参数并 InitCAN，不负责 StartCAN）。 + /// + /// 通道索引。 + /// 通道初始化参数。 + /// + /// 该方法主要完成： + /// - 设置仲裁域/数据域波特率； + /// - 设置终端电阻与总线利用率统计开关； + /// - 调用 ZCAN_InitCAN 获取通道句柄并保存到 。 + /// + /// 注意： + /// - 这里仅负责 Init，不负责 Start；Start 由 完成。 + /// + /// 任一 SetValue/InitCAN 失败。 + + private void InitCanChannelInternal(int chnIdx, ZlgCanFdChannelOptions options) + { + var path = string.Format("{0}/canfd_abit_baud_rate", chnIdx); + var ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, options.ArbitrationBaudRate.ToString()); + if (ret != 1) + { + throw new InvalidOperationException($"设置仲裁域波特率失败：{path}"); + } + + path = string.Format("{0}/canfd_dbit_baud_rate", chnIdx); + ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, options.DataBaudRate.ToString()); + if (ret != 1) + { + throw new InvalidOperationException($"设置数据域波特率失败：{path}"); + } + + path = string.Format("{0}/initenal_resistance", chnIdx); + ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, options.EnableInternalResistance ? "1" : "0"); + if (ret != 1) + { + throw new InvalidOperationException($"设置终端电阻失败：{path}"); + } + + if (options.EnableBusUsage) + { + path = string.Format("{0}/set_bus_usage_enable", chnIdx); + ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, "1"); + if (ret != 1) + { + _log.Warn($"启用总线利用率失败：{path}"); + } + + path = string.Format("{0}/set_bus_usage_period", chnIdx); + ret = ZLGCAN.ZCAN_SetValue(_deviceHandle, path, options.BusUsagePeriodMs.ToString()); + if (ret != 1) + { + _log.Warn($"设置总线利用率周期失败：{path}"); + } + } + + var initCfg = new ZLGCAN.ZCAN_CHANNEL_INIT_CONFIG + { + can_type = 1, + config = new ZLGCAN._ZCAN_CHANNEL_INIT_CONFIG + { + canfd = new ZLGCAN._ZCAN_CHANNEL_CANFD_INIT_CONFIG + { + acc_code = 0, + acc_mask = 0xFFFFFFFF, + abit_timing = 0, + dbit_timing = 0, + brp = 0, + filter = 0, + mode = (byte)(options.ListenOnly ? 1 : 0), + pad = 0, + reserved = 0 + } + } + }; + + var chnHandle = ZLGCAN.ZCAN_InitCAN(_deviceHandle, (uint)chnIdx, ref initCfg); + if (chnHandle == IntPtr.Zero) + { + throw new InvalidOperationException($"初始化 CANFD 通道失败：{chnIdx}"); + } + + _canChannelHandles[chnIdx] = chnHandle; + } + + /// + /// 启动指定 CAN 通道。 + /// + /// 通道索引。 + /// 通道句柄。 + /// + /// 调用前置条件： + /// - 已成功执行并产生通道句柄。 + /// + /// 通道句柄为空或启动失败。 + + private IntPtr StartCanChannelInternal(int chnIdx) + { + var h = _canChannelHandles[chnIdx]; + if (h == IntPtr.Zero) + { + throw new InvalidOperationException("CAN 通道句柄为空。"); + } + + var ret = ZLGCAN.ZCAN_StartCAN(h); + if (ret != 1) + { + throw new InvalidOperationException($"启动 CAN 通道失败：{chnIdx}"); + } + + return h; + } + + /// + /// 获取 CAN 通道句柄（不存在则抛异常）。 + /// + /// 通道索引。 + /// 通道句柄。 + /// 通道索引超范围。 + /// 通道未初始化。 + + private IntPtr GetCanChannelHandleOrThrow(int channelIndex) + { + if (channelIndex < 0 || channelIndex >= _canChannelHandles.Length) + { + throw new ArgumentOutOfRangeException(nameof(channelIndex)); + } + + var h = _canChannelHandles[channelIndex]; + if (h == IntPtr.Zero) + { + throw new InvalidOperationException($"CAN 通道{channelIndex}未初始化。"); + } + + return h; + } + + /// + /// 普通接收模式：按通道轮询 CAN/CANFD 缓冲区读取。 + /// + /// 取消令牌。 + /// 每次接收的最大帧数。 + /// + /// - 该模式分别调用： + /// - ZCAN_GetReceiveNum/ZCAN_Receive 接收 CAN + /// - ZCAN_GetReceiveNum/ZCAN_ReceiveFD 接收 CANFD + /// - 每次接收会在非托管堆上分配固定大小缓冲，循环中复用，退出时释放。 + /// + + private void ReceiveLoop_PerChannel(CancellationToken token, int bufferFrames) + { + const int WaitMs = 10; + + // 说明：ZLG SDK 的 Receive/ReceiveFD 需要调用方提供一段连续的非托管内存作为数组缓冲区。 + // 因为接收线程会长期运行，所以这里采用“循环外一次性分配 + 循环内复用 + finally 释放”。 + int canStructSize = Marshal.SizeOf(typeof(ZLGCAN.ZCAN_Receive_Data)); + int canfdStructSize = Marshal.SizeOf(typeof(ZLGCAN.ZCAN_ReceiveFD_Data)); + + IntPtr pCanBuffer = Marshal.AllocHGlobal(canStructSize * bufferFrames); + IntPtr pCanfdBuffer = Marshal.AllocHGlobal(canfdStructSize * bufferFrames); + + try + { + while (!token.IsCancellationRequested) + { + for (int ch = 0; ch < _canChannelHandles.Length; ch++) + { + var handle = _canChannelHandles[ch]; + if (handle == IntPtr.Zero) continue; + + // 0：CAN 经典帧缓冲区；1：CANFD 缓冲区（ZLG SDK 约定）。 + // 注意：GetReceiveNum 返回的是“当前缓存中可读数量”，但真正 Receive 返回的 actual + // 可能小于请求值（例如 bufferFrames 太小或并发到达）。 + uint canNum = ZLGCAN.ZCAN_GetReceiveNum(handle, 0); + if (canNum > 0) + { + uint actual = ZLGCAN.ZCAN_Receive(handle, pCanBuffer, (uint)bufferFrames, WaitMs); + for (int i = 0; i < actual; i++) + { + IntPtr pCur = IntPtr.Add(pCanBuffer, i * canStructSize); + var rec = Marshal.PtrToStructure(pCur); + + // Tx 回显判断：当前实现沿用项目既有逻辑，使用 __pad 的 0x20 位。 + // - 该位含义取决于 ZLG SDK 结构体定义/版本；若未来 SDK 变更，该判断可能需要同步调整。 + RaiseCanFrame(ch, rec.timestamp, false, rec.frame.can_id, rec.frame.data, rec.frame.can_dlc, (rec.frame.__pad & 0x20) == 0x20); + } + } + + uint canfdNum = ZLGCAN.ZCAN_GetReceiveNum(handle, 1); + if (canfdNum > 0) + { + uint actual = ZLGCAN.ZCAN_ReceiveFD(handle, pCanfdBuffer, (uint)bufferFrames, WaitMs); + for (int i = 0; i < actual; i++) + { + IntPtr pCur = IntPtr.Add(pCanfdBuffer, i * canfdStructSize); + var rec = Marshal.PtrToStructure(pCur); + + // Tx 回显判断：使用 flags 的 0x20 位（同样依赖 SDK 定义）。 + RaiseCanFrame(ch, rec.timestamp, true, rec.frame.can_id, rec.frame.data, rec.frame.len, (rec.frame.flags & 0x20) == 0x20); + } + } + + ZLGCAN.ZCAN_CHANNEL_ERR_INFO err = new ZLGCAN.ZCAN_CHANNEL_ERR_INFO + { + error_code = 0, + passive_ErrData = new byte[3], + arLost_ErrData = 0 + }; + + try + { + ZLGCAN.ZCAN_ReadChannelErrInfo(handle, ref err); + if (err.error_code != 0) + { + _log.Warn($"CAN通道{ch}错误码：0x{err.error_code:X}"); + } + } + catch + { + // ignore + } + } + + // 轻量节流：避免无数据时空转占满 CPU。 + // 注意：这会引入 10ms 级额外接收延迟；若有更高实时性需求，应改为事件/阻塞式等待（SDK 支持时）。 + Thread.Sleep(10); + } + } + finally + { + Marshal.FreeHGlobal(pCanfdBuffer); + Marshal.FreeHGlobal(pCanBuffer); + } + } + + /// + /// 合并接收模式：通过设备级 API（ZCAN_ReceiveData）统一接收 CAN/CANFD/LIN。 + /// + /// 取消令牌。 + /// 接收缓存容量。 + /// + /// - merge 接收模式通常用于高吞吐场景：由驱动统一将各类数据封装为 DataObj； + /// - 本方法根据 dataType 分流： + /// - 1：CAN/CANFD + /// - 4：LIN + /// - 触发事件仍通过 / 。 + /// + + private void ReceiveLoop_Merge(CancellationToken token, int bufferFrames) + { + int dataObjSize = Marshal.SizeOf(typeof(ZLGCAN.ZCANDataObj)); + int canfdSize = Marshal.SizeOf(typeof(ZLGCAN.ZCANCANFDData)); + int linSize = Marshal.SizeOf(typeof(ZLGCAN.ZCANLINData)); + + // 合并接收模式的内存模型： + // - pDataObjs：ZCANDataObj 数组（每个元素描述一条数据，含 dataType/chnl/data）。 + // - obj.data 为托管 byte[]，为了用 PtrToStructure 解析为结构体，这里做一次 Marshal.Copy 到临时非托管缓冲。 + // 这样可以避免 unsafe/pin，但会增加一次拷贝开销；在高吞吐场景下 bufferFrames 应适当调大。 + IntPtr pDataObjs = Marshal.AllocHGlobal(dataObjSize * bufferFrames); + IntPtr pCanfdBuffer = Marshal.AllocHGlobal(canfdSize); + IntPtr pLinBuffer = Marshal.AllocHGlobal(linSize); + + try + { + while (!token.IsCancellationRequested) + { + // 2：device 级合并接收缓冲区（ZLG SDK 约定）。 + // 注意：合并接收开关需要在通道初始化时通过 0/set_device_recv_merge 开启（见 OpenAndInitCan）。 + uint recvNum = ZLGCAN.ZCAN_GetReceiveNum(_deviceHandle, 2); + if (recvNum == 0) + { + Thread.Sleep(10); + continue; + } + + uint actualRecv = ZLGCAN.ZCAN_ReceiveData(_deviceHandle, pDataObjs, (uint)bufferFrames, 10); + if (actualRecv == 0) + { + continue; + } + + for (int i = 0; i < actualRecv; i++) + { + IntPtr pCur = IntPtr.Add(pDataObjs, i * dataObjSize); + var obj = Marshal.PtrToStructure(pCur); + + switch (obj.dataType) + { + case 1: + // dataType=1：CAN/CANFD 统一封装（ZCANCANFDData）。 + // - flag bit0：是否为 CANFD + // - flag bit9：是否为 Tx echo（项目中用来点亮发送指示灯） + Marshal.Copy(obj.data, 0, pCanfdBuffer, canfdSize); + var canfdData = Marshal.PtrToStructure(pCanfdBuffer); + bool isFd = (canfdData.flag & 1) == 1; + bool isTx = (canfdData.flag & (1 << 9)) != 0; + RaiseCanFrame(obj.chnl, canfdData.timeStamp, isFd, canfdData.frame.can_id, canfdData.frame.data, canfdData.frame.len, isTx); + break; + + case 4: + // dataType=4：LIN（ZCANLINData）。 + if (obj.data == null || obj.data.Length < linSize) + { + break; + } + Marshal.Copy(obj.data, 0, pLinBuffer, linSize); + var linData = Marshal.PtrToStructure(pLinBuffer); + RaiseLinFrame(obj.chnl, linData.rxData.timeStamp, linData.pid.rawVal, linData.rxData.data, linData.rxData.datalen, linData.rxData.dir); + break; + } + } + + // 微节流：在持续高流量下仍可能较占 CPU；该 sleep 也会影响“批次间”延迟。 + Thread.Sleep(1); + } + } + finally + { + Marshal.FreeHGlobal(pLinBuffer); + Marshal.FreeHGlobal(pCanfdBuffer); + Marshal.FreeHGlobal(pDataObjs); + } + } + + /// + /// 将接收到的 CAN/CANFD 帧转换为托管对象并触发事件。 + /// + /// 通道号。 + /// 时间戳（us）。 + /// 是否 CANFD。 + /// can_id（含标志位）。 + /// 原始数据缓冲区。 + /// 数据长度。 + /// 是否为发送回显（Tx）。 + /// + /// 事件派发与 DBC 解码： + /// - 始终先触发 抛出原始帧； + /// - 再依据 决定是否进行 DBC 解码并刷新 。 + /// + /// 发送/接收指示： + /// - 若 为 true，调用 ；否则调用 。 + /// + + private void RaiseCanFrame(int channel, ulong timestamp, bool isCanFd, uint canId, byte[] data, byte dlc, bool isTx) + { + try + { + var len = Math.Min(isCanFd ? 64 : 8, Math.Min((int)dlc, data?.Length ?? 0)); + var bytes = new byte[len]; + if (len > 0 && data != null) + { + Array.Copy(data, bytes, len); + } + + CanFrameReceived?.Invoke(new ZlgCanRxFrame(channel, isCanFd, canId, bytes, timestamp, isTx)); + + // 说明： + // - UI 的“接收”指示灯通常表达“收到了总线帧/驱动回调在工作”，因此包括 Tx echo 在内的任意帧均点亮接收； + // - Tx echo 仍额外点亮“发送”指示灯。 + MarkReviceOk(); + if (isTx) + { + MarkSendOk(); + } + + if (DbcDecodeEnabled) + { + TryDecodeAndUpdateModels(canId, bytes, isCanFd ? (byte)ZDBC.FT_CANFD : (byte)ZDBC.FT_CAN); + } + } + catch (Exception ex) + { + _log.Warn($"派发 CAN 帧事件异常：{ex.Message}"); + } + } + + /// + /// 将接收到的 LIN 帧转换为托管对象并触发事件。 + /// + /// 通道号。 + /// 时间戳（us）。 + /// PID。 + /// 原始数据缓冲区。 + /// 数据长度。 + /// 方向（由设备回传）。 + /// + /// - LIN 数据长度最大 8 字节，本方法会按 截断并复制； + /// - 事件在接收线程触发，订阅方若更新 UI，请自行切换线程。 + /// + + private void RaiseLinFrame(int channel, ulong timestamp, byte pid, byte[] data, byte datalen, byte dir) + { + try + { + var len = Math.Min(8, Math.Min((int)datalen, data?.Length ?? 0)); + var bytes = new byte[len]; + if (len > 0 && data != null) + { + Array.Copy(data, bytes, len); + } + + LinFrameReceived?.Invoke(new ZlgLinRxFrame(channel, pid, bytes, timestamp, dir)); + } + catch (Exception ex) + { + _log.Warn($"派发 LIN 帧事件异常：{ex.Message}"); + } + } + + /// + /// 校验指定原生 DLL 是否存在于程序输出目录（AppContext.BaseDirectory）。 + /// + /// DLL 文件名。 + /// 找不到 DLL。 + + private static void EnsureNativeDllExists(string dllName) + { + var baseDir = AppContext.BaseDirectory; + var full = Path.Combine(baseDir, dllName); + if (!File.Exists(full)) + { + throw new FileNotFoundException($"未找到 {dllName}，请将其复制到程序输出目录：{baseDir}", full); + } + + // 预加载的目的： + // - 明确从输出目录加载指定 DLL，尽量避免被 PATH 中其它目录的同名 DLL“劫持”； + // - 发生依赖缺失/入口点不存在等异常时，记录在 _preloadedZlgcanError，便于 OpenDevice 失败时诊断。 + TryPreloadNativeDll(full); + if (_preloadedZlgcanHandle == IntPtr.Zero && !string.IsNullOrWhiteSpace(_preloadedZlgcanError)) + { + throw new InvalidOperationException($"预加载 {dllName} 失败：{_preloadedZlgcanError}。DLL 路径：{full}"); + } + + // 位数匹配检查： + // - 许多现场问题来自 x86/x64 不匹配； + // - 这里通过读取 PE 头 machine 字段做静态判断，避免到 P/Invoke 时才抛 BadImageFormatException。 + // 注意：这只能检查“主 DLL”的架构，不能保证其依赖 DLL（kerneldlls 下的其它库）都齐全且位数一致。 + var dllArch = TryGetPeArchitecture(full); + if (!string.IsNullOrWhiteSpace(dllArch)) + { + var procArch = Environment.Is64BitProcess ? "x64" : "x86"; + if (Environment.Is64BitProcess && !string.Equals(dllArch, "x64", StringComparison.OrdinalIgnoreCase)) + { + throw new InvalidOperationException($"{dllName} 位数不匹配：当前进程为 {procArch}，但 DLL 架构为 {dllArch}。请替换为 x64 版本 DLL，或将程序改为 x86 运行。DLL 路径：{full}"); + } + if (!Environment.Is64BitProcess && !string.Equals(dllArch, "x86", StringComparison.OrdinalIgnoreCase)) + { + throw new InvalidOperationException($"{dllName} 位数不匹配：当前进程为 {procArch}，但 DLL 架构为 {dllArch}。请替换为 x86 版本 DLL，或将程序改为 x64 运行。DLL 路径：{full}"); + } + } + } + + /// + /// 尝试读取 PE 头判断 DLL 架构。 + /// + /// DLL 完整路径。 + /// 返回 "x86"/"x64"/"arm64"/"unknown(...)"；读取失败返回 null。 + private static string? TryGetPeArchitecture(string dllFullPath) + { + try + { + using var fs = new FileStream(dllFullPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); + using var br = new BinaryReader(fs); + + if (fs.Length < 0x40) + { + return null; + } + + var mz = br.ReadUInt16(); + if (mz != 0x5A4D) + { + return null; + } + + // e_lfanew：DOS Header + 0x3C，指向 PE Header 起始偏移。 + fs.Position = 0x3C; + var peOffset = br.ReadInt32(); + if (peOffset <= 0 || peOffset > fs.Length - 6) + { + return null; + } + + // PE signature："PE\0\0" => 0x00004550。 + fs.Position = peOffset; + var peSig = br.ReadUInt32(); + if (peSig != 0x00004550) + { + return null; + } + + // IMAGE_FILE_HEADER.Machine： + // - 0x014c = x86 + // - 0x8664 = x64 + // - 0xAA64 = arm64 + var machine = br.ReadUInt16(); + return machine switch + { + 0x014c => "x86", + 0x8664 => "x64", + 0xAA64 => "arm64", + _ => $"unknown(0x{machine:X})" + }; + } + catch + { + return null; + } + } + + /// + /// 构建 DBC 解码更新用的索引表。 + /// + /// 所有信号模型。 + /// 键为 (MsgName, SignalName) 的组合键，值为对应的 。 + /// + /// - 接收线程解码得到 (msgName, signalName) 后，可 O(1) 定位到 UI 模型进行更新； + /// - 组合键使用 ，避免字符串拼接歧义。 + /// + private static Dictionary BuildDbcModelIndex(IEnumerable models) + { + var dict = new Dictionary(StringComparer.Ordinal); + + foreach (var m in models) + { + if (string.IsNullOrWhiteSpace(m.MsgName) || string.IsNullOrWhiteSpace(m.SignalName)) + { + continue; + } + + dict[BuildMsgSigKey(m.MsgName, m.SignalName)] = m; + } + + return dict; + } + + /// + /// 构建 (MsgName, SignalName) 的唯一组合键。 + /// + /// 消息名。 + /// 信号名。 + /// 组合键字符串。 + /// + /// 使用 '\0' 作为分隔符，降低与业务字符串冲突的风险。 + /// + private static string BuildMsgSigKey(string msgName, string signalName) + { + return msgName + "\u0000" + signalName; + } + + /// + /// 尝试对原始帧做 DBC 解码，并将解码结果写回到对应的 实例。 + /// + /// CAN ID（含标志位）。 + /// 原始数据。 + /// 帧类型（CAN/CANFD）。 + /// + /// - 本方法被 在接收线程中调用； + /// - 若 DBC 未加载或索引表为空，会直接返回； + /// - 解码后按 signalName 更新 （字符串形式）。 + /// + private void TryDecodeAndUpdateModels(uint canId, byte[] payload, byte frameType) + { + ZlgDbcDatabase? dbc; + Dictionary? index; + + lock (_dbcSync) + { + dbc = _dbc; + index = _dbcModelIndex; + } + + if (dbc == null || !dbc.IsLoaded || index == null) + { + return; + } + + try + { + var (msgName, signals) = dbc.DecodeRawFrame(canId, payload, frameType); + if (string.IsNullOrWhiteSpace(msgName) || signals == null || signals.Count == 0) + { + return; + } + + foreach (var kv in signals) + { + var key = BuildMsgSigKey(msgName, kv.Key); + if (index.TryGetValue(key, out var model)) + { + model.SignalRtValue = kv.Value.ToString(); + } + } + } + catch (Exception ex) + { + _log.Warn($"DBC 解码异常：{ex.Message}"); + } + } + + /// + /// 若对象已释放则抛异常。 + /// + private void ThrowIfDisposed() + { + if (_disposed) + { + throw new ObjectDisposedException(nameof(ZlgCanFd200uDriver)); + } + } + } + + /// + /// CAN/CANFD 接收帧。 + /// + public readonly struct ZlgCanRxFrame + { + /// + /// 构造 CAN/CANFD 接收帧。 + /// + /// 通道号。 + /// 是否 CANFD。 + /// can_id（含标志位）。 + /// 数据（已截断为实际长度）。 + /// 时间戳（us）。 + /// 是否为发送回显。 + public ZlgCanRxFrame(int channel, bool isCanFd, uint canId, byte[] data, ulong timestampUs, bool isTx) + { + Channel = channel; + IsCanFd = isCanFd; + CanId = canId; + Data = data; + TimestampUs = timestampUs; + IsTx = isTx; + } + + /// + /// 通道号（0/1）。 + /// + public int Channel { get; } + + /// + /// 是否为 CANFD 帧。 + /// + public bool IsCanFd { get; } + + /// + /// can_id（包含扩展帧/错误帧等标志位，具体位定义见 ZLG 文档）。 + /// + public uint CanId { get; } + + /// + /// 数据区（已按实际长度截断拷贝）。 + /// + public byte[] Data { get; } + + /// + /// 时间戳（微秒）。 + /// + public ulong TimestampUs { get; } + + /// + /// 是否为发送回显（Tx）。 + /// + public bool IsTx { get; } + } + + /// + /// LIN 接收帧。 + /// + public readonly struct ZlgLinRxFrame + { + /// + /// 构造 LIN 接收帧。 + /// + /// 通道号。 + /// PID。 + /// 数据（已截断为实际长度）。 + /// 时间戳（us）。 + /// 方向（由设备回传）。 + public ZlgLinRxFrame(int channel, byte pid, byte[] data, ulong timestampUs, byte dir) + { + Channel = channel; + Pid = pid; + Data = data; + TimestampUs = timestampUs; + Dir = dir; + } + + /// + /// 通道号。 + /// + public int Channel { get; } + + /// + /// PID。 + /// + public byte Pid { get; } + + /// + /// 数据区（已按实际长度截断拷贝）。 + /// + public byte[] Data { get; } + + /// + /// 时间戳（微秒）。 + /// + public ulong TimestampUs { get; } + + /// + /// 方向：由设备回传，0/1 具体含义以 ZLG 文档为准。 + /// + public byte Dir { get; } + } +} diff --git a/CapMachine.Wpf/CanDrive/ZlgCan/ZlgCanIdHelper.cs b/CapMachine.Wpf/CanDrive/ZlgCan/ZlgCanIdHelper.cs new file mode 100644 index 0000000..8d0a9cd --- /dev/null +++ b/CapMachine.Wpf/CanDrive/ZlgCan/ZlgCanIdHelper.cs @@ -0,0 +1,62 @@ +using System; + +namespace CapMachine.Wpf.CanDrive.ZlgCan +{ + /// + /// ZLG CAN ID 帮助类。 + /// + public static class ZlgCanIdHelper + { + /// + /// 生成 ZLG/SocketCAN 风格的 can_id（包含扩展帧/远程帧/错误帧标志位）。 + /// + /// CAN 标识符（标准帧 11bit：0~0x7FF；扩展帧 29bit：0~0x1FFFFFFF）。 + /// 是否为扩展帧。 + /// 是否为远程帧（RTR）。 + /// 是否为错误帧。 + /// 包含标志位的 can_id。 + public static uint MakeCanId(uint id, bool isExtended, bool isRemote, bool isError) + { + // 兼容官方样例写法：bit31 扩展帧，bit30 RTR，bit29 ERR + // 注意：该函数不做强约束校验（例如扩展帧 29bit），上层可按需要增加校验。 + uint canId = id & 0x1FFFFFFF; + + if (isExtended) + { + canId |= 1u << 31; + } + + if (isRemote) + { + canId |= 1u << 30; + } + + if (isError) + { + canId |= 1u << 29; + } + + return canId; + } + + /// + /// 从 can_id 中提取 29bit 标识符。 + /// + /// 包含标志位的 can_id。 + /// 29bit 标识符。 + public static uint GetArbitrationId(uint canId) + { + return canId & 0x1FFFFFFF; + } + + /// + /// 判断 can_id 是否为扩展帧。 + /// + /// 包含标志位的 can_id。 + /// 是否扩展帧。 + public static bool IsExtended(uint canId) + { + return (canId & (1u << 31)) != 0; + } + } +} diff --git a/CapMachine.Wpf/CanDrive/ZlgCan/ZlgDbcDatabase.cs b/CapMachine.Wpf/CanDrive/ZlgCan/ZlgDbcDatabase.cs new file mode 100644 index 0000000..c573902 --- /dev/null +++ b/CapMachine.Wpf/CanDrive/ZlgCan/ZlgDbcDatabase.cs @@ -0,0 +1,728 @@ +using CapMachine.Wpf.CanDrive; +using CapMachine.Wpf.Services; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; + +namespace CapMachine.Wpf.CanDrive.ZlgCan +{ + /// + /// 基于周立功 ZDBC（zdbc.dll）的 DBC 数据库封装。 + /// + /// + /// 设计要点： + /// - zdbc.dll 为原生依赖，必须放置在程序输出目录（AppContext.BaseDirectory）。 + /// - 本类封装 DBC 文件加载、消息/信号枚举、以及基于 DBCMessage 的编码/解码能力。 + /// - 运行稳定性：实现 IDisposable，确保 ZDBC_Release 与相关非托管内存释放。 + /// + public sealed class ZlgDbcDatabase : IDisposable + { + private readonly ILogService _log; + private readonly object _sync = new object(); + + private uint _dbcHandle; + private bool _disposed; + + // 复用非托管缓冲，避免高频 Allocate/Free + private IntPtr _msgPtr = IntPtr.Zero; + private IntPtr _countPtr = IntPtr.Zero; + private IntPtr _canFramePtr = IntPtr.Zero; + private IntPtr _canFdFramePtr = IntPtr.Zero; + + private readonly Dictionary _messageByName = new Dictionary(StringComparer.Ordinal); + private readonly Dictionary _messageIdByName = new Dictionary(StringComparer.Ordinal); + + /// + /// 构造函数。 + /// + /// 日志服务。 + public ZlgDbcDatabase(ILogService logService) + { + _log = logService; + } + + /// + /// 是否已加载。 + /// + public bool IsLoaded + { + get + { + return _dbcHandle != 0 && _dbcHandle != ZDBC.INVALID_DBC_HANDLE; + } + } + + /// + /// 加载 DBC 文件。 + /// + /// DBC 文件路径。 + /// 是否启用异步解析（库内部线程）。 + /// 是否合并到当前数据库（支持加载多个文件）。 + /// 协议类型：J1939=0，其他=1。 + public void Load(string dbcPath, bool enableAsyncAnalyse = true, bool merge = false, byte protocolType = ZDBC.PROTOCOL_OTHER) + { + ThrowIfDisposed(); + + if (string.IsNullOrWhiteSpace(dbcPath)) + { + throw new ArgumentException("dbcPath 不能为空。", nameof(dbcPath)); + } + + EnsureNativeDllExists("zdbc.dll"); + + if (!File.Exists(dbcPath)) + { + throw new FileNotFoundException("DBC 文件不存在。", dbcPath); + } + + var fileSize = 0L; + try + { + fileSize = new FileInfo(dbcPath).Length; + } + catch + { + } + + var fullPath = dbcPath; + try + { + fullPath = Path.GetFullPath(dbcPath); + } + catch + { + } + + var shortPath = TryGetShortPath(fullPath); + var candidatePaths = new List(); + if (!string.IsNullOrWhiteSpace(fullPath)) candidatePaths.Add(fullPath); + if (!string.IsNullOrWhiteSpace(shortPath) + && !string.Equals(shortPath, fullPath, StringComparison.OrdinalIgnoreCase)) + { + candidatePaths.Add(shortPath); + } + + lock (_sync) + { + if (_dbcHandle == 0 || _dbcHandle == ZDBC.INVALID_DBC_HANDLE) + { + _dbcHandle = ZDBC.ZDBC_Init(0, enableAsyncAnalyse ? (byte)1 : (byte)0); + if (_dbcHandle == ZDBC.INVALID_DBC_HANDLE) + { + _dbcHandle = 0; + throw new InvalidOperationException("ZDBC_Init 初始化失败。"); + } + } + + var loadOk = false; + foreach (var path in candidatePaths) + { + var fileInfo = new ZDBC.FileInfo + { + strFilePath = BuildFixedPathBytes(path, ZDBC._MAX_FILE_PATH_ + 1), + type = protocolType, + merge = (byte)(merge ? 1 : 0) + }; + + IntPtr pFile = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZDBC.FileInfo))); + try + { + Marshal.StructureToPtr(fileInfo, pFile, false); + loadOk = ZDBC.ZDBC_LoadFile(_dbcHandle, pFile); + if (loadOk) + { + break; + } + } + finally + { + Marshal.FreeHGlobal(pFile); + } + } + + if (!loadOk) + { + // fallback：直接按内容加载，绕开路径编码问题；同时尝试多种编码以提升兼容性。 + loadOk = TryLoadContentFallback_NoLock(fullPath, merge); + } + + if (!loadOk) + { + var msg = $"ZDBC_LoadFile 失败。DbcPath={fullPath}，ShortPath={shortPath ?? string.Empty}，Size={fileSize}。请检查 DBC 文件格式，或将 DBC 放到纯英文路径后重试。"; + throw new InvalidOperationException(msg); + } + + RefreshMessageCache_NoLock(); + } + } + + /// + /// 枚举 DBC 内全部 Message/Signal 元信息，并转换为 UI 使用的 CanDbcModel 集合。 + /// + /// 信号集合。 + public ObservableCollection BuildCanDbcModels() + { + ThrowIfDisposed(); + + if (!IsLoaded) + { + return new ObservableCollection(); + } + + lock (_sync) + { + var list = new List(); + + foreach (var kv in _messageByName) + { + var msg = kv.Value; + var msgName = ByteArrayToAsciiString(msg.strName); + var msgIdStr = "0x" + msg.nID.ToString("X8"); + + var signals = msg.vSignals; + if (signals == null || signals.Length == 0) + { + continue; + } + + var signalCount = (int)Math.Min(msg.nSignalCount, (uint)signals.Length); + for (int i = 0; i < signalCount; i++) + { + var s = signals[i]; + var sigName = ByteArrayToAsciiString(s.strName); + if (string.IsNullOrWhiteSpace(sigName)) + { + continue; + } + + list.Add(new CanDbcModel + { + MsgName = msgName, + MsgId = msgIdStr, + SignalName = sigName, + SignalDesc = ByteArrayToAsciiString(s.strComment), + SignalUnit = ByteArrayToAsciiString(s.unit), + SignalRtValue = "--", + Publisher = string.Empty + }); + } + } + + return new ObservableCollection(list); + } + } + + /// + /// 根据 MsgName 获取 Message ID。 + /// + /// 消息名称。 + /// Message ID。 + public uint GetMessageIdByName(string msgName) + { + ThrowIfDisposed(); + if (string.IsNullOrWhiteSpace(msgName)) return 0; + + lock (_sync) + { + return _messageIdByName.TryGetValue(msgName, out var id) ? id : 0; + } + } + + /// + /// 根据 MsgName + 信号值集合编码为 CAN/CANFD 原始帧。 + /// + /// 消息名称。 + /// 信号值（SignalName -> 实际值）。 + /// 帧类型：FT_CAN=0，FT_CANFD=1。 + /// 编码后的 can_id 与数据。 + public (uint CanId, byte[] Data, int DataLen) EncodeToRawFrame(string msgName, IDictionary signals, byte frameType) + { + ThrowIfDisposed(); + + if (!IsLoaded) + { + throw new InvalidOperationException("DBC 未加载。"); + } + + if (string.IsNullOrWhiteSpace(msgName)) + { + throw new ArgumentException("msgName 不能为空。", nameof(msgName)); + } + + lock (_sync) + { + if (!_messageByName.TryGetValue(msgName, out var msg)) + { + throw new InvalidOperationException($"DBC 中未找到消息：{msgName}"); + } + + // 在副本上修改信号，避免污染缓存 + var workingMsg = msg; + if (workingMsg.vSignals == null) + { + workingMsg.vSignals = new ZDBC.DBCSignal[ZDBC._DBC_SIGNAL_MAX_COUNT_]; + } + + if (signals != null) + { + foreach (var kv in signals) + { + SetSignalActualValue(ref workingMsg, kv.Key, kv.Value); + } + } + + EnsureMarshalBuffers_NoLock(); + + // 写入 msg 到非托管 + Marshal.StructureToPtr(workingMsg, _msgPtr, false); + + // nCount 输入输出参数，准备 1 帧 + Marshal.WriteInt32(_countPtr, 1); + + if (frameType == ZDBC.FT_CAN) + { + var ok = ZDBC.ZDBC_Encode(_dbcHandle, _canFramePtr, _countPtr, _msgPtr, frameType); + if (!ok) + { + throw new InvalidOperationException("ZDBC_Encode(CAN) 失败。"); + } + + var frame = (ZlgNativeCanFrame)Marshal.PtrToStructure(_canFramePtr, typeof(ZlgNativeCanFrame)); + var len = Math.Min(8, (int)frame.can_dlc); + var data = new byte[len]; + if (len > 0 && frame.data != null) + { + Array.Copy(frame.data, data, len); + } + + return (frame.can_id, data, len); + } + + if (frameType == ZDBC.FT_CANFD) + { + var ok = ZDBC.ZDBC_Encode(_dbcHandle, _canFdFramePtr, _countPtr, _msgPtr, frameType); + if (!ok) + { + throw new InvalidOperationException("ZDBC_Encode(CANFD) 失败。"); + } + + var frame = (ZlgNativeCanFdFrame)Marshal.PtrToStructure(_canFdFramePtr, typeof(ZlgNativeCanFdFrame)); + var len = Math.Min(64, (int)frame.len); + var data = new byte[len]; + if (len > 0 && frame.data != null) + { + Array.Copy(frame.data, data, len); + } + + return (frame.can_id, data, len); + } + + throw new ArgumentOutOfRangeException(nameof(frameType), "frameType 仅支持 FT_CAN=0 或 FT_CANFD=1。"); + } + } + + /// + /// 将原始 CAN/CANFD 帧解码为 DBCMessage，并返回消息名称与信号实际值。 + /// + /// can_id。 + /// payload。 + /// 帧类型：FT_CAN=0，FT_CANFD=1。 + /// 解码结果。 + public (string MsgName, Dictionary Signals) DecodeRawFrame(uint canId, byte[] data, byte frameType) + { + ThrowIfDisposed(); + + if (!IsLoaded) + { + throw new InvalidOperationException("DBC 未加载。"); + } + + lock (_sync) + { + EnsureMarshalBuffers_NoLock(); + + if (frameType == ZDBC.FT_CAN) + { + var frame = ZlgNativeCanFrame.Create(canId, data ?? Array.Empty(), requestTxEcho: false); + Marshal.StructureToPtr(frame, _canFramePtr, false); + + var ok = ZDBC.ZDBC_Decode(_dbcHandle, _msgPtr, _canFramePtr, 1, frameType); + if (!ok) + { + return (string.Empty, new Dictionary()); + } + + var msg = Marshal.PtrToStructure(_msgPtr); + return ExtractActualSignals(msg); + } + + if (frameType == ZDBC.FT_CANFD) + { + var frame = ZlgNativeCanFdFrame.Create(canId, data ?? Array.Empty(), requestTxEcho: false); + Marshal.StructureToPtr(frame, _canFdFramePtr, false); + + var ok = ZDBC.ZDBC_Decode(_dbcHandle, _msgPtr, _canFdFramePtr, 1, frameType); + if (!ok) + { + return (string.Empty, new Dictionary()); + } + + var msg = Marshal.PtrToStructure(_msgPtr); + return ExtractActualSignals(msg); + } + + throw new ArgumentOutOfRangeException(nameof(frameType), "frameType 仅支持 FT_CAN=0 或 FT_CANFD=1。"); + } + } + + /// + public void Dispose() + { + if (_disposed) return; + _disposed = true; + + lock (_sync) + { + try + { + if (_dbcHandle != 0 && _dbcHandle != ZDBC.INVALID_DBC_HANDLE) + { + ZDBC.ZDBC_Release(_dbcHandle); + } + } + catch (Exception ex) + { + _log.Warn($"ZDBC_Release 异常：{ex.Message}"); + } + finally + { + _dbcHandle = 0; + } + + FreeMarshalBuffers_NoLock(); + _messageByName.Clear(); + _messageIdByName.Clear(); + } + } + + private void RefreshMessageCache_NoLock() + { + _messageByName.Clear(); + _messageIdByName.Clear(); + + if (!IsLoaded) + { + return; + } + + EnsureMarshalBuffers_NoLock(); + + // 遍历消息 + var msg = new ZDBC.DBCMessage + { + vSignals = new ZDBC.DBCSignal[ZDBC._DBC_SIGNAL_MAX_COUNT_], + strName = new byte[ZDBC._DBC_NAME_LENGTH_ + 1], + strComment = new byte[ZDBC._DBC_COMMENT_MAX_LENGTH_ + 1] + }; + + Marshal.StructureToPtr(msg, _msgPtr, false); + var ok = ZDBC.ZDBC_GetFirstMessage(_dbcHandle, _msgPtr); + while (ok) + { + var m = Marshal.PtrToStructure(_msgPtr); + var name = ByteArrayToAsciiString(m.strName); + if (!string.IsNullOrWhiteSpace(name)) + { + _messageByName[name] = m; + _messageIdByName[name] = m.nID; + } + + Marshal.StructureToPtr(msg, _msgPtr, false); + ok = ZDBC.ZDBC_GetNextMessage(_dbcHandle, _msgPtr); + } + } + + private void EnsureMarshalBuffers_NoLock() + { + if (_msgPtr == IntPtr.Zero) + { + _msgPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZDBC.DBCMessage))); + } + + if (_countPtr == IntPtr.Zero) + { + _countPtr = Marshal.AllocHGlobal(sizeof(int)); + } + + if (_canFramePtr == IntPtr.Zero) + { + _canFramePtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZlgNativeCanFrame))); + } + + if (_canFdFramePtr == IntPtr.Zero) + { + _canFdFramePtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZlgNativeCanFdFrame))); + } + } + + private void FreeMarshalBuffers_NoLock() + { + if (_canFdFramePtr != IntPtr.Zero) + { + Marshal.FreeHGlobal(_canFdFramePtr); + _canFdFramePtr = IntPtr.Zero; + } + + if (_canFramePtr != IntPtr.Zero) + { + Marshal.FreeHGlobal(_canFramePtr); + _canFramePtr = IntPtr.Zero; + } + + if (_countPtr != IntPtr.Zero) + { + Marshal.FreeHGlobal(_countPtr); + _countPtr = IntPtr.Zero; + } + + if (_msgPtr != IntPtr.Zero) + { + Marshal.FreeHGlobal(_msgPtr); + _msgPtr = IntPtr.Zero; + } + } + + private static void EnsureNativeDllExists(string dllName) + { + var baseDir = AppContext.BaseDirectory; + var full = Path.Combine(baseDir, dllName); + if (!File.Exists(full)) + { + throw new FileNotFoundException($"未找到 {dllName}，请将其复制到程序输出目录：{baseDir}", full); + } + } + + private void SetSignalActualValue(ref ZDBC.DBCMessage msg, string signalName, double actualValue) + { + if (msg.vSignals == null || msg.vSignals.Length == 0) + { + return; + } + + var count = (int)Math.Min(msg.nSignalCount, (uint)msg.vSignals.Length); + for (int i = 0; i < count; i++) + { + var s = msg.vSignals[i]; + var name = ByteArrayToAsciiString(s.strName); + if (!string.Equals(name, signalName, StringComparison.Ordinal)) + { + continue; + } + + // 使用 ZDBC_CalcRawValue 做实际值->原始值转换 + IntPtr pSgl = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZDBC.DBCSignal))); + IntPtr pVal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double))); + try + { + Marshal.StructureToPtr(s, pSgl, false); + Marshal.StructureToPtr(actualValue, pVal, false); + var raw = ZDBC.ZDBC_CalcRawValue(pSgl, pVal); + msg.vSignals[i].nRawvalue = raw; + } + finally + { + Marshal.FreeHGlobal(pVal); + Marshal.FreeHGlobal(pSgl); + } + + return; + } + } + + private (string MsgName, Dictionary Signals) ExtractActualSignals(ZDBC.DBCMessage msg) + { + var msgName = ByteArrayToAsciiString(msg.strName); + var dict = new Dictionary(StringComparer.Ordinal); + + if (msg.vSignals == null) + { + return (msgName, dict); + } + + var count = (int)Math.Min(msg.nSignalCount, (uint)msg.vSignals.Length); + for (int i = 0; i < count; i++) + { + var s = msg.vSignals[i]; + var name = ByteArrayToAsciiString(s.strName); + if (string.IsNullOrWhiteSpace(name)) + { + continue; + } + + // 使用 ZDBC_CalcActualValue 做原始值->实际值转换 + IntPtr pSgl = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZDBC.DBCSignal))); + IntPtr pRaw = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ulong))); + try + { + Marshal.StructureToPtr(s, pSgl, false); + Marshal.StructureToPtr(s.nRawvalue, pRaw, false); + var actual = ZDBC.ZDBC_CalcActualValue(pSgl, pRaw); + dict[name] = actual; + } + finally + { + Marshal.FreeHGlobal(pRaw); + Marshal.FreeHGlobal(pSgl); + } + } + + return (msgName, dict); + } + + private static byte[] BuildFixedPathBytes(string path, int fixedLen) + { + var bytes = Encoding.Default.GetBytes(path); + var dst = new byte[fixedLen]; + Array.Clear(dst, 0, dst.Length); + Array.Copy(bytes, 0, dst, 0, Math.Min(bytes.Length, fixedLen - 1)); + return dst; + } + + /// + /// 当 ZDBC_LoadFile 失败时的兜底加载策略：读取文件内容并调用 ZDBC_LoadContent。 + /// + /// DBC 完整路径。 + /// 是否合并。 + /// 加载成功返回 true。 + private bool TryLoadContentFallback_NoLock(string fullPath, bool merge) + { + // zdbc.dll 入口为 ANSI 字符串，因此这里优先使用 ASCII（将非 ASCII 字符替换为 ?）， + // 避免中文注释/特殊字符导致原生库解析失败；同时需要兼容 UTF-16 BOM，否则用 ASCII 读会出现大量 \0 造成内容截断。 + + var encodings = new List(); + + try + { + var bytes = File.ReadAllBytes(fullPath); + if (bytes.Length >= 2) + { + // UTF-16 LE BOM: FF FE + if (bytes[0] == 0xFF && bytes[1] == 0xFE) + { + encodings.Add(Encoding.Unicode); + } + // UTF-16 BE BOM: FE FF + else if (bytes[0] == 0xFE && bytes[1] == 0xFF) + { + encodings.Add(Encoding.BigEndianUnicode); + } + } + + if (bytes.Length >= 3) + { + // UTF-8 BOM: EF BB BF + if (bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF) + { + encodings.Add(Encoding.UTF8); + } + } + } + catch + { + } + + // 常规兜底编码序列 + encodings.Add(new UTF8Encoding(false, true)); + encodings.Add(Encoding.UTF8); + encodings.Add(Encoding.Default); + encodings.Add(Encoding.ASCII); + + foreach (var enc in encodings.Distinct()) + { + IntPtr pContent = IntPtr.Zero; + try + { + var content = File.ReadAllText(fullPath, enc); + pContent = Marshal.StringToHGlobalAnsi(content); + var ok = ZDBC.ZDBC_LoadContent(_dbcHandle, pContent, merge ? 1u : 0u); + if (ok) + { + return true; + } + } + catch + { + } + finally + { + if (pContent != IntPtr.Zero) + { + Marshal.FreeHGlobal(pContent); + } + } + } + + return false; + } + + /// + /// 获取 Windows 8.3 短路径。 + /// + /// 长路径。 + /// 短路径缓冲。 + /// 缓冲区大小。 + /// 返回写入的字符数量；0 表示失败。 + [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)] + private static extern uint GetShortPathName(string lpszLongPath, StringBuilder lpszShortPath, uint cchBuffer); + + /// + /// 尝试将长路径转换为短路径（8.3），用于兼容部分原生库对中文/特殊字符路径处理不完整的问题。 + /// + /// 长路径。 + /// 短路径；失败返回 null。 + private static string? TryGetShortPath(string fullPath) + { + try + { + if (string.IsNullOrWhiteSpace(fullPath)) + { + return null; + } + + var sb = new StringBuilder(1024); + var ret = GetShortPathName(fullPath, sb, (uint)sb.Capacity); + if (ret == 0) + { + return null; + } + return sb.ToString(); + } + catch + { + return null; + } + } + + private static string ByteArrayToAsciiString(byte[]? bytes) + { + if (bytes == null || bytes.Length == 0) return string.Empty; + + int len = Array.IndexOf(bytes, (byte)0); + if (len < 0) len = bytes.Length; + + return Encoding.Default.GetString(bytes, 0, len).Trim(); + } + + private void ThrowIfDisposed() + { + if (_disposed) + { + throw new ObjectDisposedException(nameof(ZlgDbcDatabase)); + } + } + } +} diff --git a/CapMachine.Wpf/CanDrive/ZlgCan/ZlgNativeFrames.cs b/CapMachine.Wpf/CanDrive/ZlgCan/ZlgNativeFrames.cs new file mode 100644 index 0000000..0aedf4f --- /dev/null +++ b/CapMachine.Wpf/CanDrive/ZlgCan/ZlgNativeFrames.cs @@ -0,0 +1,103 @@ +using System; +using System.Runtime.InteropServices; + +namespace CapMachine.Wpf.CanDrive.ZlgCan +{ + /// + /// 供 DBC 编解码/Marshal 使用的原生 CAN 帧结构（与 zlgcan can_frame 二进制布局兼容）。 + /// + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZlgNativeCanFrame + { + public uint can_id; + public byte can_dlc; + public byte __pad; + public byte __res0; + public byte __res1; + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] data; + + /// + /// 创建 CAN 帧。 + /// + /// can_id（包含扩展帧等标志位）。 + /// 数据（0~8）。 + /// 是否请求发送回显。 + /// 原生 CAN 帧。 + public static ZlgNativeCanFrame Create(uint canId, byte[] payload, bool requestTxEcho) + { + var len = Math.Min(8, payload?.Length ?? 0); + var frame = new ZlgNativeCanFrame + { + can_id = canId, + can_dlc = (byte)len, + __pad = 0, + __res0 = 0, + __res1 = 0, + data = new byte[8] + }; + + if (len > 0 && payload != null) + { + Array.Copy(payload, frame.data, len); + } + + if (requestTxEcho) + { + frame.__pad |= 0x20; + } + + return frame; + } + } + + /// + /// 供 DBC 编解码/Marshal 使用的原生 CANFD 帧结构（与 zlgcan canfd_frame 二进制布局兼容）。 + /// + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZlgNativeCanFdFrame + { + public uint can_id; + public byte len; + public byte flags; + public byte __res0; + public byte __res1; + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public byte[] data; + + /// + /// 创建 CANFD 帧。 + /// + /// can_id（包含扩展帧等标志位）。 + /// 数据（0~64）。 + /// 是否请求发送回显。 + /// 原生 CANFD 帧。 + public static ZlgNativeCanFdFrame Create(uint canId, byte[] payload, bool requestTxEcho) + { + var len = Math.Min(64, payload?.Length ?? 0); + var frame = new ZlgNativeCanFdFrame + { + can_id = canId, + len = (byte)len, + flags = 0, + __res0 = 0, + __res1 = 0, + data = new byte[64] + }; + + if (len > 0 && payload != null) + { + Array.Copy(payload, frame.data, len); + } + + if (requestTxEcho) + { + frame.flags |= 0x20; + } + + return frame; + } + } +} diff --git a/CapMachine.Wpf/CanDrive/ZlgCan/接口函数使用手册.pdf b/CapMachine.Wpf/CanDrive/ZlgCan/接口函数使用手册.pdf new file mode 100644 index 0000000000000000000000000000000000000000..4e68bec3991f0b85007e2d2241f84518e3484538 GIT binary patch literal 1666099 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Ǿ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

V7~LF^g7Kvz0@W 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

(()%vJW?qa)tD=2A%#+ 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%0AUg)q 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%0As{RUJus9QNWy{lHS*=Tgf-lzCx=;8h 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

f+ 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

A10fx2EUkFBbZnW< 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

    @ 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 + /// 调度表是否启用 + ///

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

 + public bool SchEnable + { + get { return _SchEnable; } + set { _SchEnable = value; RaisePropertyChanged(); } + } } } diff --git a/CapMachine.Wpf/Dtos/CANFdScheduleConfigDto.cs b/CapMachine.Wpf/Dtos/CANFdScheduleConfigDto.cs new file mode 100644 index 0000000..2ff33ad --- /dev/null +++ b/CapMachine.Wpf/Dtos/CANFdScheduleConfigDto.cs @@ -0,0 +1,83 @@ +using CapMachine.Model.CANLIN; +using Prism.Mvvm; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace CapMachine.Wpf.Dtos +{ + /// + /// CANFdScheduleConfigDto + /// + public class CANFdScheduleConfigDto : BindableBase + { + /// + /// 主键 + /// + public long Id { get; set; } + + private string? _MsgName; + /// + /// 消息名称/帧名称 + /// + public string? MsgName + { + get { return _MsgName; } + set { _MsgName = value; RaisePropertyChanged(); } + } + + private int _Cycle; + /// + /// 周期 + /// + public int Cycle + { + get { return _Cycle; } + set { _Cycle = value; RaisePropertyChanged(); } + } + + private int _OrderSend; + /// + /// 发送方式 + /// + public int OrderSend + { + get { return _OrderSend; } + set { _OrderSend = value; RaisePropertyChanged(); } + } + + private int _SchTabIndex; + /// + /// 调度表的Index序列 + /// + public int SchTabIndex + { + get { return _SchTabIndex; } + set { _SchTabIndex = value; RaisePropertyChanged(); } + } + + /// + /// 在更新调度表数据时,我们有一个整体的帧数据指令集合，但是这些帧数据集合，分属于不同的调度表， + /// 这个在开始时生成整体的帧数据指令集合才会把这个MsgIndex分配上，这个不需要保存到数据库中，对接使用 + /// + public int MsgIndex { get; set; } + + /// + /// 程序的ID + /// + public long CanLinConfigProId { get; set; } + + + private CanLinConfigPro _CanLinConfigPro; + /// + /// 所属的程序 + /// + public CanLinConfigPro CanLinConfigPro + { + get { return _CanLinConfigPro; } + set { _CanLinConfigPro = value; RaisePropertyChanged(); } + } + } +} diff --git a/CapMachine.Wpf/Services/CanFdDriveService.cs b/CapMachine.Wpf/Services/CanFdDriveService.cs index 7d3844f..c28b0ec 100644 --- a/CapMachine.Wpf/Services/CanFdDriveService.cs +++ b/CapMachine.Wpf/Services/CanFdDriveService.cs @@ -1,5 +1,6 @@ using CapMachine.Model.CANLIN; using CapMachine.Wpf.CanDrive; +using CapMachine.Wpf.Dtos; using CapMachine.Wpf.Models; using CapMachine.Wpf.Models.ProModelPars; using ImTools; @@ -25,9 +26,9 @@ namespace CapMachine.Wpf.Services /// /// 实例化函数 /// - public CanFdDriveService(HighSpeedDataService highSpeedDataService, IContainerProvider containerProvider, LogicRuleService logicRuleService) + public CanFdDriveService(HighSpeedDataService highSpeedDataService, IContainerProvider containerProvider, LogicRuleService logicRuleService, ILogService logService) { - ToomossCanFDDrive = new ToomossCanFD(containerProvider); + ToomossCanFDDrive = new ToomossCanFD(containerProvider, logService); //高速数据服务 HighSpeedDataService = highSpeedDataService; LogicRuleService = logicRuleService; @@ -126,6 +127,11 @@ namespace CapMachine.Wpf.Services /// public List CmdData { get; set; } = new List(); + /// + /// CNA 调度表的配置信息 + /// + public List ListCANFdScheduleConfig { get; set; } + /// /// 增加发送的指令数据 /// @@ -212,7 +218,7 @@ namespace CapMachine.Wpf.Services { if (PwLimitCanCmdData != null) { - if (PwLimitCanCmdData.LogicRuleDto==null) + if (PwLimitCanCmdData.LogicRuleDto == null) { PwLimitCanCmdData.SignalCmdValue = PwLimit; return; @@ -264,7 +270,7 @@ namespace CapMachine.Wpf.Services PTCFlowCanCmdData.SignalCmdValue = Flow; return; } - PTCFlowCanCmdData.SignalCmdValue = LogicRuleService.ApplyExpressionFast(Flow, PTCFlowCanCmdData.LogicRuleDto!); + PTCFlowCanCmdData.SignalCmdValue = LogicRuleService.ApplyExpressionFast(Flow, PTCFlowCanCmdData.LogicRuleDto!); } } @@ -322,10 +328,39 @@ namespace CapMachine.Wpf.Services { if (CmdData.Count > 0) { - ToomossCanFDDrive.IsCycleSend = true; + //把指令数据赋值给CAN 驱动 ToomossCanFDDrive.CmdData = CmdData; - //ToomossCanFDDrive.StartCycleSendMsg(); - ToomossCanFDDrive.StartPrecisionCycleSendMsg(); + + if (ToomossCanFDDrive.SchEnable) + { + + //使用调度表的话，需要在调度表中配置信息后才可以进行操作 + var GroupMsg = ToomossCanFDDrive.CmdData.GroupBy(a => a.MsgName).ToList(); + foreach (var itemMsg in GroupMsg) + { + if (!ListCANFdScheduleConfig.ToList().Any(a => a.MsgName == itemMsg.Key)) + { + System.Windows.MessageBox.Show($"你使能了调度表，但是调度表中没有设置【{itemMsg.Key}】信息，请设置后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand); + return; + } + } + + if (ListCANFdScheduleConfig == null && ListCANFdScheduleConfig!.Count() == 0) + { + System.Windows.MessageBox.Show("调度表配置为空数据，请检查！将无法发送数据", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand); + return; + } + ToomossCanFDDrive.ListCANScheduleConfig = ListCANFdScheduleConfig!; + ToomossCanFDDrive.StartSchedule(); + //ToomossCanFDDrive.StartCycleUpdateCmd(); + } + else + { + ToomossCanFDDrive.StartPrecisionCycleSendMsg(); + //ToomossCanFDDrive.StartCycleSendMsg(); + } + + ToomossCanFDDrive.IsCycleSend = true; } else { @@ -334,7 +369,15 @@ namespace CapMachine.Wpf.Services } else { - ToomossCanFDDrive.IsCycleSend = false; + if (ToomossCanFDDrive.SchEnable) + { + ToomossCanFDDrive.IsCycleSend = false; + ToomossCanFDDrive.StopSchedule(); + } + else + { + ToomossCanFDDrive.IsCycleSend = false; + } } } diff --git a/CapMachine.Wpf/Services/ComActionService.cs b/CapMachine.Wpf/Services/ComActionService.cs index f72b49b..374c146 100644 --- a/CapMachine.Wpf/Services/ComActionService.cs +++ b/CapMachine.Wpf/Services/ComActionService.cs @@ -1,4 +1,4 @@ -using CapMachine.Wpf.PrismEvent; +using CapMachine.Wpf.PrismEvent; using Prism.Events; using Prism.Services.Dialogs; using System; @@ -105,6 +105,7 @@ namespace CapMachine.Wpf.Services } + /// /// 过热度和过冷度配置弹窗 /// @@ -155,6 +156,7 @@ namespace CapMachine.Wpf.Services + #endregion diff --git a/CapMachine.Wpf/Services/NavigationMenuService.cs b/CapMachine.Wpf/Services/NavigationMenuService.cs index b5a9b8d..3e9aca6 100644 --- a/CapMachine.Wpf/Services/NavigationMenuService.cs +++ b/CapMachine.Wpf/Services/NavigationMenuService.cs @@ -44,14 +44,10 @@ namespace CapMachine.Wpf.Services { new NavigationItem("Rule","规则转换","DialogLogicRuleView"), }), - new NavigationItem("","配置导出","",new ObservableCollection() + new NavigationItem("", "配置导出","",new ObservableCollection() { new NavigationItem("","CAN/CANFD/LIN配置导入导出","DialogCanLinConfigImExport"), }), - //new NavigationItem("", "PID设置","",new ObservableCollection() - //{ - // new NavigationItem("Circle","转速PID",""), - //}), //new NavigationItem("", "通信配置","",new ObservableCollection() //{ // new NavigationItem("Circle","CAN配置","CANConfigView"), @@ -81,8 +77,10 @@ namespace CapMachine.Wpf.Services //})); MenuItems.Add(new NavigationItem("", "工艺过程", "MonitorView")); MenuItems.Add(new NavigationItem("", "CAN配置", "CANConfigView")); - MenuItems.Add(new NavigationItem("", "CANFD配置", "CANFDConfigView")); + //MenuItems.Add(new NavigationItem("", "CANFD配置", "CANFDConfigView")); MenuItems.Add(new NavigationItem("", "LIN配置", "LINConfigView")); + //MenuItems.Add(new NavigationItem("", "ZLG CAN配置", "ZlgCanDriveConfigView")); + //MenuItems.Add(new NavigationItem("", "ZLG LIN配置", "ZlgLinDriveConfigView")); MenuItems.Add(new NavigationItem("", "工艺参数", "ProConfigView")); MenuItems.Add(new NavigationItem("", "工艺曲线", "RealTimeChartView")); MenuItems.Add(new NavigationItem("", "动作日志", "ActionLogView")); diff --git a/CapMachine.Wpf/Services/ZlgCanDriveService.cs b/CapMachine.Wpf/Services/ZlgCanDriveService.cs new file mode 100644 index 0000000..d1a9c09 --- /dev/null +++ b/CapMachine.Wpf/Services/ZlgCanDriveService.cs @@ -0,0 +1,1008 @@ +using CapMachine.Model.CANLIN; +using CapMachine.Wpf.CanDrive; +using CapMachine.Wpf.CanDrive.ZlgCan; +using CapMachine.Wpf.Dtos; +using ImTools; +using Prism.Mvvm; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Diagnostics; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; + +namespace CapMachine.Wpf.Services +{ + /// + /// ZLG CAN/CANFD 驱动服务（共享设备句柄）。 + /// + /// + /// 该类属于“服务层/编排层”，主要职责： + /// - 管理 的生命周期（打开、接收线程、关闭释放）； + /// - 管理 DBC 加载与信号模型集合（）； + /// - 管理写入指令集合（）并将其注入驱动形成“DBC 编码发送”的闭环； + /// - 提供两种循环发送实现： + /// 1) 硬件定时发送（调度表）：通过周立功 auto_send 列表 + apply_auto_send（精度高） + /// 2) 软件精确定时循环发送：通过后台 Task 在 PC 侧按周期触发 （用于不依赖硬件调度或调试场景） + /// + /// 线程模型： + /// - 接收线程由 内部创建； + /// - 软件调度发送由本类创建后台 Task（见 ）； + /// - UI 绑定的属性变化通过 的 RaisePropertyChanged 通知。 + /// + public sealed class ZlgCanDriveService : BindableBase + { + /// + /// 软件调度条目（仅在软件调度线程内使用）。 + /// + /// + /// 该结构体承担“纯运行态状态”的职责： + /// - 启动时由 构建并排序； + /// - 运行中由 在单线程内更新 等字段； + /// - 不对外暴露，也不需要线程安全的读写（因为不会跨线程访问）。 + /// + private sealed class SoftwareScheduleItem + { + /// + /// 构造。 + /// + /// DBC 报文名称。 + /// 周期（Stopwatch ticks）。 + /// 发送顺序（用于排序）。 + public SoftwareScheduleItem(string msgName, long periodTicks, int orderSend) + { + MsgName = msgName; + PeriodTicks = periodTicks; + OrderSend = orderSend; + } + + /// + /// DBC 报文名称（MsgName）。 + /// + public string MsgName { get; } + + /// + /// 周期（以 ticks 表示）。 + /// + public long PeriodTicks { get; } + + /// + /// 发送顺序（用于同 tick 内的确定性排序）。 + /// + public int OrderSend { get; } + + /// + /// 下次计划发送的到期时间（sw.ElapsedTicks）。 + /// + public long NextDueTicks; + + /// + /// 上一次记录 warn 的时间（用于日志节流）。 + /// + public long LastWarnTicks; + } + + /// + /// 日志服务。 + /// + private readonly ILogService _log; + + /// + /// 共享的 ZLG 驱动实例（CAN/CANFD/LIN）。 + /// + public ZlgCanFd200uDriver Driver { get; } + + /// + /// 当前选中的配置程序（沿用原有 FreeSql 模型）。 + /// + /// + /// 该属性用于与 UI“配置程序选择”联动。 + /// - 本类不负责持久化； + /// - 只在 中用于把配置中的显示名称映射到 DBC 信号集合。 + /// + public CanLinConfigPro? SelectedCanLinConfigPro { get; set; } + + /// + /// Dbc 消息集合（用于 UI 绑定）。 + /// + /// + /// 该集合由 / 构建并替换，通常用于界面显示： + /// - MsgName/SignalName/实时值等； + /// - 也会被 用于把“配置程序中的显示名称”映射到信号上。 + /// + /// 注意： + /// - DBC 解码更新发生在 Driver 的接收线程中，若 UI 对集合元素的属性变化敏感，请确保 UI 侧的线程切换策略。 + /// + public ObservableCollection ListCanDbcModel { get; private set; } = new ObservableCollection(); + + /// + /// 的 backing 字段。 + /// + private bool _dbcParserState; + /// + /// DBC 解析状态。 + /// + /// + /// 该状态仅表示“DBC 已加载且有信号集合”，常用于 UI 控件的 enable/disable。 + /// + public bool DbcParserState + { + get { return _dbcParserState; } + private set { _dbcParserState = value; RaisePropertyChanged(); } + } + + /// + /// 的 backing 字段。 + /// + private bool _openState; + /// + /// 设备打开状态。 + /// + /// + /// 该属性与 保持一致，由构造函数中订阅 Driver.PropertyChanged 同步刷新。 + /// + public bool OpenState + { + get { return _openState; } + private set { _openState = value; RaisePropertyChanged(); } + } + + /// + /// 的 backing 字段。 + /// + private ZlgCanMode _mode; + /// + /// CAN 模式（单选：CAN 或 CANFD）。 + /// + /// + /// - 该属性影响发送/调度表下发时使用的 frameType（CAN=8字节，CANFD=64字节）； + /// - 切换 Mode 后若要立即生效，通常应重新调用 （使 Driver 侧 frameType 更新）。 + /// + public ZlgCanMode Mode + { + get { return _mode; } + set { _mode = value; RaisePropertyChanged(); } + } + + /// + /// 发送使能（与 UI 的调度表使能语义对齐）。 + /// + /// + /// 该属性透传到 ： + /// - true：允许“事件驱动发送”（CmdData 变化时发送/覆盖 auto_send） + /// - false：仅允许手动发送或软件调度任务主动调用发送接口 + /// + public bool SchEnable + { + get { return Driver.SchEnable; } + set { Driver.SchEnable = value; RaisePropertyChanged(); } + } + + /// + /// 是否启用事件驱动发送。 + /// + /// + /// 该属性透传到 。 + /// - true 且 为 true 时：CmdData 变化会触发增量发送/覆盖更新； + /// - false：CmdData 变化不会触发任何发送（由外部显式调用发送方法）。 + /// + public bool IsCycleSend + { + get { return Driver.IsCycleSend; } + set { Driver.IsCycleSend = value; RaisePropertyChanged(); } + } + + /// + /// 是否正在循环接收（对齐 Toomoss：IsCycleRevice）。 + /// + /// + /// 该属性为只读透传：接收线程由 创建。 + /// + public bool IsCycleRevice + { + get { return Driver.IsReceiving; } + } + + /// + /// 最近是否发送成功（用于 UI 指示）。 + /// + /// + /// 该标志由 Driver 的发送调用或 Tx 回显事件触发，短时间保持 true 后自动回落。 + /// + public bool IsSendOk + { + get { return Driver.IsSendOk; } + } + + /// + /// 最近是否接收成功（用于 UI 指示）。 + /// + /// + /// 该标志由 Driver 接收线程收到 Rx 帧触发，短时间保持 true 后自动回落。 + /// + public bool IsReviceOk + { + get { return Driver.IsReviceOk; } + } + + /// + /// 要发送的 CAN 指令数据。 + /// + /// + /// 该集合通常来源于“读写设置/配置程序”生成的信号写入项。 + /// - 发送时并不是逐条直接写信号，而是按 MsgName 聚合后通过 DBC 编码为帧（由 Driver 完成）。 + /// - 本类在 中将集合注入 Driver，并建立信号变化事件订阅。 + /// + public List CmdData { get; } = new List(); + + /// + /// 调度表（软件调度任务）互斥锁。 + /// + /// + /// 保护以下共享状态的并发访问： + /// - 调度表条目快照 + /// - / 生命周期切换 + /// + /// 说明： + /// - 硬件 auto_send 的生命周期主要由 Driver 内部管理； + /// - 本类在 中同时清理软件任务与硬件 auto_send，确保“停止=设备不再发”。 + /// + private readonly object _scheduleLock = new object(); + + /// + /// 当前调度表条目快照。 + /// + /// + /// 元组含义： + /// - MsgName：DBC Message Name + /// - CycleMs：周期（ms） + /// - OrderSend/SchTabIndex：用于排序，保证硬件列表 index 的确定性 + /// + private List<(string MsgName, int CycleMs, int OrderSend, int SchTabIndex)> _scheduleItems = new List<(string, int, int, int)>(); + + /// + /// 软件调度任务取消令牌。 + /// + private CancellationTokenSource? _scheduleCts; + + /// + /// 软件调度后台任务。 + /// + private Task? _scheduleTask; + + /// + /// 标记“当前循环发送使用配置的调度表项”。 + /// + /// + /// 该字段当前仅用于区分启动来源（配置调度表 or 精确定时循环），未来可用于 UI 展示或行为分支。 + /// + private bool _scheduleUseConfigItems; + + /// + /// 要发送的速度指令数据。 + /// + /// + /// 该字段用于兼容旧接口 的“手动发送转速”行为： + /// - 通过 从 中按 ConfigName=转速 选取； + /// - 若未配置该项，则手动发送会记录 warn 并忽略。 + /// + private CanCmdData? SpeedCanCmdData { get; set; } + + /// + /// 当前打开的设备索引（默认 0）。 + /// + /// + /// 由 更新，在 时作为打开参数。 + /// + private uint _deviceIndex = 0; + + /// + /// 通道0配置快照。 + /// + /// + /// 目前服务层仅初始化通道0，并将合并接收等设备级开关按通道0的配置写入设备。 + /// + private ZlgCanFdChannelOptions _channel0 = new ZlgCanFdChannelOptions(); + + /// + /// 构造。 + /// + /// 日志服务。 + /// + /// 构造时会： + /// - 创建 ； + /// - 订阅 Driver 的 ，并同步更新本服务的派生属性： + /// / / / 。 + /// + public ZlgCanDriveService(ILogService logService) + { + _log = logService; + Driver = new ZlgCanFd200uDriver(logService); + + Driver.PropertyChanged += (_, __) => + { + OpenState = Driver.OpenState; + RaisePropertyChanged(nameof(IsCycleRevice)); + RaisePropertyChanged(nameof(IsSendOk)); + RaisePropertyChanged(nameof(IsReviceOk)); + }; + + OpenState = Driver.OpenState; + Mode = ZlgCanMode.Can; + } + + /// + /// 初始化 CAN 配置信息，并将配置中的名称映射到 DBC 信号集合（用于 UI 显示）。 + /// + /// 选中的配置。 + /// + /// 该方法不与设备连接状态强绑定： + /// - 只要 已有信号集合，就可以进行“显示名称映射”。 + /// + /// 映射规则： + /// - 以 SignalName 为键，在 DBC 模型集合中找到对应信号，并把配置项的 Name 写回 。 + /// + public void InitCanConfig(CanLinConfigPro selectedCanLinConfigPro) + { + SelectedCanLinConfigPro = selectedCanLinConfigPro; + if (SelectedCanLinConfigPro?.CanLinConfigContents == null) return; + + // 先清空旧映射，避免配置项删除/切换后中文名称残留。 + if (ListCanDbcModel != null && ListCanDbcModel.Count > 0) + { + foreach (var m in ListCanDbcModel) + { + m.Name = null; + } + } + + foreach (var item in SelectedCanLinConfigPro.CanLinConfigContents) + { + CanDbcModel? find; + if (!string.IsNullOrWhiteSpace(item.MsgFrameName)) + { + find = ListCanDbcModel.FindFirst(a => a.SignalName == item.SignalName && a.MsgName == item.MsgFrameName); + } + else + { + find = ListCanDbcModel.FindFirst(a => a.SignalName == item.SignalName); + } + if (find != null) + { + find.Name = item.Name; + } + } + } + + /// + /// 更新配置（从 DTO/DB 同步到驱动）。 + /// + /// 设备索引。 + /// 仲裁波特率（bps）。 + /// 数据波特率（bps）。 + /// 终端电阻使能。 + /// 是否合并接收。 + /// 合并接收缓冲帧数。 + /// + /// 该方法仅更新服务层保存的“配置快照”，不会立即触发驱动重连。 + /// - 生效时机：下一次调用 打开设备并初始化通道。 + /// - 当前实现仅使用通道0配置。 + /// + public void UpdateConfig(uint deviceIndex, uint arbBaudRate, uint dataBaudRate, bool resEnable, bool mergeReceive = false, int mergeReceiveBufferFrames = 100) + { + _deviceIndex = deviceIndex; + _channel0.ArbitrationBaudRate = arbBaudRate; + _channel0.DataBaudRate = dataBaudRate; + _channel0.EnableInternalResistance = resEnable; + _channel0.EnableMergeReceive = mergeReceive; + _channel0.MergeReceiveBufferFrames = mergeReceiveBufferFrames; + } + + /// + /// 打开 CAN/CANFD（按 Mode）。 + /// + /// + /// - 该方法是幂等的：若 为 true，则直接返回； + /// - 成功打开后会初始化通道并启动接收线程（见 ）。 + /// + /// 注意： + /// - 本方法不会自动加载 DBC，也不会自动注入 CmdData； + /// - 建议调用顺序：UpdateConfig -> StartCanDrive -> StartDbc -> LoadCmdDataToDrive。 + /// + public void StartCanDrive() + { + if (OpenState) + { + return; + } + + Driver.OpenAndInitCan(_deviceIndex, _channel0); + Driver.StartReceiveLoop(_channel0.EnableMergeReceive, _channel0.MergeReceiveBufferFrames); + OpenState = Driver.OpenState; + } + + /// + /// 使能/停止循环接收。 + /// + /// true=启动接收线程，false=停止接收线程。 + /// + /// 说明： + /// - 接收线程属于 Driver 内部资源； + /// - 若开启合并接收，接收线程会按通道0配置决定采用 merge 或 per-channel 接收。 + /// + /// 设备未连接。 + public void SetReceiveEnabled(bool enable) + { + if (!OpenState) + { + throw new InvalidOperationException("设备未连接，无法切换循环接收。"); + } + + if (enable) + { + if (!Driver.IsReceiving) + { + Driver.StartReceiveLoop(_channel0.EnableMergeReceive, _channel0.MergeReceiveBufferFrames); + } + } + else + { + if (Driver.IsReceiving) + { + Driver.StopReceiveLoop(); + } + } + + RaisePropertyChanged(nameof(IsCycleRevice)); + } + + /// + /// 关闭设备（会同时关闭共享的 LIN 通道）。 + /// + /// + /// Close 语义强调“彻底停止后台活动”： + /// - 停止调度表：取消软件调度任务，并清理硬件 auto_send 列表（避免设备侧继续发）； + /// - 停止事件驱动发送：将 置为 false； + /// - 停止接收： 内部会停止接收线程并释放句柄。 + /// + public void CloseDevice() + { + try + { + // Close 语义：关闭时必须停止循环发送与循环接收。 + // - 循环发送：停止软件调度，并关闭事件驱动发送标志。 + // - 循环接收：Driver.Close 内部会 StopReceiveLoop。 + StopSchedule(); + IsCycleSend = false; + + Driver.Close(); + } + finally + { + OpenState = Driver.OpenState; + DbcParserState = false; + } + } + + /// + /// 设置调度表配置（CAN）。 + /// + /// 调度表配置项。 + /// + /// 该方法仅保存调度表条目快照，不会立即启动发送。 + /// - 真正启动由 触发。 + /// - MsgName 为空的条目会被过滤。 + /// + public void SetScheduleConfigs(IEnumerable configs) + { + var list = configs?.Where(a => !string.IsNullOrWhiteSpace(a.MsgName)).ToList() ?? new List(); + lock (_scheduleLock) + { + _scheduleItems = list + .Select(a => (a.MsgName!.Trim(), Math.Max(1, a.Cycle), a.OrderSend, a.SchTabIndex)) + .ToList(); + } + } + + /// + /// 设置调度表配置（CANFD）。 + /// + /// 调度表配置项。 + /// + /// 语义同 CAN 版本 ，差异仅在于配置来源 DTO 类型。 + /// + public void SetScheduleConfigs(IEnumerable configs) + { + var list = configs?.Where(a => !string.IsNullOrWhiteSpace(a.MsgName)).ToList() ?? new List(); + lock (_scheduleLock) + { + _scheduleItems = list + .Select(a => (a.MsgName!.Trim(), Math.Max(1, a.Cycle), a.OrderSend, a.SchTabIndex)) + .ToList(); + } + } + + /// + /// 启动调度表（硬件定时发送列表 auto_send）。 + /// + /// + /// 本方法选择“硬件调度表”实现： + /// - 将调度表条目转换为设备 auto_send 列表并 apply，使设备按周期自动发送； + /// - 运行时若 CmdData 对应信号值变化，Driver 会覆盖更新对应 index 的帧数据。 + /// + /// 前置条件： + /// - 设备已连接（ true）； + /// - 调度表不为空； + /// - DBC 已加载且 CmdData 可编码（否则对应 MsgName 会被 Driver 跳过并记录 warn）。 + /// + /// 设备未连接或调度表为空。 + public void StartSchedule() + { + if (!OpenState) + { + throw new InvalidOperationException("设备未连接，无法启动调度表。"); + } + + List<(string MsgName, int CycleMs, int OrderSend, int SchTabIndex)> items; + lock (_scheduleLock) + { + // 取快照： + // - 避免启动过程中与 UI 线程并发修改调度表集合； + // - 后续 Driver.StartAutoSendSchedule 会在内部再次排序并建立 MsgName->index 映射。 + items = _scheduleItems.ToList(); + } + + if (items.Count == 0) + { + throw new InvalidOperationException("调度表为空，无法启动调度表。"); + } + + // 周立功：调度表=硬件定时发送列表（auto_send） + // - 周期精度高，由设备侧时钟保障 + // - PC 仍可同时调用发送接口发送其它数据 + _scheduleUseConfigItems = true; + + // 启动前先停止已有任务（软件调度 + 硬件 auto_send） + StopSchedule(); + + // 统一：启用调度表后，等同“循环发送开启” + // 说明：这里的 IsCycleSend 指的是“允许事件驱动发送/覆盖更新”。 + // - 硬件 auto_send 本身不依赖 IsCycleSend； + // - 但运行中信号值变化要想覆盖更新到硬件列表，需要 IsCycleSend=true 且 SchEnable=true。 + IsCycleSend = true; + + // 使用硬件定时发送列表：按 scheduleItems 下发 auto_send 并 apply + Driver.StartAutoSendSchedule( + items.Select(a => (a.MsgName, a.CycleMs, a.OrderSend, a.SchTabIndex)), + channelIndex: 0, + frameType: Mode == ZlgCanMode.Can ? (byte)ZDBC.FT_CAN : (byte)ZDBC.FT_CANFD); + } + + /// + /// 启动软件精确定时循环发送。 + /// + /// 周期（ms）。 + /// + /// 与 的区别： + /// - 本方法完全在 PC 侧调度，周期精度受系统调度与负载影响； + /// - 适用于不依赖硬件 auto_send 的场景，或作为调试/兼容方案。 + /// + /// 发送对象： + /// - 按当前 中出现的 MsgName 去重后，按统一周期循环发送。 + /// + /// 设备未连接或 CmdData 为空。 + public void StartPrecisionCycleSend(int cycleMs) + { + if (!OpenState) + { + throw new InvalidOperationException("设备未连接，无法启动循环发送。"); + } + + var ms = Math.Max(1, cycleMs); + var msgNames = CmdData.Where(a => !string.IsNullOrWhiteSpace(a.MsgName)).Select(a => a.MsgName!).Distinct(StringComparer.Ordinal).ToList(); + if (msgNames.Count == 0) + { + throw new InvalidOperationException("CmdData 为空，无法启动循环发送。"); + } + + // 软件调度：把 CmdData 中出现的 MsgName 去重后按统一周期循环发送。 + // 注意：这与“配置调度表”的区别是： + // - 配置调度表：每条消息有自己的 Cycle/Order/SchTabIndex + // - 软件精确循环：所有消息同周期，OrderSend 固定为 1，SchTabIndex 固定为 0 + var items = msgNames.Select(n => (n, ms, 1, 0)).ToList(); + _scheduleUseConfigItems = false; + StartSoftwareScheduler(items); + } + + /// + /// 停止调度表/循环发送。 + /// + /// + /// 该方法会同时停止两类发送资源： + /// - 软件调度：取消 Task 并等待短时间退出； + /// - 硬件调度：调用 Driver.StopAutoSendSchedule 清空设备 auto_send 列表，防止设备继续发送。 + /// + /// 该方法不会自动将 置为 false： + /// - 保留给上层决定（例如仅暂停调度，但仍允许事件驱动发送）。 + /// + public void StopSchedule() + { + CancellationTokenSource? cts; + Task? task; + lock (_scheduleLock) + { + cts = _scheduleCts; + task = _scheduleTask; + _scheduleCts = null; + _scheduleTask = null; + } + + try + { + cts?.Cancel(); + if (task != null) + { + // 等待软件调度线程退出： + // - 这里不做无限等待，避免 UI 卡死； + // - 超时/异常会被吞掉（与旧代码风格保持一致）。 + task.Wait(TimeSpan.FromSeconds(2)); + } + } + catch + { + // 说明： + // - task.Wait 可能抛 AggregateException/TaskCanceledException； + // - StopSchedule 属于“停止/清理”语义，不应因等待异常影响后续硬件清理。 + } + finally + { + cts?.Dispose(); + } + + // 无论当前是否处于硬件定时发送，都做一次清理（clear_auto_send）保证关闭/停止时设备侧不再发。 + try + { + if (OpenState) + { + // 防御性清理： + // - 若此前是硬件调度表，必须 clear_auto_send，否则设备会继续按周期发送； + // - 若此前是软件调度，该调用也不会破坏状态（最多是清空一个空表）。 + Driver.StopAutoSendSchedule(channelIndex: 0); + } + } + catch + { + // ignored：停止流程不因硬件清理失败而中断。 + } + } + + /// + /// 启动软件调度后台任务。 + /// + /// 调度表条目集合（由调用方准备好快照）。 + /// + /// 该任务使用“下一次到期时间 due”字典进行调度： + /// - 优先 sleep 到最早 due，减少 CPU 占用； + /// - tick 内对 ready 的消息按字典序依次发送； + /// - 每次发送后更新下一次 due。 + /// + /// 注意： + /// - 这是软件调度，不保证绝对周期精度； + /// - 发送异常会记录 warn，但不会终止调度循环。 + /// + private void StartSoftwareScheduler(List<(string MsgName, int CycleMs, int OrderSend, int SchTabIndex)> items) + { + StopSchedule(); + + var cts = new CancellationTokenSource(); + lock (_scheduleLock) + { + _scheduleCts = cts; + } + + // 统一：软件调度开启后，等同“循环发送开启” + IsCycleSend = true; + + var frequency = Stopwatch.Frequency; + long ToTicks(int ms) + { + var safeMs = Math.Max(1, ms); + // 使用 long 避免溢出；周期最小为 1 tick。 + var ticks = (long)(safeMs * (double)frequency / 1000d); + return Math.Max(1, ticks); + } + + // 只在启动时做一次去重/排序；循环内不分配。 + var unique = new Dictionary(StringComparer.Ordinal); + foreach (var it in items) + { + if (string.IsNullOrWhiteSpace(it.MsgName)) continue; + var name = it.MsgName.Trim(); + if (!unique.ContainsKey(name)) + { + unique[name] = (Math.Max(1, it.CycleMs), it.OrderSend); + } + } + + var list = new List(unique.Count); + foreach (var kv in unique) + { + list.Add(new SoftwareScheduleItem(kv.Key, ToTicks(kv.Value.CycleMs), kv.Value.OrderSend)); + } + + list.Sort((a, b) => + { + var byOrder = a.OrderSend.CompareTo(b.OrderSend); + return byOrder != 0 ? byOrder : string.CompareOrdinal(a.MsgName, b.MsgName); + }); + + var scheduleItems = list.ToArray(); + + // 使用单调时钟：避免系统时间跳变导致周期紊乱。 + var sw = Stopwatch.StartNew(); + for (var i = 0; i < scheduleItems.Length; i++) + { + // 首次启动：立即发送一轮（NextDueTicks=0）。 + scheduleItems[i].NextDueTicks = 0; + scheduleItems[i].LastWarnTicks = long.MinValue; + } + + lock (_scheduleLock) + { + _scheduleTask = Task.Factory.StartNew(() => + { + // LongRunning：为调度线程提供独立线程，减少线程池饥饿导致的周期抖动。 + RunSoftwareScheduler(sw, scheduleItems, cts.Token, frequency); + }, cts.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default); + } + } + + /// + /// 软件调度循环（后台线程）。 + /// + /// 单调计时器（启动时创建，贯穿整个调度生命周期）。 + /// 调度条目数组（启动时构建；运行中会更新每项的到期时间）。 + /// 取消令牌（由 触发取消）。 + /// （用于 ticks/ms 换算）。 + /// + /// 设计目标： + /// - 尽量降低 CPU 占用：优先等待到最早 due 附近； + /// - 尽量降低抖动：临近到期使用短等待 + 自旋； + /// - 避免“积压补发”：如果错过多个周期，只发送一次并将 due 跳到 now+period。 + /// + /// 线程安全说明： + /// - 该方法仅由 创建的 LongRunning 任务调用； + /// - 在该线程内独占读写（不会跨线程访问），因此不需要额外锁。 + /// + private void RunSoftwareScheduler(Stopwatch sw, SoftwareScheduleItem[] items, CancellationToken token, long frequency) + { + // 日志节流：同一条消息每 10 秒最多记录一次发送异常。 + var warnIntervalTicks = frequency * 10; + var spin = new SpinWait(); + + while (!token.IsCancellationRequested) + { + if (!OpenState) + { + // 设备未打开时不发送： + // - 避免在 Close/重连窗口持续抛异常； + // - 这里仍然响应取消，保证 StopSchedule 不会“卡住等待”。 + 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) + { + // 混合等待： + // - 剩余时间较长：WaitOne(<=200ms) 降低 CPU 占用 + // - 临近到期：1ms 级等待 + 短自旋提升边界精度 + 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; + } + + // 到期发送： + // - 同一条消息“错过多个周期”时，只发送一次（避免 burst），然后尽快恢复节拍。 + nowTicks = sw.ElapsedTicks; + for (var i = 0; i < items.Length; i++) + { + var it = items[i]; + if (it.NextDueTicks > nowTicks) + { + continue; + } + + try + { + // 软件调度最终仍复用 Driver 的“按 MsgName 编码并发送一帧”的能力。 + // 这意味着： + // - 发送数据来源仍是 CmdData 当前值； + // - 若 DBC 未加载/MsgName 无法编码，Driver 内部会快速返回或抛异常。 + Driver.SendOneMsgByCmdData(it.MsgName, 0, Mode == ZlgCanMode.Can ? (byte)ZDBC.FT_CAN : (byte)ZDBC.FT_CANFD); + } + catch (Exception ex) + { + var t = sw.ElapsedTicks; + if (t - it.LastWarnTicks >= warnIntervalTicks) + { + it.LastWarnTicks = t; + _log.Warn($"软件循环发送失败：{it.MsgName}，{ex.Message}"); + } + } + finally + { + // 漂移控制：正常情况下按“计划时间”累加；若落后过多，则跳到 now+period（只补发一次）。 + var next = it.NextDueTicks + it.PeriodTicks; + if (next <= nowTicks) + { + next = nowTicks + it.PeriodTicks; + } + it.NextDueTicks = next; + } + } + } + } + + /// + /// 加载 DBC。 + /// + /// DBC 路径。 + /// DBC 解析得到的信号集合。 + /// + /// - DBC 加载成功后会更新 与 ； + /// - 后续发送（调度表/事件驱动/手动发送）都依赖 DBC 编码能力。 + /// + /// 设备未连接。 + public ObservableCollection StartDbc(string path) + { + if (!OpenState) + { + throw new InvalidOperationException("请先打开设备后再加载 DBC。"); + } + + // DBC 解析与信号集合构建由 Driver 负责： + // - 该过程通常涉及读取文件、解析 DBC、构建 Msg/Signal 元数据； + // - Driver 侧也会建立“收到帧 -> DBC 解码 -> 更新模型值”的解码链路。 + ListCanDbcModel = Driver.StartDbc(path); + + // 这里的状态仅用于 UI enable/disable： + // - true 代表“已有可用信号集合”； + // - 并不代表后续每次编码/发送一定成功（仍受 CmdData 是否完整、MsgName 是否匹配影响）。 + DbcParserState = ListCanDbcModel != null && ListCanDbcModel.Count > 0; + return ListCanDbcModel; + } + + /// + /// 加载要发送的数据（订阅数据变化事件）。 + /// + /// 指令数据集合。 + /// + /// 该方法会： + /// - 更新本服务的 集合； + /// - 从集合中选取“转速”项缓存到 （用于兼容旧的手动发送接口）； + /// - 调用 注入 Driver，并建立事件驱动链路。 + /// + /// 注意： + /// - frameType 由 决定；若运行时切换 Mode，建议重新调用本方法。 + /// + public void LoadCmdDataToDrive(List cmdData) + { + var list = cmdData ?? new List(); + + // 以“清空 + AddRange”的方式更新： + // - 保持 CmdData 引用不变，避免上层若持有该 List 引用时出现替换不可见； + // - 也便于在 Driver 层按引用订阅 CanCmdDataChanged 事件（其内部会自行做快照）。 + CmdData.Clear(); + CmdData.AddRange(list); + + // 兼容旧接口：从 CmdData 中缓存“转速”项。 + // - SendMsgToCanDrive 仅维护这一个信号； + // - 若业务后续扩展为多信号手动发送，应改为按 MsgName/SignalName 精确定位。 + foreach (var item in CmdData) + { + if (string.Equals(item.ConfigName, "转速", StringComparison.Ordinal)) + { + SpeedCanCmdData = item; + } + } + + // 将 CmdData 注入 Driver： + // - Driver 会订阅每个 CanCmdData 的变化事件，用于“事件驱动发送/覆盖更新 auto_send”； + // - frameType 必须与 Mode 对齐：CAN 与 CANFD 的长度/编码规则不同。 + Driver.LoadCmdDataToDrive(CmdData, channelIndex: 0, frameType: Mode == ZlgCanMode.Can ? (byte)ZDBC.FT_CAN : (byte)ZDBC.FT_CANFD); + } + + /// + /// 手动发送（目前对齐原服务：仅发送转速）。 + /// + /// 转速。 + /// + /// 行为说明： + /// - 优先将 speedData 写入 的 SignalCmdValue； + /// - 若当前未启用事件驱动发送（ 或 为 false），则主动触发一次编码发送， + /// 以维持旧版本“点击发送即下发”的体验。 + /// + public void SendMsgToCanDrive(double speedData) + { + if (!OpenState) + { + return; + } + + if (SpeedCanCmdData != null) + { + // 先更新写入值： + // - 若当前启用了事件驱动发送（IsCycleSend && SchEnable），该赋值本身会触发 Driver 的增量发送/覆盖更新； + // - 若未启用事件驱动发送，下方会主动补发一次，保证“点一下就发”的旧行为。 + SpeedCanCmdData.SignalCmdValue = speedData; + } + else + { + _log.Warn("未配置转速指令项（ConfigName=转速），忽略手动发送。"); + } + + // 若未启用事件驱动发送，则这里主动发送一次（与旧行为兼容） + if (!IsCycleSend || !SchEnable) + { + // 历史行为：选取 CmdData 的第一条 MsgName 进行发送。 + // - 由于本方法本质上是“转速”单信号写入，严格来说应按 SpeedCanCmdData.MsgName 发送； + // - 但为避免改动业务逻辑，这里保持旧逻辑，仅通过注释明确其局限。 + var firstMsg = CmdData.FirstOrDefault()?.MsgName; + if (!string.IsNullOrWhiteSpace(firstMsg)) + { + Driver.SendOneMsgByCmdData(firstMsg, 0, Mode == ZlgCanMode.Can ? (byte)ZDBC.FT_CAN : (byte)ZDBC.FT_CANFD); + } + } + } + } + + /// + /// ZLG CAN 工作模式。 + /// + public enum ZlgCanMode + { + /// + /// CAN 经典帧。 + /// + Can = 0, + /// + /// CAN FD。 + /// + CanFd = 1 + } +} diff --git a/CapMachine.Wpf/Services/ZlgLinDriveService.cs b/CapMachine.Wpf/Services/ZlgLinDriveService.cs new file mode 100644 index 0000000..7a33a3a --- /dev/null +++ b/CapMachine.Wpf/Services/ZlgLinDriveService.cs @@ -0,0 +1,1314 @@ +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 +{ + /// + /// ZLG LIN 驱动服务（共享设备句柄）。 + /// 说明： + /// - 该服务不直接持有/管理底层原生句柄，而是复用 中的 Driver（设备级句柄与接收线程均由 Driver 统一管理）。 + /// - LIN 的“调度表/循环发送”在当前实现中使用软件精确定时（ + ）完成； + /// 与 ZLG CAN/CANFD 的硬件 auto_send 不同，LIN 侧没有调用硬件调度表能力。 + /// - LDF 解析：此处实现了一个尽量容错的轻量解析器，用于建立“帧/信号 -> 位定义”的运行时索引，供 LIN 收发编解码使用。 + /// 线程与绑定： + /// - LIN 接收回调通常来自 Driver 的接收线程；更新 WPF 绑定对象时会切换到 UI 线程（见 ）。 + /// - CmdData / LDF 索引 / 调度表快照均通过独立锁对象保护，避免 UI 线程与后台线程并发修改引发的竞态。 + /// + public sealed class ZlgLinDriveService : BindableBase + { + /// + /// LIN 信号定义（运行时索引条目）。 + /// 说明：目前仅使用 StartBit/BitLength 做 bit 级读写；Factor/Offset/IsSigned 预留用于后续扩展（物理量换算）。 + /// + 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; } + } + + /// + /// LIN 帧定义（运行时索引条目）。 + /// 说明： + /// - 同时缓存裸 FrameId（0-63）与受保护 PID（含奇偶校验位）。 + /// - Signals 字典仅包含在 LDF 的 Frames 里声明且在 Signals 区能找到 bit 定义的信号。 + /// + 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 Signals { get; } = new Dictionary(StringComparer.Ordinal); + } + + /// + /// 软件调度项（以 ticks 为最小单位进行精确定时）。 + /// 说明： + /// - NextDueTicks/LastWarnTicks 会在调度线程中更新，因此不对外暴露，仅在调度线程内使用。 + /// - PeriodTicks 是基于 换算而来，与系统时间无关，抗时间跳变。 + /// + 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; + + /// + /// LDF 索引锁：保护帧/信号定义索引与 UI 绑定模型映射（_framesByName/_framesByPid/_modelIndex 等）。 + /// + private readonly object _ldfLock = new object(); + + /// + /// CmdData 锁：保护 的替换与事件订阅关系，避免并发枚举/修改。 + /// + private readonly object _cmdLock = new object(); + + /// + /// 调度锁：保护调度配置快照与调度线程的启动/停止（_scheduleCts/_scheduleTask/_scheduleRunning）。 + /// + private readonly object _scheduleLock = new object(); + + /// + /// 帧名 -> 帧定义索引（用于发送：按 MsgName 找到 PID/信号位定义）。 + /// + private Dictionary _framesByName = new Dictionary(StringComparer.Ordinal); + + /// + /// PID/ID -> 帧定义索引（用于接收：按 pid/6bit id 回查帧定义并解码信号）。 + /// + private Dictionary _framesByPid = new Dictionary(); + + /// + /// “帧名+信号名” -> UI 模型索引，用于接收线程快速定位绑定对象并更新实时值。 + /// + private Dictionary _modelIndex = new Dictionary(StringComparer.Ordinal); + + /// + /// 未知 PID 的日志节流表：避免接收线程在 LDF 缺失时刷屏。 + /// + private readonly Dictionary _unknownPidLastLogTicks = new Dictionary(); + + /// + /// 调度取消源（置空表示未运行）。 + /// + private CancellationTokenSource? _scheduleCts; + + /// + /// 调度后台任务（LongRunning）。 + /// + private Task? _scheduleTask; + + /// + /// 调度运行标记（与 _scheduleCts 配合；主要用于可读性与状态表达）。 + /// + private bool _scheduleRunning; + + /// + /// LIN 调度表 DTO 缓存（由 ViewModel/上层写入；启动调度时会取快照）。 + /// + private List _linScheduleConfigs = new List(); + + /// + /// 当前选中的配置程序（沿用原有 FreeSql 模型）。 + /// + public CanLinConfigPro? SelectedCanLinConfigPro { get; set; } + + private bool _openState; + /// + /// LIN 打开状态。 + /// + public bool OpenState + { + get { return _openState; } + private set { _openState = value; RaisePropertyChanged(); } + } + + /// + /// 解析 LDF 文本，提取 Frames/Signals/Nodes（Master）信息。 + /// 说明：这是一个轻量解析器： + /// - 目标是构建“帧-信号位定义”的索引，并支持 UI 展示； + /// - 不追求覆盖所有 LDF 语法，仅尽量兼容常见格式。 + /// + /// LDF 原始文本（建议已剔除注释）。 + /// Frames 列表、Signals 位定义字典、Master 节点名（可能为空）。 + private static (List<(string FrameName, int FrameId, int DataLen, string? Publisher, List Signals)>, Dictionary, 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*(?[A-Za-z_][A-Za-z0-9_]*)\s*;", RegexOptions.Compiled); + if (m.Success) + { + return m.Groups["name"].Value; + } + + return null; + } + + private static Dictionary ParseSignalsBlock(string? signalsBlock) + { + var dict = new Dictionary(StringComparer.Ordinal); + if (string.IsNullOrWhiteSpace(signalsBlock)) + { + return dict; + } + + // 兼容常见格式：SigName: 0, 8; + var sigRegex = new Regex(@"(?im)^\s*(?[A-Za-z_][A-Za-z0-9_]*)\s*:\s*(?\d+)\s*,\s*(?\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 Signals)> ParseFramesBlock(string? framesBlock) + { + var list = new List<(string FrameName, int FrameId, int DataLen, string? Publisher, List Signals)>(); + if (string.IsNullOrWhiteSpace(framesBlock)) + { + return list; + } + + // 常见格式：FrameName : 0x10, Publisher, 8 { SigA, SigB }; + var frameRegex = new Regex(@"(?s)(?[A-Za-z_][A-Za-z0-9_]*)\s*:\s*(?0x[0-9A-Fa-f]+|\d+)\s*,\s*(?[A-Za-z_][A-Za-z0-9_]*)\s*,\s*(?\d+)\s*\{(?.*?)\}\s*;?", RegexOptions.Compiled); + var sigRegex = new Regex(@"(?m)^[\s\t]*(?[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(); + 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)(?[A-Za-z_][A-Za-z0-9_]*)\s*:\s*.*?\{(?.*?)\}\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(); + 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); + } + + /// + /// 基于解析结果构建运行时索引： + /// - _framesByName/_framesByPid：用于发送与接收定位帧定义； + /// - ListLinLdfModel/_modelIndex：用于 UI 展示与实时值更新。 + /// + /// 帧定义集合。 + /// 信号位定义字典。 + /// Master 节点名（可能为空）。 + private void BuildRuntimeIndex( + List<(string FrameName, int FrameId, int DataLen, string? Publisher, List Signals)> frames, + Dictionary signals, + string? masterNodeName) + { + lock (_ldfLock) + { + _framesByName = new Dictionary(StringComparer.Ordinal); + _framesByPid = new Dictionary(); + _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(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; + } + } + } + } + + /// + /// 处理一帧 LIN 接收数据：按 pid 匹配帧定义，按信号位定义解码并更新 UI 实时值。 + /// 说明： + /// - 该方法可能在 Driver 的接收线程中被调用； + /// - 不做阻塞操作（如 IO/长时间锁持有），避免拖慢接收线程。 + /// + /// 原始 LIN 接收帧。 + 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; + } + + /// + /// 发送一帧（按当前 CmdData 聚合编码）。 + /// + /// 帧名。 + 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 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}"; + } + + /// + /// 启动软件精确定时循环发送（按统一周期发送当前 CmdData 中出现的帧）。 + /// + /// 周期（ms）。 + public void StartPrecisionCycleSend(int cycleMs) + { + if (!OpenState) + { + throw new InvalidOperationException("设备未连接，无法启动循环发送。"); + } + + var ms = Math.Max(1, cycleMs); + List 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); + } + } + + /// + /// 停止循环发送。 + /// + 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; + /// + /// LDF 解析状态。 + /// 说明： + /// - 当 成功解析并建立运行时索引后为 true； + /// - 若未解析/解析失败/关闭设备则为 false。 + /// - LIN 收发编解码依赖该状态（未解析时接收帧会被忽略，发送会在找不到帧定义时抛出异常）。 + /// + public bool LdfParserState + { + get { return _ldfParserState; } + private set { _ldfParserState = value; RaisePropertyChanged(); } + } + + /// + /// LDF 消息集合（UI 绑定）。 + /// 说明： + /// - 该集合由 解析并构建，用于 UI 展示“帧-信号”全集与实时值； + /// - 未解析 LDF 时保持为空。 + /// + public ObservableCollection ListLinLdfModel { get; private set; } = new ObservableCollection(); + + /// + /// 要发送的 LIN 指令集合（来源于配置程序+读写设置）。 + /// + public List CmdData { get; } = new List(); + + /// + /// 是否启用调度发送（与 UI 的调度表使能语义对齐）。 + /// + public bool SchEnable + { + get { return _zlgCanDriveService.Driver.SchEnable; } + set { _zlgCanDriveService.Driver.SchEnable = value; RaisePropertyChanged(); } + } + + /// + /// 是否启用事件驱动发送。 + /// + public bool IsCycleSend + { + get { return _zlgCanDriveService.Driver.IsCycleSend; } + set { _zlgCanDriveService.Driver.IsCycleSend = value; RaisePropertyChanged(); } + } + + /// + /// 构造。 + /// + /// 共享 CAN 服务。 + /// 日志服务。 + 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}"); + } + }; + } + + /// + /// 是否正在循环接收（透传底层 Driver 接收线程状态）。 + /// + public bool IsCycleRevice + { + get { return _zlgCanDriveService.IsCycleRevice; } + } + + /// + /// 发送状态指示（短时间保持 true 后回落，透传 Driver）。 + /// + public bool IsSendOk + { + get { return _zlgCanDriveService.IsSendOk; } + } + + /// + /// 接收状态指示（短时间保持 true 后回落，透传 Driver）。 + /// + public bool IsReviceOk + { + get { return _zlgCanDriveService.IsReviceOk; } + } + + /// + /// 开关接收线程（共享设备接收线程）。 + /// + /// 是否启用。 + public void SetReceiveEnabled(bool enable) + { + _zlgCanDriveService.SetReceiveEnabled(enable); + RaisePropertyChanged(nameof(IsCycleRevice)); + } + + /// + /// 下发调度表配置（系统层调度表，支持每帧不同周期）。 + /// + /// 调度表配置集合。 + public void SetScheduleConfigs(List configs) + { + lock (_scheduleLock) + { + // 仅缓存配置快照：真正启动调度时会再取一次快照，避免 UI 边编辑边启动导致的并发问题。 + _linScheduleConfigs = configs ?? new List(); + } + } + + /// + /// 启动软件调度（按调度表中每帧的 Cycle 分别调度发送）。 + /// 说明：ZLG LIN 当前未接入硬件调度表/auto_send，因此用软件精确定时实现。 + /// + public void StartSchedule() + { + if (!OpenState) + { + throw new InvalidOperationException("设备未连接，无法启动调度发送。"); + } + + List snapshot; + lock (_scheduleLock) + { + snapshot = _linScheduleConfigs?.ToList() ?? new List(); + } + + // 仅使用“被激活的调度表”中的“被选中消息” + 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); + } + } + + /// + /// 设置并订阅要发送的指令集合（事件驱动）。 + /// + /// 指令集合。 + public void LoadCmdDataToDrive(IEnumerable 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) + { + // 订阅变化事件：用于“值变化增量发送”（由 + 共同控制）。 + 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}"); + } + } + + /// + /// 初始化 LIN 配置信息（目前仅缓存）。 + /// + /// 选中的配置。 + public void InitLinConfig(CanLinConfigPro selectedLinConfigPro) + { + SelectedCanLinConfigPro = selectedLinConfigPro; + } + + /// + /// 打开 LIN（共享设备句柄）。 + /// + /// 设备索引。 + /// 波特率。 + /// 是否主节点。 + 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; + } + } + + /// + /// 关闭 LIN（共享设备句柄下，当前实现以 CloseDevice 为准：关闭将同时关闭 CAN/LIN）。 + /// + public void CloseDevice() + { + // ZLG 的通道句柄都在 Driver 内部；当前 Close 会关闭所有通道，保持与旧系统“同一时刻只有一种驱动工作”的原则一致。 + _zlgCanDriveService.CloseDevice(); + OpenState = false; + LdfParserState = false; + } + + /// + /// 加载并解析 LDF 文件，建立“帧/信号”的运行时索引，并生成 UI 可绑定的 集合。 + /// 说明： + /// - 这里使用轻量解析器解析常见 LDF 结构（Frames/Signals/Nodes），目的是满足当前项目的 LIN 编解码与 UI 展示需求。 + /// - 若 LDF 格式差异较大，解析可能失败并抛出异常；调用方（通常为 ViewModel）应捕获并提示。 + /// + /// LDF 路径。 + public ObservableCollection 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 ParseLdfFramesAndSignals(string ldfText) + { + // 说明：此解析器只用于生成“帧-信号全集池”，不做位宽/缩放等语义解析。 + // 目标：尽可能容错地从 Frames 区域提取 FrameName 与其包含的 SignalName 列表。 + + var framesBlock = TryExtractNamedBlock(ldfText, "Frames"); + if (string.IsNullOrWhiteSpace(framesBlock)) + { + return new List(); + } + + var result = new List(); + var exists = new HashSet(StringComparer.Ordinal); + + // Frame 定义一般形式：FrameName : ... { ... } + // 这里以非贪婪匹配提取每个 Frame 的 body + var frameRegex = new Regex(@"(?s)(?[A-Za-z_][A-Za-z0-9_]*)\s*:\s*.*?\{(?.*?)\}\s*;?", RegexOptions.Compiled); + var sigRegex = new Regex(@"(?m)^\s*(?[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; + } + } + } +} diff --git a/CapMachine.Wpf/ViewModels/CANConfigViewModel.cs b/CapMachine.Wpf/ViewModels/CANConfigViewModel.cs index c2643c6..cb0e6bc 100644 --- a/CapMachine.Wpf/ViewModels/CANConfigViewModel.cs +++ b/CapMachine.Wpf/ViewModels/CANConfigViewModel.cs @@ -1,4 +1,4 @@ -using AutoMapper; +using AutoMapper; using CapMachine.Core; using CapMachine.Model; using CapMachine.Model.CANLIN; @@ -152,12 +152,13 @@ namespace CapMachine.Wpf.ViewModels } /// - /// CAN/LIN配置变更事件处理 + /// CAN/LIN 配置导入后刷新当前页面。 /// - /// + /// 事件消息。 private void CanLinConfigChangedEventCall(string msg) { - RefreshConfigList(); + InitLoadCanConfigPro(); + InitWriteRuleCbx(); } /// @@ -948,18 +949,12 @@ namespace CapMachine.Wpf.ViewModels /// private void SchEnableCmdCall(object par) { - var dd = SelectedCANConfigExdDto.SchEnable; - var Result = (bool)par; - if (Result) + if (SelectedCANConfigExdDto == null) { - CanDriveService.ToomossCanDrive.SchEnable = true; - + return; } - else - { - CanDriveService.ToomossCanDrive.SchEnable = false; - } + CanDriveService.ToomossCanDrive.SchEnable = SelectedCANConfigExdDto.SchEnable; } @@ -1362,22 +1357,22 @@ namespace CapMachine.Wpf.ViewModels { "SelectCanLinConfigProId",SelectCanLinConfigPro.Id}, }, (par) => - { - if (par.Result == ButtonResult.OK) - { - ////程序名称 - ListCANScheduleConfigDto = par.Parameters.GetValue>("ReturnValue"); - //把更新后的最新值给当前的主集合中 - SelectCanLinConfigPro.CanScheduleConfigs = Mapper.Map>(ListCANScheduleConfigDto.ToList()); + { + if (par.Result == ButtonResult.OK) + { + ////程序名称 + ListCANScheduleConfigDto = par.Parameters.GetValue>("ReturnValue"); + //把更新后的最新值给当前的主集合中 + SelectCanLinConfigPro.CanScheduleConfigs = Mapper.Map>(ListCANScheduleConfigDto.ToList()); - } - else if (par.Result == ButtonResult.Cancel) - { - //取消 + } + else if (par.Result == ButtonResult.Cancel) + { + //取消 - } + } - }); + }); } else { diff --git a/CapMachine.Wpf/ViewModels/CANFDConfigViewModel.cs b/CapMachine.Wpf/ViewModels/CANFDConfigViewModel.cs index 7dbc90c..ea27dc2 100644 --- a/CapMachine.Wpf/ViewModels/CANFDConfigViewModel.cs +++ b/CapMachine.Wpf/ViewModels/CANFDConfigViewModel.cs @@ -172,12 +172,13 @@ namespace CapMachine.Wpf.ViewModels } /// - /// CAN/LIN配置变更事件处理 + /// CAN/LIN 配置导入后刷新当前页面。 /// - /// + /// 事件消息。 private void CanLinConfigChangedEventCall(string msg) { - RefreshConfigList(); + InitLoadCanConfigPro(); + InitWriteRuleCbx(); } /// @@ -212,7 +213,7 @@ namespace CapMachine.Wpf.ViewModels canLinConfigPros = FreeSql.Select().Where(a => a.CANLINInfo == CANLIN.CANFD) .Include(a => a.CANFdConfigExd) .IncludeMany(a => a.CanLinConfigContents, then => then.Include(b => b.LogicRule))//,then=> then.Include(b=>b.LogicRule) - //.IncludeMany(a => a.CanLinConfigContents) + .IncludeMany(a => a.CanFdScheduleConfigs)// .ToList(); ListCanLinConfigPro = new ObservableCollection(canLinConfigPros); @@ -271,6 +272,12 @@ namespace CapMachine.Wpf.ViewModels ListReadCanLinRWConfigDto = new ObservableCollection(); } + //调度表配置信息 + if (SelectCanLinConfigPro.CanFdScheduleConfigs != null && SelectCanLinConfigPro.CanFdScheduleConfigs.Count() > 0) + { + ListCANFdScheduleConfigDto = new ObservableCollection(Mapper.Map>(SelectCanLinConfigPro.CanFdScheduleConfigs)); + } + //匹配选中的SelectCanLinConfigPro.CanLinConfigContents和ListCanDbcModel MatchSeletedAndCanDbcModel(); } @@ -519,6 +526,8 @@ namespace CapMachine.Wpf.ViewModels CanFdDriveService.InitCanConfig(SelectCanLinConfigPro); InitLoadCanConfigPro(); + + CanFdDriveService.ToomossCanFDDrive.LoadCmdDataToDrive(CanFdDriveService.CmdData); } else { @@ -636,6 +645,18 @@ namespace CapMachine.Wpf.ViewModels SelectCanLinConfigProConfigName = SelectCanLinConfigPro.ConfigName; + + //调度表配置信息 + if (SelectCanLinConfigPro.CanFdScheduleConfigs != null && SelectCanLinConfigPro.CanFdScheduleConfigs.Count() > 0) + { + ListCANFdScheduleConfigDto = new ObservableCollection(Mapper.Map>(SelectCanLinConfigPro.CanFdScheduleConfigs)); + } + else + { + ListCANFdScheduleConfigDto = new ObservableCollection(); + } + + return; } //先判断是否是正确的集合数据，防止DataGrid的数据源刷新导致的触发事件 @@ -705,6 +726,33 @@ namespace CapMachine.Wpf.ViewModels #endregion + + private DelegateCommand _btnTestPLC; + /// + /// 临时测试的方法 + /// + public DelegateCommand btnTestPLC + { + set + { + _btnTestPLC = value; + } + get + { + if (_btnTestPLC == null) + { + _btnTestPLC = new DelegateCommand(() => btnTestPLCCall()); + } + return _btnTestPLC; + } + } + //临时测试的方法 + private void btnTestPLCCall() + { + CanFdDriveService.ToomossCanFDDrive.UpdateSchDataByCmdDataChanged(); + } + + #region Dbc操作 private ObservableCollection _ListCanDbcModel; @@ -938,6 +986,43 @@ namespace CapMachine.Wpf.ViewModels set { _ArbBaudRateCbxItems = value; RaisePropertyChanged(); } } + + private DelegateCommand _SchEnableCmd; + /// + /// 调度表的使能 操作的指令 + /// + public DelegateCommand SchEnableCmd + { + set + { + _SchEnableCmd = value; + } + get + { + if (_SchEnableCmd == null) + { + _SchEnableCmd = new DelegateCommand((Par) => SchEnableCmdCall(Par)); + } + return _SchEnableCmd; + } + } + /// + /// 调度表的使能信息 + /// + /// + /// + private void SchEnableCmdCall(object par) + { + if (SelectedCANConfigExdDto == null) + { + return; + } + + CanFdDriveService.ToomossCanFDDrive.SchEnable = SelectedCANConfigExdDto.SchEnable; + } + + + private DelegateCommand _CanOpCmd; /// /// CAN操作的指令 @@ -1029,6 +1114,7 @@ namespace CapMachine.Wpf.ViewModels .Set(a => a.ArbBaudRate, SelectedCANConfigExdDto.ArbBaudRate) .Set(a => a.ISOEnable, SelectedCANConfigExdDto.ISOEnable) .Set(a => a.ResEnable, SelectedCANConfigExdDto.ResEnable) + .Set(a => a.SchEnable, SelectedCANConfigExdDto.SchEnable) .Where(a => a.Id == SelectedCANConfigExdDto.Id) .ExecuteUpdated(); } @@ -1090,6 +1176,12 @@ namespace CapMachine.Wpf.ViewModels break; case "CycleSend"://循环发送你 + + //有可能加载完毕后不手动改变状态，导致值没有传输，所以这里赋值 + CanFdDriveService.ToomossCanFDDrive.SchEnable = SelectedCANConfigExdDto.SchEnable; + //无论有没有调度表，都要把这个配置给CanDriveService + CanFdDriveService.ListCANFdScheduleConfig = ListCANFdScheduleConfigDto.ToList(); + //循环发送数据 CanFdDriveService.CycleSendMsg(); @@ -1153,6 +1245,26 @@ namespace CapMachine.Wpf.ViewModels set { _WriteRuleCbxItems = value; RaisePropertyChanged(); } } + private ObservableCollection _ReadRuleCbxItems; + /// + /// 读取的规格集合 + /// + public ObservableCollection ReadRuleCbxItems + { + get { return _ReadRuleCbxItems; } + set { _ReadRuleCbxItems = value; RaisePropertyChanged(); } + } + + private ObservableCollection _ListCANFdScheduleConfigDto; + /// + ///调度表集合 + /// + public ObservableCollection ListCANFdScheduleConfigDto + { + get { return _ListCANFdScheduleConfigDto; } + set { _ListCANFdScheduleConfigDto = value; RaisePropertyChanged(); } + } + //private string _SelectedWriteName; ///// ///// 选中的写入的Name @@ -1298,6 +1410,45 @@ namespace CapMachine.Wpf.ViewModels System.Windows.MessageBox.Show("请选中后再进行【删除】操作？", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand); } + break; + + case "WriteSch"://调度表 + + var data = CanFdDriveService.CmdData.GroupBy(a => a.MsgName).Select(a => a.Key).ToList(); + + if (data != null && data.Count > 0) + { + //弹窗 + DialogService.ShowDialog("DialogCANFdSchConfigView", new DialogParameters() { + {"ListMsg", CanFdDriveService.CmdData.GroupBy(a=>a.MsgName).Select(a=>a.Key).ToList() }, + { "ListCANFdScheduleConfigDto",ListCANFdScheduleConfigDto}, + { "SelectCanLinConfigProId",SelectCanLinConfigPro.Id}, + + }, (par) => + { + if (par.Result == ButtonResult.OK) + { + ////程序名称 + ListCANFdScheduleConfigDto = par.Parameters.GetValue>("ReturnValue"); + //把更新后的最新值给当前的主集合中 + SelectCanLinConfigPro.CanFdScheduleConfigs = Mapper.Map>(ListCANFdScheduleConfigDto.ToList()); + + } + else if (par.Result == ButtonResult.Cancel) + { + //取消 + + } + + }); + } + else + { + System.Windows.MessageBox.Show("未发现写入的执行的命令数据，无法配置？", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand); + } + + + break; default: break; diff --git a/CapMachine.Wpf/ViewModels/DialogCANFdSchConfigViewModel.cs b/CapMachine.Wpf/ViewModels/DialogCANFdSchConfigViewModel.cs new file mode 100644 index 0000000..7b44af7 --- /dev/null +++ b/CapMachine.Wpf/ViewModels/DialogCANFdSchConfigViewModel.cs @@ -0,0 +1,377 @@ +using AutoMapper; +using CapMachine.Core; +using CapMachine.Model.CANLIN; +using CapMachine.Wpf.Dtos; +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 Fd 调度表配置 + /// + public class DialogCANFdSchConfigViewModel : DialogViewModel + { + /// + /// 构造函数 + /// + public DialogCANFdSchConfigViewModel(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 _ListCANFdScheduleConfigDto = new ObservableCollection(); + /// + /// CAN 调度表数据集合 + /// + public ObservableCollection ListCANFdScheduleConfigDto + { + get { return _ListCANFdScheduleConfigDto; } + set { _ListCANFdScheduleConfigDto = 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 CANFdScheduleConfigDto _CurSelectedItem; + /// + /// 选中的数据 + /// + public CANFdScheduleConfigDto 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 CANFdScheduleConfigDto; + + 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": + ListCANFdScheduleConfigDto.Add(new CANFdScheduleConfigDto + { + CanLinConfigProId = SelectCanLinConfigProId, + Cycle = 100, + SchTabIndex = 0, + OrderSend = 1, + }); + break; + case "Delete": + if (CurSelectedItem != null) + { + //直接删除掉，如果没有ID的话，这就不需要删除了 + FreeSql.Delete(CurSelectedItem.Id).ExecuteAffrows(); + ListCANFdScheduleConfigDto.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 ListCANFdScheduleConfigDto) + { + //整个的发送方式赋值给每个子项 + 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 ListCANFdScheduleConfigDto) + { + FreeSql.InsertOrUpdate() + .SetSource(Mapper.Map(item)). + ExecuteAffrows(); + } + + ListCANFdScheduleConfigDto = new ObservableCollection(Mapper.Map>(FreeSql.Select().Where(a => a.CanLinConfigProId == SelectCanLinConfigProId).ToList())); + + DialogParameters pars = new DialogParameters + { + { "ReturnValue", ListCANFdScheduleConfigDto } + }; + + 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 + })); + + ListCANFdScheduleConfigDto = parameters.GetValue>("ListCANFdScheduleConfigDto"); + //防止返回的数据为空，就无法增加了 + if (ListCANFdScheduleConfigDto == null) ListCANFdScheduleConfigDto = new ObservableCollection(); + //Name = parameters.GetValue("Name"); + if (ListCANFdScheduleConfigDto.Count > 0) + { + CurSendOrder = ListCANFdScheduleConfigDto.FirstOrDefault()!.OrderSend.ToString(); + } + + SelectCanLinConfigProId = parameters.GetValue("SelectCanLinConfigProId"); + } + + + } +} diff --git a/CapMachine.Wpf/ViewModels/DialogCanLinConfigImExportViewModel.cs b/CapMachine.Wpf/ViewModels/DialogCanLinConfigImExportViewModel.cs index 088baef..6e22ef3 100644 --- a/CapMachine.Wpf/ViewModels/DialogCanLinConfigImExportViewModel.cs +++ b/CapMachine.Wpf/ViewModels/DialogCanLinConfigImExportViewModel.cs @@ -1,4 +1,4 @@ -using CapMachine.Core; +using CapMachine.Core; using CapMachine.Wpf.PrismEvent; using CapMachine.Wpf.Services; using Microsoft.Win32; diff --git a/CapMachine.Wpf/ViewModels/DialogZlgCANFDSchConfigViewModel.cs b/CapMachine.Wpf/ViewModels/DialogZlgCANFDSchConfigViewModel.cs new file mode 100644 index 0000000..ec2f99c --- /dev/null +++ b/CapMachine.Wpf/ViewModels/DialogZlgCANFDSchConfigViewModel.cs @@ -0,0 +1,358 @@ +using AutoMapper; +using CapMachine.Core; +using CapMachine.Model.CANLIN; +using CapMachine.Wpf.Dtos; +using Prism.Commands; +using Prism.Services.Dialogs; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Linq; +using System.Windows; + +namespace CapMachine.Wpf.ViewModels +{ + /// + /// ZLG CAN FD 调度表配置弹窗 ViewModel。 + /// 说明： + /// - 调度表项本身由“读写设置”弹窗中的“加入定时调度表”能力生成，这里主要负责： + /// 1) 设置发送方式（并行/顺序） + /// 2) 配置周期（Cycle） + /// 3) 删除与保存落库 + /// - 保存时会使用 InsertOrUpdate 做 Upsert，并在保存完成后从数据库重载，作为权威数据再回传给调用方。 + /// + public class DialogZlgCANFDSchConfigViewModel : DialogViewModel + { + /// + /// 构造函数。 + /// + /// FreeSql。 + /// AutoMapper。 + public DialogZlgCANFDSchConfigViewModel(IFreeSql freeSql, IMapper mapper) + { + Title = "调度表 CANFD 配置"; + FreeSql = freeSql; + Mapper = mapper; + + SendOrderCbxItems = new ObservableCollection() + { + new CbxItems(){ + Key="0", + Text="并行", + }, + new CbxItems(){ + Key="1", + Text="顺序", + }, + }; + + SchTabIndexCbxItems = new ObservableCollection() + { + new CbxItems(){ + Key="0", + Text="0", + }, + }; + } + + /// + /// FreeSql。 + /// + public IFreeSql FreeSql { get; } + + /// + /// AutoMapper。 + /// + public IMapper Mapper { get; } + + private ObservableCollection _listCANFdScheduleConfigDto = new ObservableCollection(); + + /// + /// CAN FD 调度表数据集合。 + /// + public ObservableCollection ListCANFdScheduleConfigDto + { + get { return _listCANFdScheduleConfigDto; } + set { _listCANFdScheduleConfigDto = 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 CANFdScheduleConfigDto _curSelectedItem; + + /// + /// 当前选中项。 + /// + public CANFdScheduleConfigDto CurSelectedItem + { + get { return _curSelectedItem; } + set { _curSelectedItem = value; RaisePropertyChanged(); } + } + + private DelegateCommand _gridSelectionChangedCmd; + + /// + /// DataGrid 选中行变化。 + /// + public DelegateCommand GridSelectionChangedCmd + { + get + { + if (_gridSelectionChangedCmd == null) + { + _gridSelectionChangedCmd = new DelegateCommand(GridSelectionChangedCmdMethod); + } + return _gridSelectionChangedCmd; + } + } + + /// + /// 选中行变化处理。 + /// + /// 选中项。 + private void GridSelectionChangedCmdMethod(object par) + { + var selected = par as CANFdScheduleConfigDto; + if (selected != null) + { + CurSelectedItem = selected; + } + } + + private DelegateCommand _opCmd; + + /// + /// 操作命令（删除）。 + /// + public DelegateCommand OpCmd + { + get + { + if (_opCmd == null) + { + _opCmd = new DelegateCommand(OpCmdCall); + } + return _opCmd; + } + } + + /// + /// 操作命令处理。 + /// + /// 参数。 + private void OpCmdCall(string par) + { + switch (par) + { + case "Add": + MessageBox.Show("调度表项由【读写设置】中的写入配置通过“加入定时调度表”生成，这里不支持新增。", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + break; + case "Delete": + if (CurSelectedItem != null) + { + FreeSql.Delete(CurSelectedItem.Id).ExecuteAffrows(); + ListCANFdScheduleConfigDto.Remove(CurSelectedItem); + CurSelectedItem = null; + } + else + { + MessageBox.Show("请选中后再进行【删除】操作？", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + } + break; + default: + break; + } + } + + private DelegateCommand _saveCmd; + + /// + /// 保存命令。 + /// + public DelegateCommand SaveCmd + { + get + { + if (_saveCmd == null) + { + _saveCmd = new DelegateCommand(SaveCmdMethod); + } + return _saveCmd; + } + } + + /// + /// 保存命令处理。 + /// + private void SaveCmdMethod() + { + // 校验：确保每个调度项具备最小可用字段，避免落库无效配置。 + foreach (var item in ListCANFdScheduleConfigDto) + { + // UI 上的“发送方式”是全局下拉框，这里同步写回每个子项，确保落库数据一致。 + 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; + } + } + + foreach (var item in ListCANFdScheduleConfigDto) + { + // Upsert：逐项落库。 + FreeSql.InsertOrUpdate() + .SetSource(Mapper.Map(item)) + .ExecuteAffrows(); + } + + // 保存完成后重载： + // - 避免 UI 集合与数据库实际数据不一致； + // - 同时让新增项获取真实 Id。 + ListCANFdScheduleConfigDto = new ObservableCollection( + Mapper.Map>( + FreeSql.Select() + .Where(a => a.CanLinConfigProId == SelectCanLinConfigProId) + .ToList())); + + DialogParameters pars = new DialogParameters + { + { "ReturnValue", ListCANFdScheduleConfigDto } + }; + + RaiseRequestClose(new DialogResult(ButtonResult.OK, pars)); + } + + private DelegateCommand _cancelCmd; + + /// + /// 取消命令。 + /// + public DelegateCommand CancelCmd + { + get + { + if (_cancelCmd == null) + { + _cancelCmd = new DelegateCommand(CancelCmdMethod); + } + return _cancelCmd; + } + } + + /// + /// 取消命令处理。 + /// + private void CancelCmdMethod() + { + RaiseRequestClose(new DialogResult(ButtonResult.Cancel)); + } + + /// + /// 弹窗打开时参数接收并初始化 UI。 + /// 说明： + /// - ListMsg：用于构造消息名下拉框（候选）； + /// - ListCANFdScheduleConfigDto：用于回显当前调度表； + /// - SelectCanLinConfigProId：用于 Save 后按配置程序 id 重载。 + /// + /// 参数。 + public override void OnDialogOpened(IDialogParameters parameters) + { + if (parameters.ContainsKey("ListMsg")) + { + ListMsg = parameters.GetValue>("ListMsg"); + if (ListMsg != null) + { + // 转换为 CbxItems 集合（Key/Text 都使用消息名）。 + MsgCbxItems = new ObservableCollection( + ListMsg.Select(value => new CbxItems + { + Key = value, + Text = value + })); + } + } + + ListCANFdScheduleConfigDto = parameters.GetValue>("ListCANFdScheduleConfigDto"); + if (ListCANFdScheduleConfigDto == null) ListCANFdScheduleConfigDto = new ObservableCollection(); + + if (ListCANFdScheduleConfigDto.Count > 0) + { + // 回显：默认取第一条的 OrderSend。 + CurSendOrder = ListCANFdScheduleConfigDto.FirstOrDefault()!.OrderSend.ToString(); + } + else + { + // 默认：顺序发送。 + CurSendOrder = "1"; + } + + SelectCanLinConfigProId = parameters.GetValue("SelectCanLinConfigProId"); + } + } +} diff --git a/CapMachine.Wpf/ViewModels/DialogZlgCANSchConfigViewModel.cs b/CapMachine.Wpf/ViewModels/DialogZlgCANSchConfigViewModel.cs new file mode 100644 index 0000000..264f97d --- /dev/null +++ b/CapMachine.Wpf/ViewModels/DialogZlgCANSchConfigViewModel.cs @@ -0,0 +1,402 @@ +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 +{ + /// + /// ZLG CAN 调度表配置 + /// + public class DialogZlgCANSchConfigViewModel : DialogViewModel + { + /// + /// 构造函数 + /// + public DialogZlgCANSchConfigViewModel(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", + //}, + }; + + } + + /// + /// FreeSql（用于调度表项的删除/保存落库）。 + /// + public IFreeSql FreeSql { get; } + + /// + /// AutoMapper（DTO 与实体映射）。 + /// + 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; + /// + /// DataGrid 选中行变化。 + /// + public DelegateCommand GridSelectionChangedCmd + { + set + { + _GridSelectionChangedCmd = value; + } + get + { + if (_GridSelectionChangedCmd == null) + { + _GridSelectionChangedCmd = new DelegateCommand((par) => GridSelectionChangedCmdMethod(par)); + } + return _GridSelectionChangedCmd; + } + } + private void GridSelectionChangedCmdMethod(object par) + { + // 先判断是否是正确的集合数据，防止 DataGrid 的 ItemsSource 刷新导致的误触发。 + var Selecteddata = par as CANScheduleConfigDto; + + if (Selecteddata != null) + { + CurSelectedItem = Selecteddata; + } + } + + 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": + MessageBox.Show("调度表项由【读写设置】中的写入配置通过“加入定时调度表”生成，这里不支持新增。", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + break; + case "Delete": + if (CurSelectedItem != null) + { + // 直接落库删除（无论 UI 是否还有引用，都以数据库为准）。 + 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; + } + } + + /// + /// 保存命令方法。 + /// 说明： + /// - 先做必要校验（MsgName/Cycle/发送方式等），避免写入无效配置； + /// - 使用 InsertOrUpdate 保证“新增/修改”统一处理； + /// - 保存完成后重新从数据库加载，作为最终权威数据，并通过 DialogResult 回传给调用方。 + /// + private void SaveCmdMethod() + { + // 校验：确保每个调度项具备最小可用字段。 + foreach (var item in ListCANScheduleConfigDto) + { + // UI 上的“发送方式”是全局下拉框，这里同步写回到每个子项，确保落库数据一致。 + 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; + //} + + // Upsert：逐项落库。 + foreach (var item in ListCANScheduleConfigDto) + { + FreeSql.InsertOrUpdate() + .SetSource(Mapper.Map(item)). + ExecuteAffrows(); + } + + // 保存完成后重新加载： + // - 防止 UI 缓存与数据库实际数据不一致； + // - 同时也让新增项拿到真实 Id。 + 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)); + } + + /// + /// 弹窗打开时接收参数并初始化 UI。 + /// 说明： + /// - ListMsg 用于构造消息名下拉框； + /// - ListCANScheduleConfigDto 用于回显现有调度表； + /// - SelectCanLinConfigProId 用于 Save 时按配置程序 id 过滤重载。 + /// + /// + public override void OnDialogOpened(IDialogParameters parameters) + { + if (parameters.ContainsKey("ListMsg")) + { + ListMsg = parameters.GetValue>("ListMsg"); + if (ListMsg != null) + { + // 转换为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) + { + // 回显：默认取第一条的 OrderSend 作为当前下拉框选择。 + CurSendOrder = ListCANScheduleConfigDto.FirstOrDefault()!.OrderSend.ToString(); + } + else + { + // 默认：顺序发送。 + CurSendOrder = "1"; + } + + SelectCanLinConfigProId = parameters.GetValue("SelectCanLinConfigProId"); + } + + + } +} diff --git a/CapMachine.Wpf/ViewModels/DialogZlgCanLinRwConfigViewModel.cs b/CapMachine.Wpf/ViewModels/DialogZlgCanLinRwConfigViewModel.cs new file mode 100644 index 0000000..1e0b5da --- /dev/null +++ b/CapMachine.Wpf/ViewModels/DialogZlgCanLinRwConfigViewModel.cs @@ -0,0 +1,904 @@ +using CapMachine.Core; +using CapMachine.Model.CANLIN; +using CapMachine.Wpf.Dtos; +using CapMachine.Wpf.Services; +using FreeSql; +using Prism.Commands; +using Prism.Services.Dialogs; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Linq; +using System.Windows; +using System.Windows.Data; + +namespace CapMachine.Wpf.ViewModels +{ + /// + /// ZLG CAN/LIN 读写配置三栏管理弹窗 ViewModel。 + /// 左侧：写入/读取配置；右侧：信号全集候选池；统一保存落库。 + /// + public class DialogZlgCanLinRwConfigViewModel : DialogViewModel + { + private readonly IFreeSql _freeSql; + private readonly ILogService _logService; + private readonly LogicRuleService _logicRuleService; + + private long _canLinConfigProId; + + private bool _enableHardwareCycleSchedule = true; + private bool _useCanFdSchedule; + + /// + /// 是否启用“加入定时调度表（ZLG auto_send）”能力。 + /// 说明：该能力仅适用于 ZLG CAN/CANFD 硬件 auto_send；LIN 当前使用软件调度，不允许写入 CANScheduleConfig。 + /// + public bool EnableHardwareCycleSchedule + { + get { return _enableHardwareCycleSchedule; } + private set + { + _enableHardwareCycleSchedule = value; + RaisePropertyChanged(); + RaisePropertyChanged(nameof(CanAddCycleTimeSch)); + } + } + + /// + /// 是否允许执行“加入定时调度表”操作。 + /// 说明： + /// - 需要 打开（调用方允许硬件调度表能力）； + /// - 且弹窗处于可编辑态（）。 + /// + public bool CanAddCycleTimeSch + { + get { return EnableHardwareCycleSchedule && IsEditable; } + } + + /// + /// 是否使用 CANFD 调度表（决定“加入定时调度表”写入 还是 ）。 + /// + public bool UseCanFdSchedule + { + get { return _useCanFdSchedule; } + private set { _useCanFdSchedule = value; RaisePropertyChanged(); } + } + + /// + /// 构造函数。 + /// + /// FreeSql。 + /// 日志。 + /// 逻辑规则服务。 + public DialogZlgCanLinRwConfigViewModel(IFreeSql freeSql, ILogService logService, LogicRuleService logicRuleService) + { + _freeSql = freeSql; + _logService = logService; + _logicRuleService = logicRuleService; + + Title = "读写设置"; + + WriteConfigs = new ObservableCollection(); + ReadConfigs = new ObservableCollection(); + SignalCandidates = new ObservableCollection(); + SignalTree = new ObservableCollection(); + + SignalCandidatesView = CollectionViewSource.GetDefaultView(SignalCandidates); + SignalCandidatesView.Filter = FilterSignalCandidate; + + WriteNameCbxItems = new ObservableCollection() + { + new CbxItems(){ Key="转速",Text="转速"}, + new CbxItems(){ Key="功率限制",Text="功率限制"}, + new CbxItems(){ Key="使能",Text="使能"}, + new CbxItems(){ Key="Anti_Sleep",Text="Anti_Sleep"}, + new CbxItems(){ Key="PTC使能",Text="PTC使能"}, + new CbxItems(){ Key="PTC功率",Text="PTC功率"}, + new CbxItems(){ Key="PTC水流量",Text="PTC水流量"}, + new CbxItems(){ Key="PTC水温",Text="PTC水温"}, + }; + + ReadNameCbxItems = new ObservableCollection() + { + new CbxItems(){ Key="通讯Cmp转速",Text="通讯Cmp转速"}, + new CbxItems(){ Key="通讯Cmp母线电压",Text="通讯Cmp母线电压"}, + new CbxItems(){ Key="通讯Cmp母线电流",Text="通讯Cmp母线电流"}, + new CbxItems(){ Key="通讯Cmp逆变器温度",Text="通讯Cmp逆变器温度"}, + new CbxItems(){ Key="通讯Cmp相电流",Text="通讯Cmp相电流"}, + new CbxItems(){ Key="通讯Cmp功率",Text="通讯Cmp功率"}, + new CbxItems(){ Key="通讯Cmp芯片温度",Text="通讯Cmp芯片温度"}, + new CbxItems(){ Key="通讯PTC入水温度",Text="通讯PTC入水温度"}, + new CbxItems(){ Key="通讯PTC出水温度",Text="通讯PTC出水温度"}, + new CbxItems(){ Key="通讯PTC峰值电流",Text="通讯PTC峰值电流"}, + new CbxItems(){ Key="通讯PTC母线电流",Text="通讯PTC母线电流"}, + new CbxItems(){ Key="通讯PTC膜温",Text="通讯PTC膜温"}, + new CbxItems(){ Key="通讯PTC模块温度",Text="通讯PTC模块温度"}, + }; + + IsEditable = true; + } + + /// + /// 是否允许编辑（由调用方根据 Active/打开状态决定）。 + /// + public bool IsEditable { get; private set; } + + /// + /// 逻辑规则集合（下拉框 ItemsSource）。 + /// + public IReadOnlyList LogicRuleDtos => _logicRuleService.LogicRuleDtos; + + /// + /// 写入配置“名称”下拉框集合（参考 CANConfigViewModel）。 + /// + public ObservableCollection WriteNameCbxItems { get; private set; } + + /// + /// 读取配置“名称”下拉框集合（参考 CANConfigViewModel）。 + /// + public ObservableCollection ReadNameCbxItems { get; private set; } + + /// + /// 写入配置集合。 + /// + public ObservableCollection WriteConfigs { get; private set; } + + /// + /// 读取配置集合。 + /// + public ObservableCollection ReadConfigs { get; private set; } + + /// + /// 信号候选集合（右侧池）。 + /// + public ObservableCollection SignalCandidates { get; private set; } + + /// + /// 信号树（按帧分组）。 + /// + public ObservableCollection SignalTree { get; private set; } + + /// + /// 候选信号视图（含过滤）。 + /// + public ICollectionView SignalCandidatesView { get; private set; } + + private string? _signalFilterText; + + /// + /// 信号过滤文本（按 MsgName/SignalName/Name/Desc 匹配）。 + /// + public string? SignalFilterText + { + get { return _signalFilterText; } + set + { + _signalFilterText = value; + RaisePropertyChanged(); + SignalCandidatesView.Refresh(); + RebuildSignalTree(); + } + } + + /// + /// 当前选中的候选信号。 + /// + public SignalCandidate? SelectedSignalCandidate { get; set; } + + /// + /// 当前选中的写入配置行。 + /// + public CanLinRWConfigDto? SelectedWriteConfig { get; set; } + + private DelegateCommand? _addCycleTimeSch; + + /// + /// 将当前选中的写入配置对应的报文加入“硬件定时调度表”（ZLG auto_send）。 + /// + /// + /// 说明： + /// - 调度表按“报文/帧（MsgFrameName）”维度配置；同一报文可包含多个写入信号，但调度表只需要一条。 + /// - 该命令会直接落库到 ，随后由主界面刷新配置程序时加载显示。 + /// + public DelegateCommand AddCycleTimeSch => _addCycleTimeSch ??= new DelegateCommand(AddCycleTimeSchMethod); + + /// + /// 加入定时调度表命令处理。 + /// + private void AddCycleTimeSchMethod() + { + if (!EnableHardwareCycleSchedule) + { + MessageBox.Show("当前模式不支持加入硬件定时调度表（LIN 使用软件调度表）", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (!IsEditable) + { + MessageBox.Show("当前状态禁止修改", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (_canLinConfigProId <= 0) + { + MessageBox.Show("配置程序ID无效，无法加入调度表", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (SelectedWriteConfig == null) + { + MessageBox.Show("请先选中写入配置中的一行", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (string.IsNullOrWhiteSpace(SelectedWriteConfig.MsgFrameName)) + { + MessageBox.Show("写入配置的【消息名称】为空，无法加入调度表", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + var msgName = SelectedWriteConfig.MsgFrameName.Trim(); + + try + { + var exists = UseCanFdSchedule + ? _freeSql.Select() + .Where(a => a.CanLinConfigProId == _canLinConfigProId) + .Where(a => a.MsgName == msgName) + .Any() + : _freeSql.Select() + .Where(a => a.CanLinConfigProId == _canLinConfigProId) + .Where(a => a.MsgName == msgName) + .Any(); + + if (exists) + { + MessageBox.Show($"该报文已在定时调度表中：{msgName}", "提示", MessageBoxButton.OK, MessageBoxImage.Information); + return; + } + + if (UseCanFdSchedule) + { + _freeSql.Insert(new CANFdScheduleConfig + { + CanLinConfigProId = _canLinConfigProId, + MsgName = msgName, + Cycle = 100, + OrderSend = 1, + SchTabIndex = 0, + }).ExecuteAffrows(); + } + else + { + _freeSql.Insert(new CANScheduleConfig + { + CanLinConfigProId = _canLinConfigProId, + MsgName = msgName, + Cycle = 100, + OrderSend = 1, + SchTabIndex = 0, + }).ExecuteAffrows(); + } + + MessageBox.Show($"已加入定时调度表：{msgName}（默认周期 100ms，可在调度表中修改）", "提示", MessageBoxButton.OK, MessageBoxImage.Information); + } + catch (Exception ex) + { + _logService.Error($"加入定时调度表失败：{msgName}，{ex}"); + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + } + + /// + /// 当前选中的读取配置行。 + /// + public CanLinRWConfigDto? SelectedReadConfig { get; set; } + + private DelegateCommand? _signalTreeSelectionChangedCmd; + + /// + /// 右侧信号树选中变化（仅当选中叶子节点时回写 SelectedSignalCandidate）。 + /// + public DelegateCommand SignalTreeSelectionChangedCmd => + _signalTreeSelectionChangedCmd ??= new DelegateCommand(SignalTreeSelectionChangedCmdMethod); + + private void SignalTreeSelectionChangedCmdMethod(object par) + { + if (par is SignalCandidate leaf) + { + SelectedSignalCandidate = leaf; + RaisePropertyChanged(nameof(SelectedSignalCandidate)); + return; + } + + if (par is SignalFrameNode) + { + // 选中父节点时不变更 SelectedSignalCandidate + return; + } + } + + private DelegateCommand? _addToWriteCmd; + + /// + /// 将右侧选中信号添加到写入配置。 + /// + public DelegateCommand AddToWriteCmd => _addToWriteCmd ??= new DelegateCommand(AddToWriteCmdMethod); + + private void AddToWriteCmdMethod() + { + if (!IsEditable) + { + MessageBox.Show("当前状态禁止修改", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (SelectedSignalCandidate == null) + { + MessageBox.Show("请先在右侧信号集合中选中一条", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (string.IsNullOrWhiteSpace(SelectedSignalCandidate.SignalName) || string.IsNullOrWhiteSpace(SelectedSignalCandidate.MsgName)) + { + MessageBox.Show("选中的信号数据不完整（MsgName/SignalName 为空）", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (WriteConfigs.Any(a => string.Equals(a.SignalName, SelectedSignalCandidate.SignalName, StringComparison.Ordinal) && a.RWInfo == RW.Write)) + { + MessageBox.Show("该信号已在写入配置中，无需重复添加", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (ReadConfigs.Any(a => string.Equals(a.SignalName, SelectedSignalCandidate.SignalName, StringComparison.Ordinal) && a.RWInfo == RW.Read)) + { + MessageBox.Show("该信号已在读取配置中，同一个信号不允许同时配置为写入与读取", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + WriteConfigs.Add(new CanLinRWConfigDto + { + Id = 0, + RWInfo = RW.Write, + Name = string.IsNullOrWhiteSpace(SelectedSignalCandidate.Name) ? SelectedSignalCandidate.SignalName : SelectedSignalCandidate.Name, + MsgFrameName = SelectedSignalCandidate.MsgName, + SignalName = SelectedSignalCandidate.SignalName, + DefautValue = "0", + LogicRuleId = 0, + }); + + RebuildSignalTree(); + } + + private DelegateCommand? _addToReadCmd; + + /// + /// 将右侧选中信号添加到读取配置。 + /// + public DelegateCommand AddToReadCmd => _addToReadCmd ??= new DelegateCommand(AddToReadCmdMethod); + + private void AddToReadCmdMethod() + { + if (!IsEditable) + { + MessageBox.Show("当前状态禁止修改", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (SelectedSignalCandidate == null) + { + MessageBox.Show("请先在右侧信号集合中选中一条", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (string.IsNullOrWhiteSpace(SelectedSignalCandidate.SignalName) || string.IsNullOrWhiteSpace(SelectedSignalCandidate.MsgName)) + { + MessageBox.Show("选中的信号数据不完整（MsgName/SignalName 为空）", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (ReadConfigs.Any(a => string.Equals(a.SignalName, SelectedSignalCandidate.SignalName, StringComparison.Ordinal) && a.RWInfo == RW.Read)) + { + MessageBox.Show("该信号已在读取配置中，无需重复添加", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (WriteConfigs.Any(a => string.Equals(a.SignalName, SelectedSignalCandidate.SignalName, StringComparison.Ordinal) && a.RWInfo == RW.Write)) + { + MessageBox.Show("该信号已在写入配置中，同一个信号不允许同时配置为写入与读取", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + ReadConfigs.Add(new CanLinRWConfigDto + { + Id = 0, + RWInfo = RW.Read, + Name = string.IsNullOrWhiteSpace(SelectedSignalCandidate.Name) ? SelectedSignalCandidate.SignalName : SelectedSignalCandidate.Name, + MsgFrameName = SelectedSignalCandidate.MsgName, + SignalName = SelectedSignalCandidate.SignalName, + DefautValue = "0", + LogicRuleId = 0, + }); + + RebuildSignalTree(); + } + + private DelegateCommand? _removeWriteCmd; + + /// + /// 从写入配置移除当前选中行。 + /// + public DelegateCommand RemoveWriteCmd => _removeWriteCmd ??= new DelegateCommand(RemoveWriteCmdMethod); + + private void RemoveWriteCmdMethod() + { + if (!IsEditable) + { + MessageBox.Show("当前状态禁止修改", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (SelectedWriteConfig == null) + { + MessageBox.Show("请先选中写入列表中的一行", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + WriteConfigs.Remove(SelectedWriteConfig); + SelectedWriteConfig = null; + RaisePropertyChanged(nameof(SelectedWriteConfig)); + + RebuildSignalTree(); + } + + private DelegateCommand? _removeReadCmd; + + /// + /// 从读取配置移除当前选中行。 + /// + public DelegateCommand RemoveReadCmd => _removeReadCmd ??= new DelegateCommand(RemoveReadCmdMethod); + + private void RemoveReadCmdMethod() + { + if (!IsEditable) + { + MessageBox.Show("当前状态禁止修改", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (SelectedReadConfig == null) + { + MessageBox.Show("请先选中读取列表中的一行", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + ReadConfigs.Remove(SelectedReadConfig); + SelectedReadConfig = null; + RaisePropertyChanged(nameof(SelectedReadConfig)); + + RebuildSignalTree(); + } + + private DelegateCommand? _saveCmd; + + /// + /// 保存并落库。 + /// + public DelegateCommand SaveCmd => _saveCmd ??= new DelegateCommand(SaveCmdMethod); + + private void SaveCmdMethod() + { + if (!IsEditable) + { + MessageBox.Show("当前状态禁止修改", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (_canLinConfigProId <= 0) + { + MessageBox.Show("配置程序ID无效，无法保存", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + try + { + PersistRwConfigs(); + + var pars = new DialogParameters + { + { "Saved", true } + }; + RaiseRequestClose(new DialogResult(ButtonResult.OK, pars)); + } + catch (Exception ex) + { + _logService.Error($"ZLG 读写设置保存失败：{ex}"); + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + } + + private DelegateCommand? _cancelCmd; + + /// + /// 取消。 + /// + public DelegateCommand CancelCmd => _cancelCmd ??= new DelegateCommand(CancelCmdMethod); + + private void CancelCmdMethod() + { + RaiseRequestClose(new DialogResult(ButtonResult.Cancel)); + } + + /// + /// 弹窗打开时接收参数。 + /// + /// 参数。 + public override void OnDialogOpened(IDialogParameters parameters) + { + _canLinConfigProId = parameters.GetValue("CanLinConfigProId"); + + EnableHardwareCycleSchedule = parameters.ContainsKey("EnableHardwareCycleSchedule") + ? parameters.GetValue("EnableHardwareCycleSchedule") + : true; + + // 兼容参数命名：调用方传入的 key 为 "IsCanFdSchedule"。 + UseCanFdSchedule = parameters.ContainsKey("IsCanFdSchedule") + ? parameters.GetValue("IsCanFdSchedule") + : false; + + IsEditable = parameters.ContainsKey("IsEditable") ? parameters.GetValue("IsEditable") : true; + RaisePropertyChanged(nameof(IsEditable)); + RaisePropertyChanged(nameof(CanAddCycleTimeSch)); + + if (parameters.ContainsKey("WriteConfigs")) + { + var list = parameters.GetValue>("WriteConfigs") ?? new ObservableCollection(); + WriteConfigs = list; + RaisePropertyChanged(nameof(WriteConfigs)); + } + + if (parameters.ContainsKey("ReadConfigs")) + { + var list = parameters.GetValue>("ReadConfigs") ?? new ObservableCollection(); + ReadConfigs = list; + RaisePropertyChanged(nameof(ReadConfigs)); + } + + if (parameters.ContainsKey("SignalCandidates")) + { + var list = parameters.GetValue>("SignalCandidates") ?? new ObservableCollection(); + SignalCandidates = list; + RaisePropertyChanged(nameof(SignalCandidates)); + + SignalCandidatesView = CollectionViewSource.GetDefaultView(SignalCandidates); + SignalCandidatesView.Filter = FilterSignalCandidate; + RaisePropertyChanged(nameof(SignalCandidatesView)); + } + + RebuildSignalTree(); + + if (parameters.ContainsKey("Title")) + { + Title = parameters.GetValue("Title") ?? Title; + } + } + + private bool FilterSignalCandidate(object obj) + { + if (obj is not SignalCandidate item) + { + return false; + } + + if (string.IsNullOrWhiteSpace(SignalFilterText)) + { + return true; + } + + var key = SignalFilterText.Trim(); + + return ContainsIgnoreCase(item.MsgName, key) + || ContainsIgnoreCase(item.SignalName, key) + || ContainsIgnoreCase(item.Name, key) + || ContainsIgnoreCase(item.Desc, key); + } + + private void RebuildSignalTree() + { + // 依据过滤条件 + 全量候选池生成树。 + // 树数据源独立于 ICollectionView，避免 TreeView 过滤复杂度。 + var filtered = SignalCandidates + .Where(a => FilterSignalCandidate(a)) + .ToList(); + + var groups = filtered + .GroupBy(a => string.IsNullOrWhiteSpace(a.MsgName) ? "(未命名帧)" : a.MsgName!.Trim(), StringComparer.Ordinal) + .OrderBy(a => a.Key, StringComparer.Ordinal) + .ToList(); + + SignalTree.Clear(); + foreach (var g in groups) + { + var signalNodes = g + .OrderBy(a => a.SignalName ?? string.Empty, StringComparer.Ordinal) + .ThenBy(a => a.Name ?? string.Empty, StringComparer.Ordinal) + .Select(a => new SignalCandidate + { + MsgName = a.MsgName, + SignalName = a.SignalName, + Name = a.Name, + Desc = a.Desc, + AddedInfo = ComputeAddedInfo(a), + }) + .ToList(); + + var node = new SignalFrameNode + { + FrameName = g.Key, + Signals = new ObservableCollection(signalNodes) + }; + SignalTree.Add(node); + } + + RaisePropertyChanged(nameof(SignalTree)); + } + + /// + /// 计算候选信号是否已被添加到写入/读取。 + /// 0=未添加，1=已添加到写入，2=已添加到读取，3=同时存在于写入与读取。 + /// + /// 候选信号。 + /// AddedInfo 标志值。 + private int ComputeAddedInfo(SignalCandidate candidate) + { + if (candidate == null || string.IsNullOrWhiteSpace(candidate.SignalName)) + { + return 0; + } + + var signal = candidate.SignalName; + var inWrite = WriteConfigs.Any(a => a.RWInfo == RW.Write && string.Equals(a.SignalName, signal, StringComparison.Ordinal)); + var inRead = ReadConfigs.Any(a => a.RWInfo == RW.Read && string.Equals(a.SignalName, signal, StringComparison.Ordinal)); + + if (inWrite && inRead) return 3; + if (inWrite) return 1; + if (inRead) return 2; + return 0; + } + + private static bool ContainsIgnoreCase(string? src, string key) + { + if (string.IsNullOrEmpty(src)) return false; + return src.IndexOf(key, StringComparison.OrdinalIgnoreCase) >= 0; + } + + private void PersistRwConfigs() + { + // 互斥约束：同一 SignalName 不允许同时出现在写入与读取 + EnsureNoWriteReadConflict(); + + // 规范化 DTO（空值/默认值防御） + NormalizeRwConfigs(WriteConfigs, RW.Write); + NormalizeRwConfigs(ReadConfigs, RW.Read); + + // 防重复：同一 SignalName 在同一 RW 列表中只允许一条 + EnsureNoDuplicateSignal(WriteConfigs, RW.Write); + EnsureNoDuplicateSignal(ReadConfigs, RW.Read); + + var existing = _freeSql.Select() + .Where(a => a.CanLinConfigProId == _canLinConfigProId) + .Where(a => a.RWInfo == RW.Write || a.RWInfo == RW.Read) + .ToList(); + + var desiredWrite = WriteConfigs + .Where(a => !string.IsNullOrWhiteSpace(a.SignalName)) + .Select(a => new DesiredItem(RW.Write, a.SignalName!, a)) + .ToList(); + + var desiredRead = ReadConfigs + .Where(a => !string.IsNullOrWhiteSpace(a.SignalName)) + .Select(a => new DesiredItem(RW.Read, a.SignalName!, a)) + .ToList(); + + var desiredAll = desiredWrite.Concat(desiredRead).ToList(); + + // 以 (RWInfo + SignalName) 作为“业务主键”对齐数据库： + // - desiredKeySet：本次保存期望存在的 key 集合 + // - existingByKey：当前数据库已存在的 key -> 实体 + var desiredKeySet = new HashSet(desiredAll.Select(a => BuildKey(a.Rw, a.SignalName)), StringComparer.Ordinal); + var existingByKey = existing.ToDictionary(a => BuildKey(a.RWInfo, a.SignalName ?? string.Empty), a => a, StringComparer.Ordinal); + + // 删除：DB 中存在，但目标集合里不存在 + foreach (var old in existing) + { + var key = BuildKey(old.RWInfo, old.SignalName ?? string.Empty); + if (!desiredKeySet.Contains(key)) + { + // 保持与 UI 一致：用户在弹窗中移除的项，需要同步删除数据库记录。 + _freeSql.Delete(old.Id).ExecuteAffrows(); + } + } + + // Upsert：按 key（RWInfo + SignalName）更新或插入 + foreach (var item in desiredAll) + { + var key = BuildKey(item.Rw, item.SignalName); + if (existingByKey.TryGetValue(key, out var old)) + { + _freeSql.Update(old.Id) + .Set(a => a.Name, item.Dto.Name) + .Set(a => a.MsgFrameName, item.Dto.MsgFrameName) + .Set(a => a.SignalName, item.Dto.SignalName) + .Set(a => a.DefautValue, item.Dto.DefautValue) + .Set(a => a.LogicRuleId, item.Dto.LogicRuleId) + .ExecuteAffrows(); + } + else + { + _freeSql.Insert(new CanLinRWConfig + { + CanLinConfigProId = _canLinConfigProId, + RWInfo = item.Rw, + Name = item.Dto.Name, + MsgFrameName = item.Dto.MsgFrameName, + SignalName = item.Dto.SignalName, + DefautValue = item.Dto.DefautValue, + LogicRuleId = item.Dto.LogicRuleId, + }).ExecuteAffrows(); + } + } + } + + private static void NormalizeRwConfigs(IEnumerable list, RW rw) + { + foreach (var item in list) + { + item.RWInfo = rw; + if (string.IsNullOrWhiteSpace(item.SignalName)) + { + continue; + } + + if (string.IsNullOrWhiteSpace(item.Name)) + { + item.Name = item.SignalName; + } + + if (string.IsNullOrWhiteSpace(item.MsgFrameName)) + { + item.MsgFrameName = string.Empty; + } + + if (string.IsNullOrWhiteSpace(item.DefautValue)) + { + item.DefautValue = "0"; + } + + if (item.LogicRuleId < 0) + { + item.LogicRuleId = 0; + } + } + } + + private static void EnsureNoDuplicateSignal(IEnumerable list, RW rw) + { + var duplicates = list + .Where(a => !string.IsNullOrWhiteSpace(a.SignalName)) + .GroupBy(a => a.SignalName!, StringComparer.Ordinal) + .Where(g => g.Count() > 1) + .Select(g => g.Key) + .ToList(); + + if (duplicates.Count > 0) + { + throw new InvalidOperationException($"{rw} 配置中存在重复信号：{string.Join(",", duplicates)}"); + } + } + + private void EnsureNoWriteReadConflict() + { + var writeSet = new HashSet( + WriteConfigs + .Where(a => a.RWInfo == RW.Write) + .Select(a => a.SignalName) + .Where(a => !string.IsNullOrWhiteSpace(a)) + .Select(a => a!), + StringComparer.Ordinal); + + var readSet = new HashSet( + ReadConfigs + .Where(a => a.RWInfo == RW.Read) + .Select(a => a.SignalName) + .Where(a => !string.IsNullOrWhiteSpace(a)) + .Select(a => a!), + StringComparer.Ordinal); + + writeSet.IntersectWith(readSet); + if (writeSet.Count > 0) + { + throw new InvalidOperationException($"同一信号不允许同时配置为写入与读取，冲突信号：{string.Join(",", writeSet)}"); + } + } + + private static string BuildKey(RW rw, string signalName) + { + return $"{(int)rw}:{signalName}"; + } + + private readonly struct DesiredItem + { + /// + /// 读写类型。 + /// + public RW Rw { get; } + + /// + /// 信号名称。 + /// + public string SignalName { get; } + + /// + /// 原始 DTO。 + /// + public CanLinRWConfigDto Dto { get; } + + public DesiredItem(RW rw, string signalName, CanLinRWConfigDto dto) + { + Rw = rw; + SignalName = signalName; + Dto = dto; + } + } + + /// + /// 右侧信号候选项。 + /// + public class SignalCandidate + { + /// + /// 消息名称/帧名称。 + /// + public string? MsgName { get; set; } + + /// + /// 信号名称。 + /// + public string? SignalName { get; set; } + + /// + /// 配置名称（若解析层已有中文名则传入）。 + /// + public string? Name { get; set; } + + /// + /// 描述。 + /// + public string? Desc { get; set; } + + /// + /// 已添加标记。 + /// 0=未添加，1=已添加到写入，2=已添加到读取，3=同时存在于写入与读取。 + /// + public int AddedInfo { get; set; } + } + + /// + /// 帧节点。 + /// + public class SignalFrameNode + { + /// + /// 帧名。 + /// + public string FrameName { get; set; } = string.Empty; + + /// + /// 帧内信号集合。 + /// + public ObservableCollection Signals { get; set; } = new ObservableCollection(); + } + } +} diff --git a/CapMachine.Wpf/ViewModels/LinConfigViewModel.cs b/CapMachine.Wpf/ViewModels/LinConfigViewModel.cs index 6524712..336df1a 100644 --- a/CapMachine.Wpf/ViewModels/LinConfigViewModel.cs +++ b/CapMachine.Wpf/ViewModels/LinConfigViewModel.cs @@ -1,9 +1,10 @@ -using AutoMapper; +using AutoMapper; using CapMachine.Core; using CapMachine.Model.CANLIN; using CapMachine.Wpf.CanDrive; using CapMachine.Wpf.Dtos; using CapMachine.Wpf.LinDrive; +using CapMachine.Wpf.PrismEvent; using CapMachine.Wpf.Services; using Prism.Commands; using Prism.Events; @@ -55,8 +56,6 @@ namespace CapMachine.Wpf.ViewModels //MachineDataService = machineDataService; DialogService = dialogService; - - EventAggregator.GetEvent().Subscribe(LogicRuleChangeEventCall); EventAggregator.GetEvent().Subscribe(CanLinConfigChangedEventCall); //数据波特率 @@ -148,12 +147,13 @@ namespace CapMachine.Wpf.ViewModels } /// - /// CAN/LIN配置变更事件处理 + /// CAN/LIN 配置导入后刷新当前页面。 /// - /// + /// 事件消息。 private void CanLinConfigChangedEventCall(string msg) { - RefreshConfigList(); + InitLoadLinConfigPro(); + InitWriteRuleCbx(); } /// diff --git a/CapMachine.Wpf/ViewModels/ZlgCanDriveConfigViewModel.cs b/CapMachine.Wpf/ViewModels/ZlgCanDriveConfigViewModel.cs new file mode 100644 index 0000000..57efe98 --- /dev/null +++ b/CapMachine.Wpf/ViewModels/ZlgCanDriveConfigViewModel.cs @@ -0,0 +1,2684 @@ +using AutoMapper; +using CapMachine.Core; +using CapMachine.Model.CANLIN; +using CapMachine.Wpf.CanDrive; +using CapMachine.Wpf.Dtos; +using CapMachine.Wpf.PrismEvent; +using CapMachine.Wpf.Services; +using CapMachine.Wpf.Views; +using ImTools; +using Microsoft.Win32; +using Prism.Commands; +using Prism.Events; +using Prism.Regions; +using Prism.Services.Dialogs; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.IO; +using System.Linq; +using System.Windows; +using System.Windows.Controls; +using static CapMachine.Wpf.Models.ComEnum; + +namespace CapMachine.Wpf.ViewModels +{ + /// + /// ZLG CAN/CANFD 合并配置 ViewModel（模式切换：单选）。 + /// + /// + /// 该 ViewModel 负责 ZLG CAN/CANFD 的 UI 配置与用户交互编排，典型职责包括： + /// - 打开/关闭设备、切换模式（CAN/CANFD），并与 同步状态； + /// - 加载 DBC 并维护可绑定的信号集合（用于读写设置与实时显示）； + /// - 管理“读写设置”弹窗的数据准备与回写（写入/读取规则、信号候选集合）； + /// - 管理调度表/循环发送相关 UI 状态（软件调度 vs 硬件 auto_send 的选择由 Service/Driver 实现）。 + /// + /// 线程说明： + /// - 本类绝大多数方法由 UI 线程调用； + /// - Driver 接收线程产生的数据更新事件若需要影响 UI，应通过属性通知或 Dispatcher 进行线程切换（具体由 Service/Driver 侧处理）。 + /// + public class ZlgCanDriveConfigViewModel : NavigationViewModel + { + /// + /// 构造函数。 + /// + /// Prism 弹窗服务，用于打开读写设置等对话框。 + /// 数据访问组件，用于读取/保存配置程序与读写配置等持久化数据。 + /// 事件聚合器，用于跨模块消息通知（如状态变化/日志等）。 + /// 区域导航服务，用于页面/视图切换。 + /// 系统运行服务（与全局运行态/权限等相关）。 + /// 通信互斥控制服务，用于保证 CAN/LIN 等通道操作的互斥与安全。 + /// 日志服务，用于输出 UI 层操作过程与异常。 + /// 逻辑规则服务，为“写入规则/触发规则”下拉框提供数据源。 + /// 配置服务，用于读取/应用系统配置参数。 + /// ZLG CAN/CANFD 服务层，负责驱动生命周期、DBC、发送/调度表编排。 + /// ZLG LIN 服务层，用于互斥判断或组合配置场景。 + /// 对象映射器，用于 DTO/实体之间转换。 + /// + /// 构造时会初始化： + /// - 波特率下拉数据源； + /// - 写入规则下拉数据源； + /// - CAN 配置程序列表（用于 UI 选择）。 + /// + /// 注意：构造函数仅做“数据源初始化与依赖注入”，不会直接打开设备。 + /// + public ZlgCanDriveConfigViewModel(IDialogService dialogService, IFreeSql freeSql, + IEventAggregator eventAggregator, IRegionManager regionManager, SysRunService sysRunService, + ComActionService comActionService, ILogService logService, LogicRuleService logicRuleService, + ConfigService configService, ZlgCanDriveService zlgCanDriveService, ZlgLinDriveService zlgLinDriveService, + IMapper mapper) + { + DialogService = dialogService; + FreeSql = freeSql; + EventAggregator = eventAggregator; + RegionManager = regionManager; + SysRunService = sysRunService; + ComActionService = comActionService; + LogService = logService; + LogicRuleService = logicRuleService; + ConfigService = configService; + ZlgCanDriveService = zlgCanDriveService; + ZlgLinDriveService = zlgLinDriveService; + Mapper = mapper; + EventAggregator.GetEvent().Subscribe(CanLinConfigChangedEventCall); + + SelectedMode = ZlgCanMode.Can; + + ArbBaudRateCbxItems = new ObservableCollection() + { + new CbxItems(){ Key="10000",Text="10 Kbps"}, + new CbxItems(){ Key="20000",Text="20 Kbps"}, + new CbxItems(){ Key="33000",Text="33 Kbps"}, + new CbxItems(){ Key="50000",Text="50 Kbps"}, + new CbxItems(){ Key="83000",Text="83 Kbps"}, + new CbxItems(){ Key="100000",Text="100 Kbps"}, + new CbxItems(){ Key="125000",Text="125 Kbps"}, + new CbxItems(){ Key="150000",Text="150 Kbps"}, + new CbxItems(){ Key="200000",Text="200 Kbps"}, + new CbxItems(){ Key="250000",Text="250 Kbps"}, + new CbxItems(){ Key="300000",Text="300 Kbps"}, + new CbxItems(){ Key="400000",Text="400 Kbps"}, + new CbxItems(){ Key="500000",Text="500 Kbps"}, + new CbxItems(){ Key="666000",Text="666 Kbps"}, + new CbxItems(){ Key="800000",Text="800 Kbps"}, + new CbxItems(){ Key="1000000",Text="1.0 Mbps"}, + }; + + DataBaudRateCbxItems = new ObservableCollection() + { + new CbxItems(){ Key="100000",Text="100 Kbps"}, + new CbxItems(){ Key="125000",Text="125 Kbps"}, + new CbxItems(){ Key="200000",Text="200 Kbps"}, + new CbxItems(){ Key="250000",Text="250 Kbps"}, + new CbxItems(){ Key="400000",Text="400 Kbps"}, + new CbxItems(){ Key="500000",Text="500 Kbps"}, + new CbxItems(){ Key="666000",Text="666 Kbps"}, + new CbxItems(){ Key="800000",Text="800 Kbps"}, + new CbxItems(){ Key="1000000",Text="1.0 Mbps"}, + + new CbxItems(){ Key="1500000",Text="1.5 Mbps"}, + new CbxItems(){ Key="2000000",Text="2.0 Mbps"}, + new CbxItems(){ Key="3000000",Text="3.0 Mbps"}, + new CbxItems(){ Key="4000000",Text="4.0 Mbps"}, + new CbxItems(){ Key="5000000",Text="5.0 Mbps"}, + new CbxItems(){ Key="6700000",Text="6.7 Mbps"}, + new CbxItems(){ Key="8000000",Text="8.0 Mbps"}, + new CbxItems(){ Key="10000000",Text="10.0 Mbps"}, + }; + + InitWriteRuleCbx(); + + InitLoadCanConfigPro(); + } + + /// + /// CAN/LIN 配置导入后刷新当前页面。 + /// + /// 事件消息。 + private void CanLinConfigChangedEventCall(string msg) + { + InitWriteRuleCbx(); + ReloadCurrentConfigPro(); + } + + /// + /// 初始化“写入规则”下拉框数据源。 + /// + /// + /// 数据源来自 。 + /// - Key：规则 Id + /// - Text：规则名称 + /// + /// 该集合通常被“读写设置”弹窗中的 ComboBox 绑定使用。 + /// + private void InitWriteRuleCbx() + { + WriteRuleCbxItems = new ObservableCollection(); + foreach (var itemRule in LogicRuleService.LogicRuleDtos) + { + WriteRuleCbxItems.Add(new CbxItems() + { + Key = itemRule.Id.ToString(), + Text = itemRule.Name + }); + } + } + + /// + /// 打开“读写设置”弹窗。 + /// + /// + /// 弹窗数据准备流程： + /// - 基于当前页面的 / 克隆出可编辑副本； + /// - 根据 构建信号候选集合（MsgName/SignalName/描述等）； + /// - 通过 打开 DialogZlgCanLinRwConfigView； + /// - 用户点击 OK 后回调中调用 ReloadCurrentConfigPro 刷新当前配置并提示。 + /// + /// 前置条件： + /// - 必须先选择配置程序（ 不为 null）。 + /// - 推荐调用方在进入本方法前确保已连接设备且 DBC 已加载，否则候选信号集合可能为空。 + /// + private void OpenRwDialog() + { + try + { + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中CAN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + var writeClones = new ObservableCollection( + (ListWriteCanLinRWConfigDto ?? new ObservableCollection()) + .Select(CloneRwDto)); + + foreach (var item in writeClones) + { + item.RWInfo = RW.Write; + } + + var readClones = new ObservableCollection( + (ListReadCanLinRWConfigDto ?? new ObservableCollection()) + .Select(CloneRwDto)); + + foreach (var item in readClones) + { + item.RWInfo = RW.Read; + } + + var candidates = new ObservableCollection(); + if (ListCanDbcModel != null) + { + foreach (var sig in ListCanDbcModel) + { + candidates.Add(new DialogZlgCanLinRwConfigViewModel.SignalCandidate + { + MsgName = sig.MsgName, + SignalName = sig.SignalName, + Name = sig.Name, + Desc = sig.SignalDesc, + }); + } + } + + var pars = new DialogParameters + { + { "Title", "读写设置" }, + { "CanLinConfigProId", SelectCanLinConfigPro.Id }, + { "IsEditable", IsRwEditable }, + { "IsCanFdSchedule", SelectedMode == ZlgCanMode.CanFd }, + { "WriteConfigs", writeClones }, + { "ReadConfigs", readClones }, + { "SignalCandidates", candidates }, + }; + + DialogService.ShowDialog(nameof(DialogZlgCanLinRwConfigView), pars, r => + { + if (r.Result == ButtonResult.OK) + { + ReloadCurrentConfigPro(); + OpTip = "读写设置已保存"; + } + }); + } + catch (Exception ex) + { + LogService.Error($"ZLG 打开读写设置弹窗失败：{ex}"); + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + } + + /// + /// 克隆一个读写配置 DTO。 + /// + /// 源对象。 + /// 新实例（字段逐个复制）。 + /// + /// 目的： + /// - 弹窗编辑时不直接修改页面当前集合，避免用户取消时污染原始配置； + /// - 用户确认（OK）后再由弹窗 ViewModel 负责持久化，页面侧随后通过 Reload 刷新。 + /// + private static CanLinRWConfigDto CloneRwDto(CanLinRWConfigDto src) + { + return new CanLinRWConfigDto + { + Id = src.Id, + RWInfo = src.RWInfo, + Name = src.Name, + MsgFrameName = src.MsgFrameName, + SignalName = src.SignalName, + DefautValue = src.DefautValue, + LogicRuleId = src.LogicRuleId, + LogicRuleDto = src.LogicRuleDto, + }; + } + + /// + /// Dialog 服务。 + /// + public IDialogService DialogService { get; } + + /// + /// FreeSql。 + /// + public IFreeSql FreeSql { get; } + + /// + /// 事件聚合。 + /// + public IEventAggregator EventAggregator { get; } + + /// + /// 区域导航。 + /// + public IRegionManager RegionManager { get; } + + /// + /// 系统运行服务。 + /// + public SysRunService SysRunService { get; } + + /// + /// 通信互斥控制。 + /// + public ComActionService ComActionService { get; } + + /// + /// 日志。 + /// + public ILogService LogService { get; } + + /// + /// 逻辑规则服务。 + /// + public LogicRuleService LogicRuleService { get; } + + /// + /// 配置服务。 + /// + public ConfigService ConfigService { get; } + + /// + /// ZLG CAN 服务。 + /// + public ZlgCanDriveService ZlgCanDriveService { get; } + + /// + /// ZLG LIN 服务（用于互斥判断）。 + /// + public ZlgLinDriveService ZlgLinDriveService { get; } + + /// + /// Mapper。 + /// + public IMapper Mapper { get; } + + /// + /// 的 backing 字段。 + /// + private ObservableCollection _arbBaudRateCbxItems = new ObservableCollection(); + /// + /// 仲裁波特率下拉项（bps）。 + /// + public ObservableCollection ArbBaudRateCbxItems + { + get { return _arbBaudRateCbxItems; } + set { _arbBaudRateCbxItems = value; RaisePropertyChanged(); } + } + + /// + /// 的 backing 字段。 + /// + private ObservableCollection _dataBaudRateCbxItems = new ObservableCollection(); + /// + /// 数据波特率下拉项（bps）。 + /// + public ObservableCollection DataBaudRateCbxItems + { + get { return _dataBaudRateCbxItems; } + set { _dataBaudRateCbxItems = value; RaisePropertyChanged(); } + } + + /// + /// 配置程序列表的本地缓存（数据库读取结果）。 + /// + /// + /// 与 的区别： + /// - 本字段用于保存从数据库一次性读取的实体列表； + /// - UI 绑定通常使用 （ObservableCollection）。 + /// + private List _canLinConfigPros = new List(); + + private ObservableCollection _writeRuleCbxItems = new ObservableCollection(); + /// + /// 写入规则下拉项（逻辑规则列表）。 + /// + /// + /// 该集合由 初始化，通常绑定到读写设置弹窗或列表编辑处的 ComboBox。 + /// + public ObservableCollection WriteRuleCbxItems + { + get { return _writeRuleCbxItems; } + set { _writeRuleCbxItems = value; RaisePropertyChanged(); } + } + + private ObservableCollection _listWriteCanLinRWConfigDto = new ObservableCollection(); + /// + /// 写入配置集合（绑定到写入 DataGrid）。 + /// + /// + /// 每条记录对应一个“写入信号”配置项，包含： + /// - MsgFrameName/SignalName：定位 DBC 信号 + /// - LogicRuleId：写入规则 + /// - DefautValue：默认写入值 + /// + /// 注意： + /// - 配置程序激活（ true）时应禁止编辑。 + /// - 读写互斥/重复校验主要在读写设置弹窗 ViewModel 中实现。 + /// + public ObservableCollection ListWriteCanLinRWConfigDto + { + get { return _listWriteCanLinRWConfigDto; } + set { _listWriteCanLinRWConfigDto = value; RaisePropertyChanged(); } + } + + private ObservableCollection _listReadCanLinRWConfigDto = new ObservableCollection(); + /// + /// 读取配置集合（绑定到读取 DataGrid）。 + /// + /// + /// 每条记录对应一个“读取信号”配置项，包含： + /// - MsgFrameName/SignalName：定位 DBC 信号 + /// - DefautValue：默认值/初始值（视业务语义而定） + /// + /// 读取配置通常用于“从接收帧解码后更新 UI/变量”的目标信号集合。 + /// + public ObservableCollection ListReadCanLinRWConfigDto + { + get { return _listReadCanLinRWConfigDto; } + set { _listReadCanLinRWConfigDto = value; RaisePropertyChanged(); } + } + + /// + /// 当前在写入 DataGrid 中选中的行。 + /// + /// + /// 用于 Delete 等操作定位目标记录。该属性不直接通知 UI（由 SelectionChanged 命令更新）。 + /// + private CanLinRWConfigDto? SelectedWriteCanLinRWConfigDto { get; set; } + + /// + /// 当前在读取 DataGrid 中选中的行。 + /// + /// + /// 用于 Delete 等操作定位目标记录。该属性不直接通知 UI（由 SelectionChanged 命令更新）。 + /// + private CanLinRWConfigDto? SelectedReadCanLinRWConfigDto { get; set; } + + private string? _opTip; + /// + /// 操作提示（用于 UI 状态展示）。 + /// + public string? OpTip + { + get { return _opTip; } + set { _opTip = value; RaisePropertyChanged(); } + } + + private string? _lastError; + /// + /// 最近一次错误信息（用于 UI 状态展示）。 + /// + public string? LastError + { + get { return _lastError; } + set { _lastError = value; RaisePropertyChanged(); } + } + + private bool _isCanConfigProActive; + /// + /// 当前配置程序是否已激活（对齐图莫斯 Active 语义）。 + /// 激活后禁止切换配置程序。 + /// + public bool IsCanConfigProActive + { + get { return _isCanConfigProActive; } + set + { + _isCanConfigProActive = value; + RaisePropertyChanged(); + RaisePropertyChanged(nameof(IsRwEditable)); + } + } + + public bool IsRwEditable + { + get { return !IsCanConfigProActive; } + } + + private bool _isCANConfigDatagridActive = true; + /// + /// 配置程序 DataGrid 是否可操作（与 IsCanConfigProActive 取反）。 + /// + public bool IsCANConfigDatagridActive + { + get { return _isCANConfigDatagridActive; } + set { _isCANConfigDatagridActive = value; RaisePropertyChanged(); } + } + + /// + /// 的 backing 字段。 + /// + private ZlgCanMode _selectedMode; + /// + /// 模式选择：CAN/CANFD（单选）。 + /// + public ZlgCanMode SelectedMode + { + get { return _selectedMode; } + set + { + // 打开状态下不允许切换模式，避免驱动状态错乱。 + if (ZlgCanDriveService.OpenState && _selectedMode != value) + { + MessageBox.Show("请先关闭 CAN 后再切换 CAN/CANFD 模式", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + RaisePropertyChanged(nameof(SelectedModeKey)); + return; + } + + _selectedMode = value; + RaisePropertyChanged(); + RaisePropertyChanged(nameof(SelectedModeKey)); + RaisePropertyChanged(nameof(IsCanMode)); + RaisePropertyChanged(nameof(IsCanFdMode)); + RaisePropertyChanged(nameof(DbcPathTitle)); + RaisePropertyChanged(nameof(ConnectButtonText)); + RaisePropertyChanged(nameof(CloseButtonText)); + RaisePropertyChanged(nameof(CurrentDbcPath)); + RaisePropertyChanged(nameof(CurrentCycle)); + RaisePropertyChanged(nameof(CurrentSchEnable)); + RaisePropertyChanged(nameof(CurrentArbBaudRate)); + RaisePropertyChanged(nameof(CurrentDataBaudRate)); + RaisePropertyChanged(nameof(CurrentISOEnable)); + RaisePropertyChanged(nameof(CurrentResEnable)); + RaisePropertyChanged(nameof(BaudRateTitle)); + RaisePropertyChanged(nameof(DataBaudRateTitle)); + ZlgCanDriveService.Mode = value; + + // 当用户手动切换 CAN/CANFD 时，如果当前配置缺少对应扩展 DTO，需要先生成默认 DTO， + // 否则界面控件无法编辑（setter 会因 DTO 为空直接 return）。 + if (SelectCanLinConfigPro != null) + { + if (value == ZlgCanMode.Can) + { + if (SelectedCANConfigExdDto == null) + { + SelectedCANConfigExdDto = new CANConfigExdDto() + { + Id = 0, + BaudRate = 500000, + DbcPath = string.Empty, + Cycle = 100, + SchEnable = false, + }; + } + } + else + { + if (SelectedCANFdConfigExdDto == null) + { + SelectedCANFdConfigExdDto = new CANFdConfigExdDto() + { + Id = 0, + ArbBaudRate = 500000, + DataBaudRate = 2000000, + ISOEnable = true, + ResEnable = false, + DbcPath = string.Empty, + Cycle = 100, + SchEnable = false, + }; + } + } + } + + // 切换模式后，为避免界面仍显示旧的 DBC 信号列表，清空信号集合。 + // 配置程序列表不应随模式切换而过滤/刷新。 + ListCanDbcModel = new ObservableCollection(); + } + } + + /// + /// 写入 DataGrid 选中项变化命令。 + /// + /// + /// 由 XAML 绑定到 SelectionChanged，用于把当前选中行同步到 。 + /// + private DelegateCommand? _writeGridSelectionChangedCmd; + /// + /// 写入 DataGrid 选中项变化命令（供 XAML 绑定）。 + /// + public DelegateCommand WriteGridSelectionChangedCmd + { + get + { + if (_writeGridSelectionChangedCmd == null) + { + _writeGridSelectionChangedCmd = new DelegateCommand(WriteGridSelectionChangedCmdMethod); + } + return _writeGridSelectionChangedCmd; + } + } + + /// + /// 写入 DataGrid SelectionChanged 命令处理。 + /// + /// 选中项（期望为 ）。 + private void WriteGridSelectionChangedCmdMethod(object par) + { + if (par is CanLinRWConfigDto dto) + { + SelectedWriteCanLinRWConfigDto = dto; + } + } + + /// + /// 读取 DataGrid 选中项变化命令。 + /// + /// + /// 由 XAML 绑定到 SelectionChanged，用于把当前选中行同步到 。 + /// + private DelegateCommand? _readGridSelectionChangedCmd; + /// + /// 读取 DataGrid 选中项变化命令（供 XAML 绑定）。 + /// + public DelegateCommand ReadGridSelectionChangedCmd + { + get + { + if (_readGridSelectionChangedCmd == null) + { + _readGridSelectionChangedCmd = new DelegateCommand(ReadGridSelectionChangedCmdMethod); + } + return _readGridSelectionChangedCmd; + } + } + + /// + /// 读取 DataGrid SelectionChanged 命令处理。 + /// + /// 选中项（期望为 ）。 + private void ReadGridSelectionChangedCmdMethod(object par) + { + if (par is CanLinRWConfigDto dto) + { + SelectedReadCanLinRWConfigDto = dto; + } + } + + /// + /// 写入配置操作命令（保存/删除）。 + /// + /// + /// 约定： + /// - "Edit"：把 DataGrid 中当前列表逐条更新到数据库； + /// - "Delete"：删除当前选中项。 + /// + private DelegateCommand? _writeCmd; + /// + /// 写入配置操作命令（供 XAML 绑定）。 + /// + public DelegateCommand WriteCmd + { + get + { + if (_writeCmd == null) + { + _writeCmd = new DelegateCommand(WriteCmdMethod); + } + return _writeCmd; + } + } + + /// + /// 写入配置操作命令处理。 + /// + /// 操作类型（"Edit"/"Delete"）。 + /// + /// 前置条件： + /// - 必须已选择配置程序（ 不为 null）； + /// - 若配置已激活（ true），禁止修改写入配置。 + /// + private void WriteCmdMethod(string par) + { + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中CAN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (IsCanConfigProActive) + { + MessageBox.Show("当前配置已激活，请先取消激活后再修改写入配置", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + switch (par) + { + case "Edit": + foreach (var item in ListWriteCanLinRWConfigDto) + { + FreeSql.Update(item.Id) + .Set(a => a.Name, item.Name) + .Set(a => a.LogicRuleId, item.LogicRuleId) + .Set(a => a.DefautValue, item.DefautValue) + .ExecuteAffrows(); + } + ReloadCurrentConfigPro(); + OpTip = "写入配置已保存"; + break; + + case "Delete": + if (SelectedWriteCanLinRWConfigDto == null) + { + MessageBox.Show("请选中写入列表中的一行后再删除", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + FreeSql.Delete(SelectedWriteCanLinRWConfigDto.Id).ExecuteAffrows(); + ReloadCurrentConfigPro(); + OpTip = "写入配置已删除"; + break; + } + } + + /// + /// 读取配置操作命令（保存/删除）。 + /// + /// + /// 约定： + /// - "Edit"：把 DataGrid 中当前列表逐条更新到数据库； + /// - "Delete"：删除当前选中项。 + /// + private DelegateCommand? _readCmd; + /// + /// 读取配置操作命令（供 XAML 绑定）。 + /// + public DelegateCommand ReadCmd + { + get + { + if (_readCmd == null) + { + _readCmd = new DelegateCommand(ReadCmdMethod); + } + return _readCmd; + } + } + + /// + /// 读取配置操作命令处理。 + /// + /// 操作类型（"Edit"/"Delete"）。 + /// + /// 前置条件： + /// - 必须已选择配置程序（ 不为 null）； + /// - 若配置已激活（ true），禁止修改读取配置。 + /// + private void ReadCmdMethod(string par) + { + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中CAN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (IsCanConfigProActive) + { + MessageBox.Show("当前配置已激活，请先取消激活后再修改读取配置", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + switch (par) + { + case "Edit": + foreach (var item in ListReadCanLinRWConfigDto) + { + FreeSql.Update(item.Id) + .Set(a => a.Name, item.Name) + .Set(a => a.DefautValue, item.DefautValue) + .ExecuteAffrows(); + } + ReloadCurrentConfigPro(); + OpTip = "读取配置已保存"; + break; + + case "Delete": + if (SelectedReadCanLinRWConfigDto == null) + { + MessageBox.Show("请选中读取列表中的一行后再删除", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + FreeSql.Delete(SelectedReadCanLinRWConfigDto.Id).ExecuteAffrows(); + ReloadCurrentConfigPro(); + OpTip = "读取配置已删除"; + break; + } + } + + /// + /// 连接按钮文字（对齐 Toomoss 风格）。 + /// + public string ConnectButtonText + { + get { return SelectedMode == ZlgCanMode.Can ? "连接CAN" : "连接CANFD"; } + } + + /// + /// 当前是否为 CANFD 模式（用于 UI 启用/禁用某些仅 CANFD 支持的参数）。 + /// + public bool IsCanFdMode + { + get { return SelectedMode == ZlgCanMode.CanFd; } + } + + /// + /// 当前是否为 CAN 模式（用于 UI 启用/禁用某些仅 CANFD 支持的参数）。 + /// + public bool IsCanMode + { + get { return SelectedMode == ZlgCanMode.Can; } + } + + /// + /// 波特率标题：CAN 为“波特率”，CANFD 为“仲裁波特率”。 + /// + public string BaudRateTitle + { + get { return SelectedMode == ZlgCanMode.Can ? "波特率" : "仲裁波特率"; } + } + + /// + /// 数据波特率标题：仅 CANFD 有意义。 + /// + public string DataBaudRateTitle + { + get { return "数据波特率"; } + } + + /// + /// 关闭按钮文字（对齐 Toomoss 风格）。 + /// + public string CloseButtonText + { + get { return SelectedMode == ZlgCanMode.Can ? "关闭CAN" : "关闭CANFD"; } + } + + /// + /// 绑定用：模式 Key（Can/CanFd）。 + /// + public string SelectedModeKey + { + get { return SelectedMode == ZlgCanMode.Can ? "Can" : "CanFd"; } + set + { + if (ZlgCanDriveService.OpenState) + { + MessageBox.Show("请先关闭 CAN 后再切换 CAN/CANFD 模式", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + RaisePropertyChanged(); + return; + } + + if (string.Equals(value, "Can", StringComparison.OrdinalIgnoreCase)) + { + SelectedMode = ZlgCanMode.Can; + return; + } + + if (string.Equals(value, "CanFd", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "CanFD", StringComparison.OrdinalIgnoreCase)) + { + SelectedMode = ZlgCanMode.CanFd; + return; + } + } + } + + /// + /// DBC 路径标题。 + /// + public string DbcPathTitle + { + get { return SelectedMode == ZlgCanMode.Can ? "CAN-DBC文件路径:" : "CANFD-DBC文件路径:"; } + } + + /// + /// 的 backing 字段。 + /// + private ObservableCollection? _listCanLinConfigPro; + /// + /// 配置程序集合。 + /// + public ObservableCollection? ListCanLinConfigPro + { + get { return _listCanLinConfigPro; } + set { _listCanLinConfigPro = value; RaisePropertyChanged(); } + } + + /// + /// 选中的配置程序。 + /// + private CanLinConfigPro? _selectCanLinConfigPro; + + /// + /// 选中的配置程序。 + /// + public CanLinConfigPro? SelectCanLinConfigPro + { + get { return _selectCanLinConfigPro; } + set + { + _selectCanLinConfigPro = value; + RaisePropertyChanged(); + } + } + + private ObservableCollection? _listCanDbcModel; + /// + /// DBC 信号集合。 + /// + public ObservableCollection? ListCanDbcModel + { + get { return _listCanDbcModel; } + set { _listCanDbcModel = value; RaisePropertyChanged(); } + } + + /// + /// 当前选中的 DBC 信号。 + /// + public CanDbcModel? SelectedCanDbcModel + { + get { return _selectedCanDbcModel; } + set { _selectedCanDbcModel = value; RaisePropertyChanged(); } + } + + private CanDbcModel? _selectedCanDbcModel; + + /// + /// 的 backing 字段。 + /// + private CANConfigExdDto? _selectedCANConfigExdDto; + /// + /// CAN 配置 DTO。 + /// + public CANConfigExdDto? SelectedCANConfigExdDto + { + get { return _selectedCANConfigExdDto; } + set { _selectedCANConfigExdDto = value; RaisePropertyChanged(); } + } + + /// + /// 的 backing 字段。 + /// + private CANFdConfigExdDto? _selectedCANFdConfigExdDto; + /// + /// CANFD 配置 DTO。 + /// + public CANFdConfigExdDto? SelectedCANFdConfigExdDto + { + get { return _selectedCANFdConfigExdDto; } + set { _selectedCANFdConfigExdDto = value; RaisePropertyChanged(); } + } + + /// + /// 从数据库加载 CAN/CANFD 配置程序列表。 + /// + /// + /// 加载内容包含： + /// - 主表 + /// - 扩展配置（CAN/CANFD） + /// - 读写配置项（包含逻辑规则） + /// - 调度表配置项（CAN/CANFD） + /// + /// 该方法会刷新本地缓存 与 UI 绑定集合 。 + /// + private void InitLoadCanConfigPro() + { + _canLinConfigPros = FreeSql.Select() + .Where(a => a.CANLINInfo == CANLIN.CAN || a.CANLINInfo == CANLIN.CANFD) + .Include(a => a.CANConfigExd) + .Include(a => a.CANFdConfigExd) + .IncludeMany(a => a.CanLinConfigContents, then => then.Include(b => b.LogicRule)) + .IncludeMany(a => a.CanScheduleConfigs) + .IncludeMany(a => a.CanFdScheduleConfigs) + .ToList(); + + ListCanLinConfigPro = new ObservableCollection(_canLinConfigPros); + } + + /// + /// 同步选中的配置。 + /// + /// + /// 当 UI 选中不同配置程序时，本方法会同步以下内容到 ViewModel： + /// - 根据配置程序的 CANLINInfo 自动切换 （避免右侧参数/DBC 显示与配置类型不一致）； + /// - 映射 CAN/CANFD 两套扩展 DTO（若不存在则为 null/默认）； + /// - 从配置内容构建读写配置 DTO 列表； + /// - 根据模式加载对应调度表集合； + /// - 构建并注入 CmdData 到 （事件驱动发送依赖）； + /// - 最后重置并尝试加载当前配置的 DBC 信号集合（未连接时也会尝试解析）。 + /// + /// 注意： + /// - 已连接或已激活时，外层命令会禁止切换配置程序；该方法通常只在允许切换时被调用。 + /// + private void SyncSelectedConfig() + { + if (SelectCanLinConfigPro == null) + { + return; + } + + // 选中配置程序后，模式应跟随该配置自身的 CANLINInfo，避免“列表全量但右侧模式不匹配”。 + var proMode = SelectCanLinConfigPro.CANLINInfo == CANLIN.CAN ? ZlgCanMode.Can : ZlgCanMode.CanFd; + if (SelectedMode != proMode) + { + SelectedMode = proMode; + } + + // 同时映射两套配置（如不存在则为 null），这样用户可以在 UI 上切换模式后再保存。 + SelectedCANConfigExdDto = SelectCanLinConfigPro.CANConfigExd != null + ? Mapper.Map(SelectCanLinConfigPro.CANConfigExd) + : null; + SelectedCANFdConfigExdDto = SelectCanLinConfigPro.CANFdConfigExd != null + ? Mapper.Map(SelectCanLinConfigPro.CANFdConfigExd) + : null; + + RaisePropertyChanged(nameof(CurrentDbcPath)); + RaisePropertyChanged(nameof(CurrentCycle)); + RaisePropertyChanged(nameof(CurrentSchEnable)); + RaisePropertyChanged(nameof(CurrentArbBaudRate)); + RaisePropertyChanged(nameof(CurrentDataBaudRate)); + RaisePropertyChanged(nameof(CurrentISOEnable)); + RaisePropertyChanged(nameof(CurrentResEnable)); + RaisePropertyChanged(nameof(CanBaudRate)); + RaisePropertyChanged(nameof(CanFdArbBaudRate)); + RaisePropertyChanged(nameof(CanFdDataBaudRate)); + + BuildAndLoadCmdDataToDrive(); + + var writeData = SelectCanLinConfigPro.CanLinConfigContents?.Where(a => a.RWInfo == RW.Write).ToList() ?? new List(); + ListWriteCanLinRWConfigDto = new ObservableCollection(Mapper.Map>(writeData)); + + var readData = SelectCanLinConfigPro.CanLinConfigContents?.Where(a => a.RWInfo == RW.Read).ToList() ?? new List(); + ListReadCanLinRWConfigDto = new ObservableCollection(Mapper.Map>(readData)); + + // 调度表（按模式） + if (SelectedMode == ZlgCanMode.Can) + { + if (SelectCanLinConfigPro.CanScheduleConfigs != null && SelectCanLinConfigPro.CanScheduleConfigs.Count > 0) + { + ListCANScheduleConfigDto = new ObservableCollection(Mapper.Map>(SelectCanLinConfigPro.CanScheduleConfigs)); + } + else + { + ListCANScheduleConfigDto = new ObservableCollection(); + } + + RaisePropertyChanged(nameof(ListCANScheduleConfigDto)); + } + else + { + if (SelectCanLinConfigPro.CanFdScheduleConfigs != null && SelectCanLinConfigPro.CanFdScheduleConfigs.Count > 0) + { + ListCANFdScheduleConfigDto = new ObservableCollection(Mapper.Map>(SelectCanLinConfigPro.CanFdScheduleConfigs)); + } + else + { + ListCANFdScheduleConfigDto = new ObservableCollection(); + } + + RaisePropertyChanged(nameof(ListCANFdScheduleConfigDto)); + } + + ResetAndTryLoadDbcSignalsForSelectedConfig(); + } + + /// + /// 切换配置程序时重置并尝试加载当前配置对应的 DBC 信号集合。 + /// + /// + /// 背景：当“未连接设备”时，如果切换配置程序但不清空信号集合，UI 会残留上一次配置的信号列表。 + /// + /// 行为： + /// - 先清空 ； + /// - 未连接时： + /// - 若当前配置未设置 DBC 路径，则信号集合置空； + /// - 若有 DBC 路径，则调用 解析并加载信号集合； + /// - 已连接时：理论上禁止切换配置程序；这里做保底清空，避免 UI 残留。 + /// + private void ResetAndTryLoadDbcSignalsForSelectedConfig() + { + SelectedCanDbcModel = null; + + // 未连接时：信号集合应以当前配置的 DBC 为准（或为空），禁止沿用上一个配置的信号列表。 + if (!ZlgCanDriveService.OpenState) + { + if (string.IsNullOrWhiteSpace(CurrentDbcPath)) + { + ListCanDbcModel = new ObservableCollection(); + return; + } + + try + { + ListCanDbcModel = ZlgCanDriveService.StartDbc(CurrentDbcPath); + if (SelectCanLinConfigPro != null) + { + ZlgCanDriveService.InitCanConfig(SelectCanLinConfigPro); + } + MatchSeletedAndCanDbcModel(); + } + catch (Exception ex) + { + ListCanDbcModel = new ObservableCollection(); + OpTip = "DBC 解析失败"; + LogService.Warn($"切换配置程序时解析 DBC 失败：{CurrentDbcPath}，{ex.Message}"); + } + + return; + } + + // 已连接时：禁止切换配置程序。 + // 注意：此处不应清空信号集合，否则在“保存读写设置/刷新配置”这类操作中会导致信号表瞬间变空。 + return; + } + + /// + /// 的 backing 字段。 + /// + private ObservableCollection _listCANScheduleConfigDto = new ObservableCollection(); + /// + /// CAN 调度表集合。 + /// + public ObservableCollection ListCANScheduleConfigDto + { + get { return _listCANScheduleConfigDto; } + set { _listCANScheduleConfigDto = value; RaisePropertyChanged(); } + } + + /// + /// 的 backing 字段。 + /// + private ObservableCollection _listCANFdScheduleConfigDto = new ObservableCollection(); + /// + /// CANFD 调度表集合。 + /// + public ObservableCollection ListCANFdScheduleConfigDto + { + get { return _listCANFdScheduleConfigDto; } + set { _listCANFdScheduleConfigDto = value; RaisePropertyChanged(); } + } + + /// + /// 当前仲裁波特率（对 CAN：等同 BaudRate；对 CANFD：ArbBaudRate）。 + /// + public int CurrentArbBaudRate + { + get + { + return SelectedMode == ZlgCanMode.Can + ? (SelectedCANConfigExdDto?.BaudRate ?? 0) + : (SelectedCANFdConfigExdDto?.ArbBaudRate ?? 0); + } + set + { + if (SelectedMode == ZlgCanMode.Can) + { + if (SelectedCANConfigExdDto == null) return; + SelectedCANConfigExdDto.BaudRate = value; + } + else + { + if (SelectedCANFdConfigExdDto == null) return; + SelectedCANFdConfigExdDto.ArbBaudRate = value; + } + + RaisePropertyChanged(); + RaisePropertyChanged(nameof(CanBaudRate)); + RaisePropertyChanged(nameof(CanFdArbBaudRate)); + } + } + + /// + /// 当前数据波特率（对 CAN：等同 BaudRate；对 CANFD：DataBaudRate）。 + /// + public int CurrentDataBaudRate + { + get + { + return SelectedMode == ZlgCanMode.Can + ? (SelectedCANConfigExdDto?.BaudRate ?? 0) + : (SelectedCANFdConfigExdDto?.DataBaudRate ?? 0); + } + set + { + if (SelectedMode == ZlgCanMode.Can) + { + if (SelectedCANConfigExdDto == null) return; + SelectedCANConfigExdDto.BaudRate = value; + } + else + { + if (SelectedCANFdConfigExdDto == null) return; + SelectedCANFdConfigExdDto.DataBaudRate = value; + } + + RaisePropertyChanged(); + RaisePropertyChanged(nameof(CanBaudRate)); + RaisePropertyChanged(nameof(CanFdDataBaudRate)); + } + } + + /// + /// 当前 ISO 标准使能（仅 CANFD 有意义；CAN 固定为 false）。 + /// + public bool CurrentISOEnable + { + get { return SelectedMode == ZlgCanMode.Can ? false : (SelectedCANFdConfigExdDto?.ISOEnable ?? false); } + set + { + if (SelectedMode == ZlgCanMode.Can) + { + return; + } + + if (SelectedCANFdConfigExdDto == null) return; + SelectedCANFdConfigExdDto.ISOEnable = value; + RaisePropertyChanged(); + } + } + + /// + /// 当前终端电阻使能（仅 CANFD 有意义；CAN 固定为 true（驱动侧可忽略））。 + /// + public bool CurrentResEnable + { + get { return SelectedMode == ZlgCanMode.Can ? true : (SelectedCANFdConfigExdDto?.ResEnable ?? false); } + set + { + if (SelectedMode == ZlgCanMode.Can) + { + return; + } + + if (SelectedCANFdConfigExdDto == null) return; + SelectedCANFdConfigExdDto.ResEnable = value; + RaisePropertyChanged(); + } + } + + /// + /// 构建并加载命令数据到驱动。 + /// + /// + /// 数据流： + /// - 从当前配置程序的写入项（RW=Write）构建 列表； + /// - 每条写入项会携带 MsgName/SignalName/默认值/逻辑规则； + /// - 最终调用 注入驱动。 + /// + /// 作用： + /// - 事件驱动发送：信号值变化可触发增量发送/覆盖 auto_send； + /// - 调度表/循环发送：编码发送依赖当前 CmdData 中的信号值。 + /// + private void BuildAndLoadCmdDataToDrive() + { + try + { + if (SelectCanLinConfigPro?.CanLinConfigContents == null) + { + // 防御性清空： + // - 当前未选择配置程序或无配置内容时，服务层应收到空 CmdData，避免沿用旧配置继续触发事件驱动发送。 + ZlgCanDriveService.LoadCmdDataToDrive(new List()); + return; + } + + var writeItems = SelectCanLinConfigPro.CanLinConfigContents + .Where(a => a.RWInfo == RW.Write) + .ToList(); + + var cmdList = new List(); + foreach (var item in writeItems) + { + // 构建 CanCmdData： + // - MsgName/SignalName 决定 DBC 编码定位； + // - 默认值 DefautValue 作为 SignalCmdValue 初始值，确保首次启动循环发送时有可编码数据； + // - LogicRule 透传到发送链路（驱动侧在事件触发时可能按规则决定是否发送/如何发送）。 + cmdList.Add(new CanCmdData() + { + ConfigName = item.Name, + MsgName = item.MsgFrameName, + SignalName = item.SignalName, + SignalCmdValue = double.TryParse(item.DefautValue, out double result) ? result : 0, + LogicRuleDto = Mapper.Map(item.LogicRule), + }); + } + + // 统一入口：将 CmdData 注入 Service/Driver，建立事件驱动增量发送能力。 + ZlgCanDriveService.LoadCmdDataToDrive(cmdList); + } + catch (Exception ex) + { + LogService.Warn($"ZLG CAN 构建/下发 CmdData 失败：{ex.Message}"); + } + } + + /// + /// 当前 DBC 路径（随模式切换映射到对应 DTO）。 + /// + public string? CurrentDbcPath + { + get + { + return SelectedMode == ZlgCanMode.Can + ? SelectedCANConfigExdDto?.DbcPath + : SelectedCANFdConfigExdDto?.DbcPath; + } + set + { + if (SelectedMode == ZlgCanMode.Can) + { + if (SelectedCANConfigExdDto == null) return; + SelectedCANConfigExdDto.DbcPath = value; + } + else + { + if (SelectedCANFdConfigExdDto == null) return; + SelectedCANFdConfigExdDto.DbcPath = value; + } + + RaisePropertyChanged(); + } + } + + /// + /// 当前周期（随模式切换映射到对应 DTO）。 + /// + public int CurrentCycle + { + get + { + return SelectedMode == ZlgCanMode.Can + ? (SelectedCANConfigExdDto?.Cycle ?? 0) + : (SelectedCANFdConfigExdDto?.Cycle ?? 0); + } + set + { + if (SelectedMode == ZlgCanMode.Can) + { + if (SelectedCANConfigExdDto == null) return; + SelectedCANConfigExdDto.Cycle = value; + } + else + { + if (SelectedCANFdConfigExdDto == null) return; + SelectedCANFdConfigExdDto.Cycle = value; + } + + RaisePropertyChanged(); + } + } + + /// + /// 当前调度使能（随模式切换映射到对应 DTO）。 + /// + public bool CurrentSchEnable + { + get + { + return SelectedMode == ZlgCanMode.Can + ? (SelectedCANConfigExdDto?.SchEnable ?? false) + : (SelectedCANFdConfigExdDto?.SchEnable ?? false); + } + set + { + // 说明： + // - 该属性是“配置程序的持久化字段”（DTO/DB）的映射； + // - 它本身不一定立即下发到驱动（驱动下发由 SchEnableCmdCall 或 CycleSend 开启前的同步逻辑完成）。 + if (SelectedMode == ZlgCanMode.Can) + { + if (SelectedCANConfigExdDto == null) return; + SelectedCANConfigExdDto.SchEnable = value; + } + else + { + if (SelectedCANFdConfigExdDto == null) return; + SelectedCANFdConfigExdDto.SchEnable = value; + } + + RaisePropertyChanged(); + } + } + + /// + /// CAN 波特率。 + /// + public int CanBaudRate + { + get { return SelectedCANConfigExdDto?.BaudRate ?? 0; } + set + { + if (SelectedCANConfigExdDto == null) return; + SelectedCANConfigExdDto.BaudRate = value; + RaisePropertyChanged(); + } + } + + /// + /// CANFD 仲裁波特率。 + /// + public int CanFdArbBaudRate + { + get { return SelectedCANFdConfigExdDto?.ArbBaudRate ?? 0; } + set + { + if (SelectedCANFdConfigExdDto == null) return; + SelectedCANFdConfigExdDto.ArbBaudRate = value; + RaisePropertyChanged(); + } + } + + /// + /// CANFD 数据波特率。 + /// + public int CanFdDataBaudRate + { + get { return SelectedCANFdConfigExdDto?.DataBaudRate ?? 0; } + set + { + if (SelectedCANFdConfigExdDto == null) return; + SelectedCANFdConfigExdDto.DataBaudRate = value; + RaisePropertyChanged(); + } + } + + /// + /// 匹配选中的配置和 DBC 模型。 + /// + /// + /// 用途：对信号集合做“是否已被配置为写入/读取”的标记，便于 UI 颜色或状态提示。 + /// - RW.Write 记为 1 + /// - RW.Read 记为 2 + /// - 未配置记为 0 + /// + /// 该标记依赖 与 。 + /// + private void MatchSeletedAndCanDbcModel() + { + if (ListCanDbcModel == null || ListCanDbcModel.Count == 0) return; + if (SelectCanLinConfigPro?.CanLinConfigContents == null || SelectCanLinConfigPro.CanLinConfigContents.Count == 0) return; + + foreach (var itemCanDbcModel in ListCanDbcModel) + { + var findData = SelectCanLinConfigPro.CanLinConfigContents.FindFirst(a => a.SignalName == itemCanDbcModel.SignalName); + if (findData != null) + { + switch (findData.RWInfo) + { + case RW.Write: + itemCanDbcModel.IsSeletedInfo = 1; + break; + case RW.Read: + itemCanDbcModel.IsSeletedInfo = 2; + break; + default: + itemCanDbcModel.IsSeletedInfo = 0; + break; + } + } + else + { + itemCanDbcModel.IsSeletedInfo = 0; + } + } + } + + /// + /// 配置程序 DataGrid 选中项变化命令的 backing 字段。 + /// + private DelegateCommand? _canConfigProGridSelectionChangedCmd; + /// + /// 配置程序选中变化。 + /// + /// + /// - 打开/激活状态下禁止切换配置程序； + /// - 允许切换时会更新 并调用 。 + /// + public DelegateCommand CanConfigProGridSelectionChangedCmd + { + get + { + if (_canConfigProGridSelectionChangedCmd == null) + { + _canConfigProGridSelectionChangedCmd = new DelegateCommand(CanConfigProGridSelectionChangedCmdMethod); + } + return _canConfigProGridSelectionChangedCmd; + } + } + + /// + /// 配置程序 DataGrid SelectionChanged 命令处理。 + /// + /// + /// 可能为： + /// - （直接传入选中项）； + /// - （WPF SelectionChanged 参数）。 + /// + /// + /// WPF 的 SelectionChanged 可能被重复触发/不同类型参数混用，因此这里做了多种分支兼容。 + /// + private void CanConfigProGridSelectionChangedCmdMethod(object par) + { + if (par == null) return; + + if (ZlgCanDriveService.OpenState) + { + // 打开状态下禁止切换配置程序。 + return; + } + + if (IsCanConfigProActive) + { + // 激活状态下禁止切换配置程序。 + return; + } + if (par is SelectionChangedEventArgs) return; + + if (par is CanLinConfigPro) + { + SelectCanLinConfigPro = par as CanLinConfigPro; + SyncSelectedConfig(); + return; + } + + var args = par as SelectionChangedEventArgs; + if (args == null || args.AddedItems == null || args.AddedItems.Count == 0) return; + + var selected = args.AddedItems[0] as CanLinConfigPro; + if (selected == null) return; + + SelectCanLinConfigPro = selected; + SyncSelectedConfig(); + } + + /// + /// 配置程序切换前拦截命令的 backing 字段。 + /// + private DelegateCommand? _canConfigProGridPreviewMouseLeftButtonDownCmd; + /// + /// 配置程序切换前拦截（对齐图莫斯 PreviewMouseLeftButtonDown）。 + /// 打开/激活状态下禁止切换，防止状态错乱。 + /// + public DelegateCommand CanConfigProGridPreviewMouseLeftButtonDownCmd + { + get + { + if (_canConfigProGridPreviewMouseLeftButtonDownCmd == null) + { + _canConfigProGridPreviewMouseLeftButtonDownCmd = new DelegateCommand(CanConfigProGridPreviewMouseLeftButtonDownCmdMethod); + } + return _canConfigProGridPreviewMouseLeftButtonDownCmd; + } + } + + /// + /// 配置程序切换前拦截命令处理。 + /// + /// 鼠标事件参数（可能为 ）。 + /// + /// 若拦截命中，会将 MouseButtonEventArgs.Handled 置为 true，阻止 DataGrid 继续改变选中项。 + /// + private void CanConfigProGridPreviewMouseLeftButtonDownCmdMethod(object par) + { + try + { + if (ZlgCanDriveService.OpenState) + { + MessageBox.Show("CAN 已连接，请先关闭后再切换配置程序", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + if (par is System.Windows.Input.MouseButtonEventArgs e) e.Handled = true; + return; + } + + if (IsCanConfigProActive) + { + MessageBox.Show("当前配置程序已激活，请先取消激活后再切换", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + if (par is System.Windows.Input.MouseButtonEventArgs e) e.Handled = true; + return; + } + } + catch (Exception ex) + { + LogService.Warn($"配置切换拦截异常：{ex.Message}"); + } + } + + /// + /// 选择 DBC 文件命令的 backing 字段。 + /// + private DelegateCommand? _loadDbcCmd; + /// + /// 选择 DBC 文件。 + /// + /// + /// 该命令只负责让用户选择文件并写回 ， + /// 不会自动解析；解析由 CAN 操作命令中的 "Parse" 或连接流程中的自动解析触发。 + /// + public DelegateCommand LoadDbcCmd + { + get + { + if (_loadDbcCmd == null) + { + _loadDbcCmd = new DelegateCommand(LoadDbcCmdMethod); + } + return _loadDbcCmd; + } + } + + /// + /// 选择 DBC 文件命令处理。 + /// + /// + /// 前置条件：必须已选择配置程序（）。 + /// + /// 选择成功后会更新 ；用户取消则保持原值。 + /// + private void LoadDbcCmdMethod() + { + try + { + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中CAN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + OpenFileDialog openFileDialogInfo = new OpenFileDialog(); + openFileDialogInfo.Filter = "(*.dbc;*.dbc)|*.dbc;*.dbc|all|*.*"; + openFileDialogInfo.CheckFileExists = true; + openFileDialogInfo.CheckPathExists = true; + var dialogResult = openFileDialogInfo.ShowDialog(); + if (dialogResult != true) + { + // 用户取消：保持原值，不清空 CurrentDbcPath + return; + } + + var fileName = openFileDialogInfo.FileName; + if (string.IsNullOrWhiteSpace(fileName)) + { + return; + } + + if (!File.Exists(fileName)) + { + MessageBox.Show("文件不存在，请重新选择", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + CurrentDbcPath = fileName; + } + catch (Exception ex) + { + LogService.Error($"选择 DBC 文件失败：{ex}"); + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + } + + /// + /// 调度使能下发命令的 backing 字段。 + /// + private DelegateCommand? _schEnableCmd; + /// + /// 调度使能写入驱动。 + /// + /// + /// 该命令用于把 UI 的 立即同步到 。 + /// - SchEnable 影响事件驱动发送与调度表/auto_send 相关行为。 + /// + public DelegateCommand SchEnableCmd + { + get + { + if (_schEnableCmd == null) + { + _schEnableCmd = new DelegateCommand(SchEnableCmdCall); + } + return _schEnableCmd; + } + } + + /// + /// 调度使能同步到驱动。 + /// + /// 未使用（与 XAML CommandParameter 兼容）。 + private void SchEnableCmdCall(object par) + { + // 与旧 Toomoss 行为对齐：UI 勾选后立即下发到驱动 + // 说明： + // - SchEnable 控制“事件驱动发送/覆盖更新 auto_send”的总开关； + // - 仅修改 CurrentSchEnable（DTO）不会影响驱动，必须执行该命令（或在 CycleSend 开启前同步）。 + ZlgCanDriveService.SchEnable = CurrentSchEnable; + } + + /// + /// 配置程序操作命令的 backing 字段。 + /// + private DelegateCommand? _canLinConfigProCmd; + /// + /// 配置程序操作（新建/修改/删除）。 + /// + /// + /// 约定： + /// - "Add"：新建配置程序（按当前 创建 CAN 或 CANFD 扩展表记录）； + /// - "Edit"：修改配置程序名称； + /// - "Delete"：删除配置程序及其内容（包含读写配置、调度表、扩展表）； + /// - "Active"：激活/取消激活当前配置程序（激活后禁止切换配置程序）。 + /// + /// 激活语义： + /// - 激活要求设备已连接且 DBC 已解析成功； + /// - 激活后会把当前配置下发到服务层（CmdData + 调度表），用于循环发送/硬件调度表等功能。 + /// + public DelegateCommand CanLinConfigProCmd + { + get + { + if (_canLinConfigProCmd == null) + { + _canLinConfigProCmd = new DelegateCommand(CanLinConfigProCmdMethod); + } + return _canLinConfigProCmd; + } + } + + /// + /// 配置程序操作命令处理。 + /// + /// 操作类型（Add/Edit/Delete/Active）。 + /// + /// 约束说明： + /// - 打开 CAN（）或已激活（）时， + /// 禁止新建/修改/删除与切换配置程序，避免“驱动正在运行但底层配置被替换”导致状态错乱。 + /// - Delete 会同时清理 CAN/CANFD 两套扩展配置（如果都存在），避免孤儿记录残留。 + /// + private void CanLinConfigProCmdMethod(string par) + { + if (string.IsNullOrWhiteSpace(par)) return; + + try + { + switch (par) + { + case "Add": + if (IsCanConfigProActive) + { + MessageBox.Show("当前配置已激活，请先取消激活后再新建/修改配置程序", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (ZlgCanDriveService.OpenState) + { + MessageBox.Show("请先关闭 CAN 后再新建配置程序", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + DialogService.ShowDialog("DialogCanLinConfigCreateView", new DialogParameters() { { "Name", "" } }, r => + { + if (r.Result != ButtonResult.OK) return; + + try + { + var name = r.Parameters.GetValue("Name")?.Trim(); + if (string.IsNullOrWhiteSpace(name)) + { + MessageBox.Show("名称不能为空", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + var info = SelectedMode == ZlgCanMode.Can ? CANLIN.CAN : CANLIN.CANFD; + var exists = FreeSql.Select() + .Where(a => a.CANLINInfo == info) + .Where(a => a.ConfigName == name) + .Any(); + if (exists) + { + MessageBox.Show("名称已存在，请更换名称", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + long newProId = 0; + + FreeSql.Transaction(() => + { + if (SelectedMode == ZlgCanMode.Can) + { + var exdList = FreeSql.Insert(new CANConfigExd() + { + BaudRate = 500000, + DbcPath = string.Empty, + Cycle = 100, + SchEnable = false, + }).ExecuteInserted(); + + var exd = exdList?.FirstOrDefault(); + if (exd == null) + { + throw new InvalidOperationException("创建 CAN 扩展配置失败"); + } + + var proList = FreeSql.Insert(new CanLinConfigPro() + { + ConfigName = name, + CANLINInfo = CANLIN.CAN, + CANConfigExdId = exd.Id, + }).ExecuteInserted(); + + var pro = proList?.FirstOrDefault(); + if (pro == null) + { + throw new InvalidOperationException("创建 CAN 配置程序失败"); + } + + newProId = pro.Id; + } + else + { + var exdList = FreeSql.Insert(new CANFdConfigExd() + { + ArbBaudRate = 500000, + DataBaudRate = 2000000, + ISOEnable = true, + ResEnable = false, + DbcPath = string.Empty, + Cycle = 100, + SchEnable = false, + }).ExecuteInserted(); + + var exd = exdList?.FirstOrDefault(); + if (exd == null) + { + throw new InvalidOperationException("创建 CANFD 扩展配置失败"); + } + + var proList = FreeSql.Insert(new CanLinConfigPro() + { + ConfigName = name, + CANLINInfo = CANLIN.CANFD, + CANFdConfigExdId = exd.Id, + }).ExecuteInserted(); + + var pro = proList?.FirstOrDefault(); + if (pro == null) + { + throw new InvalidOperationException("创建 CANFD 配置程序失败"); + } + + newProId = pro.Id; + } + }); + + InitLoadCanConfigPro(); + SelectCanLinConfigPro = _canLinConfigPros.Find(a => a.Id == newProId); + SyncSelectedConfig(); + MatchSeletedAndCanDbcModel(); + } + catch (Exception ex) + { + LogService.Error($"ZLG 新建配置程序失败：{ex}"); + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + }); + break; + + case "Edit": + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (IsCanConfigProActive) + { + MessageBox.Show("当前配置已激活，请先取消激活后再修改配置程序", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (ZlgCanDriveService.OpenState) + { + MessageBox.Show("请先关闭 CAN 后再修改配置程序", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + DialogService.ShowDialog("DialogCanLinConfigCreateView", new DialogParameters() { { "Name", SelectCanLinConfigPro.ConfigName } }, r => + { + if (r.Result != ButtonResult.OK) return; + + try + { + var name = r.Parameters.GetValue("Name")?.Trim(); + if (string.IsNullOrWhiteSpace(name)) + { + MessageBox.Show("名称不能为空", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + var info = SelectedMode == ZlgCanMode.Can ? CANLIN.CAN : CANLIN.CANFD; + var exists = FreeSql.Select() + .Where(a => a.CANLINInfo == info) + .Where(a => a.ConfigName == name) + .Where(a => a.Id != SelectCanLinConfigPro.Id) + .Any(); + if (exists) + { + MessageBox.Show("名称已存在，请更换名称", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + FreeSql.Update() + .Set(a => a.ConfigName, name) + .Where(a => a.Id == SelectCanLinConfigPro.Id) + .ExecuteAffrows(); + + ReloadCurrentConfigPro(); + } + catch (Exception ex) + { + LogService.Error($"ZLG 修改配置程序失败：{ex}"); + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + }); + break; + + case "Delete": + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (IsCanConfigProActive) + { + MessageBox.Show("当前配置已激活，请先取消激活后再删除配置程序", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (ZlgCanDriveService.OpenState) + { + MessageBox.Show("请先关闭 CAN 后再删除配置程序", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (MessageBox.Show($"确定删除配置程序：{SelectCanLinConfigPro.ConfigName}？", "确认", MessageBoxButton.OKCancel, MessageBoxImage.Warning) != MessageBoxResult.OK) + { + return; + } + + // 删除主表与内容 + var repo = FreeSql.GetRepository(); + repo.DbContextOptions.EnableCascadeSave = true; + + var delList = repo.Select + .Include(a => a.CANConfigExd) + .Include(a => a.CANFdConfigExd) + .IncludeMany(a => a.CanLinConfigContents) + .IncludeMany(a => a.CanScheduleConfigs) + .IncludeMany(a => a.CanFdScheduleConfigs) + .Where(a => a.Id == SelectCanLinConfigPro.Id) + .ToList(); + + repo.Delete(delList); + foreach (var item in delList) + { + // 允许配置在 CAN/CANFD 间切换保存后同时具备两套扩展表，此处统一清理避免残留孤儿记录。 + if (item.CANConfigExdId > 0) + { + FreeSql.Delete(item.CANConfigExdId).ExecuteAffrows(); + } + if (item.CANFdConfigExdId > 0) + { + FreeSql.Delete(item.CANFdConfigExdId).ExecuteAffrows(); + } + } + + SelectCanLinConfigPro = null; + SelectedCANConfigExdDto = null; + SelectedCANFdConfigExdDto = null; + InitLoadCanConfigPro(); + ListCanDbcModel = new ObservableCollection(); + break; + + case "Active": + // 激活到取消的状态的判断 + if (IsCanConfigProActive) + { + IsCanConfigProActive = false; + IsCANConfigDatagridActive = true; + + // 停止调度/发送，避免“取消激活但仍在发送” + ZlgCanDriveService.StopSchedule(); + ZlgCanDriveService.IsCycleSend = false; + ZlgCanDriveService.LoadCmdDataToDrive(new List()); + + OpTip = "已取消激活"; + return; + } + + if (!ZlgCanDriveService.OpenState) + { + MessageBox.Show("请确保 CAN 已连接后再激活", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (string.IsNullOrWhiteSpace(CurrentDbcPath)) + { + MessageBox.Show("请先选择并解析 DBC 文件后再激活", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + // 激活前强制按“当前配置的 DBC 路径”重新解析，避免 DbcParserState 来自其它配置导致错配。 + try + { + ListCanDbcModel = ZlgCanDriveService.StartDbc(CurrentDbcPath); + MatchSeletedAndCanDbcModel(); + } + catch (Exception ex) + { + LogService.Error($"ZLG 激活前解析 DBC 失败：{ex}"); + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + return; + } + + IsCanConfigProActive = true; + IsCANConfigDatagridActive = false; + + // 当前使用的配置程序 + ZlgCanDriveService.InitCanConfig(SelectCanLinConfigPro); + + // 下发指令集合与调度表 + BuildAndLoadCmdDataToDrive(); + if (SelectedMode == ZlgCanMode.Can) + { + ZlgCanDriveService.SetScheduleConfigs(ListCANScheduleConfigDto?.ToList() ?? new List()); + } + else + { + ZlgCanDriveService.SetScheduleConfigs(ListCANFdScheduleConfigDto?.ToList() ?? new List()); + } + + OpTip = "已激活当前配置"; + break; + } + } + catch (Exception ex) + { + LogService.Error($"ZLG 配置程序操作失败：{par}，{ex}"); + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + } + + /// + /// 调度表配置弹窗命令的 backing 字段。 + /// + private DelegateCommand? _scheduleConfigCmd; + /// + /// 调度表配置（弹窗）。 + /// + /// + /// 打开调度表弹窗时，会从 中提取 MsgName 列表作为候选消息帧。 + /// - CAN 模式：打开 DialogCANSchConfigView + /// - CANFD 模式：打开 DialogCANFdSchConfigView + /// + /// 弹窗确认后会把返回的调度表 DTO 写回当前配置程序实体，并调用 ReloadCurrentConfigPro 刷新。 + /// + public DelegateCommand ScheduleConfigCmd + { + get + { + if (_scheduleConfigCmd == null) + { + _scheduleConfigCmd = new DelegateCommand(ScheduleConfigCmdMethod); + } + return _scheduleConfigCmd; + } + } + + /// + /// 调度表配置弹窗命令处理。 + /// + /// + /// 前置条件： + /// - 必须选中配置程序； + /// - 必须存在可发送消息（CmdData 非空且 MsgName 有效），否则无法配置调度表。 + /// + /// 注意： + /// - 调度表本身并不直接发送；真正启动发送由 CAN 操作命令中的 "CycleSend" 触发。 + /// + private void ScheduleConfigCmdMethod() + { + try + { + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中CAN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + // 调度表弹窗需要 MsgName 候选列表： + // - 来源于当前已下发的 CmdData（写入项聚合后的消息名）； + // - 这样能保证“可配置的调度表项”与“实际会被编码发送的消息帧”一致。 + var msgList = ZlgCanDriveService.CmdData.GroupBy(a => a.MsgName).Select(a => a.Key).Where(a => !string.IsNullOrWhiteSpace(a)).ToList(); + if ((msgList == null || msgList.Count == 0) && (ListCANScheduleConfigDto == null || ListCANScheduleConfigDto.Count == 0)) + { + MessageBox.Show("未发现写入指令数据（CmdData 为空），无法配置调度表", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (SelectedMode == ZlgCanMode.Can) + { + // CAN 调度表弹窗： + // - 入参包含当前调度表 DTO（用于回显） + // - 确认后返回新的调度表 DTO 集合并回写到配置程序实体 + DialogService.ShowDialog(nameof(DialogZlgCANSchConfigView), new DialogParameters() + { + { "ListMsg", msgList }, + { "ListCANScheduleConfigDto", ListCANScheduleConfigDto }, + { "SelectCanLinConfigProId", SelectCanLinConfigPro.Id }, + }, r => + { + if (r.Result != ButtonResult.OK) return; + ListCANScheduleConfigDto = r.Parameters.GetValue>("ReturnValue") ?? new ObservableCollection(); + + // DTO -> 实体：用于持久化（保存到数据库），并在后续激活/循环发送前由 SyncSelectedConfig 再同步到 Service。 + SelectCanLinConfigPro.CanScheduleConfigs = Mapper.Map>(ListCANScheduleConfigDto.ToList()); + ReloadCurrentConfigPro(); + }); + } + else + { + // CANFD 调度表弹窗：语义同 CAN。 + DialogService.ShowDialog(nameof(DialogZlgCANFDSchConfigView), new DialogParameters() + { + { "ListMsg", msgList }, + { "ListCANFdScheduleConfigDto", ListCANFdScheduleConfigDto }, + { "SelectCanLinConfigProId", SelectCanLinConfigPro.Id }, + }, r => + { + if (r.Result != ButtonResult.OK) return; + ListCANFdScheduleConfigDto = r.Parameters.GetValue>("ReturnValue") ?? new ObservableCollection(); + SelectCanLinConfigPro.CanFdScheduleConfigs = Mapper.Map>(ListCANFdScheduleConfigDto.ToList()); + ReloadCurrentConfigPro(); + }); + } + } + catch (Exception ex) + { + LogService.Error($"调度表配置失败：{ex}"); + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + } + + /// + /// 读写配置操作命令的 backing 字段。 + /// + private DelegateCommand? _writeReadConfigCmd; + /// + /// 写入/读取/删除 信号配置项。 + /// + /// + /// 常见取值： + /// - "OpenDialog"：打开“读写设置”弹窗（需要已连接且信号集合非空）； + /// - "Write"：将当前选中信号加入写入配置； + /// - "Read"：将当前选中信号加入读取配置； + /// - "Delete"：删除当前选中信号的配置项。 + /// + public DelegateCommand WriteReadConfigCmd + { + get + { + if (_writeReadConfigCmd == null) + { + _writeReadConfigCmd = new DelegateCommand(WriteReadConfigCmdMethod); + } + return _writeReadConfigCmd; + } + } + + /// + /// 写入/读取/删除信号配置项命令处理。 + /// + /// 操作类型。 + /// + /// 数据来源： + /// - 操作对象为右侧信号列表中当前选中的 。 + /// + /// 重要约束： + /// - 配置程序激活后禁止变更读写配置（避免发送/解析过程中配置被修改）； + /// - "OpenDialog" 会强校验：设备已连接 + 信号集合非空，防止弹窗候选集合为空。 + /// + /// 注意： + /// - 读写互斥与更严格的冲突校验主要在读写设置弹窗 ViewModel 中实现； + /// - 此处只做“同一 RWInfo 下禁止重复”与基础防御校验。 + /// + private void WriteReadConfigCmdMethod(string par) + { + if (string.IsNullOrWhiteSpace(par)) return; + + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中CAN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (string.Equals(par, "OpenDialog", StringComparison.OrdinalIgnoreCase)) + { + if (!ZlgCanDriveService.OpenState) + { + MessageBox.Show("当前未连接 CAN/CANFD，无法打开【读写设置】。请先连接设备后再操作。", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (ListCanDbcModel == null || ListCanDbcModel.Count == 0) + { + MessageBox.Show("当前信号集合为空，无法打开【读写设置】。请先解析 DBC 并确保信号列表已加载后再操作。", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + OpenRwDialog(); + return; + } + + if (IsCanConfigProActive) + { + MessageBox.Show("当前配置已激活，请先取消激活后再修改写入/读取配置", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (SelectedCanDbcModel == null) + { + MessageBox.Show("请在右侧信号表中选中一个信号后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (string.IsNullOrWhiteSpace(SelectedCanDbcModel.SignalName) || string.IsNullOrWhiteSpace(SelectedCanDbcModel.MsgName)) + { + MessageBox.Show("选中的信号数据不完整（SignalName/MsgName 为空）", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + try + { + if (par == "Delete") + { + FreeSql.Delete() + .Where(a => a.CanLinConfigProId == SelectCanLinConfigPro.Id) + .Where(a => a.SignalName == SelectedCanDbcModel.SignalName) + .ExecuteAffrows(); + + ReloadCurrentConfigPro(); + OpTip = "已删除配置项"; + return; + } + + var rw = par == "Write" ? RW.Write : RW.Read; + + // 防重复：同一个 SignalName + RWInfo 只允许一条 + var exists = FreeSql.Select() + .Where(a => a.CanLinConfigProId == SelectCanLinConfigPro.Id) + .Where(a => a.SignalName == SelectedCanDbcModel.SignalName) + .Where(a => a.RWInfo == rw) + .Any(); + + if (exists) + { + OpTip = "配置已存在"; + return; + } + + FreeSql.Insert(new CanLinRWConfig() + { + Name = SelectedCanDbcModel.SignalName, + SignalName = SelectedCanDbcModel.SignalName, + MsgFrameName = SelectedCanDbcModel.MsgName, + CanLinConfigProId = SelectCanLinConfigPro.Id, + DefautValue = "0", + RWInfo = rw, + LogicRuleId = 0, + }).ExecuteInserted(); + + ReloadCurrentConfigPro(); + OpTip = rw == RW.Write ? "已加入写入配置" : "已加入读取配置"; + } + catch (Exception ex) + { + LogService.Error($"ZLG 写入/读取配置操作失败：{par}，{ex}"); + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + } + + /// + /// 重新从数据库加载配置程序，并保持当前选中项。 + /// + /// + /// 用途： + /// - 在新增/删除/保存读写配置、保存调度表等操作后，刷新 UI 绑定对象，确保界面与数据库一致； + /// - 刷新后会重新执行 ，从而重建 CmdData、读写列表与调度表列表。 + /// + private void ReloadCurrentConfigPro() + { + var id = SelectCanLinConfigPro?.Id; + InitLoadCanConfigPro(); + + if (id != null) + { + SelectCanLinConfigPro = _canLinConfigPros.Find(a => a.Id == id.Value); + SyncSelectedConfig(); + } + + if (SelectCanLinConfigPro != null) + { + ZlgCanDriveService.InitCanConfig(SelectCanLinConfigPro); + } + MatchSeletedAndCanDbcModel(); + } + + /// + /// CAN 操作命令的 backing 字段。 + /// + private DelegateCommand? _canOpCmd; + /// + /// CAN 操作命令。 + /// + /// + /// 常见取值： + /// - "Open"：按当前模式与参数打开设备并启动接收线程 + /// - "Close"：关闭设备（同时停止循环发送/循环接收，并退出激活态） + /// - "Parse"：解析当前 DBC（需要已连接且 DBC 路径有效） + /// - "CycleSend"：循环发送开关（第一次开启，第二次关闭） + /// - "CycleRecive"：循环接收开关 + /// - "Save"：保存当前配置（包括 CAN/CANFD 扩展配置与模式切换） + /// + public DelegateCommand CanOpCmd + { + get + { + if (_canOpCmd == null) + { + _canOpCmd = new DelegateCommand(CanOpCmdMethod); + } + return _canOpCmd; + } + } + + /// + /// CAN 操作命令处理。 + /// + /// 操作类型。 + /// + /// 循环发送两种实现： + /// - 若 为 true：使用调度表（硬件 auto_send）；会校验每个 MsgName 在调度表中都有配置。 + /// - 若 为 false：使用软件精确定时循环发送（周期取 ）。 + /// + /// 互斥约束： + /// - 开启 CAN 前会检查 与 状态，防止 CAN/LIN 同时占用。 + /// - Close 时会通过 Service 层确保停止发送/接收与硬件 auto_send 清理。 + /// + private void CanOpCmdMethod(string par) + { + if (string.IsNullOrWhiteSpace(par)) + { + return; + } + + try + { + switch (par) + { + case "Open": + if (ComActionService.IsCanToDoWork() == false) + { + MessageBox.Show("请关闭LIN连接后才能开启CAN，同一个时刻只能有一个通信驱动压缩机", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (ZlgLinDriveService.OpenState) + { + MessageBox.Show("请先关闭 ZLG LIN 连接后再开启 ZLG CAN", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中CAN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (SelectedMode == ZlgCanMode.Can) + { + if (SelectedCANConfigExdDto == null) + { + MessageBox.Show("CAN配置为空", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + // ZLG 底层实际为 CANFD 通道，CAN 经典帧使用 arbitration 波特率（data 亦沿用，保持一致即可） + ZlgCanDriveService.UpdateConfig(0, (uint)SelectedCANConfigExdDto.BaudRate, (uint)SelectedCANConfigExdDto.BaudRate, resEnable: true); + } + else + { + if (SelectedCANFdConfigExdDto == null) + { + MessageBox.Show("CANFD配置为空", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + ZlgCanDriveService.UpdateConfig(0, (uint)SelectedCANFdConfigExdDto.ArbBaudRate, (uint)SelectedCANFdConfigExdDto.DataBaudRate, SelectedCANFdConfigExdDto.ResEnable); + } + + ZlgCanDriveService.StartCanDrive(); + + if (ZlgCanDriveService.OpenState) + { + LastError = null; + OpTip = "CAN 已连接"; + ConfigService.CanLinRunStateModel.CurSysSelectedCanLin = SelectedMode == ZlgCanMode.Can ? CanLinEnum.Can : CanLinEnum.CANFD; + } + else + { + OpTip = "CAN 连接失败"; + MessageBox.Show("CAN 连接失败（OpenState=false），请检查设备/驱动/参数。", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + // 自动解析 DBC + if (!string.IsNullOrWhiteSpace(CurrentDbcPath)) + { + ListCanDbcModel = ZlgCanDriveService.StartDbc(CurrentDbcPath); + if (SelectCanLinConfigPro != null) + { + ZlgCanDriveService.InitCanConfig(SelectCanLinConfigPro); + } + MatchSeletedAndCanDbcModel(); + } + + // 将当前配置的 CmdData 下发到驱动（用于事件驱动增量发送） + BuildAndLoadCmdDataToDrive(); + + break; + + case "Close": + ZlgCanDriveService.CloseDevice(); + ConfigService.CanLinRunStateModel.CurSysSelectedCanLin = CanLinEnum.No; + LastError = null; + OpTip = "CAN 已关闭"; + + // 关闭设备时自动退出激活，恢复可切换状态 + IsCanConfigProActive = false; + IsCANConfigDatagridActive = true; + break; + + case "Parse": + if (!ZlgCanDriveService.OpenState) + { + MessageBox.Show("请先打开CAN后再解析", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (string.IsNullOrWhiteSpace(CurrentDbcPath)) + { + MessageBox.Show("请选择DBC文件后再操作", "提示", MessageBoxButton.OKCancel, MessageBoxImage.Hand); + return; + } + + ListCanDbcModel = ZlgCanDriveService.StartDbc(CurrentDbcPath); + if (SelectCanLinConfigPro != null) + { + ZlgCanDriveService.InitCanConfig(SelectCanLinConfigPro); + } + MatchSeletedAndCanDbcModel(); + LastError = null; + OpTip = "DBC 已解析"; + break; + + case "CycleSend": + if (!ZlgCanDriveService.OpenState) + { + MessageBox.Show("请先打开 CAN 后再进行循环发送", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (!ZlgCanDriveService.DbcParserState) + { + MessageBox.Show("请先解析 DBC 后再进行循环发送", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + // 与图莫斯一致：第一次点击开启，第二次点击关闭 + if (!ZlgCanDriveService.IsCycleSend) + { + // 开启前：确保最新 CmdData 已下发 + BuildAndLoadCmdDataToDrive(); + + // 同步 SchEnable（防止 UI 勾选但未触发 Command 导致服务端状态不一致） + // 说明： + // - SchEnable=true 时，Service 会走“硬件调度表(auto_send)”路径； + // - SchEnable=false 时，Service 会走“软件精确定时循环发送”路径； + // - 因此 CycleSend 开启前必须保证 Service.SchEnable 与 UI/DTO 一致。 + ZlgCanDriveService.SchEnable = CurrentSchEnable; + + if (ZlgCanDriveService.SchEnable) + { + // 使用调度表：校验每个 MsgName 都配置了周期 + // 注意： + // - 这里校验的是“当前会被发送的消息帧集合”（CmdData 聚合）是否都在调度表中配置； + // - 缺失配置会导致硬件 auto_send 无法周期性发送对应帧，因此直接阻止开启。 + var groupMsg = ZlgCanDriveService.CmdData + .Where(a => !string.IsNullOrWhiteSpace(a.MsgName)) + .GroupBy(a => a.MsgName) + .Select(g => g.Key) + .ToList(); + + if (groupMsg.Count == 0) + { + MessageBox.Show("未发现可发送的消息帧（CmdData.MsgName 为空）", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (SelectedMode == ZlgCanMode.Can) + { + foreach (var msg in groupMsg) + { + if (!ListCANScheduleConfigDto.Any(a => string.Equals(a.MsgName, msg, StringComparison.Ordinal))) + { + MessageBox.Show($"你使能了调度表，但是调度表中没有设置【{msg}】信息，请设置后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + } + + if (ListCANScheduleConfigDto == null || ListCANScheduleConfigDto.Count == 0) + { + MessageBox.Show("调度表配置为空数据，请检查！将无法发送数据", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + ZlgCanDriveService.SetScheduleConfigs(ListCANScheduleConfigDto.ToList()); + } + else + { + foreach (var msg in groupMsg) + { + if (!ListCANFdScheduleConfigDto.Any(a => string.Equals(a.MsgName, msg, StringComparison.Ordinal))) + { + MessageBox.Show($"你使能了调度表，但是调度表中没有设置【{msg}】信息，请设置后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + } + + if (ListCANFdScheduleConfigDto == null || ListCANFdScheduleConfigDto.Count == 0) + { + MessageBox.Show("调度表配置为空数据，请检查！将无法发送数据", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + ZlgCanDriveService.SetScheduleConfigs(ListCANFdScheduleConfigDto.ToList()); + } + + // 启动硬件调度表： + // - Service 层会 StopSchedule 清理旧任务/旧 auto_send，然后下发 auto_send 并 apply； + // - 运行中 CmdData 信号变化会由 Driver 覆盖更新对应 index 的帧数据（需要 IsCycleSend=true 且 SchEnable=true）。 + ZlgCanDriveService.StartSchedule(); + } + else + { + // 不使用调度表：按当前配置周期做精确循环发送 + // 说明：该路径完全在 PC 侧按周期触发发送，精度受系统调度影响，但不依赖硬件 auto_send。 + var cycle = Math.Max(1, CurrentCycle); + ZlgCanDriveService.StartPrecisionCycleSend(cycle); + } + + OpTip = "循环发送：已开启"; + } + else + { + // 关闭循环发送： + // - 先关闭事件驱动发送标志（避免 CmdData 变化继续触发增量发送/覆盖更新）； + // - 再调用 StopSchedule：停止软件任务 + clear_auto_send（防止硬件继续发）。 + ZlgCanDriveService.IsCycleSend = false; + ZlgCanDriveService.StopSchedule(); + OpTip = "循环发送：已关闭"; + } + break; + + case "CycleRecive": + ZlgCanDriveService.SetReceiveEnabled(!ZlgCanDriveService.IsCycleRevice); + OpTip = ZlgCanDriveService.IsCycleRevice ? "循环接收：已开启" : "循环接收：已关闭"; + break; + + case "Save": + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中CAN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + // 允许在 UI 上修改当前配置的模式（CAN/CANFD），保存时同步更新 CanLinConfigPro.CANLINInfo。 + FreeSql.Transaction(() => + { + if (SelectedMode == ZlgCanMode.Can) + { + if (SelectedCANConfigExdDto == null || SelectedCANConfigExdDto.Id <= 0) + { + // 若原配置为 CANFD，切换到 CAN 时可能尚未存在 CAN 扩展配置，这里按默认值创建。 + var inserted = FreeSql.Insert(new CANConfigExd() + { + BaudRate = 500000, + DbcPath = string.Empty, + Cycle = 100, + SchEnable = false, + }).ExecuteInserted(); + var exd = inserted?.FirstOrDefault(); + if (exd == null) throw new InvalidOperationException("创建 CAN 扩展配置失败"); + SelectedCANConfigExdDto = Mapper.Map(exd); + } + + FreeSql.Update() + .Set(a => a.DbcPath, SelectedCANConfigExdDto.DbcPath) + .Set(a => a.Cycle, SelectedCANConfigExdDto.Cycle) + .Set(a => a.BaudRate, SelectedCANConfigExdDto.BaudRate) + .Set(a => a.SchEnable, SelectedCANConfigExdDto.SchEnable) + .Where(a => a.Id == SelectedCANConfigExdDto.Id) + .ExecuteUpdated(); + + FreeSql.Update() + .Set(a => a.CANLINInfo, CANLIN.CAN) + .Set(a => a.CANConfigExdId, SelectedCANConfigExdDto.Id) + .Where(a => a.Id == SelectCanLinConfigPro.Id) + .ExecuteAffrows(); + } + else + { + if (SelectedCANFdConfigExdDto == null || SelectedCANFdConfigExdDto.Id <= 0) + { + // 若原配置为 CAN，切换到 CANFD 时可能尚未存在 CANFD 扩展配置，这里按默认值创建。 + var inserted = FreeSql.Insert(new CANFdConfigExd() + { + ArbBaudRate = 500000, + DataBaudRate = 2000000, + ISOEnable = true, + ResEnable = false, + DbcPath = string.Empty, + Cycle = 100, + SchEnable = false, + }).ExecuteInserted(); + var exd = inserted?.FirstOrDefault(); + if (exd == null) throw new InvalidOperationException("创建 CANFD 扩展配置失败"); + SelectedCANFdConfigExdDto = Mapper.Map(exd); + } + + FreeSql.Update() + .Set(a => a.DbcPath, SelectedCANFdConfigExdDto.DbcPath) + .Set(a => a.Cycle, SelectedCANFdConfigExdDto.Cycle) + .Set(a => a.DataBaudRate, SelectedCANFdConfigExdDto.DataBaudRate) + .Set(a => a.ArbBaudRate, SelectedCANFdConfigExdDto.ArbBaudRate) + .Set(a => a.ISOEnable, SelectedCANFdConfigExdDto.ISOEnable) + .Set(a => a.ResEnable, SelectedCANFdConfigExdDto.ResEnable) + .Set(a => a.SchEnable, SelectedCANFdConfigExdDto.SchEnable) + .Where(a => a.Id == SelectedCANFdConfigExdDto.Id) + .ExecuteUpdated(); + + FreeSql.Update() + .Set(a => a.CANLINInfo, CANLIN.CANFD) + .Set(a => a.CANFdConfigExdId, SelectedCANFdConfigExdDto.Id) + .Where(a => a.Id == SelectCanLinConfigPro.Id) + .ExecuteAffrows(); + } + }); + + ReloadCurrentConfigPro(); + LastError = null; + OpTip = "配置已保存"; + break; + } + } + catch (Exception ex) + { + LastError = ex.Message; + OpTip = "操作失败"; + LogService.Error($"ZLG CAN 操作失败：{par}，{ex}"); + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + } + } +} diff --git a/CapMachine.Wpf/ViewModels/ZlgLinDriveConfigViewModel.cs b/CapMachine.Wpf/ViewModels/ZlgLinDriveConfigViewModel.cs new file mode 100644 index 0000000..e7e6882 --- /dev/null +++ b/CapMachine.Wpf/ViewModels/ZlgLinDriveConfigViewModel.cs @@ -0,0 +1,1171 @@ +using AutoMapper; +using CapMachine.Core; +using CapMachine.Model.CANLIN; +using CapMachine.Wpf.Dtos; +using CapMachine.Wpf.LinDrive; +using CapMachine.Wpf.PrismEvent; +using CapMachine.Wpf.Services; +using CapMachine.Wpf.Views; +using ImTools; +using Microsoft.Win32; +using Prism.Commands; +using Prism.Events; +using Prism.Regions; +using Prism.Services.Dialogs; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Linq; +using System.Windows; +using System.Windows.Controls; +using static CapMachine.Wpf.Models.ComEnum; + +namespace CapMachine.Wpf.ViewModels +{ + /// + /// ZLG LIN 配置 ViewModel。 + /// + public class ZlgLinDriveConfigViewModel : NavigationViewModel + { + /// + /// 构造函数。 + /// + public ZlgLinDriveConfigViewModel(IDialogService dialogService, IFreeSql freeSql, + IEventAggregator eventAggregator, IRegionManager regionManager, SysRunService sysRunService, + ConfigService configService, ZlgLinDriveService zlgLinDriveService, ZlgCanDriveService zlgCanDriveService, + ComActionService comActionService, LogicRuleService logicRuleService, + IMapper mapper) + { + DialogService = dialogService; + FreeSql = freeSql; + EventAggregator = eventAggregator; + RegionManager = regionManager; + SysRunService = sysRunService; + ConfigService = configService; + ZlgLinDriveService = zlgLinDriveService; + ZlgCanDriveService = zlgCanDriveService; + ComActionService = comActionService; + LogicRuleService = logicRuleService; + Mapper = mapper; + EventAggregator.GetEvent().Subscribe(CanLinConfigChangedEventCall); + + InitLoadLinConfigPro(); + } + + /// + /// CAN/LIN 配置导入后刷新当前页面。 + /// + /// 事件消息。 + private void CanLinConfigChangedEventCall(string msg) + { + ReloadCurrentConfigPro(); + } + + /// + /// Prism 弹窗服务。 + /// + public IDialogService DialogService { get; } + + /// + /// FreeSql（用于 LIN 配置程序/读写项/调度表 的查询与持久化）。 + /// + public IFreeSql FreeSql { get; } + + /// + /// 事件聚合器。 + /// + public IEventAggregator EventAggregator { get; } + + /// + /// 区域管理器。 + /// + public IRegionManager RegionManager { get; } + + /// + /// 系统运行状态服务。 + /// + public SysRunService SysRunService { get; } + + /// + /// 全局配置服务（用于记录当前系统选择的通信类型等状态）。 + /// + public ConfigService ConfigService { get; } + + /// + /// ZLG LIN 服务（LIN 生命周期、LDF 解析、软件调度、收发指示灯等）。 + /// + public ZlgLinDriveService ZlgLinDriveService { get; } + + /// + /// ZLG CAN 服务。 + /// 说明：LIN 与 CAN 共用同一硬件/设备句柄，打开 LIN 前需要确保 CAN 已关闭。 + /// + public ZlgCanDriveService ZlgCanDriveService { get; } + + /// + /// 通信驱动互斥控制服务（同一时刻只能有一种驱动操作压缩机）。 + /// + public ComActionService ComActionService { get; } + + /// + /// 逻辑规则服务。 + /// + public LogicRuleService LogicRuleService { get; } + + /// + /// AutoMapper。 + /// + public IMapper Mapper { get; } + + private List linConfigPros = new List(); + + private ObservableCollection? _ListCanLinConfigPro; + /// + /// LIN 配置程序集合。 + /// + public ObservableCollection? ListCanLinConfigPro + { + get { return _ListCanLinConfigPro; } + set { _ListCanLinConfigPro = value; RaisePropertyChanged(); } + } + + /// + /// 选中的配置程序。 + /// + public CanLinConfigPro? SelectCanLinConfigPro { get; set; } + + private ObservableCollection _listWriteCanLinRWConfigDto = new ObservableCollection(); + /// + /// 写入配置 DTO 集合（UI 展示/编辑用）。 + /// + public ObservableCollection ListWriteCanLinRWConfigDto + { + get { return _listWriteCanLinRWConfigDto; } + set { _listWriteCanLinRWConfigDto = value; RaisePropertyChanged(); } + } + + private ObservableCollection _listReadCanLinRWConfigDto = new ObservableCollection(); + /// + /// 读取配置 DTO 集合（UI 展示/编辑用）。 + /// + public ObservableCollection ListReadCanLinRWConfigDto + { + get { return _listReadCanLinRWConfigDto; } + set { _listReadCanLinRWConfigDto = value; RaisePropertyChanged(); } + } + + private ObservableCollection _listLINScheduleConfigDto = new ObservableCollection(); + /// + /// LIN 调度表集合（系统层）。 + /// + public ObservableCollection ListLINScheduleConfigDto + { + get { return _listLINScheduleConfigDto; } + set { _listLINScheduleConfigDto = value; RaisePropertyChanged(); } + } + + private bool _isLinConfigProActive; + /// + /// 当前配置程序是否已激活（对齐 CAN Active 语义）。激活后禁止切换配置程序。 + /// + public bool IsLinConfigProActive + { + get { return _isLinConfigProActive; } + set + { + _isLinConfigProActive = value; + RaisePropertyChanged(); + RaisePropertyChanged(nameof(IsRwEditable)); + } + } + + private bool _isLINConfigDatagridActive = true; + /// + /// 配置程序 DataGrid 是否可操作（与 IsLinConfigProActive 取反）。 + /// + public bool IsLINConfigDatagridActive + { + get { return _isLINConfigDatagridActive; } + set { _isLINConfigDatagridActive = value; RaisePropertyChanged(); } + } + + /// + /// 读写设置是否允许编辑。 + /// 说明：与 语义绑定：激活后代表“配置已下发并进入运行态”，因此禁止编辑配置/切换配置程序。 + /// + public bool IsRwEditable + { + get { return !IsLinConfigProActive; } + } + + private LINConfigExdDto? _SelectedLINConfigExdDto; + /// + /// 选中的 LIN 配置 DTO。 + /// + public LINConfigExdDto? SelectedLINConfigExdDto + { + get { return _SelectedLINConfigExdDto; } + set + { + _SelectedLINConfigExdDto = value; + RaisePropertyChanged(); + + // SelectedLINConfigExdDto 变更时，需要同步刷新其映射的“派生属性”（都是 UI 绑定入口）。 + RaisePropertyChanged(nameof(CurrentLdfPath)); + RaisePropertyChanged(nameof(CurrentSchEnable)); + RaisePropertyChanged(nameof(LinBaudRate)); + } + } + + /// + /// 当前 LDF 路径。 + /// + public string? CurrentLdfPath + { + get { return SelectedLINConfigExdDto?.LdfPath; } + set + { + if (SelectedLINConfigExdDto == null) return; + SelectedLINConfigExdDto.LdfPath = value; + RaisePropertyChanged(); + } + } + + /// + /// 循环周期（ms）。 + /// + public int CurrentCycle + { + get { return SelectedLINConfigExdDto?.Cycle ?? 0; } + set + { + if (SelectedLINConfigExdDto == null) return; + SelectedLINConfigExdDto.Cycle = value; + RaisePropertyChanged(); + } + } + + /// + /// 连接按钮文字。 + /// + public string ConnectButtonText + { + get { return "连接LIN"; } + } + + /// + /// 关闭按钮文字。 + /// + public string CloseButtonText + { + get { return "关闭LIN"; } + } + + /// + /// LIN 波特率。 + /// + public int LinBaudRate + { + get { return SelectedLINConfigExdDto?.BaudRate ?? 0; } + set + { + if (SelectedLINConfigExdDto == null) return; + SelectedLINConfigExdDto.BaudRate = value; + RaisePropertyChanged(); + } + } + + /// + /// 调度表使能。 + /// + public bool CurrentSchEnable + { + get { return SelectedLINConfigExdDto?.SchEnable ?? false; } + set + { + if (SelectedLINConfigExdDto == null) return; + SelectedLINConfigExdDto.SchEnable = value; + RaisePropertyChanged(); + } + } + + private void InitLoadLinConfigPro() + { + // 从数据库加载 LIN 配置程序： + // - 同时 include 扩展配置、读写项（含逻辑规则）、调度表 + // - 供主界面 DataGrid 与右侧配置区域绑定 + linConfigPros = FreeSql.Select() + .Where(a => a.CANLINInfo == CANLIN.LIN) + .Include(a => a.LINConfigExd) + .IncludeMany(a => a.CanLinConfigContents, then => then.Include(b => b.LogicRule)) + .IncludeMany(a => a.LinScheduleConfigs) + .ToList(); + + ListCanLinConfigPro = new ObservableCollection(linConfigPros); + } + + private void SyncSelectedConfig() + { + if (SelectCanLinConfigPro == null) return; + + // 实体 -> DTO： + // - DTO 用于 UI 编辑（双向绑定）； + // - 保存时再由 VM 负责落库； + // - 激活时则以 DTO/当前列表为准，下发到 Service（避免直接引用数据库实体导致并发/脏写）。 + SelectedLINConfigExdDto = Mapper.Map(SelectCanLinConfigPro.LINConfigExd); + + var writeData = SelectCanLinConfigPro.CanLinConfigContents?.Where(a => a.RWInfo == RW.Write).ToList() ?? new List(); + ListWriteCanLinRWConfigDto = new ObservableCollection(Mapper.Map>(writeData)); + + var readData = SelectCanLinConfigPro.CanLinConfigContents?.Where(a => a.RWInfo == RW.Read).ToList() ?? new List(); + ListReadCanLinRWConfigDto = new ObservableCollection(Mapper.Map>(readData)); + + var schData = SelectCanLinConfigPro.LinScheduleConfigs?.ToList() ?? new List(); + ListLINScheduleConfigDto = new ObservableCollection(Mapper.Map>(schData)); + + // 触发依赖属性刷新：IsRwEditable 与 CurrentCycle 取决于当前选择的配置与激活状态。 + RaisePropertyChanged(nameof(IsRwEditable)); + RaisePropertyChanged(nameof(CurrentCycle)); + } + + private DelegateCommand? _LinConfigProGridSelectionChangedCmd; + /// + /// LIN 配置程序选中变化。 + /// + public DelegateCommand LinConfigProGridSelectionChangedCmd + { + get + { + if (_LinConfigProGridSelectionChangedCmd == null) + { + _LinConfigProGridSelectionChangedCmd = new DelegateCommand(LinConfigProGridSelectionChangedCmdMethod); + } + return _LinConfigProGridSelectionChangedCmd; + } + } + + private void LinConfigProGridSelectionChangedCmdMethod(object par) + { + if (par == null) return; + if (par is SelectionChangedEventArgs) return; + + if (IsLinConfigProActive) + { + MessageBox.Show("当前配置程序已激活，请先取消激活后再切换", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (par is CanLinConfigPro) + { + SelectCanLinConfigPro = par as CanLinConfigPro; + SyncSelectedConfig(); + return; + } + + var args = par as SelectionChangedEventArgs; + if (args == null || args.AddedItems == null || args.AddedItems.Count == 0) return; + var selected = args.AddedItems[0] as CanLinConfigPro; + if (selected == null) return; + + SelectCanLinConfigPro = selected; + SyncSelectedConfig(); + } + + private DelegateCommand? _linConfigProCmd; + /// + /// 配置程序操作（新建/修改/删除/激活）。 + /// + public DelegateCommand LinConfigProCmd + { + get + { + if (_linConfigProCmd == null) + { + _linConfigProCmd = new DelegateCommand(LinConfigProCmdMethod); + } + return _linConfigProCmd; + } + } + + private void LinConfigProCmdMethod(string par) + { + if (string.IsNullOrWhiteSpace(par)) return; + + try + { + switch (par) + { + case "Add": + if (IsLinConfigProActive) + { + MessageBox.Show("当前配置已激活，请先取消激活后再新建/修改配置程序", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + if (ZlgLinDriveService.OpenState) + { + MessageBox.Show("请先关闭 LIN 后再新建配置程序", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + DialogService.ShowDialog("DialogCanLinConfigCreateView", new DialogParameters() { { "Name", "" } }, r => + { + if (r.Result != ButtonResult.OK) return; + + var name = r.Parameters.GetValue("Name")?.Trim(); + if (string.IsNullOrWhiteSpace(name)) + { + MessageBox.Show("名称不能为空", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + var exists = FreeSql.Select() + .Where(a => a.CANLINInfo == CANLIN.LIN) + .Where(a => a.ConfigName == name) + .Any(); + if (exists) + { + MessageBox.Show("名称已存在，请更换名称", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + long newProId = 0; + FreeSql.Transaction(() => + { + var exdList = FreeSql.Insert(new LINConfigExd() + { + BaudRate = 19200, + Cycle = 100, + LdfPath = string.Empty, + SchEnable = false, + }).ExecuteInserted(); + var exd = exdList?.FirstOrDefault(); + if (exd == null) + { + throw new InvalidOperationException("创建 LIN 扩展配置失败"); + } + + var proList = FreeSql.Insert(new CanLinConfigPro() + { + ConfigName = name, + CANLINInfo = CANLIN.LIN, + LINConfigExdId = exd.Id, + }).ExecuteInserted(); + var pro = proList?.FirstOrDefault(); + if (pro == null) + { + throw new InvalidOperationException("创建 LIN 配置程序失败"); + } + + newProId = pro.Id; + }); + + InitLoadLinConfigPro(); + SelectCanLinConfigPro = linConfigPros.Find(a => a.Id == newProId); + SyncSelectedConfig(); + }); + break; + + case "Edit": + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + if (IsLinConfigProActive) + { + MessageBox.Show("当前配置已激活，请先取消激活后再修改配置程序", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + if (ZlgLinDriveService.OpenState) + { + MessageBox.Show("请先关闭 LIN 后再修改配置程序", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + DialogService.ShowDialog("DialogCanLinConfigCreateView", new DialogParameters() { { "Name", SelectCanLinConfigPro.ConfigName } }, r => + { + if (r.Result != ButtonResult.OK) return; + + var name = r.Parameters.GetValue("Name")?.Trim(); + if (string.IsNullOrWhiteSpace(name)) + { + MessageBox.Show("名称不能为空", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + var exists = FreeSql.Select() + .Where(a => a.CANLINInfo == CANLIN.LIN) + .Where(a => a.ConfigName == name) + .Where(a => a.Id != SelectCanLinConfigPro.Id) + .Any(); + if (exists) + { + MessageBox.Show("名称已存在，请更换名称", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + FreeSql.Update() + .Set(a => a.ConfigName, name) + .Where(a => a.Id == SelectCanLinConfigPro.Id) + .ExecuteAffrows(); + + ReloadCurrentConfigPro(); + }); + break; + + case "Delete": + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + if (IsLinConfigProActive) + { + MessageBox.Show("当前配置已激活，请先取消激活后再删除配置程序", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + if (ZlgLinDriveService.OpenState) + { + MessageBox.Show("请先关闭 LIN 后再删除配置程序", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + if (MessageBox.Show($"确定删除配置程序：{SelectCanLinConfigPro.ConfigName}？", "确认", MessageBoxButton.OKCancel, MessageBoxImage.Warning) != MessageBoxResult.OK) + { + return; + } + + var repo = FreeSql.GetRepository(); + repo.DbContextOptions.EnableCascadeSave = true; + var delList = repo.Select + .Include(a => a.LINConfigExd) + .IncludeMany(a => a.CanLinConfigContents) + .IncludeMany(a => a.LinScheduleConfigs) + .Where(a => a.Id == SelectCanLinConfigPro.Id) + .ToList(); + repo.Delete(delList); + foreach (var item in delList) + { + if (item.LINConfigExdId > 0) + { + FreeSql.Delete(item.LINConfigExdId).ExecuteAffrows(); + } + } + + SelectCanLinConfigPro = null; + SelectedLINConfigExdDto = null; + InitLoadLinConfigPro(); + ListLINScheduleConfigDto = new ObservableCollection(); + break; + + case "Active": + if (IsLinConfigProActive) + { + // 取消激活： + // - 停止循环/调度发送 + // - 关闭事件驱动发送开关 + // - 清空 CmdData（避免残留订阅导致误发送） + IsLinConfigProActive = false; + IsLINConfigDatagridActive = true; + + ZlgLinDriveService.StopSchedule(); + ZlgLinDriveService.IsCycleSend = false; + ZlgLinDriveService.LoadCmdDataToDrive(new List()); + + return; + } + + if (!ZlgLinDriveService.OpenState) + { + MessageBox.Show("请确保 LIN 已连接后再激活", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (SelectCanLinConfigPro == null || SelectedLINConfigExdDto == null) + { + MessageBox.Show("选中后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (string.IsNullOrWhiteSpace(CurrentLdfPath)) + { + MessageBox.Show("请先选择并解析 LDF 文件后再激活", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + // 激活前强制按“当前配置的 LDF 路径”重新解析，避免 LdfParserState 来自其它配置导致错配。 + try + { + ZlgLinDriveService.StartLdf(CurrentLdfPath); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + return; + } + + IsLinConfigProActive = true; + IsLINConfigDatagridActive = false; + + // 激活后： + // - 将当前配置程序引用交给 Service（用于后续业务关联/显示） + // - 构建并下发 CmdData + // - 下发调度表配置快照（仅缓存，真正启动由 CycleSend/SchEnable 控制） + ZlgLinDriveService.SelectedCanLinConfigPro = SelectCanLinConfigPro; + BuildAndLoadCmdDataToDrive(); + ZlgLinDriveService.SetScheduleConfigs(ListLINScheduleConfigDto?.ToList() ?? new List()); + break; + } + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + } + + private DelegateCommand? _LoadLdfCmd; + /// + /// 选择 LDF 文件。 + /// + public DelegateCommand LoadLdfCmd + { + get + { + if (_LoadLdfCmd == null) + { + _LoadLdfCmd = new DelegateCommand(LoadLdfCmdMethod); + } + return _LoadLdfCmd; + } + } + + private void LoadLdfCmdMethod() + { + try + { + if (SelectCanLinConfigPro == null || SelectedLINConfigExdDto == null) + { + MessageBox.Show("选中LIN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + OpenFileDialog openFileDialogInfo = new OpenFileDialog(); + openFileDialogInfo.Filter = "(*.ldf;*.ldf)|*.ldf;*.ldf|all|*.*"; + openFileDialogInfo.CheckFileExists = true; + openFileDialogInfo.CheckPathExists = true; + openFileDialogInfo.ShowDialog(); + + CurrentLdfPath = openFileDialogInfo.FileName; + } + catch + { + MessageBox.Show("可能未选择信息", "提示", MessageBoxButton.OKCancel, MessageBoxImage.Hand); + } + } + + private DelegateCommand? _LinOpCmd; + /// + /// LIN 操作命令。 + /// + public DelegateCommand LinOpCmd + { + get + { + if (_LinOpCmd == null) + { + _LinOpCmd = new DelegateCommand(LinOpCmdMethod); + } + return _LinOpCmd; + } + } + + private void LinOpCmdMethod(string par) + { + switch (par) + { + case "Open": + if (ComActionService.IsLINToDoWork() == false) + { + MessageBox.Show("请关闭CAN连接后才能开启LIN，同一个时刻只能有一个通信驱动压缩机", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (ZlgCanDriveService.OpenState) + { + MessageBox.Show("请先关闭 ZLG CAN 连接后再开启 ZLG LIN", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (SelectCanLinConfigPro == null || SelectedLINConfigExdDto == null) + { + MessageBox.Show("选中LIN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + // 打开 LIN（不依赖 LDF） + ZlgLinDriveService.StartLinDrive(0, (uint)SelectedLINConfigExdDto.BaudRate, isMaster: true); + if (ZlgLinDriveService.OpenState) + { + ConfigService.CanLinRunStateModel.CurSysSelectedCanLin = CanLinEnum.Lin; + } + + // 打开后同步调度使能状态（避免 UI 未触发 Click 时服务端状态不一致） + ZlgLinDriveService.SchEnable = CurrentSchEnable; + + RaisePropertyChanged(nameof(IsRwEditable)); + break; + + case "Close": + try + { + // 停止循环发送/事件驱动发送，避免关闭后仍持续发送 + ZlgLinDriveService.StopSchedule(); + ZlgLinDriveService.IsCycleSend = false; + ZlgLinDriveService.LoadCmdDataToDrive(new List()); + } + catch + { + // ignore + } + ZlgLinDriveService.CloseDevice(); + ConfigService.CanLinRunStateModel.CurSysSelectedCanLin = CanLinEnum.No; + + // 关闭设备时自动退出激活，恢复可切换状态 + IsLinConfigProActive = false; + IsLINConfigDatagridActive = true; + + RaisePropertyChanged(nameof(IsRwEditable)); + break; + + case "Save": + if (SelectCanLinConfigPro == null || SelectedLINConfigExdDto == null) + { + MessageBox.Show("选中LIN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + // 仅保存 LINConfigExd（LDF 路径/周期/波特率/SchEnable 等）； + // 读写项/调度表由各自弹窗或其它操作链路持久化。 + FreeSql.Update() + .Set(a => a.LdfPath, SelectedLINConfigExdDto.LdfPath) + .Set(a => a.Cycle, SelectedLINConfigExdDto.Cycle) + .Set(a => a.BaudRate, SelectedLINConfigExdDto.BaudRate) + .Set(a => a.SchEnable, SelectedLINConfigExdDto.SchEnable) + .Where(a => a.Id == SelectedLINConfigExdDto.Id) + .ExecuteUpdated(); + + InitLoadLinConfigPro(); + break; + + case "Parse": + // 解析 LDF： + // - 解析成功后会建立运行时索引（帧/信号位定义），用于后续编码发送与接收解码； + // - 并同步构建 CmdData（用于后续调度/事件驱动）。 + if (SelectCanLinConfigPro == null || SelectedLINConfigExdDto == null) + { + MessageBox.Show("选中LIN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + try + { + ZlgLinDriveService.StartLdf(SelectedLINConfigExdDto.LdfPath ?? string.Empty); + + // 解析完成后同步 CmdData（用于后续调度/事件驱动） + BuildAndLoadCmdDataToDrive(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + } + break; + + case "CycleSend": + if (!ZlgLinDriveService.OpenState) + { + MessageBox.Show("请先打开 LIN 后再进行循环发送", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (!ZlgLinDriveService.LdfParserState) + { + MessageBox.Show("请先解析 LDF 后再进行循环发送", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + // 第一次点击开启，第二次点击关闭 + if (!ZlgLinDriveService.IsCycleSend) + { + // 开启前：确保最新 CmdData 已下发 + BuildAndLoadCmdDataToDrive(); + + // 同步 SchEnable + ZlgLinDriveService.SchEnable = CurrentSchEnable; + + if (ZlgLinDriveService.SchEnable) + { + var groupMsg = ZlgLinDriveService.CmdData + .Where(a => !string.IsNullOrWhiteSpace(a.MsgName)) + .GroupBy(a => a.MsgName) + .Select(g => g.Key) + .ToList(); + + if (groupMsg.Count == 0) + { + MessageBox.Show("未发现可发送的消息帧（CmdData.MsgName 为空）", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + foreach (var msg in groupMsg) + { + if (!ListLINScheduleConfigDto.Any(a => string.Equals(a.MsgName, msg, StringComparison.Ordinal))) + { + MessageBox.Show($"你使能了调度表，但是调度表中没有设置【{msg}】信息，请设置后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + } + + if (ListLINScheduleConfigDto == null || ListLINScheduleConfigDto.Count == 0) + { + MessageBox.Show("调度表配置为空数据，请检查！将无法发送数据", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + // LIN 调度表：软件调度（每帧独立周期） + ZlgLinDriveService.SetScheduleConfigs(ListLINScheduleConfigDto.ToList()); + ZlgLinDriveService.StartSchedule(); + } + else + { + // 未启用调度表：按统一周期对 CmdData 中出现的帧做软件精确定时循环发送。 + var cycle = Math.Max(1, CurrentCycle); + ZlgLinDriveService.StartPrecisionCycleSend(cycle); + } + + ZlgLinDriveService.IsCycleSend = true; + } + else + { + ZlgLinDriveService.IsCycleSend = false; + ZlgLinDriveService.StopSchedule(); + } + break; + + case "CycleRecive": + ZlgLinDriveService.SetReceiveEnabled(!ZlgLinDriveService.IsCycleRevice); + break; + } + } + + /// + /// 从当前配置程序的写入配置构建并下发 LinCmdData。 + /// + private void BuildAndLoadCmdDataToDrive() + { + try + { + if (SelectCanLinConfigPro?.CanLinConfigContents == null) + { + ZlgLinDriveService.LoadCmdDataToDrive(new List()); + return; + } + + var writeItems = SelectCanLinConfigPro.CanLinConfigContents + .Where(a => a.RWInfo == RW.Write) + .ToList(); + + var cmdList = new List(); + foreach (var item in writeItems) + { + cmdList.Add(new LinCmdData() + { + ConfigName = item.Name, + MsgName = item.MsgFrameName, + SignalName = item.SignalName, + SignalCmdValue = double.TryParse(item.DefautValue, out double result) ? result : 0, + LogicRuleDto = Mapper.Map(item.LogicRule), + }); + } + + ZlgLinDriveService.LoadCmdDataToDrive(cmdList); + } + catch (Exception ex) + { + MessageBox.Show($"构建/下发 LIN CmdData 失败：{ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + } + + private DelegateCommand? _openRwDialogCmd; + /// + /// 打开“读写设置”弹窗。 + /// 说明： + /// - 弹窗内允许编辑写入/读取项，并可从 LDF 解析得到的信号池中选择； + /// - 弹窗确认后通过 重新从数据库加载并刷新 UI。 + /// + public DelegateCommand OpenRwDialogCmd + { + get + { + if (_openRwDialogCmd == null) + { + _openRwDialogCmd = new DelegateCommand(OpenRwDialogCmdMethod); + } + return _openRwDialogCmd; + } + } + + private void OpenRwDialogCmdMethod() + { + try + { + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中LIN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + var writeClones = new ObservableCollection( + (ListWriteCanLinRWConfigDto ?? new ObservableCollection()) + .Select(CloneRwDto)); + + foreach (var item in writeClones) + { + item.RWInfo = RW.Write; + } + + var readClones = new ObservableCollection( + (ListReadCanLinRWConfigDto ?? new ObservableCollection()) + .Select(CloneRwDto)); + + foreach (var item in readClones) + { + item.RWInfo = RW.Read; + } + + var candidates = new ObservableCollection(); + if (ZlgLinDriveService.ListLinLdfModel != null) + { + // 信号候选池：由 LDF 解析结果生成（帧名+信号名）。 + foreach (var sig in ZlgLinDriveService.ListLinLdfModel) + { + candidates.Add(new DialogZlgCanLinRwConfigViewModel.SignalCandidate + { + MsgName = sig.MsgName, + SignalName = sig.SignalName, + Name = sig.Name, + Desc = sig.SignalDesc, + }); + } + } + + var pars = new DialogParameters + { + { "Title", "读写设置" }, + { "CanLinConfigProId", SelectCanLinConfigPro.Id }, + { "IsEditable", IsRwEditable }, + { "EnableHardwareCycleSchedule", false }, + { "WriteConfigs", writeClones }, + { "ReadConfigs", readClones }, + { "SignalCandidates", candidates }, + }; + + DialogService.ShowDialog(nameof(DialogZlgCanLinRwConfigView), pars, r => + { + if (r.Result == ButtonResult.OK) + { + // 弹窗内部会持久化保存；这里仅负责重新加载并刷新当前 UI 绑定。 + ReloadCurrentConfigPro(); + } + }); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + } + + private void ReloadCurrentConfigPro() + { + var id = SelectCanLinConfigPro?.Id; + InitLoadLinConfigPro(); + + if (id != null) + { + SelectCanLinConfigPro = linConfigPros.Find(a => a.Id == id.Value); + SyncSelectedConfig(); + } + } + + /// + /// 克隆读写配置 DTO。 + /// 说明：打开弹窗前先克隆一份，避免用户在弹窗中编辑时直接影响主界面集合（取消时也不会污染当前 UI 状态）。 + /// + /// 源 DTO。 + /// 克隆后的 DTO。 + private static CanLinRWConfigDto CloneRwDto(CanLinRWConfigDto src) + { + return new CanLinRWConfigDto + { + Id = src.Id, + RWInfo = src.RWInfo, + Name = src.Name, + MsgFrameName = src.MsgFrameName, + SignalName = src.SignalName, + DefautValue = src.DefautValue, + LogicRuleId = src.LogicRuleId, + LogicRuleDto = src.LogicRuleDto, + }; + } + + private DelegateCommand? _SchEnableCmd; + /// + /// 调度表使能写入驱动。 + /// + public DelegateCommand SchEnableCmd + { + get + { + if (_SchEnableCmd == null) + { + _SchEnableCmd = new DelegateCommand(SchEnableCmdCall); + } + return _SchEnableCmd; + } + } + + private void SchEnableCmdCall(object par) + { + bool enable; + if (par is bool b) + { + enable = b; + } + else + { + enable = CurrentSchEnable; + } + + // 立即同步到 Service： + // - CurrentSchEnable 只是 DTO 字段，改变它并不等于驱动侧状态已更新； + // - 这里的命令用于“用户点击开关时”立刻让 Service/Driver 生效。 + ZlgLinDriveService.SchEnable = enable; + } + + private DelegateCommand? _scheduleConfigCmd; + /// + /// 调度表配置（弹窗）。 + /// + public DelegateCommand ScheduleConfigCmd + { + get + { + if (_scheduleConfigCmd == null) + { + _scheduleConfigCmd = new DelegateCommand(ScheduleConfigCmdMethod); + } + return _scheduleConfigCmd; + } + } + + private void ScheduleConfigCmdMethod() + { + try + { + if (SelectCanLinConfigPro == null) + { + MessageBox.Show("选中LIN配置名称后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + if (IsLinConfigProActive) + { + MessageBox.Show("当前配置已激活，请先取消激活后再配置调度表", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + // 确保 CmdData 最新（用于候选消息帧） + BuildAndLoadCmdDataToDrive(); + + // 调度表弹窗的 MsgName 候选列表：来自当前 CmdData 聚合。 + // 这样能保证“可配置的调度表项”与“实际会被编码发送的帧”一致。 + var msgList = ZlgLinDriveService.CmdData + .GroupBy(a => a.MsgName) + .Select(g => g.Key) + .Where(a => !string.IsNullOrWhiteSpace(a)) + .ToList(); + + if ((msgList == null || msgList.Count == 0) && (ListLINScheduleConfigDto == null || ListLINScheduleConfigDto.Count == 0)) + { + MessageBox.Show("未发现写入指令数据（CmdData 为空），无法配置调度表", "提示", MessageBoxButton.OK, MessageBoxImage.Hand); + return; + } + + DialogService.ShowDialog(nameof(DialogLINSchConfigView), new DialogParameters() + { + { "ListMsg", msgList }, + { "ListLINScheduleConfigDto", ListLINScheduleConfigDto }, + { "SelectCanLinConfigProId", SelectCanLinConfigPro.Id }, + }, r => + { + if (r.Result != ButtonResult.OK) return; + ListLINScheduleConfigDto = r.Parameters.GetValue>("ReturnValue") ?? new ObservableCollection(); + + // DTO -> 实体：用于持久化到数据库；后续激活/循环发送前会再次由 SyncSelectedConfig/BuildAndLoadCmdDataToDrive 同步到 Service。 + SelectCanLinConfigPro.LinScheduleConfigs = Mapper.Map>(ListLINScheduleConfigDto.ToList()); + ReloadCurrentConfigPro(); + }); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "错误", MessageBoxButton.OK, MessageBoxImage.Error); + } + } + + /// + /// 根据 UI 当前 SchEnable/Cycle 状态启动或停止发送。 + /// + private void ApplyScheduleByUiState(bool schEnable) + { + if (!ZlgLinDriveService.OpenState) + { + return; + } + + if (!schEnable) + { + ZlgLinDriveService.StopSchedule(); + ZlgLinDriveService.IsCycleSend = false; + return; + } + + // 开启前：确保 LDF 已解析（否则无法编码） + if (!ZlgLinDriveService.LdfParserState) + { + if (SelectedLINConfigExdDto == null) + { + throw new InvalidOperationException("未选择 LIN 配置，无法启用调度。"); + } + + ZlgLinDriveService.StartLdf(SelectedLINConfigExdDto.LdfPath ?? string.Empty); + } + + // 下发 CmdData + BuildAndLoadCmdDataToDrive(); + + // 打开事件驱动发送（用于“值变化增量发送”） + ZlgLinDriveService.IsCycleSend = true; + + // 启动软件精确定时循环发送（作为当前 ZLG LIN 的“调度表”能力） + var cycle = SelectedLINConfigExdDto?.Cycle ?? 0; + if (cycle <= 0) + { + cycle = 100; + } + ZlgLinDriveService.StartPrecisionCycleSend(cycle); + } + + private void ApplyScheduleByUiState() + { + ApplyScheduleByUiState(CurrentSchEnable); + } + } +} diff --git a/CapMachine.Wpf/Views/DialogCANFdSchConfigView.xaml b/CapMachine.Wpf/Views/DialogCANFdSchConfigView.xaml new file mode 100644 index 0000000..c69316f --- /dev/null +++ b/CapMachine.Wpf/Views/DialogCANFdSchConfigView.xaml @@ -0,0 +1,206 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CapMachine.Wpf/Views/ZlgCanDriveConfigView.xaml.cs b/CapMachine.Wpf/Views/ZlgCanDriveConfigView.xaml.cs new file mode 100644 index 0000000..7b3efa3 --- /dev/null +++ b/CapMachine.Wpf/Views/ZlgCanDriveConfigView.xaml.cs @@ -0,0 +1,28 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Documents; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using System.Windows.Navigation; +using System.Windows.Shapes; + +namespace CapMachine.Wpf.Views +{ + /// + /// ZlgCanDriveConfigView.xaml 的交互逻辑 + /// + public partial class ZlgCanDriveConfigView : UserControl + { + public ZlgCanDriveConfigView() + { + InitializeComponent(); + } + } +} diff --git a/CapMachine.Wpf/Views/ZlgLinDriveConfigView.xaml b/CapMachine.Wpf/Views/ZlgLinDriveConfigView.xaml new file mode 100644 index 0000000..88b969a --- /dev/null +++ b/CapMachine.Wpf/Views/ZlgLinDriveConfigView.xaml @@ -0,0 +1,741 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CapMachine.Wpf/Views/ZlgLinDriveConfigView.xaml.cs b/CapMachine.Wpf/Views/ZlgLinDriveConfigView.xaml.cs new file mode 100644 index 0000000..b98d01b --- /dev/null +++ b/CapMachine.Wpf/Views/ZlgLinDriveConfigView.xaml.cs @@ -0,0 +1,28 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Documents; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using System.Windows.Navigation; +using System.Windows.Shapes; + +namespace CapMachine.Wpf.Views +{ + /// + /// ZlgLinDriveConfigView.xaml 的交互逻辑 + /// + public partial class ZlgLinDriveConfigView : UserControl + { + public ZlgLinDriveConfigView() + { + InitializeComponent(); + } + } +} diff --git a/Sample/C#_USBCANFD_251215/USBCANFD/ZLGAPI.cs b/Sample/C#_USBCANFD_251215/USBCANFD/ZLGAPI.cs new file mode 100644 index 0000000..13d3592 --- /dev/null +++ b/Sample/C#_USBCANFD_251215/USBCANFD/ZLGAPI.cs @@ -0,0 +1,1236 @@ +// update time 2025/12/11 + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Runtime.InteropServices; + +namespace ZLGAPI +{ + + public class ZLGCAN + { + + #region 设备类型 + public static UInt32 ZCAN_PCI9810 = 2; + public static UInt32 ZCAN_USBCAN1 = 3; + public static UInt32 ZCAN_USBCAN2 = 4; + public static UInt32 ZCAN_PCI9820 = 5; + public static UInt32 ZCAN_CANETUDP = 12; + public static UInt32 ZCAN_PCI9840 = 14; + public static UInt32 ZCAN_PCI9820I = 16; + public static UInt32 ZCAN_CANETTCP = 17; + public static UInt32 ZCAN_PCI5010U = 19; + public static UInt32 ZCAN_USBCAN_E_U = 20; + public static UInt32 ZCAN_USBCAN_2E_U = 21; + public static UInt32 ZCAN_PCI5020U = 22; + public static UInt32 ZCAN_PCIE9221 = 24; + public static UInt32 ZCAN_WIFICAN_TCP = 25; + public static UInt32 ZCAN_WIFICAN_UDP = 26; + public static UInt32 ZCAN_PCIe9120 = 27; + public static UInt32 ZCAN_PCIe9110 = 28; + public static UInt32 ZCAN_PCIe9140 = 29; + public static UInt32 ZCAN_USBCAN_4E_U = 31; + public static UInt32 ZCAN_CANDTU_200UR = 32; + public static UInt32 ZCAN_USBCAN_8E_U = 34; + public static UInt32 ZCAN_CANDTU_NET = 36; + public static UInt32 ZCAN_CANDTU_100UR = 37; + public static UInt32 ZCAN_PCIE_CANFD_200U = 39; + public static UInt32 ZCAN_PCIE_CANFD_400U = 40; + public static UInt32 ZCAN_USBCANFD_200U = 41; + public static UInt32 ZCAN_USBCANFD_100U = 42; + public static UInt32 ZCAN_USBCANFD_MINI = 43; + public static UInt32 ZCAN_CANSCOPE = 45; + public static UInt32 ZCAN_CLOUD = 46; + public static UInt32 ZCAN_CANDTU_NET_400 = 47; + public static UInt32 ZCAN_CANFDNET_TCP = 48; + public static UInt32 ZCAN_CANFDNET_200U_TCP = 48; + public static UInt32 ZCAN_CANFDNET_UDP = 49; + public static UInt32 ZCAN_CANFDNET_200U_UDP = 49; + public static UInt32 ZCAN_CANFDWIFI_TCP = 50; + public static UInt32 ZCAN_CANFDWIFI_100U_TCP = 50; + public static UInt32 ZCAN_CANFDWIFI_UDP = 51; + public static UInt32 ZCAN_CANFDWIFI_100U_UDP = 51; + public static UInt32 ZCAN_CANFDNET_400U_TCP = 52; + public static UInt32 ZCAN_CANFDNET_400U_UDP = 53; + public static UInt32 ZCAN_CANFDNET_100U_TCP = 55; + public static UInt32 ZCAN_CANFDNET_100U_UDP = 56; + public static UInt32 ZCAN_CANFDNET_800U_TCP = 57; + public static UInt32 ZCAN_CANFDNET_800U_UDP = 58; + public static UInt32 ZCAN_USBCANFD_800U = 59; + public static UInt32 ZCAN_PCIE_CANFD_100U_EX = 60; + public static UInt32 ZCAN_PCIE_CANFD_400U_EX = 61; + public static UInt32 ZCAN_PCIE_CANFD_200U_MINI = 62; + public static UInt32 ZCAN_PCIE_CANFD_200U_EX = 63; + public static UInt32 ZCAN_PCIE_CANFD_200U_M2 = 63; + public static UInt32 ZCAN_CANFDDTU_400_TCP = 64; + public static UInt32 ZCAN_CANFDDTU_400_UDP = 65; + public static UInt32 ZCAN_CANFDWIFI_200U_TCP = 66; + public static UInt32 ZCAN_CANFDWIFI_200U_UDP = 67; + public static UInt32 ZCAN_CANFDDTU_800ER_TCP = 68; + public static UInt32 ZCAN_CANFDDTU_800ER_UDP = 69; + public static UInt32 ZCAN_CANFDDTU_800EWGR_TCP = 70; + public static UInt32 ZCAN_CANFDDTU_800EWGR_UDP = 71; + public static UInt32 ZCAN_CANFDDTU_600EWGR_TCP = 72; + public static UInt32 ZCAN_CANFDDTU_600EWGR_UDP = 73; + public static UInt32 ZCAN_CANFDDTU_CASCADE_TCP = 74; + public static UInt32 ZCAN_CANFDDTU_CASCADE_UDP = 75; + public static UInt32 ZCAN_USBCANFD_400U = 76; + public static UInt32 ZCAN_CANFDDTU_200U = 77; + public static UInt32 ZCAN_ZPSCANFD_TCP = 78; + public static UInt32 ZCAN_ZPSCANFD_USB = 79; + public static UInt32 ZCAN_CANFDBRIDGE_PLUS = 80; + public static UInt32 ZCAN_CANFDDTU_300U = 81; + public static UInt32 ZCAN_PCIE_CANFD_800U = 82; + public static UInt32 ZCAN_PCIE_CANFD_1200U = 83; + public static UInt32 ZCAN_MINI_PCIE_CANFD = 84; + public static UInt32 ZCAN_USBCANFD_800H = 85; + #endregion + + #region LIN事件 + public static UInt32 ZCAN_LIN_WAKE_UP = 1; + public static UInt32 ZCAN_LIN_ENTERED_SLEEP_MODE = 2; + public static UInt32 ZCAN_LIN_EXITED_SLEEP_MODE = 3; + #endregion + + #region 函数 + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_OpenDevice(uint device_type, uint device_index, uint reserved); + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_OpenDeviceByName(uint device_type, string name); + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_CloseDevice(IntPtr device_handle); + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_IsDeviceOnLine(IntPtr device_handle); + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_GetDeviceInf(IntPtr device_handle, IntPtr pInfo); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_InitCAN(IntPtr device_handle, uint can_index, IntPtr pInitConfig); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_InitCAN(IntPtr device_handle, uint can_index, ref ZCAN_CHANNEL_INIT_CONFIG config); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_StartCAN(IntPtr chn_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ResetCAN(IntPtr chn_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ClearBuffer(IntPtr chn_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReadChannelErrInfo(IntPtr chn_handle, ref ZCAN_CHANNEL_ERR_INFO pErrInfo); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_GetReceiveNum(IntPtr channel_handle, byte type); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_Transmit(IntPtr channel_handle, IntPtr pTransmit, uint len); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_TransmitFD(IntPtr channel_handle, IntPtr pTransmit, uint len); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_TransmitData(IntPtr device_handle, IntPtr pTransmit, uint len); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_Receive(IntPtr channel_handle, IntPtr pReceive, uint len, int wait_time = -1); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReceiveFD(IntPtr channel_handle, IntPtr pReceive, uint len, int wait_time = -1); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReceiveData(IntPtr device_handle, IntPtr pReceive, uint len, int wait_time); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetValue(IntPtr device_handle, string path, string value); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetValue(IntPtr device_handle, string path, IntPtr value); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetValue(IntPtr device_handle, string path, ref ZCAN_AUTO_TRANSMIT_OBJ value); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetValue(IntPtr device_handle, string path, ref ZCANFD_AUTO_TRANSMIT_OBJ value); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_GetValue(IntPtr device_handle, string path); + + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_InitLIN(IntPtr device_handle, uint lin_index, IntPtr pLINInitConfig); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_StartLIN(IntPtr channel_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ResetLIN(IntPtr channel_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_TransmitLIN(IntPtr channel_handle, IntPtr pSend, uint Len); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_GetLINReceiveNum(IntPtr channel_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReceiveLIN(IntPtr channel_handle, IntPtr pReceive, uint Len, int WaitTime); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetLINPublish(IntPtr channel_handle, IntPtr pSend, uint nPublishCount); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetLINSubscribe(IntPtr channel_handle, IntPtr pSend, uint nSubscribeCount); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_WakeUpLIN(IntPtr channel_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_Request(IntPtr device_handle, IntPtr req, IntPtr resp, IntPtr dataBuf, uint dataBufSize); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_Control(IntPtr device_handle, IntPtr ctrl, IntPtr resp); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_RequestEX(IntPtr device_handle, IntPtr requestData, IntPtr resp, IntPtr dataBuf, uint dataBufSize); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_ControlEX(IntPtr device_handle, uint dataType, IntPtr ctrl, IntPtr resp); + #endregion + + #region 结构体 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_DEVICE_INFO + { + public ushort hw_Version; + public ushort fw_Version; + public ushort dr_Version; + public ushort in_Version; + public ushort irq_Num; + public byte can_Num; + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)] + public char[] str_Serial_Num; + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 40)] + public char[] str_hw_Type; + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] + public byte[] reserved; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_CHANNEL_INIT_CONFIG + { + public uint can_type; + public _ZCAN_CHANNEL_INIT_CONFIG config; + } + + + [StructLayout(LayoutKind.Explicit, Pack = 1)] + public struct _ZCAN_CHANNEL_INIT_CONFIG + { + [FieldOffset(0)] + public _ZCAN_CHANNEL_CAN_INIT_CONFIG can; + [FieldOffset(0)] + public _ZCAN_CHANNEL_CANFD_INIT_CONFIG canfd; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZCAN_CHANNEL_CAN_INIT_CONFIG + { + public uint acc_code; + public uint acc_mask; + public uint reserved; + public byte filter; + public byte timing0; + public byte timing1; + public byte mode; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZCAN_CHANNEL_CANFD_INIT_CONFIG + { + public uint acc_code; + public uint acc_mask; + public uint abit_timing; + public uint dbit_timing; + public uint brp; + public byte filter; + public byte mode; + public ushort pad; + public uint reserved; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_CHANNEL_ERR_INFO + { + public uint error_code; + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] + public byte[] passive_ErrData; + public byte arLost_ErrData; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_Transmit_Data + { + public can_frame frame; + public uint transmit_type; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class can_frame + { + public uint can_id; + public byte can_dlc; // frame payload length in byte (0 .. CAN_MAX_DLEN) + public byte __pad; // padding + public byte __res0; // reserved / padding + public byte __res1; // reserved / padding + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] data; // frame data + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class canfd_frame + { + public uint can_id; + public byte len; + public byte flags; + public byte __res0; + public byte __res1; /* reserved / padding */ + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public byte[] data; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZCAN_Receive_Data + { + public can_frame frame; + public UInt64 timestamp; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZCAN_ReceiveFD_Data + { + public canfd_frame frame; + public UInt64 timestamp; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_AUTO_TRANSMIT_OBJ //CANFD定时发送帧结构体 + { + public ushort enable; //0-禁用，1-使能 + public ushort index; //定时报文索引 + public uint interval; //定时周期 + public ZCAN_Transmit_Data obj; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANFD_AUTO_TRANSMIT_OBJ //CANFD定时发送帧结构体 + { + public ushort enable; //0-禁用，1-使能 + public ushort index; //定时报文索引 + public uint interval; //定时周期 + public ZCAN_TransmitFD_Data obj; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_TransmitFD_Data + { + public canfd_frame frame; // 报文数据信息，详见 canfd_frame 结构说明。 + public uint transmit_type; // 发送方式，0=正常发送，1=单次发送，2=自发自收，3=单次自发自收。 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANCANFDData + { + public UInt64 timeStamp; + public UInt32 flag; // flag用于设置一些参数，内部结构可以通过以下函数实现设置和取值 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] + public byte[] extraData; //未使用 + public canfd_frame frame; //实际报文结构体 + + // frameType 帧类型 0-CAN 1-CANFD + public uint frameType { + get { return (flag & 0x03); } + set { flag = (uint)((flag & ~0x03) | (value & 0x03)); } + } + + // txDelay队列发送延时，延时时间存放在 timeStamp 字段；0-不启用延时，1-启用延时，单位1ms，2-启用延时，单位100us + public uint txDelay { + get { return ((flag >> 2) & 0x03); } + set { flag = (uint)((flag & ~0x0C) | (value & 0x03) << 2); } + } + + public uint transmitType { + get { return ((flag >> 4) & 0x0F); } + set { flag = (uint)((flag & ~0x0F) | (value & 0x0F) << 4); } + } + + public uint txEchoRequest { + get { return ((flag >> 8) & 0x01); } + set { flag = (uint)(flag | (value & 0x01) << 8); } + } + + public uint txEchoed { + get { return ((flag >> 9) & 0x01); } // bit9 + set { flag = (uint)((flag & ~0x200) | (value & 0x01) << 9); } + } + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct PID + { + public byte rawVal; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct RxData + { + public UInt64 timeStamp; + public byte datalen; + public byte dir; + public byte chkSum; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 13)] + public byte[] reserved; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] data; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANDataObj + { + public byte dataType; // 1-CAN/CANFD数据, 4-LIN数据 + public byte chnl; // 数据通道 + public UInt16 flag; // 未使用 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] + public byte[] extraData; // 未使用 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 92)] + public byte[] data; // 报文结构体 + } + + + // LIN + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINData + { + public PID pid; // 受保护的ID + public RxData rxData; // 数据 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINErrData + { + public UInt64 timeStamp; // 时间戳，单位微秒(us) + public PID pid; // 受保护的ID + + public byte dataLen; // 数据长度 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] data; // 数据 + + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] + public byte[] errData; // 错误信息 + + public byte dir; // 传输方向 + public byte chkSum; // 数据校验，部分设备不支持校验数据的获取 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINEventData + { + public UInt64 timeStamp; // 时间戳，单位微秒(us) + public byte type; // 数据长度 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_MSG + { + public byte chnl; // 数据通道 + public byte dataType; // 0-LIN，1-ErrLIN + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 46)] + public byte[] data; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_INIT_CONFIG + { + public byte linMode; // 0-slave,1-master + public byte chkSumMode; // 1-经典校验，2-增强校验 3-自动(对应eZLINChkSumMode的模式) + public byte maxLength; // 最大数据长度，8~64 + public byte reserved; + public uint libBaud; // 波特率，取值1000~20000 + + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_PUBLISH_CFG + { + public byte ID; // 受保护的ID（ID取值范围为0-63） + public byte datelen; // 范围1~8 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] // 数据段内容 + public byte[] data; + public byte chkSumMode; // 校验方式：0-默认，启动时配置 1-经典校验 2-增强校验(对应eZLINChkSumMode的模式) + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] + public byte[] reserved; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_SUBSCIBE_CFG + { + public byte ID; // 受保护的ID（ID取值范围为0-63） + public byte datelen; // dataLen范围为1-8 当为255（0xff）则表示设备自动识别报文长度 + public byte chkSumMode; // 校验方式：0-默认，启动时配置 1-经典校验 2-增强校验(对应eZLINChkSumMode的模式) + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] + public byte[] reserved; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct SESSION_PARAM + { + public uint timeout; // 响应超时时间(ms)。因PC定时器误差，建议设置不小于200ms + public uint enhanced_timeout; // 收到消极响应错误码为0x78后的超时时间(ms)。因PC定时器误差，建议设置不小于200ms + public byte threeInOne; //三合一，把下面三个变量写进这一个变量 + + // threeInOne 包含以下三个变量 + // BYTE check_any_negative_response : 1; // 接收到非本次请求服务的消极响应时是否需要判定为响应错误 + // BYTE wait_if_suppress_response : 1; // 抑制响应时是否需要等待消极响应，等待时长为响应超时时间 + // BYTE flag : 6; // 保留 + public byte check_any_negative_response + { + get { return (byte)(threeInOne & 0x0001); } + set { threeInOne = (byte)((threeInOne & ~0x0001) | (value & 0x0001)); } + } + public byte wait_if_suppress_response + { + get { return (byte)((threeInOne & 0x0002) >> 1); } + set { threeInOne = (byte)((threeInOne & ~0x0002) | (value & 0x0002)); } + } + public byte flag + { + get { return (byte)((threeInOne & 0x00FC) >> 2); } + set { threeInOne = (byte)((threeInOne & ~0x00FC) | (value & 0x00FC)); } + } + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] + public byte[] reserved0; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct TRANS_PARAM + { + public byte version; // 传输协议版本，VERSION_0，VERSION_1 + public byte max_data_len; // 单帧最大数据长度，can:8，canfd:64 + public byte local_st_min; // 本程序发送流控时用，连续帧之间的最小间隔，0x00-0x7F(0ms~127ms)，0xF1-0xF9(100us~900us) + public byte block_size; // 流控帧的块大小 + public byte fill_byte; // 无效字节的填充数据 + public byte ext_frame; // 0:标准帧 1:扩展帧 + public byte is_modify_ecu_st_min; // 是否忽略ECU 返回流控的STmin，强制使用本程序设置的remote_st_min 参数代替 + public byte remote_st_min; // 发送多帧时用, is_modify_ecu_st_min = 1 时有效，0x00 - 0x7F(0ms~127ms), 0xF1 - 0xF9(100us~900us) + public uint fc_timeout; // 接收流控超时时间(ms)，如发送首帧后需要等待回应流控帧 + public byte fill_mode; // 数据长度填充模式 0-就近填充 1-不填充 2-最大填充 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] + public byte[] reserved0; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct TRANS_PARAM_LIN + { + public byte fill_byte; // 无效字节的填充数据 + public byte st_min; // 从节点准备接收诊断请求的下一帧或传输诊断响应的下一帧所需的最小时间 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] + public byte[] reserved0; + }; + + + // CAN UDS请求数据 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_UDS_REQUEST // 硬件UDS接口构体 + { + public uint req_id; // 请求事务索引ID，范围0~65535 + public byte channel; // 设备通道索引 + public byte frame_type; // 帧类型 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] + public byte[] reserved0; + public uint src_addr; // 请求地址 + public uint dst_addr; // 响应地址 + public byte suppress_response; // 1-抑制响应 + public byte sid; // 请求服务id + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] + public byte[] reserved1; + + public SESSION_PARAM session_param; + public TRANS_PARAM trans_param; + public IntPtr data; // 数据数组(不包含SID) + public uint data_len; // 数据数组的长度 + public uint reserved2; + } + + + // LIN UDS请求数据 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZLIN_UDS_REQUEST // 硬件UDS接口构体 + { + public uint req_id; // 请求事务索引ID，范围0~65535 + public byte channel; // 设备通道索引 + public byte suppress_response; // 1:抑制响应 0:不抑制 + public byte sid; // 请求服务id + public byte Nad; // 节点地址 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] reserved1; + + + public SESSION_PARAM session_param; + public TRANS_PARAM_LIN trans_param; + public IntPtr data; // 数据数组(不包含SID) + public uint data_len; // 数据数组的长度 + public uint reserved2; + } + + + // UDS响应数据 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_UDS_RESPONSE + { + public byte status; // 响应状态 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] + public byte[] reserved; + public byte type; // 响应类型 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] // 大小为8 + public byte[] raw; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct UDS_RESPONSE_Positive + { + public byte sid; // 响应服务id + public uint data_len; // 数据长度(不包含SID), 数据存放在接口传入的dataBuf中 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct UDS_RESPONSE_Negative + { + public byte neg_code; // 固定为0x7F + public byte sid; // 请求服务id + public byte error_code; // 错误码 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct UDS_RESPONSE_raw + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] // 大小为8 + public byte[] raw; + } + + + [StructLayout(LayoutKind.Explicit)] + public struct _UDS_RESPONSE_union + { + [FieldOffset(0)] + public UDS_RESPONSE_Positive zudsPositive; + + [FieldOffset(0)] + public UDS_RESPONSE_Negative zudsNegative; + + [FieldOffset(0)] + public UDS_RESPONSE_raw raw; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANCANFDUdsData + { + public IntPtr req; // 请求信息 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 24)] + public byte[] reserved; // 保留位 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINUdsData + { + public IntPtr req; // 请求信息 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 24)] + public byte[] reserved; // 保留位 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANUdsRequestDataObj + { + public uint dataType; // 数据类型 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 63)] + public byte[] data; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] + public byte[] reserved; // 保留位 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_DYNAMIC_CONFIG_DATA + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public char[] key; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public char[] value; + } + + [StructLayout(LayoutKind.Sequential)] + public struct BusUsage + { + public ulong nTimeStampBegin; // 测量起始时间戳，单位us + public ulong nTimeStampEnd; // 测量结束时间戳，单位us + public byte nChnl; // 通道 + public byte nReserved; // 保留 + public ushort nBusUsage; // 总线利用率(%)，总线利用率*100展示。取值0~10000，如8050表示80.50% + public uint nFrameCount; // 帧数量 + } + #endregion + } + + + public class ZDBC + { + #region 常量定义 + public const int _MAX_FILE_PATH_ = 260; // 最长文件路径 + public const int _DBC_NAME_LENGTH_ = 127; // 名称最长长度 + public const int _DBC_COMMENT_MAX_LENGTH_ = 127; // 注释最长长度 + public const int _DBC_UNIT_MAX_LENGTH_ = 23; // 单位最长长度 + public const int _DBC_SIGNAL_MAX_COUNT_ = 256; // 一个消息含有的信号的最大数目 + + public const int MUTIPLEXER_NONE = 0; // 不使用复用器 + public const int MUTIPLEXER_M_VALUE = 1; // 复用信号，当复用器开关的值为multiplexer_value时，该信号有效 + public const int MUTIPLEXER_M_SWITCH = 2; // 复用器开关，一个DBC消息只能有一个信号为开关 + + public const int FT_CAN = 0; // CAN + public const int FT_CANFD = 1; // CANFD + + public const int PROTOCOL_J1939 = 0; + public const int PROTOCOL_OTHER = 1; + public const uint INVALID_DBC_HANDLE = 0xffffffff; // 无效的DBC句柄 + #endregion + + #region 函数部分 + + // ZDBC.dll + public delegate bool OnSend(IntPtr ctx, IntPtr pObj); + public delegate void OnMultiTransDone(IntPtr ctx, IntPtr pMsg, IntPtr data, UInt16 nLen, byte nDirection); + public static OnSend onSend; + public static OnMultiTransDone onMultiTransDone; + + /// + /// 此函数用于初始化解析模块，只需要初始化一次。 + /// + /// 是否关闭多帧发送，为 1 时不支持多帧的消息发送。 + /// 是否开启异步解析；0-不启动，ZDBC_AsyncAnalyse 接口无效；1-启动, 独立线程解析出消息。 + /// 为 INVALID_DBC_HANDLE 表示初始化失败，其他表示初始化成功，保存该返回值，之后的函数调用都要用到该句柄。 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZDBC_Init(byte disableMultiSend = 0, byte enableAsyncAnalyse = 1); + + /// + /// 释放资源, 与DBC_Init配对使用 + /// + /// hDBC-句柄, ZDBC_Init的返回值 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_Release(uint DBCHandle); + + /// + /// 此函数用以加载 DBC 格式文件。 + /// + /// 句柄；ZDBC_Init的返回值 + /// 结构体 FileInfo的指针 + /// 为 true 表示加载成功，false 表示失败。 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_LoadFile(uint DBCHandle, IntPtr pFileInfo); + + /// + /// 从字符串加载DBC + /// + /// hDBC-句柄, DBC_Load的返回值 + /// pFileContent-文件内容字符串 + /// merge-是否合并到当前数据库; 1:不清除现有的数据, 即支持加载多个文件;0：清除原来的数据 + /// + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_LoadContent(uint DBCHandle, IntPtr pFileContent, uint merge); + + /// + /// 获取文件的第一条消息。 + /// + /// hDBC-句柄, DBC_Load的返回值 + /// pMsg 存储消息的信息 + /// true表示成功 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetFirstMessage(uint DBCHandle, IntPtr pMsg); + + /// + /// 获取下一条消息。 + /// + /// hDBC-句柄, DBC_Load的返回值 + /// pMsg 存储消息的信息 + /// true表示成功 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetNextMessage(uint DBCHandle, IntPtr pMsg); + + /// + /// 此函数用以根据 ID 获取消息数据。 + /// + /// 句柄； + /// 帧 ID； + /// 消息信息结构体 + /// + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetMessageById(uint DBCHandle, uint nID, IntPtr pMsg); + + /// + /// 此函数用以获取 DBC 文件中含有的消息数目。 + /// + /// DBC句柄 + /// DBC 文件中含有的消息数目 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZDBC_GetMessageCount(uint DBCHandle); + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_Analyse(uint DBCHandle, IntPtr pObj, IntPtr pMsg); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_AsyncAnalyse(uint DBCHandle, IntPtr pObj, uint frame_type, UInt64 extraData); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_OnReceive(uint DBCHandle, IntPtr pObj, uint frame_type); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_SetSender(uint hDBC, OnSend sender, IntPtr ctx); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_SetOnMultiTransDoneFunc(uint hDBC, OnMultiTransDone func, IntPtr ctx); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern byte ZDBC_Send(uint hDBC, IntPtr pMsg); + + /// + /// 根据原始数据解码为 DBCMessage。 + /// + /// DBC句柄 + /// 输出参数，解析结果。 + /// 帧数据数组, ControlCAN 传入 VCI_CAN_OBJ, zlgcan 传入 can_frame。 + /// 原始帧数据个数, 即数组大小。 + /// frame_type 帧类型, 参考FT_CAN=0、FT_CANFD=1，ControlCAN不支持CANFD。 + /// 是否成功。 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_Decode(uint DBCHandle, IntPtr P2DBCMessage, IntPtr P2Obj, uint nCount, byte frame_type); + + /// + /// 根据 DBCMessage 编码为原始数据。 + /// + /// DBC句柄； + /// 编码的原始数据缓冲区数组, ControlCAN 传入 VCI_CAN_OBJ, zlgcan 传入 can_frame。 + /// 输出参数，pObj 缓冲区大小, 返回时为实际原始数据个数。 + /// 输入参数，DBC 消息。 + /// frame_type 帧类型, FT_CAN=0、FT_CANFD=1，ControlCAN不支持CANFD。 + /// 是否成功。 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_Encode(uint DBCHandle, IntPtr P2Obj, IntPtr P2nCount, IntPtr pMsg, byte frame_type); + + /// + /// 信号原始值转换为实际值 + /// + /// sgl 信号 + /// rawVal 原始值, 如果该值超出信号长度可表示范围，会被截断。 + /// 实际值 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern double ZDBC_CalcActualValue(IntPtr sgl, IntPtr rawVal); //原始值通过计算转为实际值,实际值会传入rawVal的地址 + + /// + /// 信号实际值转换为原始值 + /// + /// sgl 信号 + /// actualVal 实际值, 超出可表示范围时会被修正 + /// 原始值 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt64 ZDBC_CalcRawValue(IntPtr sgl, IntPtr actualVal); + + /// + /// 获取网络节点数量 + /// + /// ZDBC_Init的返回值 + /// 网络节点总数量 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt32 ZDBC_GetNetworkNodeCount(uint DBCHandle); + + /// + /// + /// + /// ZDBC_Init的返回值 + /// index 位置索引 + /// DBCNetworkNode * node 网络节点信息 + /// + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetNetworkNodeAt(uint DBCHandle, UInt32 index, IntPtr node); + + + /// + /// 获取具体信号的值与含义对个数 + /// + /// ZDBC_Init的返回值 + /// message的ID + /// signal的名字 + /// + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt32 ZDBC_GetValDescPairCount(uint DBCHandle, UInt32 mag_id, string signal_name); + + + /// + /// 获取具体信号的值与含义对 + /// + /// ZDBC_Init的返回值 + /// message的ID + /// signal的名字 + /// ValDescPair结构体类型 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_GetValDescPair(uint DBCHandle, UInt32 mag_id, string signal_name, IntPtr pair); + + + #endregion + + #region DBC 结构体部分 + + public struct FileInfo + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _MAX_FILE_PATH_ + 1)] + public byte[] strFilePath; // dbc文件路径 + public byte type; // dbc的协议类型, j1939选择PROTOCOL_J1939, 其他协议选择PROTOCOL_OTHER + public byte merge; // 1:不清除现有的数据, 即支持加载多个文件 0：清除原来的数据 + }; + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct DBCSignal + { + + public UInt32 nStartBit; // 起始位 + public UInt32 nLen; // 位长度 + public double nFactor; // 转换因子 + public double nOffset; // 转换偏移实际值=原始值*nFactor+nOffset + public double nMin; // 最小值 + public double nMax; // 最大值 + public UInt64 nRawvalue; // 原始值 + public byte is_signed; // 1:有符号数据, 0:无符号 + public byte is_motorola; // 是否摩托罗拉格式 + public byte multiplexer_type; // 复用器类型 + public byte val_type; // 0:integer, 1:float, 2:double + public UInt32 multiplexer_value; // 复用器开关值为此值时信号有效 + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_UNIT_MAX_LENGTH_ + 1)] + public byte[] unit; //单位 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strName; //名称 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_COMMENT_MAX_LENGTH_ + 1)] + public byte[] strComment; //注释 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strValDesc; //值描述 + + public double initialValue; // 初始化值（原始值） + public uint initialValueValid; // 初始值是否有效 + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct DBCMessage + { + public UInt32 nSignalCount; // 信号数量 + public UInt32 nID; // ID + public UInt32 nSize; // 消息占的字节数目 + public double nCycleTime; // 发送周期 + public byte nExtend; // 1:扩展帧, 0:标准帧 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_SIGNAL_MAX_COUNT_)] + public DBCSignal[] vSignals; // 信号集合 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strName; // 名称 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_COMMENT_MAX_LENGTH_ + 1)] + public byte[] strComment; // 注释 + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct ValDescPair + { + public double value; // 信号值 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strName; // 对应的值描述 + } + #endregion + } + + + public class ZUDS + { + #region 参数定义 + + public static uint udsRTR = 0x40000000; // Remote Transmission Request + public static uint udsEFF = 0x80000000; // Extend Frame Flag + public static uint udsERR = 0x20000000; // Err flag + + #endregion + + #region 函数部分 + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + public delegate uint OnUDSTransmitDelegate(IntPtr ctx, IntPtr frame, uint count); + + + /// + /// 该函数用于初始化 UDS 函数库，返回操作句柄，用于后续的操作，与 ZUDS_Release + /// 配对使用。 + /// typedef uint32 TP_TYPE; // transport protocol + /// #define DoCAN 0 + /// + /// + /// 操作句柄，= ZUDS_INVALID_HANDLE 为无效句柄，其他值为有效句柄。 + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt32 ZUDS_Init(uint type); + + + /// + /// 该函数用于释放资源，与 ZUDS_Init 配对使用。 + /// + /// + /// + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_Release(uint type); + + + /// + /// 该函数用于设置函数库的参数。 + /// + /// + /// 参数类型,= PARAM_TYPE_SESSION 0 用 于 设 置 会 话 层 参 数 ， = + ///PARAM_TYPE_ISO15765 1 用于设置 ISO15765 的通信参数； + /// 参数值,type =PARAM_TYPE_SESSION 0 时为 ZUDS_SESSION_PARAM， + ///type= PARAM_TYPE_ISO15765 1 时为 ZUDS_ISO15765_PARAM。 + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_SetParam(UInt32 ZUDS_HANDLE, byte type, IntPtr param); + + + /// + /// 该函数用于设置发送回调函数。函数库自身并不发送帧数据，把打包的帧数据通过回调 + ///函数传出给用户发送，用户可通过 zlgcan 函数库进行帧数据发送。 + /// + /// + /// ctx 上下文参数, 在回调函数中传出, 库内部不会处理该参数； + /// ：回调函数原型；typedef uint32 (*OnUDSTransmit)(void* ctx, const ZUDS_FRAME* frame, uint32 count); + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_SetTransmitHandler(UInt32 ZUDS_HANDLE, IntPtr ctx, OnUDSTransmitDelegate onUDSTransmit); + + + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_OnReceive(UInt32 ZUDS_HANDLE, IntPtr ZUDS_FRAME); + + + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_Request(UInt32 ZUDS_HANDLE, IntPtr ZUDS_REQUEST, IntPtr ZUDS_RESPONSE); + + + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_Stop(UInt32 ZUDS_HANDLE); + + + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_SetTesterPresent(UInt32 ZUDS_HANDLE, byte enable, IntPtr param); + + #endregion + + #region 结构体部分 + /// + /// 会话层面参数；即一应一答传输时的通讯参数。 + /// + public struct ZUDS_SESSION_PARAM + { + public UInt16 timeout;// ms, timeout to wait the response of the server + public UInt16 enhanced_timeout; // ms,timeout to wait after negative response: error code 0x78 + public UInt32 reserved0; // 保留 + public UInt32 reserved1; // 保留 + } + + + /// + /// 传输数据部分的参数，例如传输时侯每帧报文的字节数。 + /// + public struct ZUDS_ISO15765_PARAM + { + public byte version; // VERSION_0, VERSION_1格式版本，为 VERSION_0 时符合 ISO15765-2 的 2004 版本格式要求；为 + //hVERSION_1 是符合 ISO15765-2 的 2016 版本新增的格式要求，如下图所示 + public byte max_data_len; // max data length, can:8, canfd:64 + public byte local_st_min; // ms, min time between two consecutive frames + public byte block_size; + public byte fill_byte; // fill to invalid byte + public byte frame_type; // 0:std 1:ext + public byte is_modify_ecu_st_min; //是否忽略 ECU 返回流控的 STmin，强制使用本程序设置的 + //remote_st_min 参数代替 + + public byte remote_st_min; //发 送 多 帧 时 用, is_ignore_ecu_st_min = 1 时 有 效 , + //0x00-0x7F(0ms ~127ms), 0xF1-0xF9(100us ~900us) + public UInt16 fc_timeout; //接收流控超时时间(ms), 如发送首帧后需要等待回应流控帧。 + public byte fill_mode;//字节填充模式。FILL_MODE_NONE-不填充0；FILL_MODE_SHORT- 小于 8 字节填充至 8 字节，大于 8 字节时按 DLC 就近填充1；FILL_MODE_MAX- 始终填充至最大数据长度 (不建议)2。 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZUDS_TESTER_PRESENT_PARAM + { + public UInt32 addr;//会话保持的请求地址； + public UInt16 cycle;//发送周期，单位毫秒； + public byte suppress_response; // 1:suppress是否抑制响应，建议设置为 1； + public UInt32 reserved;//：保留，忽略即可。 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZUDS_REQUEST + { + public uint src_addr; // 请求地址 + public uint dst_addr; // 响应地址 + public byte suppress_response; // 1:抑制响应 + public byte sid; //service id of request + public ushort reserve0; + public IntPtr param; //array,params of the service + public uint param_len; //参数数组的长度 + public uint reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZUDS_RESPONSE + { + public byte status; + public byte type; // RT_POSITIVE, RT_NEGATIVE + public _ZUDS_Union union; + public uint reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZUDS_positive + { + public byte sid; // service id of response + public IntPtr param; // array, params of the service, don't free + public uint param_len; + + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZUDS_negative + { + public byte neg_code; // 0x7F + public byte sid; //service id of response + public byte error_code;//消极响应的错误码 + + } + + + [StructLayout(LayoutKind.Explicit)] + public struct _ZUDS_Union + { + [FieldOffset(0)] + public ZUDS_positive zudsPositive; + + [FieldOffset(0)] + public _ZUDS_negative zudsNegative; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZUDS_FRAME + { + public uint id; + public byte extend; + public byte remote; + public byte data_len; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public byte[] data; + public uint reserved; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZUDS_CTX + { + public IntPtr can_type; // 0-CAN 1-CANFD 2-CANFD加速 + public IntPtr chn_handle; // 通道句柄 + } + #endregion + } +} diff --git a/Sample/zdbc_c#_251106/DBC/ZLGAPI.cs b/Sample/zdbc_c#_251106/DBC/ZLGAPI.cs new file mode 100644 index 0000000..503c751 --- /dev/null +++ b/Sample/zdbc_c#_251106/DBC/ZLGAPI.cs @@ -0,0 +1,1169 @@ +// update time 2025/7/16 + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Runtime.InteropServices; + +namespace ZLGAPI +{ + + public class ZLGCAN + { + + #region 设备类型 + public static UInt32 ZCAN_PCI9810 = 2; + public static UInt32 ZCAN_USBCAN1 = 3; + public static UInt32 ZCAN_USBCAN2 = 4; + public static UInt32 ZCAN_PCI9820 = 5; + public static UInt32 ZCAN_CANETUDP = 12; + public static UInt32 ZCAN_PCI9840 = 14; + public static UInt32 ZCAN_PCI9820I = 16; + public static UInt32 ZCAN_CANETTCP = 17; + public static UInt32 ZCAN_PCI5010U = 19; + public static UInt32 ZCAN_USBCAN_E_U = 20; + public static UInt32 ZCAN_USBCAN_2E_U = 21; + public static UInt32 ZCAN_PCI5020U = 22; + public static UInt32 ZCAN_PCIE9221 = 24; + public static UInt32 ZCAN_WIFICAN_TCP = 25; + public static UInt32 ZCAN_WIFICAN_UDP = 26; + public static UInt32 ZCAN_PCIe9120 = 27; + public static UInt32 ZCAN_PCIe9110 = 28; + public static UInt32 ZCAN_PCIe9140 = 29; + public static UInt32 ZCAN_USBCAN_4E_U = 31; + public static UInt32 ZCAN_CANDTU_200UR = 32; + public static UInt32 ZCAN_USBCAN_8E_U = 34; + public static UInt32 ZCAN_CANDTU_NET = 36; + public static UInt32 ZCAN_CANDTU_100UR = 37; + public static UInt32 ZCAN_PCIE_CANFD_200U = 39; + public static UInt32 ZCAN_PCIE_CANFD_400U = 40; + public static UInt32 ZCAN_USBCANFD_200U = 41; + public static UInt32 ZCAN_USBCANFD_100U = 42; + public static UInt32 ZCAN_USBCANFD_MINI = 43; + public static UInt32 ZCAN_CANSCOPE = 45; + public static UInt32 ZCAN_CLOUD = 46; + public static UInt32 ZCAN_CANDTU_NET_400 = 47; + public static UInt32 ZCAN_CANFDNET_TCP = 48; + public static UInt32 ZCAN_CANFDNET_200U_TCP = 48; + public static UInt32 ZCAN_CANFDNET_UDP = 49; + public static UInt32 ZCAN_CANFDNET_200U_UDP = 49; + public static UInt32 ZCAN_CANFDWIFI_TCP = 50; + public static UInt32 ZCAN_CANFDWIFI_100U_TCP = 50; + public static UInt32 ZCAN_CANFDWIFI_UDP = 51; + public static UInt32 ZCAN_CANFDWIFI_100U_UDP = 51; + public static UInt32 ZCAN_CANFDNET_400U_TCP = 52; + public static UInt32 ZCAN_CANFDNET_400U_UDP = 53; + public static UInt32 ZCAN_CANFDNET_100U_TCP = 55; + public static UInt32 ZCAN_CANFDNET_100U_UDP = 56; + public static UInt32 ZCAN_CANFDNET_800U_TCP = 57; + public static UInt32 ZCAN_CANFDNET_800U_UDP = 58; + public static UInt32 ZCAN_USBCANFD_800U = 59; + public static UInt32 ZCAN_PCIE_CANFD_100U_EX = 60; + public static UInt32 ZCAN_PCIE_CANFD_400U_EX = 61; + public static UInt32 ZCAN_PCIE_CANFD_200U_MINI = 62; + public static UInt32 ZCAN_PCIE_CANFD_200U_EX = 63; + public static UInt32 ZCAN_PCIE_CANFD_200U_M2 = 63; + public static UInt32 ZCAN_CANFDDTU_400_TCP = 64; + public static UInt32 ZCAN_CANFDDTU_400_UDP = 65; + public static UInt32 ZCAN_CANFDWIFI_200U_TCP = 66; + public static UInt32 ZCAN_CANFDWIFI_200U_UDP = 67; + public static UInt32 ZCAN_CANFDDTU_800ER_TCP = 68; + public static UInt32 ZCAN_CANFDDTU_800ER_UDP = 69; + public static UInt32 ZCAN_CANFDDTU_800EWGR_TCP = 70; + public static UInt32 ZCAN_CANFDDTU_800EWGR_UDP = 71; + public static UInt32 ZCAN_CANFDDTU_600EWGR_TCP = 72; + public static UInt32 ZCAN_CANFDDTU_600EWGR_UDP = 73; + public static UInt32 ZCAN_CANFDDTU_CASCADE_TCP = 74; + public static UInt32 ZCAN_CANFDDTU_CASCADE_UDP = 75; + public static UInt32 ZCAN_USBCANFD_400U = 76; + public static UInt32 ZCAN_CANFDDTU_200U = 77; + public static UInt32 ZCAN_ZPSCANFD_TCP = 78; + public static UInt32 ZCAN_ZPSCANFD_USB = 79; + public static UInt32 ZCAN_CANFDBRIDGE_PLUS = 80; + public static UInt32 ZCAN_CANFDDTU_300U = 81; + public static UInt32 ZCAN_PCIE_CANFD_800U = 82; + public static UInt32 ZCAN_PCIE_CANFD_1200U = 83; + public static UInt32 ZCAN_MINI_PCIE_CANFD = 84; + public static UInt32 ZCAN_USBCANFD_800H = 85; + #endregion + + #region LIN事件 + public static UInt32 ZCAN_LIN_WAKE_UP = 1; + public static UInt32 ZCAN_LIN_ENTERED_SLEEP_MODE = 2; + public static UInt32 ZCAN_LIN_EXITED_SLEEP_MODE = 3; + #endregion + + #region 函数 + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_OpenDevice(uint device_type, uint device_index, uint reserved); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_CloseDevice(IntPtr device_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_InitCAN(IntPtr device_handle, uint can_index, IntPtr pInitConfig); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_StartCAN(IntPtr chn_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ResetCAN(IntPtr chn_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ClearBuffer(IntPtr chn_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_GetReceiveNum(IntPtr channel_handle, byte type); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_Transmit(IntPtr channel_handle, IntPtr pTransmit, uint len); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_TransmitFD(IntPtr channel_handle, IntPtr pTransmit, uint len); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_TransmitData(IntPtr device_handle, IntPtr pTransmit, uint len); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_Receive(IntPtr channel_handle, IntPtr pReceive, uint len, int wait_time = -1); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReceiveFD(IntPtr channel_handle, IntPtr pReceive, uint len, int wait_time = -1); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReceiveData(IntPtr device_handle, IntPtr pReceive, uint len, int wait_time); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetValue(IntPtr device_handle, string path, string value); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetValue(IntPtr device_handle, string path, IntPtr value); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_GetValue(IntPtr device_handle, string path); + + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_InitLIN(IntPtr device_handle, uint lin_index, IntPtr pLINInitConfig); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_StartLIN(IntPtr channel_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ResetLIN(IntPtr channel_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_TransmitLIN(IntPtr channel_handle, IntPtr pSend, uint Len); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_GetLINReceiveNum(IntPtr channel_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReceiveLIN(IntPtr channel_handle, IntPtr pReceive, uint Len, int WaitTime); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetLINPublish(IntPtr channel_handle, IntPtr pSend, uint nPublishCount); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetLINSubscribe(IntPtr channel_handle, IntPtr pSend, uint nSubscribeCount); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_WakeUpLIN(IntPtr channel_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_Request(IntPtr device_handle, IntPtr req, IntPtr resp, IntPtr dataBuf, uint dataBufSize); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_Control(IntPtr device_handle, IntPtr ctrl, IntPtr resp); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_RequestEX(IntPtr device_handle, IntPtr requestData, IntPtr resp, IntPtr dataBuf, uint dataBufSize); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_ControlEX(IntPtr device_handle, uint dataType, IntPtr ctrl, IntPtr resp); + #endregion + + #region 结构体 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_CHANNEL_INIT_CONFIG + { + public uint can_type; + public _ZCAN_CHANNEL_INIT_CONFIG config; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZCAN_CHANNEL_INIT_CONFIG + { + public _ZCAN_CHANNEL_CAN_INIT_CONFIG can; + public _ZCAN_CHANNEL_CANFD_INIT_CONFIG canfd; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZCAN_CHANNEL_CAN_INIT_CONFIG + { + public uint acc_code; + public uint acc_mask; + public uint reserved; + public byte filter; + public byte timing0; + public byte timing1; + public byte mode; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZCAN_CHANNEL_CANFD_INIT_CONFIG + { + public uint acc_code; + public uint acc_mask; + public uint abit_timing; + public uint dbit_timing; + public uint brp; + public byte filter; + public byte mode; + public ushort pad; + public uint reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_Transmit_Data + { + public can_frame frame; + public uint transmit_type; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class can_frame + { + public uint can_id; + public byte can_dlc; // frame payload length in byte (0 .. CAN_MAX_DLEN) + public byte __pad; // padding + public byte __res0; // reserved / padding + public byte __res1; // reserved / padding + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] data; // frame data + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class canfd_frame + { + public uint can_id; + public byte len; + public byte flags; + public byte __res0; + public byte __res1; /* reserved / padding */ + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public byte[] data; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZCAN_Receive_Data + { + public can_frame frame; + public UInt64 timestamp; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZCAN_ReceiveFD_Data + { + public canfd_frame frame; + public UInt64 timestamp; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_AUTO_TRANSMIT_OBJ //CANFD定时发送帧结构体 + { + public ushort enable; //0-禁用，1-使能 + public ushort index; //定时报文索引 + public uint interval; //定时周期 + public ZCAN_Transmit_Data obj; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANFD_AUTO_TRANSMIT_OBJ //CANFD定时发送帧结构体 + { + public ushort enable; //0-禁用，1-使能 + public ushort index; //定时报文索引 + public uint interval; //定时周期 + public ZCAN_TransmitFD_Data obj; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_TransmitFD_Data + { + public canfd_frame frame; // 报文数据信息，详见 canfd_frame 结构说明。 + public uint transmit_type; // 发送方式，0=正常发送，1=单次发送，2=自发自收，3=单次自发自收。 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANCANFDData + { + public UInt64 timeStamp; + public UInt32 flag; // flag用于设置一些参数，内部结构可以通过以下函数实现设置和取值 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] + public byte[] extraData; //未使用 + public canfd_frame frame; //实际报文结构体 + + // frameType 帧类型 0-CAN 1-CANFD + public uint frameType { + get { return (flag & 0x03); } + set { flag = (uint)((flag & ~0x03) | (value & 0x03)); } + } + + // txDelay队列发送延时，延时时间存放在 timeStamp 字段；0-不启用延时，1-启用延时，单位1ms，2-启用延时，单位100us + public uint txDelay { + get { return ((flag >> 2) & 0x03); } + set { flag = (uint)((flag & ~0x0C) | (value & 0x03) << 2); } + } + + public uint transmitType { + get { return ((flag >> 4) & 0x0F); } + set { flag = (uint)((flag & ~0x0F) | (value & 0x0F) << 4); } + } + + public uint txEchoRequest { + get { return ((flag >> 8) & 0x01); } + set { flag = (uint)(flag | (value & 0x01) << 8); } + } + + public uint txEchoed { + get { return ((flag >> 9) & 0x01); } // bit9 + set { flag = (uint)((flag & ~0x200) | (value & 0x01) << 9); } + } + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct PID + { + public byte rawVal; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct RxData + { + public UInt64 timeStamp; + public byte datalen; + public byte dir; + public byte chkSum; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 13)] + public byte[] reserved; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] data; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANDataObj + { + public byte dataType; // 1-CAN/CANFD数据, 4-LIN数据 + public byte chnl; // 数据通道 + public UInt16 flag; // 未使用 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] + public byte[] extraData; // 未使用 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 92)] + public byte[] data; // 报文结构体 + } + + + // LIN + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINData + { + public PID pid; // 受保护的ID + public RxData rxData; // 数据 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINErrData + { + public UInt64 timeStamp; // 时间戳，单位微秒(us) + public PID pid; // 受保护的ID + + public byte dataLen; // 数据长度 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] data; // 数据 + + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] + public byte[] errData; // 错误信息 + + public byte dir; // 传输方向 + public byte chkSum; // 数据校验，部分设备不支持校验数据的获取 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINEventData + { + public UInt64 timeStamp; // 时间戳，单位微秒(us) + public byte type; // 数据长度 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_MSG + { + public byte chnl; // 数据通道 + public byte dataType; // 0-LIN，1-ErrLIN + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 46)] + public byte[] data; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_INIT_CONFIG + { + public byte linMode; // 0-slave,1-master + public byte chkSumMode; // 1-经典校验，2-增强校验 3-自动(对应eZLINChkSumMode的模式) + public byte maxLength; // 最大数据长度，8~64 + public byte reserved; + public uint libBaud; // 波特率，取值1000~20000 + + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_PUBLISH_CFG + { + public byte ID; // 受保护的ID（ID取值范围为0-63） + public byte datelen; // 范围1~8 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] // 数据段内容 + public byte[] data; + public byte chkSumMode; // 校验方式：0-默认，启动时配置 1-经典校验 2-增强校验(对应eZLINChkSumMode的模式) + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] + public byte[] reserved; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_SUBSCIBE_CFG + { + public byte ID; // 受保护的ID（ID取值范围为0-63） + public byte datelen; // dataLen范围为1-8 当为255（0xff）则表示设备自动识别报文长度 + public byte chkSumMode; // 校验方式：0-默认，启动时配置 1-经典校验 2-增强校验(对应eZLINChkSumMode的模式) + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] + public byte[] reserved; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct SESSION_PARAM + { + public uint timeout; // 响应超时时间(ms)。因PC定时器误差，建议设置不小于200ms + public uint enhanced_timeout; // 收到消极响应错误码为0x78后的超时时间(ms)。因PC定时器误差，建议设置不小于200ms + public byte threeInOne; //三合一，把下面三个变量写进这一个变量 + + // threeInOne 包含以下三个变量 + // BYTE check_any_negative_response : 1; // 接收到非本次请求服务的消极响应时是否需要判定为响应错误 + // BYTE wait_if_suppress_response : 1; // 抑制响应时是否需要等待消极响应，等待时长为响应超时时间 + // BYTE flag : 6; // 保留 + public byte check_any_negative_response + { + get { return (byte)(threeInOne & 0x0001); } + set { threeInOne = (byte)((threeInOne & ~0x0001) | (value & 0x0001)); } + } + public byte wait_if_suppress_response + { + get { return (byte)((threeInOne & 0x0002) >> 1); } + set { threeInOne = (byte)((threeInOne & ~0x0002) | (value & 0x0002)); } + } + public byte flag + { + get { return (byte)((threeInOne & 0x00FC) >> 2); } + set { threeInOne = (byte)((threeInOne & ~0x00FC) | (value & 0x00FC)); } + } + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] + public byte[] reserved0; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct TRANS_PARAM + { + public byte version; // 传输协议版本，VERSION_0，VERSION_1 + public byte max_data_len; // 单帧最大数据长度，can:8，canfd:64 + public byte local_st_min; // 本程序发送流控时用，连续帧之间的最小间隔，0x00-0x7F(0ms~127ms)，0xF1-0xF9(100us~900us) + public byte block_size; // 流控帧的块大小 + public byte fill_byte; // 无效字节的填充数据 + public byte ext_frame; // 0:标准帧 1:扩展帧 + public byte is_modify_ecu_st_min; // 是否忽略ECU 返回流控的STmin，强制使用本程序设置的remote_st_min 参数代替 + public byte remote_st_min; // 发送多帧时用, is_modify_ecu_st_min = 1 时有效，0x00 - 0x7F(0ms~127ms), 0xF1 - 0xF9(100us~900us) + public uint fc_timeout; // 接收流控超时时间(ms)，如发送首帧后需要等待回应流控帧 + public byte fill_mode; // 数据长度填充模式 0-就近填充 1-不填充 2-最大填充 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] + public byte[] reserved0; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct TRANS_PARAM_LIN + { + public byte fill_byte; // 无效字节的填充数据 + public byte st_min; // 从节点准备接收诊断请求的下一帧或传输诊断响应的下一帧所需的最小时间 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] + public byte[] reserved0; + }; + + + // CAN UDS请求数据 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_UDS_REQUEST // 硬件UDS接口构体 + { + public uint req_id; // 请求事务索引ID，范围0~65535 + public byte channel; // 设备通道索引 + public byte frame_type; // 帧类型 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] + public byte[] reserved0; + public uint src_addr; // 请求地址 + public uint dst_addr; // 响应地址 + public byte suppress_response; // 1-抑制响应 + public byte sid; // 请求服务id + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] + public byte[] reserved1; + + public SESSION_PARAM session_param; + public TRANS_PARAM trans_param; + public IntPtr data; // 数据数组(不包含SID) + public uint data_len; // 数据数组的长度 + public uint reserved2; + } + + + // LIN UDS请求数据 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZLIN_UDS_REQUEST // 硬件UDS接口构体 + { + public uint req_id; // 请求事务索引ID，范围0~65535 + public byte channel; // 设备通道索引 + public byte suppress_response; // 1:抑制响应 0:不抑制 + public byte sid; // 请求服务id + public byte Nad; // 节点地址 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] reserved1; + + + public SESSION_PARAM session_param; + public TRANS_PARAM_LIN trans_param; + public IntPtr data; // 数据数组(不包含SID) + public uint data_len; // 数据数组的长度 + public uint reserved2; + } + + + // UDS响应数据 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_UDS_RESPONSE + { + public byte status; // 响应状态 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] + public byte[] reserved; + public byte type; // 响应类型 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] // 大小为8 + public byte[] raw; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct UDS_RESPONSE_Positive + { + public byte sid; // 响应服务id + public uint data_len; // 数据长度(不包含SID), 数据存放在接口传入的dataBuf中 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct UDS_RESPONSE_Negative + { + public byte neg_code; // 固定为0x7F + public byte sid; // 请求服务id + public byte error_code; // 错误码 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct UDS_RESPONSE_raw + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] // 大小为8 + public byte[] raw; + } + + + [StructLayout(LayoutKind.Explicit)] + public struct _UDS_RESPONSE_union + { + [FieldOffset(0)] + public UDS_RESPONSE_Positive zudsPositive; + + [FieldOffset(0)] + public UDS_RESPONSE_Negative zudsNegative; + + [FieldOffset(0)] + public UDS_RESPONSE_raw raw; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANCANFDUdsData + { + public IntPtr req; // 请求信息 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 24)] + public byte[] reserved; // 保留位 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINUdsData + { + public IntPtr req; // 请求信息 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 24)] + public byte[] reserved; // 保留位 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANUdsRequestDataObj + { + public uint dataType; // 数据类型 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 63)] + public byte[] data; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] + public byte[] reserved; // 保留位 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_DYNAMIC_CONFIG_DATA + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public char[] key; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public char[] value; + } + #endregion + } + + + public class ZDBC + { + #region 常量定义 + public const int _MAX_FILE_PATH_ = 260; // 最长文件路径 + public const int _DBC_NAME_LENGTH_ = 127; // 名称最长长度 + public const int _DBC_COMMENT_MAX_LENGTH_ = 127; // 注释最长长度 + public const int _DBC_UNIT_MAX_LENGTH_ = 23; // 单位最长长度 + public const int _DBC_SIGNAL_MAX_COUNT_ = 256; // 一个消息含有的信号的最大数目 + + public const int MUTIPLEXER_NONE = 0; // 不使用复用器 + public const int MUTIPLEXER_M_VALUE = 1; // 复用信号，当复用器开关的值为multiplexer_value时，该信号有效 + public const int MUTIPLEXER_M_SWITCH = 2; // 复用器开关，一个DBC消息只能有一个信号为开关 + + public const int FT_CAN = 0; // CAN + public const int FT_CANFD = 1; // CANFD + + public const int PROTOCOL_J1939 = 0; + public const int PROTOCOL_OTHER = 1; + public const uint INVALID_DBC_HANDLE = 0xffffffff; // 无效的DBC句柄 + #endregion + + #region 函数部分 + + // ZDBC.dll + public delegate bool OnSend(IntPtr ctx, IntPtr pObj); + public delegate void OnMultiTransDone(IntPtr ctx, IntPtr pMsg, IntPtr data, UInt16 nLen, byte nDirection); + public static OnSend onSend; + public static OnMultiTransDone onMultiTransDone; + + /// + /// 此函数用于初始化解析模块，只需要初始化一次。 + /// + /// 是否关闭多帧发送，为 1 时不支持多帧的消息发送。 + /// 是否开启异步解析；0-不启动，ZDBC_AsyncAnalyse 接口无效；1-启动, 独立线程解析出消息。 + /// 为 INVALID_DBC_HANDLE 表示初始化失败，其他表示初始化成功，保存该返回值，之后的函数调用都要用到该句柄。 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZDBC_Init(byte disableMultiSend = 0, byte enableAsyncAnalyse = 1); + + /// + /// 释放资源, 与DBC_Init配对使用 + /// + /// hDBC-句柄, ZDBC_Init的返回值 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_Release(uint DBCHandle); + + /// + /// 此函数用以加载 DBC 格式文件。 + /// + /// 句柄；ZDBC_Init的返回值 + /// 结构体 FileInfo的指针 + /// 为 true 表示加载成功，false 表示失败。 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_LoadFile(uint DBCHandle, IntPtr pFileInfo); + + /// + /// 从字符串加载DBC + /// + /// hDBC-句柄, DBC_Load的返回值 + /// pFileContent-文件内容字符串 + /// merge-是否合并到当前数据库; 1:不清除现有的数据, 即支持加载多个文件;0：清除原来的数据 + /// + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_LoadContent(uint DBCHandle, IntPtr pFileContent, uint merge); + + /// + /// 获取文件的第一条消息。 + /// + /// hDBC-句柄, DBC_Load的返回值 + /// pMsg 存储消息的信息 + /// true表示成功 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetFirstMessage(uint DBCHandle, IntPtr pMsg); + + /// + /// 获取下一条消息。 + /// + /// hDBC-句柄, DBC_Load的返回值 + /// pMsg 存储消息的信息 + /// true表示成功 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetNextMessage(uint DBCHandle, IntPtr pMsg); + + /// + /// 此函数用以根据 ID 获取消息数据。 + /// + /// 句柄； + /// 帧 ID； + /// 消息信息结构体 + /// + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetMessageById(uint DBCHandle, uint nID, IntPtr pMsg); + + /// + /// 此函数用以获取 DBC 文件中含有的消息数目。 + /// + /// DBC句柄 + /// DBC 文件中含有的消息数目 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZDBC_GetMessageCount(uint DBCHandle); + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_Analyse(uint DBCHandle, IntPtr pObj, IntPtr pMsg); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_AsyncAnalyse(uint DBCHandle, IntPtr pObj, uint frame_type, UInt64 extraData); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_OnReceive(uint DBCHandle, IntPtr pObj, uint frame_type); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_SetSender(uint hDBC, OnSend sender, IntPtr ctx); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_SetOnMultiTransDoneFunc(uint hDBC, OnMultiTransDone func, IntPtr ctx); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern byte ZDBC_Send(uint hDBC, IntPtr pMsg); + + /// + /// 根据原始数据解码为 DBCMessage。 + /// + /// DBC句柄 + /// 输出参数，解析结果。 + /// 帧数据数组, ControlCAN 传入 VCI_CAN_OBJ, zlgcan 传入 can_frame。 + /// 原始帧数据个数, 即数组大小。 + /// frame_type 帧类型, 参考FT_CAN=0、FT_CANFD=1，ControlCAN不支持CANFD。 + /// 是否成功。 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_Decode(uint DBCHandle, IntPtr P2DBCMessage, IntPtr P2Obj, uint nCount, byte frame_type); + + /// + /// 根据 DBCMessage 编码为原始数据。 + /// + /// DBC句柄； + /// 编码的原始数据缓冲区数组, ControlCAN 传入 VCI_CAN_OBJ, zlgcan 传入 can_frame。 + /// 输出参数，pObj 缓冲区大小, 返回时为实际原始数据个数。 + /// 输入参数，DBC 消息。 + /// frame_type 帧类型, FT_CAN=0、FT_CANFD=1，ControlCAN不支持CANFD。 + /// 是否成功。 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_Encode(uint DBCHandle, IntPtr P2Obj, IntPtr P2nCount, IntPtr pMsg, byte frame_type); + + /// + /// 信号原始值转换为实际值 + /// + /// sgl 信号 + /// rawVal 原始值, 如果该值超出信号长度可表示范围，会被截断。 + /// 实际值 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern double ZDBC_CalcActualValue(IntPtr sgl, IntPtr rawVal); //原始值通过计算转为实际值,实际值会传入rawVal的地址 + + /// + /// 信号实际值转换为原始值 + /// + /// sgl 信号 + /// actualVal 实际值, 超出可表示范围时会被修正 + /// 原始值 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt64 ZDBC_CalcRawValue(IntPtr sgl, IntPtr actualVal); + + /// + /// 获取网络节点数量 + /// + /// ZDBC_Init的返回值 + /// 网络节点总数量 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt32 ZDBC_GetNetworkNodeCount(uint DBCHandle); + + /// + /// + /// + /// ZDBC_Init的返回值 + /// index 位置索引 + /// DBCNetworkNode * node 网络节点信息 + /// + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetNetworkNodeAt(uint DBCHandle, UInt32 index, IntPtr node); + + + /// + /// 获取具体信号的值与含义对个数 + /// + /// ZDBC_Init的返回值 + /// message的ID + /// signal的名字 + /// + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt32 ZDBC_GetValDescPairCount(uint DBCHandle, UInt32 mag_id, string signal_name); + + + /// + /// 获取具体信号的值与含义对 + /// + /// ZDBC_Init的返回值 + /// message的ID + /// signal的名字 + /// ValDescPair结构体类型 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_GetValDescPair(uint DBCHandle, UInt32 mag_id, string signal_name, IntPtr pair); + + + #endregion + + #region DBC 结构体部分 + + public struct FileInfo + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _MAX_FILE_PATH_ + 1)] + public byte[] strFilePath; // dbc文件路径 + public byte type; // dbc的协议类型, j1939选择PROTOCOL_J1939, 其他协议选择PROTOCOL_OTHER + public byte merge; // 1:不清除现有的数据, 即支持加载多个文件 0：清除原来的数据 + }; + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct DBCSignal + { + + public UInt32 nStartBit; // 起始位 + public UInt32 nLen; // 位长度 + public double nFactor; // 转换因子 + public double nOffset; // 转换偏移实际值=原始值*nFactor+nOffset + public double nMin; // 最小值 + public double nMax; // 最大值 + public UInt64 nRawvalue; // 原始值 + public byte is_signed; // 1:有符号数据, 0:无符号 + public byte is_motorola; // 是否摩托罗拉格式 + public byte multiplexer_type; // 复用器类型 + public byte val_type; // 0:integer, 1:float, 2:double + public UInt32 multiplexer_value; // 复用器开关值为此值时信号有效 + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_UNIT_MAX_LENGTH_ + 1)] + public byte[] unit; //单位 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strName; //名称 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_COMMENT_MAX_LENGTH_ + 1)] + public byte[] strComment; //注释 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strValDesc; //值描述 + + public double initialValue; // 初始化值（原始值） + public uint initialValueValid; // 初始值是否有效 + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct DBCMessage + { + public UInt32 nSignalCount; // 信号数量 + public UInt32 nID; // ID + public UInt32 nSize; // 消息占的字节数目 + public double nCycleTime; // 发送周期 + public byte nExtend; // 1:扩展帧, 0:标准帧 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_SIGNAL_MAX_COUNT_)] + public DBCSignal[] vSignals; // 信号集合 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strName; // 名称 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_COMMENT_MAX_LENGTH_ + 1)] + public byte[] strComment; // 注释 + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct ValDescPair + { + public double value; // 信号值 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strName; // 对应的值描述 + } + #endregion + } + + + public class ZUDS + { + #region 参数定义 + + public static uint udsRTR = 0x40000000; // Remote Transmission Request + public static uint udsEFF = 0x80000000; // Extend Frame Flag + public static uint udsERR = 0x20000000; // Err flag + + #endregion + + #region 函数部分 + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + public delegate uint OnUDSTransmitDelegate(IntPtr ctx, IntPtr frame, uint count); + + + /// + /// 该函数用于初始化 UDS 函数库，返回操作句柄，用于后续的操作，与 ZUDS_Release + /// 配对使用。 + /// typedef uint32 TP_TYPE; // transport protocol + /// #define DoCAN 0 + /// + /// + /// 操作句柄，= ZUDS_INVALID_HANDLE 为无效句柄，其他值为有效句柄。 + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt32 ZUDS_Init(uint type); + + + /// + /// 该函数用于释放资源，与 ZUDS_Init 配对使用。 + /// + /// + /// + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_Release(uint type); + + + /// + /// 该函数用于设置函数库的参数。 + /// + /// + /// 参数类型,= PARAM_TYPE_SESSION 0 用 于 设 置 会 话 层 参 数 ， = + ///PARAM_TYPE_ISO15765 1 用于设置 ISO15765 的通信参数； + /// 参数值,type =PARAM_TYPE_SESSION 0 时为 ZUDS_SESSION_PARAM， + ///type= PARAM_TYPE_ISO15765 1 时为 ZUDS_ISO15765_PARAM。 + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_SetParam(UInt32 ZUDS_HANDLE, byte type, IntPtr param); + + + /// + /// 该函数用于设置发送回调函数。函数库自身并不发送帧数据，把打包的帧数据通过回调 + ///函数传出给用户发送，用户可通过 zlgcan 函数库进行帧数据发送。 + /// + /// + /// ctx 上下文参数, 在回调函数中传出, 库内部不会处理该参数； + /// ：回调函数原型；typedef uint32 (*OnUDSTransmit)(void* ctx, const ZUDS_FRAME* frame, uint32 count); + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_SetTransmitHandler(UInt32 ZUDS_HANDLE, IntPtr ctx, OnUDSTransmitDelegate onUDSTransmit); + + + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_OnReceive(UInt32 ZUDS_HANDLE, IntPtr ZUDS_FRAME); + + + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_Request(UInt32 ZUDS_HANDLE, IntPtr ZUDS_REQUEST, IntPtr ZUDS_RESPONSE); + + + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_Stop(UInt32 ZUDS_HANDLE); + + + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_SetTesterPresent(UInt32 ZUDS_HANDLE, byte enable, IntPtr param); + + #endregion + + #region 结构体部分 + /// + /// 会话层面参数；即一应一答传输时的通讯参数。 + /// + public struct ZUDS_SESSION_PARAM + { + public UInt16 timeout;// ms, timeout to wait the response of the server + public UInt16 enhanced_timeout; // ms,timeout to wait after negative response: error code 0x78 + public UInt32 reserved0; // 保留 + public UInt32 reserved1; // 保留 + } + + + /// + /// 传输数据部分的参数，例如传输时侯每帧报文的字节数。 + /// + public struct ZUDS_ISO15765_PARAM + { + public byte version; // VERSION_0, VERSION_1格式版本，为 VERSION_0 时符合 ISO15765-2 的 2004 版本格式要求；为 + //hVERSION_1 是符合 ISO15765-2 的 2016 版本新增的格式要求，如下图所示 + public byte max_data_len; // max data length, can:8, canfd:64 + public byte local_st_min; // ms, min time between two consecutive frames + public byte block_size; + public byte fill_byte; // fill to invalid byte + public byte frame_type; // 0:std 1:ext + public byte is_modify_ecu_st_min; //是否忽略 ECU 返回流控的 STmin，强制使用本程序设置的 + //remote_st_min 参数代替 + + public byte remote_st_min; //发 送 多 帧 时 用, is_ignore_ecu_st_min = 1 时 有 效 , + //0x00-0x7F(0ms ~127ms), 0xF1-0xF9(100us ~900us) + public UInt16 fc_timeout; //接收流控超时时间(ms), 如发送首帧后需要等待回应流控帧。 + public byte fill_mode;//字节填充模式。FILL_MODE_NONE-不填充0；FILL_MODE_SHORT- 小于 8 字节填充至 8 字节，大于 8 字节时按 DLC 就近填充1；FILL_MODE_MAX- 始终填充至最大数据长度 (不建议)2。 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZUDS_TESTER_PRESENT_PARAM + { + public UInt32 addr;//会话保持的请求地址； + public UInt16 cycle;//发送周期，单位毫秒； + public byte suppress_response; // 1:suppress是否抑制响应，建议设置为 1； + public UInt32 reserved;//：保留，忽略即可。 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZUDS_REQUEST + { + public uint src_addr; // 请求地址 + public uint dst_addr; // 响应地址 + public byte suppress_response; // 1:抑制响应 + public byte sid; //service id of request + public ushort reserve0; + public IntPtr param; //array,params of the service + public uint param_len; //参数数组的长度 + public uint reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZUDS_RESPONSE + { + public byte status; + public byte type; // RT_POSITIVE, RT_NEGATIVE + public _ZUDS_Union union; + public uint reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZUDS_positive + { + public byte sid; // service id of response + public IntPtr param; // array, params of the service, don't free + public uint param_len; + + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZUDS_negative + { + public byte neg_code; // 0x7F + public byte sid; //service id of response + public byte error_code;//消极响应的错误码 + + } + + + [StructLayout(LayoutKind.Explicit)] + public struct _ZUDS_Union + { + [FieldOffset(0)] + public ZUDS_positive zudsPositive; + + [FieldOffset(0)] + public _ZUDS_negative zudsNegative; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZUDS_FRAME + { + public uint id; + public byte extend; + public byte remote; + public byte data_len; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public byte[] data; + public uint reserved; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZUDS_CTX + { + public IntPtr can_type; // 0-CAN 1-CANFD 2-CANFD加速 + public IntPtr chn_handle; // 通道句柄 + } + #endregion + } +} diff --git a/Sample/zdbc_c#_251106/zdbc_c#_251106/DBC/ZLGAPI.cs b/Sample/zdbc_c#_251106/zdbc_c#_251106/DBC/ZLGAPI.cs new file mode 100644 index 0000000..503c751 --- /dev/null +++ b/Sample/zdbc_c#_251106/zdbc_c#_251106/DBC/ZLGAPI.cs @@ -0,0 +1,1169 @@ +// update time 2025/7/16 + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Runtime.InteropServices; + +namespace ZLGAPI +{ + + public class ZLGCAN + { + + #region 设备类型 + public static UInt32 ZCAN_PCI9810 = 2; + public static UInt32 ZCAN_USBCAN1 = 3; + public static UInt32 ZCAN_USBCAN2 = 4; + public static UInt32 ZCAN_PCI9820 = 5; + public static UInt32 ZCAN_CANETUDP = 12; + public static UInt32 ZCAN_PCI9840 = 14; + public static UInt32 ZCAN_PCI9820I = 16; + public static UInt32 ZCAN_CANETTCP = 17; + public static UInt32 ZCAN_PCI5010U = 19; + public static UInt32 ZCAN_USBCAN_E_U = 20; + public static UInt32 ZCAN_USBCAN_2E_U = 21; + public static UInt32 ZCAN_PCI5020U = 22; + public static UInt32 ZCAN_PCIE9221 = 24; + public static UInt32 ZCAN_WIFICAN_TCP = 25; + public static UInt32 ZCAN_WIFICAN_UDP = 26; + public static UInt32 ZCAN_PCIe9120 = 27; + public static UInt32 ZCAN_PCIe9110 = 28; + public static UInt32 ZCAN_PCIe9140 = 29; + public static UInt32 ZCAN_USBCAN_4E_U = 31; + public static UInt32 ZCAN_CANDTU_200UR = 32; + public static UInt32 ZCAN_USBCAN_8E_U = 34; + public static UInt32 ZCAN_CANDTU_NET = 36; + public static UInt32 ZCAN_CANDTU_100UR = 37; + public static UInt32 ZCAN_PCIE_CANFD_200U = 39; + public static UInt32 ZCAN_PCIE_CANFD_400U = 40; + public static UInt32 ZCAN_USBCANFD_200U = 41; + public static UInt32 ZCAN_USBCANFD_100U = 42; + public static UInt32 ZCAN_USBCANFD_MINI = 43; + public static UInt32 ZCAN_CANSCOPE = 45; + public static UInt32 ZCAN_CLOUD = 46; + public static UInt32 ZCAN_CANDTU_NET_400 = 47; + public static UInt32 ZCAN_CANFDNET_TCP = 48; + public static UInt32 ZCAN_CANFDNET_200U_TCP = 48; + public static UInt32 ZCAN_CANFDNET_UDP = 49; + public static UInt32 ZCAN_CANFDNET_200U_UDP = 49; + public static UInt32 ZCAN_CANFDWIFI_TCP = 50; + public static UInt32 ZCAN_CANFDWIFI_100U_TCP = 50; + public static UInt32 ZCAN_CANFDWIFI_UDP = 51; + public static UInt32 ZCAN_CANFDWIFI_100U_UDP = 51; + public static UInt32 ZCAN_CANFDNET_400U_TCP = 52; + public static UInt32 ZCAN_CANFDNET_400U_UDP = 53; + public static UInt32 ZCAN_CANFDNET_100U_TCP = 55; + public static UInt32 ZCAN_CANFDNET_100U_UDP = 56; + public static UInt32 ZCAN_CANFDNET_800U_TCP = 57; + public static UInt32 ZCAN_CANFDNET_800U_UDP = 58; + public static UInt32 ZCAN_USBCANFD_800U = 59; + public static UInt32 ZCAN_PCIE_CANFD_100U_EX = 60; + public static UInt32 ZCAN_PCIE_CANFD_400U_EX = 61; + public static UInt32 ZCAN_PCIE_CANFD_200U_MINI = 62; + public static UInt32 ZCAN_PCIE_CANFD_200U_EX = 63; + public static UInt32 ZCAN_PCIE_CANFD_200U_M2 = 63; + public static UInt32 ZCAN_CANFDDTU_400_TCP = 64; + public static UInt32 ZCAN_CANFDDTU_400_UDP = 65; + public static UInt32 ZCAN_CANFDWIFI_200U_TCP = 66; + public static UInt32 ZCAN_CANFDWIFI_200U_UDP = 67; + public static UInt32 ZCAN_CANFDDTU_800ER_TCP = 68; + public static UInt32 ZCAN_CANFDDTU_800ER_UDP = 69; + public static UInt32 ZCAN_CANFDDTU_800EWGR_TCP = 70; + public static UInt32 ZCAN_CANFDDTU_800EWGR_UDP = 71; + public static UInt32 ZCAN_CANFDDTU_600EWGR_TCP = 72; + public static UInt32 ZCAN_CANFDDTU_600EWGR_UDP = 73; + public static UInt32 ZCAN_CANFDDTU_CASCADE_TCP = 74; + public static UInt32 ZCAN_CANFDDTU_CASCADE_UDP = 75; + public static UInt32 ZCAN_USBCANFD_400U = 76; + public static UInt32 ZCAN_CANFDDTU_200U = 77; + public static UInt32 ZCAN_ZPSCANFD_TCP = 78; + public static UInt32 ZCAN_ZPSCANFD_USB = 79; + public static UInt32 ZCAN_CANFDBRIDGE_PLUS = 80; + public static UInt32 ZCAN_CANFDDTU_300U = 81; + public static UInt32 ZCAN_PCIE_CANFD_800U = 82; + public static UInt32 ZCAN_PCIE_CANFD_1200U = 83; + public static UInt32 ZCAN_MINI_PCIE_CANFD = 84; + public static UInt32 ZCAN_USBCANFD_800H = 85; + #endregion + + #region LIN事件 + public static UInt32 ZCAN_LIN_WAKE_UP = 1; + public static UInt32 ZCAN_LIN_ENTERED_SLEEP_MODE = 2; + public static UInt32 ZCAN_LIN_EXITED_SLEEP_MODE = 3; + #endregion + + #region 函数 + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_OpenDevice(uint device_type, uint device_index, uint reserved); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_CloseDevice(IntPtr device_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_InitCAN(IntPtr device_handle, uint can_index, IntPtr pInitConfig); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_StartCAN(IntPtr chn_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ResetCAN(IntPtr chn_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ClearBuffer(IntPtr chn_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_GetReceiveNum(IntPtr channel_handle, byte type); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_Transmit(IntPtr channel_handle, IntPtr pTransmit, uint len); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_TransmitFD(IntPtr channel_handle, IntPtr pTransmit, uint len); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_TransmitData(IntPtr device_handle, IntPtr pTransmit, uint len); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_Receive(IntPtr channel_handle, IntPtr pReceive, uint len, int wait_time = -1); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReceiveFD(IntPtr channel_handle, IntPtr pReceive, uint len, int wait_time = -1); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReceiveData(IntPtr device_handle, IntPtr pReceive, uint len, int wait_time); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetValue(IntPtr device_handle, string path, string value); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetValue(IntPtr device_handle, string path, IntPtr value); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_GetValue(IntPtr device_handle, string path); + + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern IntPtr ZCAN_InitLIN(IntPtr device_handle, uint lin_index, IntPtr pLINInitConfig); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_StartLIN(IntPtr channel_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ResetLIN(IntPtr channel_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_TransmitLIN(IntPtr channel_handle, IntPtr pSend, uint Len); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_GetLINReceiveNum(IntPtr channel_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_ReceiveLIN(IntPtr channel_handle, IntPtr pReceive, uint Len, int WaitTime); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetLINPublish(IntPtr channel_handle, IntPtr pSend, uint nPublishCount); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_SetLINSubscribe(IntPtr channel_handle, IntPtr pSend, uint nSubscribeCount); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_WakeUpLIN(IntPtr channel_handle); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_Request(IntPtr device_handle, IntPtr req, IntPtr resp, IntPtr dataBuf, uint dataBufSize); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_Control(IntPtr device_handle, IntPtr ctrl, IntPtr resp); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_RequestEX(IntPtr device_handle, IntPtr requestData, IntPtr resp, IntPtr dataBuf, uint dataBufSize); + + + [DllImport(".\\zlgcan.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZCAN_UDS_ControlEX(IntPtr device_handle, uint dataType, IntPtr ctrl, IntPtr resp); + #endregion + + #region 结构体 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_CHANNEL_INIT_CONFIG + { + public uint can_type; + public _ZCAN_CHANNEL_INIT_CONFIG config; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZCAN_CHANNEL_INIT_CONFIG + { + public _ZCAN_CHANNEL_CAN_INIT_CONFIG can; + public _ZCAN_CHANNEL_CANFD_INIT_CONFIG canfd; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZCAN_CHANNEL_CAN_INIT_CONFIG + { + public uint acc_code; + public uint acc_mask; + public uint reserved; + public byte filter; + public byte timing0; + public byte timing1; + public byte mode; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZCAN_CHANNEL_CANFD_INIT_CONFIG + { + public uint acc_code; + public uint acc_mask; + public uint abit_timing; + public uint dbit_timing; + public uint brp; + public byte filter; + public byte mode; + public ushort pad; + public uint reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_Transmit_Data + { + public can_frame frame; + public uint transmit_type; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class can_frame + { + public uint can_id; + public byte can_dlc; // frame payload length in byte (0 .. CAN_MAX_DLEN) + public byte __pad; // padding + public byte __res0; // reserved / padding + public byte __res1; // reserved / padding + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] data; // frame data + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class canfd_frame + { + public uint can_id; + public byte len; + public byte flags; + public byte __res0; + public byte __res1; /* reserved / padding */ + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public byte[] data; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZCAN_Receive_Data + { + public can_frame frame; + public UInt64 timestamp; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZCAN_ReceiveFD_Data + { + public canfd_frame frame; + public UInt64 timestamp; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_AUTO_TRANSMIT_OBJ //CANFD定时发送帧结构体 + { + public ushort enable; //0-禁用，1-使能 + public ushort index; //定时报文索引 + public uint interval; //定时周期 + public ZCAN_Transmit_Data obj; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANFD_AUTO_TRANSMIT_OBJ //CANFD定时发送帧结构体 + { + public ushort enable; //0-禁用，1-使能 + public ushort index; //定时报文索引 + public uint interval; //定时周期 + public ZCAN_TransmitFD_Data obj; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_TransmitFD_Data + { + public canfd_frame frame; // 报文数据信息，详见 canfd_frame 结构说明。 + public uint transmit_type; // 发送方式，0=正常发送，1=单次发送，2=自发自收，3=单次自发自收。 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANCANFDData + { + public UInt64 timeStamp; + public UInt32 flag; // flag用于设置一些参数，内部结构可以通过以下函数实现设置和取值 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] + public byte[] extraData; //未使用 + public canfd_frame frame; //实际报文结构体 + + // frameType 帧类型 0-CAN 1-CANFD + public uint frameType { + get { return (flag & 0x03); } + set { flag = (uint)((flag & ~0x03) | (value & 0x03)); } + } + + // txDelay队列发送延时，延时时间存放在 timeStamp 字段；0-不启用延时，1-启用延时，单位1ms，2-启用延时，单位100us + public uint txDelay { + get { return ((flag >> 2) & 0x03); } + set { flag = (uint)((flag & ~0x0C) | (value & 0x03) << 2); } + } + + public uint transmitType { + get { return ((flag >> 4) & 0x0F); } + set { flag = (uint)((flag & ~0x0F) | (value & 0x0F) << 4); } + } + + public uint txEchoRequest { + get { return ((flag >> 8) & 0x01); } + set { flag = (uint)(flag | (value & 0x01) << 8); } + } + + public uint txEchoed { + get { return ((flag >> 9) & 0x01); } // bit9 + set { flag = (uint)((flag & ~0x200) | (value & 0x01) << 9); } + } + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct PID + { + public byte rawVal; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct RxData + { + public UInt64 timeStamp; + public byte datalen; + public byte dir; + public byte chkSum; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 13)] + public byte[] reserved; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] data; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANDataObj + { + public byte dataType; // 1-CAN/CANFD数据, 4-LIN数据 + public byte chnl; // 数据通道 + public UInt16 flag; // 未使用 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] + public byte[] extraData; // 未使用 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 92)] + public byte[] data; // 报文结构体 + } + + + // LIN + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINData + { + public PID pid; // 受保护的ID + public RxData rxData; // 数据 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINErrData + { + public UInt64 timeStamp; // 时间戳，单位微秒(us) + public PID pid; // 受保护的ID + + public byte dataLen; // 数据长度 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] data; // 数据 + + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] + public byte[] errData; // 错误信息 + + public byte dir; // 传输方向 + public byte chkSum; // 数据校验，部分设备不支持校验数据的获取 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINEventData + { + public UInt64 timeStamp; // 时间戳，单位微秒(us) + public byte type; // 数据长度 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_MSG + { + public byte chnl; // 数据通道 + public byte dataType; // 0-LIN，1-ErrLIN + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 46)] + public byte[] data; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_INIT_CONFIG + { + public byte linMode; // 0-slave,1-master + public byte chkSumMode; // 1-经典校验，2-增强校验 3-自动(对应eZLINChkSumMode的模式) + public byte maxLength; // 最大数据长度，8~64 + public byte reserved; + public uint libBaud; // 波特率，取值1000~20000 + + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_PUBLISH_CFG + { + public byte ID; // 受保护的ID（ID取值范围为0-63） + public byte datelen; // 范围1~8 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] // 数据段内容 + public byte[] data; + public byte chkSumMode; // 校验方式：0-默认，启动时配置 1-经典校验 2-增强校验(对应eZLINChkSumMode的模式) + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] + public byte[] reserved; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_LIN_SUBSCIBE_CFG + { + public byte ID; // 受保护的ID（ID取值范围为0-63） + public byte datelen; // dataLen范围为1-8 当为255（0xff）则表示设备自动识别报文长度 + public byte chkSumMode; // 校验方式：0-默认，启动时配置 1-经典校验 2-增强校验(对应eZLINChkSumMode的模式) + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] + public byte[] reserved; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct SESSION_PARAM + { + public uint timeout; // 响应超时时间(ms)。因PC定时器误差，建议设置不小于200ms + public uint enhanced_timeout; // 收到消极响应错误码为0x78后的超时时间(ms)。因PC定时器误差，建议设置不小于200ms + public byte threeInOne; //三合一，把下面三个变量写进这一个变量 + + // threeInOne 包含以下三个变量 + // BYTE check_any_negative_response : 1; // 接收到非本次请求服务的消极响应时是否需要判定为响应错误 + // BYTE wait_if_suppress_response : 1; // 抑制响应时是否需要等待消极响应，等待时长为响应超时时间 + // BYTE flag : 6; // 保留 + public byte check_any_negative_response + { + get { return (byte)(threeInOne & 0x0001); } + set { threeInOne = (byte)((threeInOne & ~0x0001) | (value & 0x0001)); } + } + public byte wait_if_suppress_response + { + get { return (byte)((threeInOne & 0x0002) >> 1); } + set { threeInOne = (byte)((threeInOne & ~0x0002) | (value & 0x0002)); } + } + public byte flag + { + get { return (byte)((threeInOne & 0x00FC) >> 2); } + set { threeInOne = (byte)((threeInOne & ~0x00FC) | (value & 0x00FC)); } + } + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] + public byte[] reserved0; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct TRANS_PARAM + { + public byte version; // 传输协议版本，VERSION_0，VERSION_1 + public byte max_data_len; // 单帧最大数据长度，can:8，canfd:64 + public byte local_st_min; // 本程序发送流控时用，连续帧之间的最小间隔，0x00-0x7F(0ms~127ms)，0xF1-0xF9(100us~900us) + public byte block_size; // 流控帧的块大小 + public byte fill_byte; // 无效字节的填充数据 + public byte ext_frame; // 0:标准帧 1:扩展帧 + public byte is_modify_ecu_st_min; // 是否忽略ECU 返回流控的STmin，强制使用本程序设置的remote_st_min 参数代替 + public byte remote_st_min; // 发送多帧时用, is_modify_ecu_st_min = 1 时有效，0x00 - 0x7F(0ms~127ms), 0xF1 - 0xF9(100us~900us) + public uint fc_timeout; // 接收流控超时时间(ms)，如发送首帧后需要等待回应流控帧 + public byte fill_mode; // 数据长度填充模式 0-就近填充 1-不填充 2-最大填充 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] + public byte[] reserved0; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct TRANS_PARAM_LIN + { + public byte fill_byte; // 无效字节的填充数据 + public byte st_min; // 从节点准备接收诊断请求的下一帧或传输诊断响应的下一帧所需的最小时间 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] + public byte[] reserved0; + }; + + + // CAN UDS请求数据 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_UDS_REQUEST // 硬件UDS接口构体 + { + public uint req_id; // 请求事务索引ID，范围0~65535 + public byte channel; // 设备通道索引 + public byte frame_type; // 帧类型 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] + public byte[] reserved0; + public uint src_addr; // 请求地址 + public uint dst_addr; // 响应地址 + public byte suppress_response; // 1-抑制响应 + public byte sid; // 请求服务id + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] + public byte[] reserved1; + + public SESSION_PARAM session_param; + public TRANS_PARAM trans_param; + public IntPtr data; // 数据数组(不包含SID) + public uint data_len; // 数据数组的长度 + public uint reserved2; + } + + + // LIN UDS请求数据 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZLIN_UDS_REQUEST // 硬件UDS接口构体 + { + public uint req_id; // 请求事务索引ID，范围0~65535 + public byte channel; // 设备通道索引 + public byte suppress_response; // 1:抑制响应 0:不抑制 + public byte sid; // 请求服务id + public byte Nad; // 节点地址 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + public byte[] reserved1; + + + public SESSION_PARAM session_param; + public TRANS_PARAM_LIN trans_param; + public IntPtr data; // 数据数组(不包含SID) + public uint data_len; // 数据数组的长度 + public uint reserved2; + } + + + // UDS响应数据 + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_UDS_RESPONSE + { + public byte status; // 响应状态 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] + public byte[] reserved; + public byte type; // 响应类型 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] // 大小为8 + public byte[] raw; + }; + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct UDS_RESPONSE_Positive + { + public byte sid; // 响应服务id + public uint data_len; // 数据长度(不包含SID), 数据存放在接口传入的dataBuf中 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct UDS_RESPONSE_Negative + { + public byte neg_code; // 固定为0x7F + public byte sid; // 请求服务id + public byte error_code; // 错误码 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct UDS_RESPONSE_raw + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] // 大小为8 + public byte[] raw; + } + + + [StructLayout(LayoutKind.Explicit)] + public struct _UDS_RESPONSE_union + { + [FieldOffset(0)] + public UDS_RESPONSE_Positive zudsPositive; + + [FieldOffset(0)] + public UDS_RESPONSE_Negative zudsNegative; + + [FieldOffset(0)] + public UDS_RESPONSE_raw raw; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANCANFDUdsData + { + public IntPtr req; // 请求信息 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 24)] + public byte[] reserved; // 保留位 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANLINUdsData + { + public IntPtr req; // 请求信息 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 24)] + public byte[] reserved; // 保留位 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCANUdsRequestDataObj + { + public uint dataType; // 数据类型 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 63)] + public byte[] data; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] + public byte[] reserved; // 保留位 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZCAN_DYNAMIC_CONFIG_DATA + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public char[] key; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public char[] value; + } + #endregion + } + + + public class ZDBC + { + #region 常量定义 + public const int _MAX_FILE_PATH_ = 260; // 最长文件路径 + public const int _DBC_NAME_LENGTH_ = 127; // 名称最长长度 + public const int _DBC_COMMENT_MAX_LENGTH_ = 127; // 注释最长长度 + public const int _DBC_UNIT_MAX_LENGTH_ = 23; // 单位最长长度 + public const int _DBC_SIGNAL_MAX_COUNT_ = 256; // 一个消息含有的信号的最大数目 + + public const int MUTIPLEXER_NONE = 0; // 不使用复用器 + public const int MUTIPLEXER_M_VALUE = 1; // 复用信号，当复用器开关的值为multiplexer_value时，该信号有效 + public const int MUTIPLEXER_M_SWITCH = 2; // 复用器开关，一个DBC消息只能有一个信号为开关 + + public const int FT_CAN = 0; // CAN + public const int FT_CANFD = 1; // CANFD + + public const int PROTOCOL_J1939 = 0; + public const int PROTOCOL_OTHER = 1; + public const uint INVALID_DBC_HANDLE = 0xffffffff; // 无效的DBC句柄 + #endregion + + #region 函数部分 + + // ZDBC.dll + public delegate bool OnSend(IntPtr ctx, IntPtr pObj); + public delegate void OnMultiTransDone(IntPtr ctx, IntPtr pMsg, IntPtr data, UInt16 nLen, byte nDirection); + public static OnSend onSend; + public static OnMultiTransDone onMultiTransDone; + + /// + /// 此函数用于初始化解析模块，只需要初始化一次。 + /// + /// 是否关闭多帧发送，为 1 时不支持多帧的消息发送。 + /// 是否开启异步解析；0-不启动，ZDBC_AsyncAnalyse 接口无效；1-启动, 独立线程解析出消息。 + /// 为 INVALID_DBC_HANDLE 表示初始化失败，其他表示初始化成功，保存该返回值，之后的函数调用都要用到该句柄。 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZDBC_Init(byte disableMultiSend = 0, byte enableAsyncAnalyse = 1); + + /// + /// 释放资源, 与DBC_Init配对使用 + /// + /// hDBC-句柄, ZDBC_Init的返回值 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_Release(uint DBCHandle); + + /// + /// 此函数用以加载 DBC 格式文件。 + /// + /// 句柄；ZDBC_Init的返回值 + /// 结构体 FileInfo的指针 + /// 为 true 表示加载成功，false 表示失败。 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_LoadFile(uint DBCHandle, IntPtr pFileInfo); + + /// + /// 从字符串加载DBC + /// + /// hDBC-句柄, DBC_Load的返回值 + /// pFileContent-文件内容字符串 + /// merge-是否合并到当前数据库; 1:不清除现有的数据, 即支持加载多个文件;0：清除原来的数据 + /// + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_LoadContent(uint DBCHandle, IntPtr pFileContent, uint merge); + + /// + /// 获取文件的第一条消息。 + /// + /// hDBC-句柄, DBC_Load的返回值 + /// pMsg 存储消息的信息 + /// true表示成功 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetFirstMessage(uint DBCHandle, IntPtr pMsg); + + /// + /// 获取下一条消息。 + /// + /// hDBC-句柄, DBC_Load的返回值 + /// pMsg 存储消息的信息 + /// true表示成功 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetNextMessage(uint DBCHandle, IntPtr pMsg); + + /// + /// 此函数用以根据 ID 获取消息数据。 + /// + /// 句柄； + /// 帧 ID； + /// 消息信息结构体 + /// + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetMessageById(uint DBCHandle, uint nID, IntPtr pMsg); + + /// + /// 此函数用以获取 DBC 文件中含有的消息数目。 + /// + /// DBC句柄 + /// DBC 文件中含有的消息数目 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern uint ZDBC_GetMessageCount(uint DBCHandle); + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_Analyse(uint DBCHandle, IntPtr pObj, IntPtr pMsg); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_AsyncAnalyse(uint DBCHandle, IntPtr pObj, uint frame_type, UInt64 extraData); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_OnReceive(uint DBCHandle, IntPtr pObj, uint frame_type); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_SetSender(uint hDBC, OnSend sender, IntPtr ctx); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_SetOnMultiTransDoneFunc(uint hDBC, OnMultiTransDone func, IntPtr ctx); + + + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern byte ZDBC_Send(uint hDBC, IntPtr pMsg); + + /// + /// 根据原始数据解码为 DBCMessage。 + /// + /// DBC句柄 + /// 输出参数，解析结果。 + /// 帧数据数组, ControlCAN 传入 VCI_CAN_OBJ, zlgcan 传入 can_frame。 + /// 原始帧数据个数, 即数组大小。 + /// frame_type 帧类型, 参考FT_CAN=0、FT_CANFD=1，ControlCAN不支持CANFD。 + /// 是否成功。 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_Decode(uint DBCHandle, IntPtr P2DBCMessage, IntPtr P2Obj, uint nCount, byte frame_type); + + /// + /// 根据 DBCMessage 编码为原始数据。 + /// + /// DBC句柄； + /// 编码的原始数据缓冲区数组, ControlCAN 传入 VCI_CAN_OBJ, zlgcan 传入 can_frame。 + /// 输出参数，pObj 缓冲区大小, 返回时为实际原始数据个数。 + /// 输入参数，DBC 消息。 + /// frame_type 帧类型, FT_CAN=0、FT_CANFD=1，ControlCAN不支持CANFD。 + /// 是否成功。 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_Encode(uint DBCHandle, IntPtr P2Obj, IntPtr P2nCount, IntPtr pMsg, byte frame_type); + + /// + /// 信号原始值转换为实际值 + /// + /// sgl 信号 + /// rawVal 原始值, 如果该值超出信号长度可表示范围，会被截断。 + /// 实际值 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern double ZDBC_CalcActualValue(IntPtr sgl, IntPtr rawVal); //原始值通过计算转为实际值,实际值会传入rawVal的地址 + + /// + /// 信号实际值转换为原始值 + /// + /// sgl 信号 + /// actualVal 实际值, 超出可表示范围时会被修正 + /// 原始值 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt64 ZDBC_CalcRawValue(IntPtr sgl, IntPtr actualVal); + + /// + /// 获取网络节点数量 + /// + /// ZDBC_Init的返回值 + /// 网络节点总数量 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt32 ZDBC_GetNetworkNodeCount(uint DBCHandle); + + /// + /// + /// + /// ZDBC_Init的返回值 + /// index 位置索引 + /// DBCNetworkNode * node 网络节点信息 + /// + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern bool ZDBC_GetNetworkNodeAt(uint DBCHandle, UInt32 index, IntPtr node); + + + /// + /// 获取具体信号的值与含义对个数 + /// + /// ZDBC_Init的返回值 + /// message的ID + /// signal的名字 + /// + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt32 ZDBC_GetValDescPairCount(uint DBCHandle, UInt32 mag_id, string signal_name); + + + /// + /// 获取具体信号的值与含义对 + /// + /// ZDBC_Init的返回值 + /// message的ID + /// signal的名字 + /// ValDescPair结构体类型 + [DllImport(".\\zdbc.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZDBC_GetValDescPair(uint DBCHandle, UInt32 mag_id, string signal_name, IntPtr pair); + + + #endregion + + #region DBC 结构体部分 + + public struct FileInfo + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _MAX_FILE_PATH_ + 1)] + public byte[] strFilePath; // dbc文件路径 + public byte type; // dbc的协议类型, j1939选择PROTOCOL_J1939, 其他协议选择PROTOCOL_OTHER + public byte merge; // 1:不清除现有的数据, 即支持加载多个文件 0：清除原来的数据 + }; + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct DBCSignal + { + + public UInt32 nStartBit; // 起始位 + public UInt32 nLen; // 位长度 + public double nFactor; // 转换因子 + public double nOffset; // 转换偏移实际值=原始值*nFactor+nOffset + public double nMin; // 最小值 + public double nMax; // 最大值 + public UInt64 nRawvalue; // 原始值 + public byte is_signed; // 1:有符号数据, 0:无符号 + public byte is_motorola; // 是否摩托罗拉格式 + public byte multiplexer_type; // 复用器类型 + public byte val_type; // 0:integer, 1:float, 2:double + public UInt32 multiplexer_value; // 复用器开关值为此值时信号有效 + + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_UNIT_MAX_LENGTH_ + 1)] + public byte[] unit; //单位 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strName; //名称 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_COMMENT_MAX_LENGTH_ + 1)] + public byte[] strComment; //注释 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strValDesc; //值描述 + + public double initialValue; // 初始化值（原始值） + public uint initialValueValid; // 初始值是否有效 + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct DBCMessage + { + public UInt32 nSignalCount; // 信号数量 + public UInt32 nID; // ID + public UInt32 nSize; // 消息占的字节数目 + public double nCycleTime; // 发送周期 + public byte nExtend; // 1:扩展帧, 0:标准帧 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_SIGNAL_MAX_COUNT_)] + public DBCSignal[] vSignals; // 信号集合 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strName; // 名称 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_COMMENT_MAX_LENGTH_ + 1)] + public byte[] strComment; // 注释 + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct ValDescPair + { + public double value; // 信号值 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = _DBC_NAME_LENGTH_ + 1)] + public byte[] strName; // 对应的值描述 + } + #endregion + } + + + public class ZUDS + { + #region 参数定义 + + public static uint udsRTR = 0x40000000; // Remote Transmission Request + public static uint udsEFF = 0x80000000; // Extend Frame Flag + public static uint udsERR = 0x20000000; // Err flag + + #endregion + + #region 函数部分 + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + public delegate uint OnUDSTransmitDelegate(IntPtr ctx, IntPtr frame, uint count); + + + /// + /// 该函数用于初始化 UDS 函数库，返回操作句柄，用于后续的操作，与 ZUDS_Release + /// 配对使用。 + /// typedef uint32 TP_TYPE; // transport protocol + /// #define DoCAN 0 + /// + /// + /// 操作句柄，= ZUDS_INVALID_HANDLE 为无效句柄，其他值为有效句柄。 + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern UInt32 ZUDS_Init(uint type); + + + /// + /// 该函数用于释放资源，与 ZUDS_Init 配对使用。 + /// + /// + /// + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_Release(uint type); + + + /// + /// 该函数用于设置函数库的参数。 + /// + /// + /// 参数类型,= PARAM_TYPE_SESSION 0 用 于 设 置 会 话 层 参 数 ， = + ///PARAM_TYPE_ISO15765 1 用于设置 ISO15765 的通信参数； + /// 参数值,type =PARAM_TYPE_SESSION 0 时为 ZUDS_SESSION_PARAM， + ///type= PARAM_TYPE_ISO15765 1 时为 ZUDS_ISO15765_PARAM。 + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_SetParam(UInt32 ZUDS_HANDLE, byte type, IntPtr param); + + + /// + /// 该函数用于设置发送回调函数。函数库自身并不发送帧数据，把打包的帧数据通过回调 + ///函数传出给用户发送，用户可通过 zlgcan 函数库进行帧数据发送。 + /// + /// + /// ctx 上下文参数, 在回调函数中传出, 库内部不会处理该参数； + /// ：回调函数原型；typedef uint32 (*OnUDSTransmit)(void* ctx, const ZUDS_FRAME* frame, uint32 count); + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_SetTransmitHandler(UInt32 ZUDS_HANDLE, IntPtr ctx, OnUDSTransmitDelegate onUDSTransmit); + + + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_OnReceive(UInt32 ZUDS_HANDLE, IntPtr ZUDS_FRAME); + + + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_Request(UInt32 ZUDS_HANDLE, IntPtr ZUDS_REQUEST, IntPtr ZUDS_RESPONSE); + + + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_Stop(UInt32 ZUDS_HANDLE); + + + [DllImport(".\\zuds.dll", CallingConvention = CallingConvention.StdCall)] + public static extern void ZUDS_SetTesterPresent(UInt32 ZUDS_HANDLE, byte enable, IntPtr param); + + #endregion + + #region 结构体部分 + /// + /// 会话层面参数；即一应一答传输时的通讯参数。 + /// + public struct ZUDS_SESSION_PARAM + { + public UInt16 timeout;// ms, timeout to wait the response of the server + public UInt16 enhanced_timeout; // ms,timeout to wait after negative response: error code 0x78 + public UInt32 reserved0; // 保留 + public UInt32 reserved1; // 保留 + } + + + /// + /// 传输数据部分的参数，例如传输时侯每帧报文的字节数。 + /// + public struct ZUDS_ISO15765_PARAM + { + public byte version; // VERSION_0, VERSION_1格式版本，为 VERSION_0 时符合 ISO15765-2 的 2004 版本格式要求；为 + //hVERSION_1 是符合 ISO15765-2 的 2016 版本新增的格式要求，如下图所示 + public byte max_data_len; // max data length, can:8, canfd:64 + public byte local_st_min; // ms, min time between two consecutive frames + public byte block_size; + public byte fill_byte; // fill to invalid byte + public byte frame_type; // 0:std 1:ext + public byte is_modify_ecu_st_min; //是否忽略 ECU 返回流控的 STmin，强制使用本程序设置的 + //remote_st_min 参数代替 + + public byte remote_st_min; //发 送 多 帧 时 用, is_ignore_ecu_st_min = 1 时 有 效 , + //0x00-0x7F(0ms ~127ms), 0xF1-0xF9(100us ~900us) + public UInt16 fc_timeout; //接收流控超时时间(ms), 如发送首帧后需要等待回应流控帧。 + public byte fill_mode;//字节填充模式。FILL_MODE_NONE-不填充0；FILL_MODE_SHORT- 小于 8 字节填充至 8 字节，大于 8 字节时按 DLC 就近填充1；FILL_MODE_MAX- 始终填充至最大数据长度 (不建议)2。 + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] + public byte[] reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZUDS_TESTER_PRESENT_PARAM + { + public UInt32 addr;//会话保持的请求地址； + public UInt16 cycle;//发送周期，单位毫秒； + public byte suppress_response; // 1:suppress是否抑制响应，建议设置为 1； + public UInt32 reserved;//：保留，忽略即可。 + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZUDS_REQUEST + { + public uint src_addr; // 请求地址 + public uint dst_addr; // 响应地址 + public byte suppress_response; // 1:抑制响应 + public byte sid; //service id of request + public ushort reserve0; + public IntPtr param; //array,params of the service + public uint param_len; //参数数组的长度 + public uint reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZUDS_RESPONSE + { + public byte status; + public byte type; // RT_POSITIVE, RT_NEGATIVE + public _ZUDS_Union union; + public uint reserved; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ZUDS_positive + { + public byte sid; // service id of response + public IntPtr param; // array, params of the service, don't free + public uint param_len; + + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct _ZUDS_negative + { + public byte neg_code; // 0x7F + public byte sid; //service id of response + public byte error_code;//消极响应的错误码 + + } + + + [StructLayout(LayoutKind.Explicit)] + public struct _ZUDS_Union + { + [FieldOffset(0)] + public ZUDS_positive zudsPositive; + + [FieldOffset(0)] + public _ZUDS_negative zudsNegative; + } + + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZUDS_FRAME + { + public uint id; + public byte extend; + public byte remote; + public byte data_len; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] + public byte[] data; + public uint reserved; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public class ZUDS_CTX + { + public IntPtr can_type; // 0-CAN 1-CANFD 2-CANFD加速 + public IntPtr chn_handle; // 通道句柄 + } + #endregion + } +}