1916 lines
85 KiB
C#
1916 lines
85 KiB
C#
using CapMachine.Wpf.Dtos;
|
||
using CapMachine.Wpf.Models;
|
||
using CapMachine.Wpf.Services;
|
||
using ImTools;
|
||
using Prism.Ioc;
|
||
using Prism.Mvvm;
|
||
using System.Collections.ObjectModel;
|
||
using System.Diagnostics;
|
||
using System.IO;
|
||
using System.Runtime.InteropServices;
|
||
using System.Text;
|
||
|
||
namespace CapMachine.Wpf.CanDrive
|
||
{
|
||
/// <summary>
|
||
/// 图莫斯（Toomoss）CAN 驱动封装。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 职责边界：
|
||
/// - 负责图莫斯 USB2XXX SDK 的设备扫描/打开/初始化/关闭；
|
||
/// - 负责 DBC 文件解析，并提供“信号值 <-> CAN 帧”的互转（通过 SDK 的 DBCParser 接口）；
|
||
/// - 提供三类发送能力：
|
||
/// - 单次发送（<see cref="SendCanMsg"/>）；
|
||
/// - 软件侧精确周期发送（<see cref="StartPrecisionCycleSendMsg"/>）；
|
||
/// - 硬件侧调度表发送（<see cref="StartSchedule"/> / <see cref="StopSchedule"/>，以及 <see cref="UpdateSchDataByCmdDataChanged"/> 增量更新）；
|
||
/// - 提供接收能力：后台轮询读取报文并同步到 DBC 信号值（<see cref="StartCycleReviceCanMsg"/>）。
|
||
///
|
||
/// 线程与资源：
|
||
/// - 发送/接收/调度表更新均可能在后台线程运行；
|
||
/// - 本类会分配非托管内存（IntPtr 缓冲区）。必须通过 <see cref="CloseDevice"/> 释放，且释放过程需要与接收线程互斥。
|
||
///
|
||
/// 重要约束：
|
||
/// - <see cref="DBCHandle"/> 为 0 表示 DBC 未解析成功，任何 DBC_* 调用都应视为不可用；
|
||
/// - <see cref="WriteCANIndex"/> / <see cref="ReadCANIndex"/> 表示 CAN 通道索引（0=CAN1,1=CAN2），当前实现约定读写通道一致。
|
||
/// </remarks>
|
||
public class ToomossCan : BindableBase
|
||
{
|
||
/// <summary>
|
||
/// Prism 容器，用于解析运行时依赖（如 <see cref="HighSpeedDataService"/>）。
|
||
/// </summary>
|
||
private readonly IContainerProvider ContainerProvider;
|
||
|
||
/// <summary>
|
||
/// 构造函数。
|
||
/// </summary>
|
||
/// <param name="containerProvider">DI 容器。</param>
|
||
/// <param name="logService">日志服务（外部注入，避免驱动类自己创建日志对象）。</param>
|
||
public ToomossCan(IContainerProvider containerProvider, ILogService logService)
|
||
{
|
||
ContainerProvider = containerProvider;
|
||
HighSpeedDataService = ContainerProvider.Resolve<HighSpeedDataService>();
|
||
LoggerService = logService;
|
||
|
||
//monitorValueLog = new MonitorValueLog(logService, "SetSignalValue", "SyncValueToCanMsg", "ret", "CanNum", "SyncCANMsgToValue");
|
||
|
||
//Stopwatch.Frequency表示高精度计时器每秒的计数次数（ticks/秒）每毫秒的ticks数 = 每秒的ticks数 ÷ 1000
|
||
TicksPerMs = Stopwatch.Frequency / 1000.0;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 启动 CAN 驱动（设备准备流程）。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 执行顺序与 SDK 依赖一致：
|
||
/// 1) 校验 DLL 是否存在；
|
||
/// 2) 扫描设备并选取句柄；
|
||
/// 3) 打开设备；
|
||
/// 4) 读取设备信息；
|
||
/// 5) 获取 CAN 初始化配置；
|
||
/// 6) 初始化 CAN。
|
||
///
|
||
/// 注意：该方法不解析 DBC；DBC 解析由 <see cref="StartDbc"/> 显式触发。
|
||
/// </remarks>
|
||
public void StartCanDrive()
|
||
{
|
||
IsExistsDllFile();
|
||
ScanDevice();
|
||
OpenDevice();
|
||
GetDeviceInfo();
|
||
GetCANConfig();
|
||
InitCAN();
|
||
|
||
//LoggerService.Info($"Start CAN Drive");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 高速数据服务：用于把接收到的原始报文写入高速记录/显示通道。
|
||
/// </summary>
|
||
public HighSpeedDataService HighSpeedDataService { get; set; }
|
||
|
||
/// <summary>
|
||
/// 日志服务。
|
||
/// </summary>
|
||
public ILogService LoggerService { get; set; }
|
||
|
||
/// <summary>
|
||
/// 解析并加载 DBC 文件。
|
||
/// </summary>
|
||
/// <param name="DbcPath">DBC 文件路径。</param>
|
||
/// <returns>解析得到的信号列表（用于 UI 展示与实时值刷新）。</returns>
|
||
public ObservableCollection<CanDbcModel> StartDbc(string DbcPath)
|
||
{
|
||
DBC_Parser(DbcPath);
|
||
return ListCanDbcModel;
|
||
}
|
||
|
||
///// <summary>
|
||
///// 获取Can DBC数据集合
|
||
///// </summary>
|
||
//public void LoadCanDbcData(ObservableCollection<CanDbcModel> canDbcModels)
|
||
//{
|
||
// ListCanDbcModel = canDbcModels;
|
||
//}
|
||
|
||
/// <summary>
|
||
/// DBC 解析得到的信号集合。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// - 该集合的每个元素代表一个信号（Signal），包含所属报文名、信号名、单位/描述、实时值等。
|
||
/// - 接收线程会持续更新 <see cref="CanDbcModel.SignalRtValue"/>。
|
||
/// </remarks>
|
||
public ObservableCollection<CanDbcModel> ListCanDbcModel { get; set; } = new ObservableCollection<CanDbcModel>();
|
||
|
||
|
||
#region 公共变量
|
||
|
||
/// <summary>
|
||
/// 设备固件信息（由 SDK 填充）。
|
||
/// </summary>
|
||
public USB_DEVICE.DEVICE_INFO DevInfo = new USB_DEVICE.DEVICE_INFO();
|
||
|
||
/// <summary>
|
||
/// CAN 初始化配置（由 <see cref="GetCANConfig"/> 读取或计算后用于 <see cref="InitCAN"/>）。
|
||
/// </summary>
|
||
USB2CAN.CAN_INIT_CONFIG CANConfig = new USB2CAN.CAN_INIT_CONFIG();
|
||
|
||
/// <summary>
|
||
/// DBC 解析成功后得到的句柄。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// - 为 0 表示 DBC 未解析/解析失败；
|
||
/// - 发送与接收解析均依赖该句柄。
|
||
/// </remarks>
|
||
public UInt64 DBCHandle { get; set; }
|
||
|
||
/// <summary>
|
||
/// 扫描到的设备句柄数组（SDK 输出）。
|
||
/// </summary>
|
||
public Int32[] DevHandles { get; set; } = new Int32[20];
|
||
|
||
/// <summary>
|
||
/// 当前打开的设备句柄。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 该值由 <see cref="ScanDevice"/> 选取并在 <see cref="OpenDevice"/> 中打开。
|
||
/// </remarks>
|
||
public Int32 DevHandle { get; set; } = 0;
|
||
|
||
/// <summary>
|
||
/// Write CAN Index
|
||
/// 通道的含义
|
||
/// 描述：
|
||
/// 读取接收到的CAN消息，推荐使用该函数。
|
||
///原型：
|
||
///int WINAPI CAN_GetMsgWithSize(int DevHandle, unsigned char CANIndex, CAN_MSG* pCanGetMsg, int BufferSize);
|
||
///参数：
|
||
///DevHandle 设备句柄，本质为设备序号的低4字节，可以通过调用USB_ScanDevice函数获得。
|
||
///CANIndex CAN通道索引号，0-对应CAN1,1-对应CAN2。
|
||
///pCanGetMsg 存储CAN消息缓冲区首地址。
|
||
///BufferSize 存储CAN消息缓冲区大小。
|
||
///返回值：
|
||
//大于等于0表示从CAN适配器内部成功读取到的CAN消息帧数，若返回值小于0则说明调用该函数失败。
|
||
/// 目前是WriteCANIndex和ReadCANIndex需要相同
|
||
/// </summary>
|
||
public Byte WriteCANIndex { get; set; } = 0;
|
||
|
||
/// <summary>
|
||
/// Read CAN Index
|
||
/// 通道的含义
|
||
/// 描述：
|
||
///读取接收到的CAN消息，推荐使用该函数。
|
||
///原型：
|
||
///int WINAPI CAN_GetMsgWithSize(int DevHandle, unsigned char CANIndex, CAN_MSG* pCanGetMsg, int BufferSize);
|
||
///参数：
|
||
///DevHandle 设备句柄，本质为设备序号的低4字节，可以通过调用USB_ScanDevice函数获得。
|
||
///CANIndex CAN通道索引号，0-对应CAN1,1-对应CAN2。
|
||
///pCanGetMsg 存储CAN消息缓冲区首地址。
|
||
///BufferSize 存储CAN消息缓冲区大小。
|
||
///返回值：
|
||
///大于等于0表示从CAN适配器内部成功读取到的CAN消息帧数，若返回值小于0则说明调用该函数失败。
|
||
/// </summary>
|
||
public Byte ReadCANIndex { get; set; } = 0;
|
||
|
||
|
||
private bool _OpenState;
|
||
/// <summary>
|
||
/// 设备打开状态。
|
||
/// </summary>
|
||
public bool OpenState
|
||
{
|
||
get { return _OpenState; }
|
||
set { _OpenState = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
private bool _DbcParserState;
|
||
/// <summary>
|
||
/// DBC 解析状态。
|
||
/// </summary>
|
||
public bool DbcParserState
|
||
{
|
||
get { return _DbcParserState; }
|
||
set { _DbcParserState = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 扫描到设备个数
|
||
/// </summary>
|
||
public Int32 DevNum { get; set; }
|
||
|
||
public Int32 ret { get; set; }
|
||
|
||
/// <summary>
|
||
/// USB2XXX SDK 的 DLL 文件名。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 注意：此处仅校验 DLL 是否存在，实际的 DllImport 绑定仍由运行时加载机制决定。
|
||
/// </remarks>
|
||
public string dllFilePath { get; set; } = "USB2XXX.dll";
|
||
|
||
|
||
/// <summary>
|
||
/// 消息值Pt
|
||
/// </summary>
|
||
public IntPtr msgPt { get; set; }
|
||
|
||
#endregion
|
||
|
||
/// <summary>
|
||
/// 【1】检查 USB2XXX SDK 的 DLL 是否存在。
|
||
/// </summary>
|
||
/// <returns>存在返回 true，否则返回 false。</returns>
|
||
/// <remarks>
|
||
/// 这是最前置的防御性校验，避免后续调用直接触发 DllNotFoundException。
|
||
/// </remarks>
|
||
public bool IsExistsDllFile()
|
||
{
|
||
if (!File.Exists(dllFilePath))
|
||
{
|
||
Console.WriteLine("请先将USB2XXX.dll和libusb-1.0.dll文件复制到exe程序文件输出目录下!");
|
||
Console.WriteLine("dll文件在‘usb2can_lin_pwm_example/sdk/libs/windows’目录下！");
|
||
Console.WriteLine("程序是32位的就复制‘x86’目录下文件，程序是64位的就复制‘x86_64’目录下文件！");
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 【2】扫描设备。
|
||
/// </summary>
|
||
/// <returns>扫描到设备返回 true，否则返回 false。</returns>
|
||
/// <remarks>
|
||
/// SDK 会把设备句柄写入 <see cref="DevHandles"/>，并返回设备数量。
|
||
/// 当前实现默认选取第一个设备句柄作为 <see cref="DevHandle"/>。
|
||
/// </remarks>
|
||
public bool ScanDevice()
|
||
{
|
||
DevNum = USB_DEVICE.USB_ScanDevice(DevHandles);
|
||
if (DevNum <= 0)
|
||
{
|
||
Console.WriteLine("No device connected!");
|
||
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("Have {0} device connected!", DevNum);
|
||
DevHandle = DevHandles[0];//获取第一个设备的设备号
|
||
return true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// ******************【3】*********************
|
||
/// 打开设备
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public bool OpenDevice()
|
||
{
|
||
//打开设备
|
||
OpenState = USB_DEVICE.USB_OpenDevice(DevHandle);
|
||
if (!OpenState)
|
||
{
|
||
Console.WriteLine("Open device error!");
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("Open device success!");
|
||
return true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// ******************【4】*********************
|
||
/// 获取设备的固件信息
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public bool GetDeviceInfo()
|
||
{
|
||
//获取固件信息
|
||
StringBuilder FuncStr = new StringBuilder(256);
|
||
OpenState = USB_DEVICE.DEV_GetDeviceInfo(DevHandle, ref DevInfo, FuncStr);
|
||
if (!OpenState)
|
||
{
|
||
Console.WriteLine("Get device infomation error!");
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("Firmware Info:");
|
||
Console.WriteLine(" Name:" + Encoding.Default.GetString(DevInfo.FirmwareName));
|
||
Console.WriteLine(" Build Date:" + Encoding.Default.GetString(DevInfo.BuildDate));
|
||
Console.WriteLine(" Firmware Version:v{0}.{1}.{2}", (DevInfo.FirmwareVersion >> 24) & 0xFF, (DevInfo.FirmwareVersion >> 16) & 0xFF, DevInfo.FirmwareVersion & 0xFFFF);
|
||
Console.WriteLine(" Hardware Version:v{0}.{1}.{2}", (DevInfo.HardwareVersion >> 24) & 0xFF, (DevInfo.HardwareVersion >> 16) & 0xFF, DevInfo.HardwareVersion & 0xFFFF);
|
||
Console.WriteLine(" Functions:" + DevInfo.Functions.ToString("X8"));
|
||
Console.WriteLine(" Functions String:" + FuncStr);
|
||
StringBuilder DLLBuildDate = new StringBuilder(256);
|
||
USB_DEVICE.DEV_GetDllBuildTime(DLLBuildDate);
|
||
Console.WriteLine(" DLL Build Date:" + DLLBuildDate);
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// ******************【5】*********************
|
||
/// 获取设备Config配置
|
||
/// </summary>
|
||
public void GetCANConfig()
|
||
{
|
||
CANConfig.CAN_Mode = 0x80;//正常模式并接入终端电阻
|
||
//获取CAN波特率参数
|
||
ret = USB2CAN.CAN_GetCANSpeedArg(DevHandle, ref CANConfig, 500000);
|
||
if (ret != USB2CAN.CAN_SUCCESS)
|
||
{
|
||
Console.WriteLine("Get CAN Speed failed!");
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("Get CAN Speed Success!");
|
||
}
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// ******************【6】*********************
|
||
/// 初始化CAN
|
||
/// </summary>
|
||
public void InitCAN()
|
||
{
|
||
//初始化CAN
|
||
|
||
ret = USB2CAN.CAN_Init(DevHandle, WriteCANIndex, ref CANConfig);
|
||
if (ret != USB2CAN.CAN_SUCCESS)
|
||
{
|
||
Console.WriteLine("Config CAN failed!");
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("WriteCANIndex Config CAN Success!");
|
||
}
|
||
|
||
ret = USB2CAN.CAN_Init(DevHandle, ReadCANIndex, ref CANConfig);
|
||
if (ret != USB2CAN.CAN_SUCCESS)
|
||
{
|
||
Console.WriteLine("Config CAN failed!");
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("ReadCANIndex Config CAN Success!");
|
||
}
|
||
Console.WriteLine("");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 【7】解析 DBC 文件并构建信号列表。
|
||
/// </summary>
|
||
/// <param name="Path">DBC 文件路径。</param>
|
||
/// <remarks>
|
||
/// 解析结果：
|
||
/// - <see cref="DBCHandle"/>：后续信号赋值/取值/同步帧均依赖它；
|
||
/// - <see cref="ListCanDbcModel"/>：用于 UI 列表展示与实时值更新。
|
||
/// </remarks>
|
||
public void DBC_Parser(string Path)
|
||
{
|
||
//解析DBC文件
|
||
DBCHandle = CAN_DBCParser.DBC_ParserFile(DevHandle, new StringBuilder(Path));
|
||
if (DBCHandle == 0)
|
||
{
|
||
Console.WriteLine("Parser DBC File error!");
|
||
DbcParserState = false;
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("Parser DBC File success!");
|
||
}
|
||
|
||
ListCanDbcModel.Clear();
|
||
|
||
//打印DBC里面报文和信号相关信息
|
||
int DBCMsgNum = CAN_DBCParser.DBC_GetMsgQuantity(DBCHandle);
|
||
for (int i = 0; i < DBCMsgNum; i++)
|
||
{
|
||
StringBuilder MsgName = new StringBuilder(32);
|
||
CAN_DBCParser.DBC_GetMsgName(DBCHandle, i, MsgName);
|
||
Console.WriteLine("Msg.Name = {0}", MsgName);
|
||
int DBCSigNum = CAN_DBCParser.DBC_GetMsgSignalQuantity(DBCHandle, MsgName);
|
||
StringBuilder Publisher = new StringBuilder(32);
|
||
CAN_DBCParser.DBC_GetMsgPublisher(DBCHandle, MsgName, Publisher);
|
||
long MsgId;
|
||
MsgId = CAN_DBCParser.DBC_GetMsgIDByName(DBCHandle, MsgName);
|
||
|
||
Console.Write("Signals:");
|
||
for (int j = 0; j < DBCSigNum; j++)
|
||
{
|
||
StringBuilder SigName = new StringBuilder(32);
|
||
CAN_DBCParser.DBC_GetMsgSignalName(DBCHandle, MsgName, j, SigName);
|
||
Console.Write("{0} ", SigName);
|
||
|
||
//增加信息数据
|
||
ListCanDbcModel.Add(new CanDbcModel()
|
||
{
|
||
MsgName = MsgName.ToString(),
|
||
MsgId = "0x" + MsgId.ToString("X8"),
|
||
SignalName = SigName.ToString(),
|
||
SignalDesc = "",
|
||
SignalUnit = "",
|
||
SignalRtValue = "",
|
||
Publisher = Publisher.ToString()
|
||
});
|
||
}
|
||
Console.WriteLine("");
|
||
}
|
||
|
||
//Dbc解析成功
|
||
DbcParserState = true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 单次发送：根据 CmdData 中的信号值构建 CAN 报文并发送。
|
||
/// </summary>
|
||
/// <param name="CmdData">待发送的信号指令集合（按 MsgName 分组后组成帧）。</param>
|
||
/// <remarks>
|
||
/// 数据流：
|
||
/// 1) 按 MsgName 分组（每组代表同一个报文/帧）；
|
||
/// 2) 对每个分组：逐信号调用 DBC_SetSignalValue 写入 DBC 缓存；
|
||
/// 3) 调用 DBC_SyncValueToCANMsg 生成帧；
|
||
/// 4) 调用 CAN_SendMsg 一次性批量发送。
|
||
///
|
||
/// 注意：此方法会分配临时非托管内存 msgPt，并在结束前释放。
|
||
/// </remarks>
|
||
public void SendCanMsg(List<CanCmdData> CmdData)
|
||
{
|
||
var GroupMsg = CmdData.GroupBy(x => x.MsgName);
|
||
USB2CAN.CAN_MSG[] CanMsg = new USB2CAN.CAN_MSG[GroupMsg.Count()];
|
||
for (int i = 0; i < GroupMsg.Count(); i++)
|
||
{
|
||
CanMsg[i] = new USB2CAN.CAN_MSG();
|
||
CanMsg[i].Data = new Byte[64];
|
||
}
|
||
|
||
// 非托管缓冲：SDK API 以指针形式写入帧结构体
|
||
IntPtr msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)));
|
||
int Index = 0;
|
||
//循环给MSG赋值数据
|
||
foreach (var itemMsg in GroupMsg)
|
||
{
|
||
foreach (var itemSignal in itemMsg)
|
||
{
|
||
CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
|
||
}
|
||
CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPt);
|
||
CanMsg[Index] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPt, typeof(USB2CAN.CAN_MSG));
|
||
Index++;
|
||
}
|
||
|
||
//设置信号值
|
||
//DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), 2412);
|
||
//DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), 980);
|
||
//DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), 120);
|
||
|
||
//通过DBC写入数据后生成CanMsg
|
||
//将信号值填入CAN消息里面
|
||
|
||
// 释放临时非托管缓冲区，避免内存泄漏
|
||
Marshal.FreeHGlobal(msgPt);
|
||
Console.WriteLine("");
|
||
//发送CAN数据
|
||
int SendedNum = USB2CAN.CAN_SendMsg(DevHandle, WriteCANIndex, CanMsg, (uint)CanMsg.Length);
|
||
if (SendedNum >= 0)
|
||
{
|
||
Console.WriteLine("Success send frames:{0}", SendedNum);
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("Send CAN data failed! {0}", SendedNum);
|
||
}
|
||
}
|
||
|
||
|
||
private bool _IsCycleRevice;
|
||
/// <summary>
|
||
/// 是否循环接收数据。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 由 UI/Service 控制开关，接收任务 <see cref="StartCycleReviceCanMsg"/> 以该标记作为退出条件。
|
||
/// </remarks>
|
||
public bool IsCycleRevice
|
||
{
|
||
get { return _IsCycleRevice; }
|
||
set { _IsCycleRevice = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
private bool _IsCycleSend;
|
||
/// <summary>
|
||
/// 是否循环发送数据。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 由 UI/Service 控制开关：
|
||
/// - 软件精确周期发送：<see cref="StartPrecisionCycleSendMsg"/> / <see cref="StopCycleSendMsg"/>；
|
||
/// - 调度表发送：<see cref="StartSchedule"/> / <see cref="StopSchedule"/>。
|
||
/// </remarks>
|
||
public bool IsCycleSend
|
||
{
|
||
get { return _IsCycleSend; }
|
||
set { _IsCycleSend = value; RaisePropertyChanged(); }
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 循环发送周期（毫秒）。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 该周期用于软件侧循环发送/接收 Task.Delay；硬件调度表发送周期由调度表项的 Cycle 决定。
|
||
/// </remarks>
|
||
public ushort SendCycle { get; set; } = 100;
|
||
|
||
/// <summary>
|
||
/// 循环接收轮询周期（毫秒）。
|
||
/// </summary>
|
||
public ushort ReviceCycle { get; set; } = 500;
|
||
|
||
/// <summary>
|
||
/// 循环接收任务。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 这里是 static：意味着同进程内多个实例会共享该任务引用（这在多设备场景需要特别注意）。
|
||
/// </remarks>
|
||
private static Task CycleReviceTask { get; set; }
|
||
|
||
/// <summary>
|
||
/// 循环发送任务。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 这里是 static：意味着同进程内多个实例会共享该任务引用（这在多设备场景需要特别注意）。
|
||
/// </remarks>
|
||
private static Task CycleSendTask { get; set; }
|
||
|
||
/// <summary>
|
||
/// （旧方案）周期性刷新调度表任务。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 当前已引入“CmdData 变化事件 -> 增量更新调度表”的机制（见 <see cref="UpdateSchDataByCmdDataChanged"/>），
|
||
/// 该 Task 属于保留兼容路径。
|
||
/// </remarks>
|
||
private static Task CycleUpdateCmdTask { get; set; }
|
||
|
||
StringBuilder ValueSb = new StringBuilder(16);
|
||
double[] ValueDouble = new double[5];
|
||
|
||
// 接收缓冲池（重用，避免每轮分配）
|
||
private IntPtr RecvMsgBufferPtr = IntPtr.Zero;
|
||
private int RecvMsgBufferCapacity = 1024;
|
||
private readonly int CanMsgSize = Marshal.SizeOf(typeof(USB2CAN.CAN_MSG));
|
||
|
||
// 名称 StringBuilder 缓存（DBC 调用复用，避免频繁分配）
|
||
private readonly Dictionary<string, StringBuilder> MsgNameSBCache = new Dictionary<string, StringBuilder>(StringComparer.Ordinal);
|
||
private readonly Dictionary<string, StringBuilder> SigNameSBCache = new Dictionary<string, StringBuilder>(StringComparer.Ordinal);
|
||
|
||
// 控制台调试输出开关（默认关闭，防止日志风暴）
|
||
public bool EnableConsoleDebugLog { get; set; } = false;
|
||
|
||
// 保护接收缓冲的并发锁（接收读与关闭释放之间的互斥）
|
||
private readonly object RecvBufferSync = new object();
|
||
|
||
private StringBuilder GetCachedSB(Dictionary<string, StringBuilder> cache, string key)
|
||
{
|
||
key ??= string.Empty;
|
||
if (cache.TryGetValue(key, out var sb)) return sb;
|
||
var nsb = new StringBuilder(key);
|
||
cache[key] = nsb;
|
||
return nsb;
|
||
}
|
||
private StringBuilder GetMsgSB(string key) => GetCachedSB(MsgNameSBCache, key);
|
||
private StringBuilder GetSigSB(string key) => GetCachedSB(SigNameSBCache, key);
|
||
|
||
private bool _IsSendOk;
|
||
/// <summary>
|
||
/// 最近一次发送是否成功。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// - 软件循环发送路径：由 CAN_SendMsg 返回值决定；
|
||
/// - 调度表更新路径：由 CAN_UpdateSchedule 返回值决定。
|
||
/// </remarks>
|
||
public bool IsSendOk
|
||
{
|
||
get { return _IsSendOk; }
|
||
set
|
||
{
|
||
if (_IsSendOk != value)
|
||
{
|
||
RaisePropertyChanged();
|
||
_IsSendOk = value;
|
||
}
|
||
//RaisePropertyChanged();
|
||
}
|
||
}
|
||
|
||
private bool _IsReviceOk;
|
||
/// <summary>
|
||
/// 最近一次接收是否成功。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 该状态反映最近一次轮询读取 CAN_GetMsgWithSize 的结果：
|
||
/// - CanNum > 0：成功收到数据；
|
||
/// - CanNum == 0：本轮无数据；
|
||
/// - CanNum < 0：调用失败。
|
||
/// </remarks>
|
||
public bool IsReviceOk
|
||
{
|
||
get { return _IsReviceOk; }
|
||
set
|
||
{
|
||
if (_IsReviceOk != value)
|
||
{
|
||
RaisePropertyChanged();
|
||
_IsReviceOk = value;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 当前激活的指令集合（由 Service/UI 下发）。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// - 每个元素代表一个信号的写入指令；
|
||
/// - 发送时按 MsgName 分组，同一 MsgName 下的多个信号会被打包到同一帧。
|
||
/// </remarks>
|
||
public List<CanCmdData> CmdData { get; set; } = new List<CanCmdData>();
|
||
|
||
/// <summary>
|
||
/// （普通）软件循环发送：以 <see cref="SendCycle"/> 为周期构建帧并发送。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 该方法属于早期实现，精度与线程抖动相关；若追求更高精度建议使用 <see cref="StartPrecisionCycleSendMsg"/>。
|
||
/// </remarks>
|
||
public void StartCycleSendMsg()
|
||
{
|
||
CycleSendTask = Task.Run(async () =>
|
||
{
|
||
while (IsCycleSend)
|
||
{
|
||
await Task.Delay(SendCycle);
|
||
try
|
||
{
|
||
var GroupMsg = CmdData.GroupBy(x => x.MsgName);
|
||
USB2CAN.CAN_MSG[] CanMsg = new USB2CAN.CAN_MSG[GroupMsg.Count()];
|
||
for (int i = 0; i < GroupMsg.Count(); i++)
|
||
{
|
||
CanMsg[i] = new USB2CAN.CAN_MSG();
|
||
CanMsg[i].Data = new Byte[64];
|
||
}
|
||
|
||
IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)));
|
||
int Index = 0;
|
||
//循环给MSG赋值数据
|
||
foreach (var itemMsg in GroupMsg)
|
||
{
|
||
foreach (var itemSignal in itemMsg)
|
||
{
|
||
CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
|
||
}
|
||
CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend);
|
||
CanMsg[Index] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CAN.CAN_MSG));
|
||
Index++;
|
||
}
|
||
//通过DBC写入数据后生成CanMsg
|
||
//将信号值填入CAN消息里面
|
||
|
||
//释放申请的临时缓冲区
|
||
Marshal.FreeHGlobal(msgPtSend);
|
||
Console.WriteLine("");
|
||
//发送CAN数据
|
||
int SendedNum = USB2CAN.CAN_SendMsg(DevHandle, WriteCANIndex, CanMsg, (uint)CanMsg.Length);
|
||
if (SendedNum >= 0)
|
||
{
|
||
Console.WriteLine("Success send frames:{0}", SendedNum);
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("Send CAN data failed! {0}", SendedNum);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
//LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
#region 定时器发送报文数据
|
||
|
||
// 定时器发送：采用单次触发+校准的方式避免周期漂移，减少长时间运行误差
|
||
// 说明：不修改 StartPrecisionCycleSendMsg 的任何内容；此处仅实现定时器版本
|
||
|
||
// 定时器与资源
|
||
private System.Threading.Timer _sendTimer;
|
||
private readonly object _sendTimerSync = new object();
|
||
private volatile int _sendTimerRunningFlag = 0; // 防止回调重入
|
||
private int _sendTimerPeriodMs = 100; // 默认100ms
|
||
private readonly Stopwatch _sendTimerWatch = new Stopwatch();
|
||
private long _sendTimerNextTicks;
|
||
|
||
// 发送缓冲重用，减少分配
|
||
private USB2CAN.CAN_MSG[] _timerCanMsgBuffer;
|
||
private IntPtr _timerMsgPtr = IntPtr.Zero;
|
||
|
||
/// <summary>
|
||
/// 启动基于定时器的周期发送（毫秒）。支持典型的50/100/200ms等周期。
|
||
/// 使用单次触发+绝对时间校准的算法，尽量减少漂移；并使用重用缓冲降低内存分配。
|
||
/// </summary>
|
||
/// <param name="periodMs">发送周期（毫秒）</param>
|
||
public void StartTimerCycleSendMsg(int periodMs)
|
||
{
|
||
if (periodMs <= 0) periodMs = 1;
|
||
|
||
lock (_sendTimerSync)
|
||
{
|
||
// 先停止旧的
|
||
StopTimerCycleSendMsg_NoLock();
|
||
|
||
_sendTimerPeriodMs = periodMs;
|
||
IsCycleSend = true;
|
||
|
||
if (_timerMsgPtr == IntPtr.Zero)
|
||
{
|
||
_timerMsgPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)));
|
||
}
|
||
|
||
_sendTimerWatch.Restart();
|
||
_sendTimerNextTicks = _sendTimerWatch.ElapsedTicks + (long)(_sendTimerPeriodMs * TicksPerMs);
|
||
|
||
// 使用单次触发模式，每次回调后手动调度下一次，便于按绝对时间校准
|
||
_sendTimer = new System.Threading.Timer(SendTimerCallback, null, 0, System.Threading.Timeout.Infinite);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 启动基于定时器的周期发送（使用 SendCycle 属性作为周期参数）
|
||
/// </summary>
|
||
public void StartTimerCycleSendMsg()
|
||
{
|
||
StartTimerCycleSendMsg((int)SendCycle);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 便捷方法：启动50ms周期发送
|
||
/// </summary>
|
||
public void StartTimerCycleSendMsg50ms() => StartTimerCycleSendMsg(50);
|
||
|
||
/// <summary>
|
||
/// 便捷方法：启动100ms周期发送
|
||
/// </summary>
|
||
public void StartTimerCycleSendMsg100ms() => StartTimerCycleSendMsg(100);
|
||
|
||
/// <summary>
|
||
/// 便捷方法：启动200ms周期发送
|
||
/// </summary>
|
||
public void StartTimerCycleSendMsg200ms() => StartTimerCycleSendMsg(200);
|
||
|
||
/// <summary>
|
||
/// 停止定时器周期发送并释放资源
|
||
/// </summary>
|
||
public void StopTimerCycleSendMsg()
|
||
{
|
||
lock (_sendTimerSync)
|
||
{
|
||
IsCycleSend = false;
|
||
StopTimerCycleSendMsg_NoLock();
|
||
}
|
||
}
|
||
|
||
private void StopTimerCycleSendMsg_NoLock()
|
||
{
|
||
var t = _sendTimer;
|
||
_sendTimer = null;
|
||
if (t != null)
|
||
{
|
||
try { t.Dispose(); } catch { }
|
||
}
|
||
|
||
// 等待在途回调结束，避免释放资源时发生竞争
|
||
System.Threading.SpinWait.SpinUntil(() => System.Threading.Interlocked.CompareExchange(ref _sendTimerRunningFlag, 0, 0) == 0, 200);
|
||
|
||
_sendTimerWatch.Stop();
|
||
|
||
if (_timerMsgPtr != IntPtr.Zero)
|
||
{
|
||
try { Marshal.FreeHGlobal(_timerMsgPtr); } catch { } finally { _timerMsgPtr = IntPtr.Zero; }
|
||
}
|
||
_timerCanMsgBuffer = null; // 让GC回收
|
||
IsSendOk = false;
|
||
}
|
||
|
||
// 定时器回调（单次触发）；回调结束时会按绝对时间校准下一次触发
|
||
private void SendTimerCallback(object state)
|
||
{
|
||
try
|
||
{
|
||
if (!IsCycleSend) return;
|
||
|
||
// 防止回调重入（当某次发送耗时超过周期时避免并发）
|
||
if (System.Threading.Interlocked.Exchange(ref _sendTimerRunningFlag, 1) == 1)
|
||
{
|
||
ScheduleNextTick();
|
||
return;
|
||
}
|
||
|
||
var localCmd = CmdData; // 快照引用，避免枚举时被替换
|
||
if (localCmd == null || localCmd.Count == 0)
|
||
{
|
||
IsSendOk = false;
|
||
return;
|
||
}
|
||
|
||
// 依据消息名进行分组（与 StartPrecisionCycleSendMsg 的发送逻辑一致）
|
||
IEnumerable<IGrouping<string, CanCmdData>> groupMsg;
|
||
try
|
||
{
|
||
groupMsg = localCmd.GroupBy(x => x.MsgName).ToList(); // ToList 避免重复枚举
|
||
}
|
||
catch
|
||
{
|
||
// 罕见并发异常，跳过本次
|
||
IsSendOk = false;
|
||
return;
|
||
}
|
||
|
||
int msgCount = groupMsg.Count();
|
||
if (msgCount <= 0)
|
||
{
|
||
IsSendOk = false;
|
||
return;
|
||
}
|
||
|
||
// 确保发送缓冲容量，尽量复用，减少频繁分配
|
||
if (_timerCanMsgBuffer == null || _timerCanMsgBuffer.Length != msgCount)
|
||
{
|
||
_timerCanMsgBuffer = new USB2CAN.CAN_MSG[msgCount];
|
||
for (int i = 0; i < msgCount; i++)
|
||
{
|
||
_timerCanMsgBuffer[i] = new USB2CAN.CAN_MSG();
|
||
_timerCanMsgBuffer[i].Data = new byte[64];
|
||
}
|
||
}
|
||
|
||
int index = 0;
|
||
foreach (var itemMsg in groupMsg)
|
||
{
|
||
foreach (var itemSignal in itemMsg)
|
||
{
|
||
// 与 StartPrecisionCycleSendMsg 保持一致的调用形态，避免与其他线程共享缓存的并发问题
|
||
CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
|
||
}
|
||
|
||
// 将信号同步到 CAN 帧
|
||
CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), _timerMsgPtr);
|
||
_timerCanMsgBuffer[index] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(_timerMsgPtr, typeof(USB2CAN.CAN_MSG));
|
||
index++;
|
||
}
|
||
|
||
// 发送 CAN 数据
|
||
int sendedNum = USB2CAN.CAN_SendMsg(DevHandle, WriteCANIndex, _timerCanMsgBuffer, (uint)_timerCanMsgBuffer.Length);
|
||
IsSendOk = sendedNum >= 0;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
IsSendOk = false;
|
||
LoggerService?.Info($"定时器周期发送CAN数据异常: {ex.Message}");
|
||
}
|
||
finally
|
||
{
|
||
// 标记回调完成并调度下一次
|
||
System.Threading.Interlocked.Exchange(ref _sendTimerRunningFlag, 0);
|
||
ScheduleNextTick();
|
||
}
|
||
}
|
||
|
||
// 计算并调度下一次触发时间（基于绝对时间进行校准，减少漂移）
|
||
private void ScheduleNextTick()
|
||
{
|
||
try
|
||
{
|
||
if (!IsCycleSend) return;
|
||
var timer = _sendTimer;
|
||
if (timer == null) return;
|
||
|
||
long now = _sendTimerWatch.ElapsedTicks;
|
||
long periodTicks = (long)(_sendTimerPeriodMs * TicksPerMs);
|
||
|
||
if (_sendTimerNextTicks == 0)
|
||
{
|
||
_sendTimerNextTicks = now + periodTicks;
|
||
}
|
||
else if (now >= _sendTimerNextTicks)
|
||
{
|
||
// 若已错过计划时间，跳至最近的未来时刻，避免累计漂移
|
||
long missed = (now - _sendTimerNextTicks) / periodTicks + 1;
|
||
_sendTimerNextTicks += missed * periodTicks;
|
||
}
|
||
|
||
long dueTicks = _sendTimerNextTicks - now;
|
||
int dueMs = dueTicks <= 0 ? 0 : (int)(dueTicks / TicksPerMs);
|
||
|
||
timer.Change(dueMs, System.Threading.Timeout.Infinite);
|
||
}
|
||
catch (ObjectDisposedException)
|
||
{
|
||
// 计时器已被释放，忽略
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LoggerService?.Info($"定时器调度异常: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
|
||
#region 精确发送报文数据
|
||
|
||
// 添加取消标记源字段用于停止任务
|
||
private CancellationTokenSource CycleSendCts;
|
||
|
||
/// <summary>
|
||
/// 计算每毫秒对应的ticks数（只需计算一次）
|
||
/// </summary>
|
||
private double TicksPerMs;
|
||
|
||
// 类成员变量定义 精确记时用
|
||
private readonly Stopwatch Stopwatcher = new Stopwatch();
|
||
private long NextExecutionTime;
|
||
// 计算需要等待的时间
|
||
private long CurrentTime;
|
||
private long DelayTicks;
|
||
private int DelayMs;
|
||
|
||
private static readonly Random _random = new Random();
|
||
|
||
/// <summary>
|
||
/// 软件侧精确周期发送 CAN 数据。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 关键点：
|
||
/// - 使用 <see cref="Stopwatch"/> tick 作为时间基准，减少 DateTime 带来的抖动；
|
||
/// - 使用 Task.Delay + SpinWait 组合：大等待让出 CPU，小等待自旋微调；
|
||
/// - 使用 <see cref="CycleSendCts"/> 支持外部取消。
|
||
///
|
||
/// 注意：调用方需要先将 <see cref="IsCycleSend"/> 置为 true；停止时请调用 <see cref="StopCycleSendMsg"/>。
|
||
/// </remarks>
|
||
public void StartPrecisionCycleSendMsg()
|
||
{
|
||
// 创建取消标记源 用于控制任务的取消 允许在需要时通过取消令牌来优雅停止任务
|
||
var cancellationTokenSource = new CancellationTokenSource();
|
||
var token = cancellationTokenSource.Token;
|
||
|
||
// 保存取消标记，以便在停止时使用
|
||
CycleSendCts = cancellationTokenSource;//将取消标记源保存到类的成员变量CycleSendCts，这样在外部调用停止方法时可以访问它
|
||
NextExecutionTime = 0;//初始化NextExecutionTime为0，这个变量用于记录下一次执行的目标时间点
|
||
|
||
CycleSendTask = Task.Factory.StartNew(async () =>
|
||
{
|
||
try
|
||
{
|
||
// 设置当前线程为高优先级
|
||
Thread.CurrentThread.Priority = ThreadPriority.AboveNormal;
|
||
|
||
// 初始化完成后开始计时
|
||
Stopwatcher.Restart();
|
||
// 预先计算固定值
|
||
long CycleInTicks = (long)(SendCycle * TicksPerMs);
|
||
//临时测试用
|
||
//long lastTicks = Stopwatcher.ElapsedTicks;
|
||
//IsCycleSend
|
||
while (IsCycleSend && !token.IsCancellationRequested)
|
||
{
|
||
try
|
||
{
|
||
// 计算下一次执行时间点 ，将当前设置的发送周期SendCycle(毫秒)转换为Stopwatch的计时单位(tick)，累加到NextExecutionTime上
|
||
NextExecutionTime += CycleInTicks; // 转换为Stopwatch计时单位
|
||
|
||
// 获取当前时间点，以Stopwatch的tick为单位
|
||
CurrentTime = Stopwatcher.ElapsedTicks;
|
||
//计算需要等待的时间，即目标时间点(NextExecutionTime)与当前时间点(CurrentTime)的差值
|
||
DelayTicks = NextExecutionTime - CurrentTime;
|
||
|
||
// 如果还有等待时间，则等待，只有在目标时间点还未到达时才执行等待
|
||
if (DelayTicks > 0)
|
||
{
|
||
////此时是需要等待的，那么需要等待多久呢， 将需等待的tick数转换回毫秒
|
||
DelayMs = (int)(DelayTicks / TicksPerMs);
|
||
//20这个数据是预估和测试的，可能跟Windows抖动误差就是20ms左右，当然可以不用这个IF()判断，直接SpinWait.SpinUntil(() => Stopwatcher.ElapsedTicks >= NextExecutionTime);但是会导致当前独占一个CPU核心线程
|
||
//所以设置一个20的阈值，20ms以下的延迟使用SpinWait.SpinUntil进行自旋等待，20ms以上的延迟使用Task.Delay进行异步等待，让CPU不至于一直的独占
|
||
if (DelayMs <= 20)
|
||
{
|
||
SpinWait.SpinUntil(() => Stopwatcher.ElapsedTicks >= NextExecutionTime);
|
||
}
|
||
else
|
||
{
|
||
////使用Task.Delay进行异步等待，大部分等待时间通过这种方式完成，避免线程阻塞
|
||
await Task.Delay(DelayMs - 20, token);
|
||
//// 使用SpinWait.SpinUntil进行精确的微调等待。自旋等待会占用CPU资源，但能提供更高的定时精度，确保在精确的时间点执行
|
||
////上面的Task.Delay可能会因为系统调度等原因导致实际执行时间稍晚于预期，因此在这里使用SpinWait.SpinUntil来确保在精确的时间点执行
|
||
SpinWait.SpinUntil(() => Stopwatcher.ElapsedTicks >= NextExecutionTime);
|
||
}
|
||
}
|
||
|
||
// 如果已经超过了计划时间，立即执行并重新校准
|
||
if (Stopwatcher.ElapsedTicks >= NextExecutionTime + CycleInTicks)
|
||
{
|
||
//检测是否发生了严重延迟(超过一个周期)。如果当前时间已经超过了下一次计划时间，则说明系统负载过高或其他原因导致无法按时执行，
|
||
//此时重置NextExecutionTime为当前时间，避免连续的延迟累积
|
||
// 严重延迟，重新校准
|
||
NextExecutionTime = Stopwatcher.ElapsedTicks;
|
||
Console.WriteLine("定时发送延迟过大，重新校准时间");
|
||
LoggerService.Info($"定时发送延迟过大，重新校准时间");
|
||
}
|
||
|
||
// 使用Stopwatch记录实际的执行间隔，而不是DateTime
|
||
//Console.WriteLine($"--实际间隔(ms): {(Stopwatcher.ElapsedTicks - lastTicks) / TicksPerMs:F3}, 目标: {SendCycle}");
|
||
//lastTicks = Stopwatcher.ElapsedTicks;
|
||
|
||
//Console.WriteLine($"--当前时间(毫秒): {DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}");
|
||
|
||
|
||
// 执行发送CAN逻辑
|
||
{
|
||
|
||
var GroupMsg = CmdData.GroupBy(x => x.MsgName);
|
||
USB2CAN.CAN_MSG[] CanMsg = new USB2CAN.CAN_MSG[GroupMsg.Count()];
|
||
for (int i = 0; i < GroupMsg.Count(); i++)
|
||
{
|
||
CanMsg[i] = new USB2CAN.CAN_MSG();
|
||
CanMsg[i].Data = new Byte[64];
|
||
}
|
||
|
||
// 发送构帧临时缓冲：每轮申请/释放，避免与其他线程共享同一指针导致并发问题
|
||
IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)));
|
||
int Index = 0;
|
||
//循环给MSG赋值数据
|
||
foreach (var itemMsg in GroupMsg)
|
||
{
|
||
foreach (var itemSignal in itemMsg)
|
||
{
|
||
CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
|
||
}
|
||
CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend);
|
||
CanMsg[Index] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CAN.CAN_MSG));
|
||
Index++;
|
||
}
|
||
|
||
//通过DBC写入数据后生成CanMsg
|
||
//将信号值填入CAN消息里面
|
||
|
||
// 释放非托管缓冲区（务必释放，否则长时间运行会造成内存泄漏）
|
||
Marshal.FreeHGlobal(msgPtSend);
|
||
|
||
//发送CAN数据
|
||
int SendedNum = USB2CAN.CAN_SendMsg(DevHandle, WriteCANIndex, CanMsg, (uint)CanMsg.Length);
|
||
if (SendedNum >= 0)
|
||
{
|
||
//Console.WriteLine("Success send frames:{0}", SendedNum);
|
||
IsSendOk = true;
|
||
}
|
||
else
|
||
{
|
||
//Console.WriteLine("Send CAN data failed! {0}", SendedNum);
|
||
IsSendOk = false;
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
catch (TaskCanceledException)
|
||
{
|
||
LoggerService.Info($"精确周期发送CAN数据-任务被取消，正常退出");
|
||
// 任务被取消，正常退出
|
||
IsSendOk = false;
|
||
break;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Console.WriteLine($"CAN周期发送异常: {ex.Message}");
|
||
// 短暂暂停避免异常情况下CPU占用过高
|
||
IsSendOk = false;
|
||
await Task.Delay(10, token);
|
||
|
||
LoggerService.Info($"精确周期发送CAN数据-{ex.Message}");
|
||
}
|
||
}
|
||
|
||
IsSendOk = false;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// 确保在任何情况下（正常退出、异常、取消）都会停止计时器
|
||
Stopwatcher.Stop();
|
||
LoggerService.Info($"精确周期发送CAN数据-{ex.Message}");
|
||
// 清理其他可能的资源
|
||
Console.WriteLine("CAN周期发送任务已结束，资源已清理");
|
||
IsSendOk = false;
|
||
}
|
||
finally
|
||
{
|
||
// 确保在任何情况下（正常退出、异常、取消）都会停止计时器
|
||
Stopwatcher.Stop();
|
||
LoggerService.Info("精确周期发送CAN数据-正常退出、异常、取消）都会停止计时器");
|
||
IsSendOk = false;
|
||
}
|
||
|
||
}, token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
|
||
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 停止软件循环发送。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// - 置 <see cref="IsCycleSend"/> 为 false，循环自然退出；
|
||
/// - 触发 <see cref="CycleSendCts"/> 取消，用于尽快唤醒 Delay 并退出。
|
||
/// </remarks>
|
||
public void StopCycleSendMsg()
|
||
{
|
||
IsCycleSend = false;
|
||
CycleSendCts?.Cancel();
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 调度表发送报文
|
||
|
||
private bool _SchEnable;
|
||
/// <summary>
|
||
/// 调度表使能开关。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 该开关用于控制“硬件调度表发送”及“CmdData 变化时是否增量更新调度表”。
|
||
/// </remarks>
|
||
public bool SchEnable
|
||
{
|
||
get { return _SchEnable; }
|
||
set
|
||
{
|
||
_SchEnable = value;
|
||
RaisePropertyChanged();
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 当前已下发到设备调度表的帧缓存。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// - 在 <see cref="StartSchedule"/> 中构建，并通过 CAN_SetSchedule 下发；
|
||
/// - 在 <see cref="UpdateSchDataByCmdDataChanged"/> 中重建并通过 CAN_UpdateSchedule 覆盖更新。
|
||
/// </remarks>
|
||
private USB2CAN.CAN_MSG[] SchCanMsg { get; set; }
|
||
|
||
/// <summary>
|
||
/// CmdData 按 MsgName 分组后的视图。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 该分组的遍历顺序决定了 <see cref="SchCanMsg"/> 中每个帧的 Index，
|
||
/// 因而要求：调度表启动后，更新时必须按相同顺序遍历（当前实现保持一致）。
|
||
/// </remarks>
|
||
private IEnumerable<IGrouping<string, CanCmdData>> GroupMsg { get; set; }
|
||
|
||
/// <summary>
|
||
/// 调度表集合数据
|
||
/// 总共3个调度表，第一个表里面包含3帧数据，第二个调度表包含6帧数据，第三个调度表包含11帧数据
|
||
/// Byte[] MsgTabNum = new Byte[3] { 3, 6, 11 };
|
||
/// </summary>
|
||
private Byte[] MsgTabNum { get; set; }
|
||
|
||
/// <summary>
|
||
/// 调度表发送的次数集合
|
||
/// 第一个调度表循环发送数据，第二个调度表循环发送数据，第三个调度表只发送3次
|
||
/// UInt16[] SendTimes = new UInt16[3] { 0xFFFF, 0xFFFF, 3 };
|
||
/// </summary>
|
||
private UInt16[] SendTimes { get; set; }
|
||
|
||
/// <summary>
|
||
/// 预设的调度表的个数 常值
|
||
/// </summary>
|
||
private const int MsgTabCount = 5;
|
||
|
||
/// <summary>
|
||
/// 定时更新时间
|
||
/// </summary>
|
||
private int UpdateCycle { get; set; } = 100;
|
||
|
||
/// <summary>
|
||
/// CNA 调度表的配置信息
|
||
/// </summary>
|
||
public List<CANScheduleConfigDto> ListCANScheduleConfig { get; set; }
|
||
|
||
Random random = new Random();
|
||
|
||
/// <summary>
|
||
/// 监控数据
|
||
/// 查找问题用，平时不用
|
||
/// </summary>
|
||
//public MonitorValueLog monitorValueLog { get; set; }
|
||
|
||
/// <summary>
|
||
/// 更新数据 测试用废弃了
|
||
/// </summary>
|
||
public void UpdateValue()
|
||
{
|
||
// 通过 DBC 生成每一帧的原始数据（Data/DataLen/ID 等）
|
||
IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)));
|
||
int Index = 0;
|
||
//循环给MSG赋值数据
|
||
foreach (var itemMsg in GroupMsg)
|
||
{
|
||
foreach (var itemSignal in itemMsg)
|
||
{
|
||
itemSignal.SignalCmdValue = random.Next(0, 100);
|
||
CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
|
||
}
|
||
CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend);
|
||
SchCanMsg[Index] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CAN.CAN_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 = USB2CAN.CAN_SetSchedule(DevHandle, WriteCANIndex, SchCanMsg, MsgTabNum, SendTimes, 1);//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可
|
||
var ret = USB2CAN.CAN_UpdateSchedule(DevHandle, WriteCANIndex, 0, 0, SchCanMsg, 1);//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可
|
||
if (ret == USB2CAN.CAN_SUCCESS)
|
||
{
|
||
Console.WriteLine("Update CAN Schedule Success");
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("Update CAN Schedule Error ret = {0}", ret);
|
||
return;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 启动硬件调度表。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 流程：
|
||
/// 1) 基于当前 <see cref="CmdData"/> 分组构建帧数组 <see cref="SchCanMsg"/>；
|
||
/// 2) 使用 DBC 将信号值同步到帧；
|
||
/// 3) 根据 <see cref="ListCANScheduleConfig"/> 把周期写入帧的 TimeStamp 字段；
|
||
/// 4) 调用 CAN_SetSchedule 下发；
|
||
/// 5) 调用 CAN_StartSchedule 启动（当前约定只启动调度器 0）。
|
||
///
|
||
/// 注意：本实现把所有报文都放入调度表 0，因此 UI 上的 SchTabIndex 实际未被使用。
|
||
/// </remarks>
|
||
public void StartSchedule()
|
||
{
|
||
if (CmdData.Count() == 0) return;
|
||
|
||
//依据报文进行分组
|
||
GroupMsg = CmdData.GroupBy(x => x.MsgName)!;
|
||
//初始化调度表要发送的消息结构
|
||
SchCanMsg = new USB2CAN.CAN_MSG[GroupMsg.Count()];
|
||
for (int i = 0; i < GroupMsg.Count(); i++)
|
||
{
|
||
SchCanMsg[i] = new USB2CAN.CAN_MSG();
|
||
SchCanMsg[i].Data = new Byte[64];
|
||
}
|
||
|
||
//通过DBC进行对消息赋值
|
||
IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)));
|
||
int Index = 0;
|
||
//循环给MSG赋值数据
|
||
foreach (var itemMsg in GroupMsg)
|
||
{
|
||
foreach (var itemSignal in itemMsg)
|
||
{
|
||
CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
|
||
}
|
||
CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend);
|
||
//每个分组就是一个帧指令/消息数据
|
||
SchCanMsg[Index] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CAN.CAN_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 = USB2CAN.CAN_SetSchedule(DevHandle, WriteCANIndex, SchCanMsg, MsgTabNum, SendTimes, MsgTabCount);//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可
|
||
if (ret == USB2CAN.CAN_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 = USB2CAN.CAN_StartSchedule(DevHandle, WriteCANIndex, (byte)0, (byte)100, (byte)ListCANScheduleConfig.FirstOrDefault()!.OrderSend);
|
||
if (ret == USB2CAN.CAN_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 = USB2CAN.CAN_StartSchedule(DevHandle, WriteCANIndex, (byte)CANScheduleConfig.SchTabIndex, (byte)CANScheduleConfig.Cycle, (byte)CANScheduleConfig.OrderSend);
|
||
// if (ret == USB2CAN.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;
|
||
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 停止硬件调度表。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 停止后设备侧将不再按周期自动发送。
|
||
/// </remarks>
|
||
public void StopSchedule()
|
||
{
|
||
ret = USB2CAN.CAN_StopSchedule(DevHandle, WriteCANIndex);//启动第一个调度表,表里面的CAN帧并行发送
|
||
if (ret == USB2CAN.CAN_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;
|
||
}
|
||
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 循环使用的
|
||
/// </summary>
|
||
private int CycleUpdateIndex = 0;
|
||
|
||
/// <summary>
|
||
/// 循环更新调度表的指令数据
|
||
/// 定时更新数据到调度表中
|
||
/// </summary>
|
||
public void StartCycleUpdateCmd()
|
||
{
|
||
CycleUpdateCmdTask = Task.Run(async () =>
|
||
{
|
||
while (IsCycleSend)
|
||
{
|
||
await Task.Delay(UpdateCycle);
|
||
try
|
||
{
|
||
|
||
//通过DBC进行对消息赋值
|
||
IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)));
|
||
CycleUpdateIndex = 0;
|
||
//循环给MSG赋值数据，顺序是固定的，跟初始时设置是一样的
|
||
foreach (var itemMsg in GroupMsg)
|
||
{
|
||
foreach (var itemSignal in itemMsg)
|
||
{
|
||
//itemSignal.SignalCmdValue = random.Next(0, 100); //仿真测试数据使用
|
||
CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
|
||
}
|
||
CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend);
|
||
SchCanMsg[CycleUpdateIndex] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CAN.CAN_MSG));
|
||
CycleUpdateIndex++;
|
||
}
|
||
|
||
//通过DBC写入数据后生成CanMsg
|
||
//将信号值填入CAN消息里面
|
||
|
||
//释放申请的临时缓冲区
|
||
Marshal.FreeHGlobal(msgPtSend);
|
||
|
||
//CAN_UpdateSchedule 官网解释
|
||
// ---MsgTabIndex CAN调度表索引号
|
||
// ---MsgIndex 开始更新帧起始索引，若起始索引大于调度表帧数，则将帧添加到调度表后面
|
||
// ---pCanMsg 需要更新的CAN帧指针
|
||
// ---MsgNum pCanMsgTab里面包含的有效帧数
|
||
|
||
//CAN_UpdateSchedule中的MsgIndex表示当前的调度器中的帧Index序号
|
||
//因为调度表中的帧集合和控制帧的集合和要更新的帧集合都是同一个集合SchCanMsg
|
||
//默认1号调度表，一个更新所有的帧数据
|
||
var ret = USB2CAN.CAN_UpdateSchedule(DevHandle, WriteCANIndex, (byte)0, (byte)(0), SchCanMsg, (byte)SchCanMsg.Count());//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可
|
||
if (ret == USB2CAN.CAN_SUCCESS)
|
||
{
|
||
IsSendOk = true;
|
||
Console.WriteLine($"Update CAN Schedule Success -- SchTabIndex：{(byte)0} -- MsgIndex：{(byte)(0)} ");
|
||
}
|
||
else
|
||
{
|
||
IsSendOk = false;
|
||
Console.WriteLine($"Update CAN Schedule Error ret = {ret} -- SchTabIndex：{(byte)0} -- MsgIndex：{(byte)(0)}");
|
||
//return;
|
||
}
|
||
|
||
//一个报文帧一个报文帧进行更新数据
|
||
////配置信息 默认启用1号调度器,MsgTabIndex=0；
|
||
//foreach (var itemMsgSchConfig in ListCANScheduleConfig)
|
||
//{
|
||
// //USB2CAN.CAN_MSG[] SchCanMsg1=new CAN_MSG[1];
|
||
// //SchCanMsg1[0] = SchCanMsg[itemMsgSchConfig.MsgIndex];
|
||
|
||
// // MsgTabIndex CAN调度表索引号 ;MsgIndex 开始更新帧起始索引，若起始索引大于调度表帧数，则将帧添加到调度表后面， ;
|
||
// // pCanMsg 需要更新的CAN帧指针,消息数据 ; MsgNum pCanMsgTab里面包含的有效帧数，一个调度表对应一个帧/消息，即为：1 (byte)(itemMsgSchConfig.MsgIndex+0)
|
||
// var ret = USB2CAN.CAN_UpdateSchedule(DevHandle, WriteCANIndex, (byte)0, (byte)(itemMsgSchConfig.MsgIndex), SchCanMsg, 1);//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可
|
||
// if (ret == USB2CAN.CAN_SUCCESS)
|
||
// {
|
||
// Console.WriteLine($"Update CAN Schedule Success -- SchTabIndex：{(byte)itemMsgSchConfig.SchTabIndex} -- MsgIndex：{(byte)(itemMsgSchConfig.MsgIndex)} ");
|
||
// }
|
||
// else
|
||
// {
|
||
// Console.WriteLine($"Update CAN Schedule Error ret = {ret} -- SchTabIndex：{(byte)itemMsgSchConfig.SchTabIndex} -- MsgIndex：{(byte)(itemMsgSchConfig.MsgIndex)}");
|
||
// //return;
|
||
// }
|
||
//}
|
||
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
IsSendOk = false;
|
||
LoggerService.Info($"时间:{DateTime.Now.ToString()}-【MSG】-{ex.Message}");
|
||
}
|
||
}
|
||
|
||
IsSendOk = false;
|
||
});
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 绑定/刷新驱动侧要发送的 CmdData，并自动维护“值变化事件”的订阅。
|
||
/// </summary>
|
||
/// <param name="cmdData">新的指令集合。</param>
|
||
/// <remarks>
|
||
/// 目的：当某个信号值变化时（CanCmdData.SignalCmdValue setter 触发），
|
||
/// 可以通过 <see cref="CmdData_CanCmdDataChangedHandler"/> 触发调度表增量刷新。
|
||
///
|
||
/// 注意：必须先对旧集合取消订阅，否则会造成重复触发和内存泄漏。
|
||
/// </remarks>
|
||
public void LoadCmdDataToDrive(List<CanCmdData> 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;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// CmdData 中任意信号值变化事件处理。
|
||
/// </summary>
|
||
/// <param name="sender">事件源。</param>
|
||
/// <param name="e">变化的 MsgName（约定为报文名）。</param>
|
||
/// <remarks>
|
||
/// 当前实现采取“全量覆盖更新调度表”的方式（UpdateSchedule），并未按 MsgName 做局部更新。
|
||
/// </remarks>
|
||
private void CmdData_CanCmdDataChangedHandler(object? sender, string e)
|
||
{
|
||
UpdateSchDataByCmdDataChanged();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 调度表更新互斥锁。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// - CmdData 变化事件可能高频触发；
|
||
/// - 同时 UpdateSchedule 调用耗时且涉及非托管内存与 DBC 操作，必须串行化。
|
||
/// </remarks>
|
||
private readonly object SchUpdateLock = new object();
|
||
|
||
/// <summary>
|
||
/// 当 CmdData 中信号值变化时，增量刷新调度表的帧数据。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 触发条件：<see cref="IsCycleSend"/> 与 <see cref="SchEnable"/> 同时为 true。
|
||
///
|
||
/// 当前实现策略：
|
||
/// - 为保证简单与一致性：每次变化都重建所有帧并全量调用 CAN_UpdateSchedule 覆盖更新；
|
||
/// - 若后续性能成为瓶颈，可根据变化的 MsgName 实现“按帧更新（MsgIndex + MsgNum=1）”。
|
||
/// </remarks>
|
||
private 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(USB2CAN.CAN_MSG)));
|
||
int CycleUpdateIndex = 0;
|
||
//循环给MSG赋值数据，顺序是固定的，跟初始时设置是一样的
|
||
foreach (var itemMsg in GroupMsg)
|
||
{
|
||
foreach (var itemSignal in itemMsg)
|
||
{
|
||
//itemSignal.SignalCmdValue = random.Next(0, 100); //仿真测试数据使用
|
||
var SetSignalValue = CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
|
||
//monitorValueLog.UpdateValue1(SetSignalValue);
|
||
}
|
||
var SyncValueToCanMsg = CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend);
|
||
//monitorValueLog.UpdateValue2(SyncValueToCanMsg);
|
||
SchCanMsg[CycleUpdateIndex] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CAN.CAN_MSG));
|
||
CycleUpdateIndex++;
|
||
}
|
||
|
||
//通过DBC写入数据后生成CanMsg
|
||
//将信号值填入CAN消息里面
|
||
|
||
// 释放非托管缓冲
|
||
Marshal.FreeHGlobal(msgPtSend);
|
||
|
||
//CAN_UpdateSchedule 官网解释
|
||
// ---MsgTabIndex CAN调度表索引号
|
||
// ---MsgIndex 开始更新帧起始索引，若起始索引大于调度表帧数，则将帧添加到调度表后面
|
||
// ---pCanMsg 需要更新的CAN帧指针
|
||
// ---MsgNum pCanMsgTab里面包含的有效帧数
|
||
|
||
//CAN_UpdateSchedule中的MsgIndex表示当前的调度器中的帧Index序号
|
||
//因为调度表中的帧集合和控制帧的集合和要更新的帧集合都是同一个集合SchCanMsg
|
||
// 默认调度表索引 0：一次性覆盖更新所有帧（MsgIndex=0, MsgNum=帧数）
|
||
var ret = USB2CAN.CAN_UpdateSchedule(DevHandle, WriteCANIndex, (byte)0, (byte)(0), SchCanMsg, (byte)SchCanMsg.Count());//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可
|
||
if (ret == USB2CAN.CAN_SUCCESS)
|
||
{
|
||
IsSendOk = true;
|
||
//Console.WriteLine($"Update CAN Schedule Success -- SchTabIndex：{(byte)0} -- MsgIndex：{(byte)(0)} ");
|
||
//monitorValueLog.UpdateValue3(ret);
|
||
}
|
||
else
|
||
{
|
||
IsSendOk = false;
|
||
//Console.WriteLine($"Update CAN Schedule Error ret = {ret} -- SchTabIndex：{(byte)0} -- MsgIndex：{(byte)(0)}");
|
||
//monitorValueLog.UpdateValue3(ret);
|
||
LoggerService.Info($"更新调度表失败，错误码：{ret}");
|
||
//return;
|
||
}
|
||
}
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
IsSendOk = false;
|
||
LoggerService.Info($"时间:{DateTime.Now.ToString()}-【MSG】-{ex.Message}");
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
#endregion
|
||
|
||
/// <summary>
|
||
/// 启动后台循环接收 CAN 报文，并同步到 DBC 信号实时值。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 关键点：
|
||
/// - 使用 CAN_GetMsgWithSize 从设备内部 FIFO 拉取报文；
|
||
/// - 使用 <see cref="RecvMsgBufferPtr"/> 作为重用缓冲，避免每轮申请/释放非托管内存导致碎片与性能问题；
|
||
/// - 使用 <see cref="RecvBufferSync"/> 与 <see cref="CloseDevice"/> 互斥，避免指针并发释放。
|
||
/// </remarks>
|
||
public void StartCycleReviceCanMsg()
|
||
{
|
||
// 防止重复启动，若已有任务在运行则直接返回
|
||
if (CycleReviceTask != null && !CycleReviceTask.IsCompleted)
|
||
{
|
||
return;
|
||
}
|
||
//monitorValueLog
|
||
CycleReviceTask = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
while (IsCycleRevice)
|
||
{
|
||
await Task.Delay(ReviceCycle);
|
||
try
|
||
{
|
||
// 另一个CAN通道读取数据（与 CloseDevice 释放互斥，保护指针安全）
|
||
IntPtr msgPtRead;
|
||
int CanNum;
|
||
lock (RecvBufferSync)
|
||
{
|
||
if (RecvMsgBufferPtr == IntPtr.Zero)
|
||
{
|
||
RecvMsgBufferPtr = Marshal.AllocHGlobal(CanMsgSize * RecvMsgBufferCapacity);
|
||
LoggerService.Info("申请 RecvMsgBufferPtr");
|
||
}
|
||
msgPtRead = RecvMsgBufferPtr;
|
||
CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, ReadCANIndex, msgPtRead, RecvMsgBufferCapacity);
|
||
//int CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, 1, msgPtRead, RecvMsgBufferCapacity);//测试用，CAN卡 CAN1和CAN2 短接时测试用
|
||
//monitorValueLog.UpdateValue4(CanNum);
|
||
if (CanNum > 0)
|
||
{
|
||
IsReviceOk = true;
|
||
if (EnableConsoleDebugLog) Console.WriteLine("Read CanMsgNum = {0}", CanNum);
|
||
for (int i = 0; i < CanNum; i++)
|
||
{
|
||
var msgPtr = (IntPtr)(msgPtRead + i * CanMsgSize);
|
||
var msg = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtr, typeof(USB2CAN.CAN_MSG));
|
||
|
||
if (EnableConsoleDebugLog)
|
||
{
|
||
Console.WriteLine("CanMsg[{0}].ID = 0x{1}", i, msg.ID.ToString("X8"));
|
||
Console.WriteLine("CanMsg[{0}].TimeStamp = {1}", i, msg.TimeStamp);
|
||
Console.Write("CanMsg[{0}].Data = ", i);
|
||
for (int j = 0; j < msg.DataLen; j++)
|
||
{
|
||
Console.Write("{0} ", msg.Data[j].ToString("X2"));
|
||
}
|
||
Console.WriteLine("");
|
||
}
|
||
|
||
// 报文给高速记录的服务
|
||
HighSpeedDataService.AppendOrUpdateMsg(new Models.HighSpeed.CommMsg()
|
||
{
|
||
Category = "CAN",
|
||
MsgInfo = "0x" + msg.ID.ToString("X8"),
|
||
MsgData = BitConverter.ToString(msg.Data),
|
||
Time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")
|
||
});
|
||
}
|
||
}
|
||
else if (CanNum == 0)
|
||
{
|
||
IsReviceOk = false;
|
||
if (EnableConsoleDebugLog) Console.WriteLine("No CAN data!");
|
||
}
|
||
else
|
||
{
|
||
IsReviceOk = false;
|
||
if (EnableConsoleDebugLog) Console.WriteLine("Get CAN data error!");
|
||
}
|
||
// 将CAN消息数据填充到信号里面，用DBC解析数据（仍在锁内，避免指针被并发释放）
|
||
var SyncCANMsgToValue = CAN_DBCParser.DBC_SyncCANMsgToValue(DBCHandle, msgPtRead, CanNum);
|
||
//monitorValueLog.UpdateValue5(SyncCANMsgToValue);
|
||
}
|
||
|
||
//循环获取消息的数据
|
||
foreach (var item in ListCanDbcModel)
|
||
{
|
||
// 复用 StringBuilder 缓存，避免频繁分配
|
||
var msgNameSB = GetMsgSB(item.MsgName);
|
||
var sigNameSB = GetSigSB(item.SignalName);
|
||
CAN_DBCParser.DBC_GetSignalValue(DBCHandle, msgNameSB, sigNameSB, ValueDouble);
|
||
item.SignalRtValue = ValueDouble[0].ToString();
|
||
//Console.Write(ValueSb.ToString());
|
||
}
|
||
// 缓冲区在 CloseDevice 或任务退出的 finally 中统一释放，避免频繁申请/释放
|
||
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
IsReviceOk = false;
|
||
LoggerService.Info($"CAN指令接收出现异常:{ex.Message}");
|
||
}
|
||
//finally
|
||
//{
|
||
// IsReviceOk = false;
|
||
//}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
IsReviceOk = false;
|
||
LoggerService.Info("CAN指令接收 finally结束");
|
||
// 接收任务退出时释放接收缓冲，避免仅停止接收时的缓冲常驻
|
||
lock (RecvBufferSync)
|
||
{
|
||
if (RecvMsgBufferPtr != IntPtr.Zero)
|
||
{
|
||
try { Marshal.FreeHGlobal(RecvMsgBufferPtr); }
|
||
catch { }
|
||
finally { RecvMsgBufferPtr = IntPtr.Zero; }
|
||
}
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
/// <summary>
|
||
/// 接受CAN消息
|
||
/// </summary>
|
||
public void ReciveCanMsg()
|
||
{
|
||
//另外一个CAN通道读取数据
|
||
USB2CAN.CAN_MSG[] CanMsgBuffer = new USB2CAN.CAN_MSG[10];
|
||
msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)) * CanMsgBuffer.Length);
|
||
try
|
||
{
|
||
int CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, ReadCANIndex, msgPt, CanMsgBuffer.Length);
|
||
if (CanNum > 0)
|
||
{
|
||
Console.WriteLine("Read CanMsgNum = {0}", CanNum);
|
||
for (int i = 0; i < CanNum; i++)
|
||
{
|
||
CanMsgBuffer[i] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure((IntPtr)((UInt32)msgPt + i * Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))), typeof(USB2CAN.CAN_MSG));
|
||
Console.WriteLine("CanMsg[{0}].ID = 0x{1}", i, CanMsgBuffer[i].ID.ToString("X8"));
|
||
//Console.WriteLine("CanMsg[{0}].TimeStamp = {1}",i,CanMsgBuffer[i].TimeStamp);
|
||
Console.Write("CanMsg[{0}].Data = ", i);
|
||
for (int j = 0; j < CanMsgBuffer[i].DataLen; j++)
|
||
{
|
||
Console.Write("{0} ", CanMsgBuffer[i].Data[j].ToString("X2"));
|
||
}
|
||
Console.WriteLine("");
|
||
}
|
||
}
|
||
else if (CanNum == 0)
|
||
{
|
||
Console.WriteLine("No CAN data!");
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("Get CAN data error!");
|
||
}
|
||
Console.WriteLine("");
|
||
|
||
//将CAN消息数据填充到信号里面
|
||
CAN_DBCParser.DBC_SyncCANMsgToValue(DBCHandle, msgPt, CanNum);
|
||
//获取信号值并打印出来
|
||
StringBuilder ValueStr = new StringBuilder(32);
|
||
CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), ValueStr);
|
||
Console.WriteLine("moto_speed = {0}", ValueStr);
|
||
CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), ValueStr);
|
||
Console.WriteLine("oil_pressure = {0}", ValueStr);
|
||
CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), ValueStr);
|
||
Console.WriteLine("speed_can = {0}", ValueStr);
|
||
}
|
||
finally
|
||
{
|
||
if (msgPt != IntPtr.Zero)
|
||
{
|
||
try { Marshal.FreeHGlobal(msgPt); }
|
||
catch { }
|
||
finally { msgPt = IntPtr.Zero; }
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 关闭设备并释放资源。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 释放顺序要点：
|
||
/// - 先关闭设备并下置状态位；
|
||
/// - 若启用调度表则先停止；
|
||
/// - 停止定时器/周期发送；
|
||
/// - 等待接收任务退出（短等待，避免 UI 卡死）；
|
||
/// - 在互斥锁内释放接收缓冲指针，避免接收线程仍在使用。
|
||
/// </remarks>
|
||
public void CloseDevice()
|
||
{
|
||
//关闭设备
|
||
USB_DEVICE.USB_CloseDevice(DevHandle);
|
||
OpenState = false;
|
||
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 { }
|
||
// 在锁内安全释放，避免与接收线程并发访问同一指针
|
||
lock (RecvBufferSync)
|
||
{
|
||
if (RecvMsgBufferPtr != IntPtr.Zero)
|
||
{
|
||
try { Marshal.FreeHGlobal(RecvMsgBufferPtr); }
|
||
catch { }
|
||
finally { RecvMsgBufferPtr = IntPtr.Zero; }
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|