TyroneGit/CapMachine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

CAN FD增加

Browse Source
This commit is contained in:
Tyrone CT
2025-07-11 23:47:23 +08:00
parent 735c42f909
commit 169ea7b93d
20 changed files with 4250 additions and 513 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CapMachine.Wpf/App.xaml.cs
View File

@@ -137,6 +137,7 @@ namespace CapMachine.Wpf
////注册设备服务
//containerRegistry.RegisterSingleton<MachineDataService>();
containerRegistry.RegisterSingleton<CanDriveService>();
containerRegistry.RegisterSingleton<CanFdDriveService>();
containerRegistry.RegisterSingleton<LinDriveService>();
containerRegistry.RegisterSingleton<MachineRtDataService>();
containerRegistry.RegisterSingleton<DataRecordService>();
@@ -187,6 +188,7 @@ namespace CapMachine.Wpf
containerRegistry.RegisterForNavigation<QuickMeterStepView, QuickMeterStepViewModel>();
containerRegistry.RegisterForNavigation<HistoryDataView, HistoryDataViewModel>();
containerRegistry.RegisterForNavigation<CANConfigView, CANConfigViewModel>();
containerRegistry.RegisterForNavigation<CANFDConfigView, CANFDConfigViewModel>();
containerRegistry.RegisterForNavigation<LINConfigView, LinConfigViewModel>();

57
CapMachine.Wpf/CanDrive/CanFD/DBCParserByFD.cs Normal file
View File

@@ -0,0 +1,57 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace CapMachine.Wpf.CanDrive.CanFD
{
/// <summary>
/// 和DBCParser一样，但用于处理USB设备的DBC文件解析。
/// DBCParserByFD类用于处理USB设备的DBC文件解析。
/// </summary>
public class DBCParserByFD
{
public const Int32 DBC_PARSER_OK = 0;//没有错误
public const Int32 DBC_PARSER_FILE_OPEN = (-1);//打开文件出错
public const Int32 DBC_PARSER_FILE_FORMAT = (-2);//文件格式错误
public const Int32 DBC_PARSER_DEV_DISCONNECT = (-3);//设备未连接
public const Int32 DBC_PARSER_HANDLE_ERROR = (-4);//LDF Handle错误
public const Int32 DBC_PARSER_GET_INFO_ERROR = (-5);//获取解析后的数据出错
public const Int32 DBC_PARSER_DATA_ERROR = (-6);//数据处理错误
public const Int32 DBC_PARSER_SLAVE_NACK = (-7);//从机未响应数据
[DllImport("USB2XXX.dll")]
public static extern UInt64 DBC_ParserFile(int DevHandle, StringBuilder pDBCFileName);
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_GetMsgQuantity(UInt64 DBCHandle);
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_GetMsgName(UInt64 DBCHandle, int index, StringBuilder pMsgName);
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_GetMsgSignalQuantity(UInt64 DBCHandle, StringBuilder pMsgName);
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_GetMsgSignalName(UInt64 DBCHandle, StringBuilder pMsgName, int index, StringBuilder pSignalName);
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_GetMsgPublisher(UInt64 DBCHandle, StringBuilder pMsgName, StringBuilder pPublisher);
//设置信号值
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_SetSignalValue(UInt64 DBCHandle, StringBuilder pMsgName, StringBuilder pSignalName, double Value);
//获取信号值
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_GetSignalValue(UInt64 DBCHandle, StringBuilder pMsgName, StringBuilder pSignalName, double[] pValue);
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_GetSignalValueStr(UInt64 DBCHandle, StringBuilder pMsgName, StringBuilder pSignalName, StringBuilder pValueStr);
//将CAN消息数据填充到信号里面
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_SyncCANMsgToValue(UInt64 DBCHandle, IntPtr pCANMsg, int MsgLen);
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_SyncCANFDMsgToValue(UInt64 DBCHandle, IntPtr pCANFDMsg, int MsgLen);
//将信号数据填充到CAN消息里面
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_SyncValueToCANMsg(UInt64 DBCHandle, StringBuilder pMsgName, IntPtr pCANMsg);
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_SyncValueToCANFDMsg(UInt64 DBCHandle, StringBuilder pMsgName, IntPtr pCANFDMsg);
}
}

899
CapMachine.Wpf/CanDrive/CanFD/ToomossCanFD.cs Normal file
View File

@@ -0,0 +1,899 @@
using CapMachine.Wpf.CanDrive.CanFD;
using CapMachine.Wpf.Models.Tag;
using CapMachine.Wpf.Services;
using NPOI.OpenXmlFormats.Wordprocessing;
using Prism.Ioc;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Windows.Interop;
namespace CapMachine.Wpf.CanDrive
{
/// <summary>
/// Toomoss CANFD
/// </summary>
public class ToomossCanFD : BindableBase
{
private readonly IContainerProvider ContainerProvider;
/// <summary>
/// 实例化函数
/// </summary>
public ToomossCanFD(IContainerProvider containerProvider)
{
ContainerProvider = containerProvider;
HighSpeedDataService = ContainerProvider.Resolve<HighSpeedDataService>();
LogService = ContainerProvider.Resolve<ILogService>();
//Stopwatch.Frequency表示高精度计时器每秒的计数次数（ticks/秒）每毫秒的ticks数 = 每秒的ticks数 ÷ 1000
TicksPerMs = Stopwatch.Frequency / 1000.0;
}
/// <summary>
/// HighSpeedDataService 实例
/// </summary>
public HighSpeedDataService HighSpeedDataService { get; set; }
public ILogService LogService { get; set; }
/// <summary>
/// 开始CAN的驱动
/// </summary>
public void StartCanDrive()
{
try
{
IsExistsDllFile();
ScanDevice();
OpenDevice();
GetDeviceInfo();
GetCANConfig();
InitCAN();
}
catch (Exception ex)
{
LogService.Error(ex.Message);
System.Windows.MessageBox.Show($"{ex.Message}", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
}
}
/// <summary>
/// 开始Dbc文件写入
/// </summary>
public ObservableCollection<CanDbcModel> StartDbc(string DbcPath)
{
DBC_Parser(DbcPath);
return ListCanFdDbcModel;
}
/// <summary>
/// Dbc消息集合
/// </summary>
public ObservableCollection<CanDbcModel> ListCanFdDbcModel { get; set; } = new ObservableCollection<CanDbcModel>();
#region 公共变量
/// <summary>
/// 仲裁波特率
/// </summary>
public uint ArbBaudRate { get; set; } = 500000;
/// <summary>
/// 数据波特率
/// </summary>
public uint DataBaudRate { get; set; } = 2000000;
/// <summary>
/// CAN FD标准 ISO是否启用
/// </summary>
public bool ISOEnable { get; set; } = true;
/// <summary>
/// 终端电阻 是否启用
/// </summary>
public bool ResEnable { get; set; } = true;
/// <summary>
/// 更新配置
/// </summary>
public void UpdateConfig(uint arbBaudRate, uint dataBaudRate, bool iSOEnable, bool resEnable, ushort sendCycle)
{
ArbBaudRate = arbBaudRate;
DataBaudRate = dataBaudRate;
ISOEnable = iSOEnable;
ResEnable = resEnable;
SendCycle = sendCycle;
}
/// <summary>
/// 设备固件信息
/// </summary>
public USB_DEVICEByFD.DEVICE_INFO DevInfo = new USB_DEVICEByFD.DEVICE_INFO();
/// <summary>
/// CAN Config
/// </summary>
USB2CANFD.CANFD_INIT_CONFIG CANConfig = new USB2CANFD.CANFD_INIT_CONFIG();
/// <summary>
/// 诊断信息
/// </summary>
public USB2CANFD.CANFD_DIAGNOSTIC CurCANFD_DIAGNOSTIC = new USB2CANFD.CANFD_DIAGNOSTIC();
/// <summary>
/// CANFD总线错误信息
/// </summary>
public USB2CANFD.CANFD_BUS_ERROR CurCANFD_BUS_ERROR = new USB2CANFD.CANFD_BUS_ERROR();
/// <summary>
/// DBC Handle
/// </summary>
public UInt64 DBCHandle { get; set; }
/// <summary>
/// 扫描设备Handle集合
/// </summary>
public Int32[] DevHandles { get; set; } = new Int32[20];
/// <summary>
/// 扫描设备Handle
/// </summary>
public Int32 DevHandle { get; set; } = 0;
/// <summary>
/// Write CAN Index
/// </summary>
public Byte WriteCANIndex { get; set; } = 0;
/// <summary>
/// Read CAN Index
/// </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; }
public string dllFilePath { get; set; } = "USB2XXX.dll";
/// <summary>
/// 消息值Pt
/// </summary>
public IntPtr msgPt { get; set; }
#endregion
/// <summary>
/// ******************【1】*********************
/// 是否存在Dll文件
/// </summary>
/// <returns></returns>
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></returns>
public bool ScanDevice()
{
DevNum = USB_DEVICEByFD.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_DEVICEByFD.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_DEVICEByFD.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(" SerialNumber:" + DevInfo.SerialNumber[0] + DevInfo.SerialNumber[1] + DevInfo.SerialNumber[2]);
Console.WriteLine(" Functions String:" + FuncStr);
StringBuilder DLLBuildDate = new StringBuilder(256);
USB_DEVICEByFD.DEV_GetDllBuildTime(DLLBuildDate);
Console.WriteLine(" DLL Build Date:" + DLLBuildDate);
return true;
}
}
/// <summary>
/// ******************【5】*********************
/// 获取设备Config配置
/// </summary>
public void GetCANConfig()
{
//获取CAN波特率参数
ret = USB2CANFD.CANFD_GetCANSpeedArg(DevHandle, ref CANConfig, ArbBaudRate, DataBaudRate);
if (ret != USB2CANFD.CANFD_SUCCESS)
{
Console.WriteLine("Get CAN Speed failed!");
return;
}
else
{
Console.WriteLine("Get CAN Speed Success!");
}
}
/// <summary>
/// ******************【6】*********************
/// 初始化CAN
/// </summary>
public void InitCAN()
{
//初始化CAN
CANConfig.ISOCRCEnable = ISOEnable == true ? (byte)1 : (byte)0;//使能ISOCRC
CANConfig.ResEnable = ResEnable == true ? (byte)1 : (byte)0;//使能终端电阻
ret = USB2CANFD.CANFD_Init(DevHandle, WriteCANIndex, ref CANConfig);
if (ret != USB2CANFD.CANFD_SUCCESS)
{
Console.WriteLine("Config CAN failed!");
return;
}
else
{
Console.WriteLine("WriteCANIndex Config CAN Success!");
}
ret = USB2CANFD.CANFD_Init(DevHandle, ReadCANIndex, ref CANConfig);
if (ret != USB2CANFD.CANFD_SUCCESS)
{
Console.WriteLine("Config CAN failed!");
return;
}
else
{
Console.WriteLine("ReadCANIndex Config CAN Success!");
}
Console.WriteLine("");
}
/// <summary>
/// ******************【7】*********************
/// DBC解析
/// </summary>
public void DBC_Parser(string Path)
{
//解析DBC文件
DBCHandle = DBCParserByFD.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!");
}
ListCanFdDbcModel.Clear();
//打印DBC里面报文和信号相关信息
int DBCMsgNum = DBCParserByFD.DBC_GetMsgQuantity(DBCHandle);
for (int i = 0; i < DBCMsgNum; i++)
{
StringBuilder MsgName = new StringBuilder(32);
DBCParserByFD.DBC_GetMsgName(DBCHandle, i, MsgName);
Console.WriteLine("Msg.Name = {0}", MsgName);
int DBCSigNum = DBCParserByFD.DBC_GetMsgSignalQuantity(DBCHandle, MsgName);
StringBuilder Publisher = new StringBuilder(32);
DBCParserByFD.DBC_GetMsgPublisher(DBCHandle, MsgName, Publisher);
Console.Write("Signals:");
for (int j = 0; j < DBCSigNum; j++)
{
StringBuilder SigName = new StringBuilder(32);
DBCParserByFD.DBC_GetMsgSignalName(DBCHandle, MsgName, j, SigName);
Console.Write("{0} ", SigName);
//增加信息数据
ListCanFdDbcModel.Add(new CanDbcModel()
{
MsgName = MsgName.ToString(),
MsgId = "",
SignalName = SigName.ToString(),
SignalDesc = "",
SignalUnit = "",
SignalRtValue = "",
Publisher = Publisher.ToString()
});
}
Console.WriteLine("");
}
//Dbc解析成功
DbcParserState = true;
}
/// <summary>
/// 发送CAN数据
/// </summary>
public void SendCanMsg(List<CanCmdData> CmdData)
{
var GroupMsg = CmdData.GroupBy(x => x.MsgName);
USB2CANFD.CANFD_MSG[] CanMsg = new USB2CANFD.CANFD_MSG[GroupMsg.Count()];
for (int i = 0; i < GroupMsg.Count(); i++)
{
CanMsg[i] = new USB2CANFD.CANFD_MSG();
CanMsg[i].Data = new Byte[64];
}
IntPtr msgPt = 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), msgPt);
CanMsg[Index] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPt, typeof(USB2CANFD.CANFD_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消息里面
//IntPtr msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG)));
//DBCParser.DBC_SyncValueToCANFDMsg(DBCHandle, new StringBuilder("msg_moto_speed"), msgPt);
//CanMsg[0] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPt, typeof(USB2CANFD.CANFD_MSG));
//DBCParser.DBC_SyncValueToCANFDMsg(DBCHandle, new StringBuilder("msg_oil_pressure"), msgPt);
//CanMsg[1] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPt, typeof(USB2CANFD.CANFD_MSG));
//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数据
int SendedNum = USB2CANFD.CANFD_SendMsg(DevHandle, WriteCANIndex, CanMsg, (Int32)CanMsg.Length);
if (SendedNum >= 0)
{
Console.WriteLine("Success send frames:{0}", SendedNum);
}
else
{
Console.WriteLine("Send CAN data failed! {0}", SendedNum);
}
}
#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>
public void StartPrecisionCycleSendMsg()
{
// 创建取消标记源 用于控制任务的取消 允许在需要时通过取消令牌来优雅停止任务
var cancellationTokenSource = new CancellationTokenSource();
var token = cancellationTokenSource.Token;
// 保存取消标记，以便在停止时使用
CycleSendCts = cancellationTokenSource;//将取消标记源保存到类的成员变量CycleSendCts，这样在外部调用停止方法时可以访问它
NextExecutionTime = 0;//初始化NextExecutionTime为0，这个变量用于记录下一次执行的目标时间点
CycleSendTask = Task.Factory.StartNew(async () =>
{
try
{
// 设置当前线程为高优先级
Thread.CurrentThread.Priority = ThreadPriority.AboveNormal;
// 初始化完成后开始计时
Stopwatcher.Restart();
// 预先计算固定值
long CycleInTicks = (long)(SendCycle * TicksPerMs);
//临时测试用
//long lastTicks = Stopwatcher.ElapsedTicks;
//IsCycleSend
while (IsCycleSend && !token.IsCancellationRequested)
{
try
{
// 计算下一次执行时间点 ，将当前设置的发送周期SendCycle(毫秒)转换为Stopwatch的计时单位(tick)，累加到NextExecutionTime上
NextExecutionTime += CycleInTicks; // 转换为Stopwatch计时单位
// 获取当前时间点，以Stopwatch的tick为单位
CurrentTime = Stopwatcher.ElapsedTicks;
//计算需要等待的时间，即目标时间点(NextExecutionTime)与当前时间点(CurrentTime)的差值
DelayTicks = NextExecutionTime - CurrentTime;
// 如果还有等待时间，则等待，只有在目标时间点还未到达时才执行等待
if (DelayTicks > 0)
{
////此时是需要等待的，那么需要等待多久呢， 将需等待的tick数转换回毫秒
DelayMs = (int)(DelayTicks / TicksPerMs);
//20这个数据是预估和测试的，可能跟Windows抖动误差就是20ms左右，当然可以不用这个IF()判断，直接SpinWait.SpinUntil(() => Stopwatcher.ElapsedTicks >= NextExecutionTime);但是会导致当前独占一个CPU核心线程
//所以设置一个20的阈值，20ms以下的延迟使用SpinWait.SpinUntil进行自旋等待，20ms以上的延迟使用Task.Delay进行异步等待，让CPU不至于一直的独占
if (DelayMs <= 20)
{
SpinWait.SpinUntil(() => Stopwatcher.ElapsedTicks >= NextExecutionTime);
}
else
{
////使用Task.Delay进行异步等待，大部分等待时间通过这种方式完成，避免线程阻塞
await Task.Delay(DelayMs - 20, token);
//// 使用SpinWait.SpinUntil进行精确的微调等待。自旋等待会占用CPU资源，但能提供更高的定时精度，确保在精确的时间点执行
////上面的Task.Delay可能会因为系统调度等原因导致实际执行时间稍晚于预期，因此在这里使用SpinWait.SpinUntil来确保在精确的时间点执行
SpinWait.SpinUntil(() => Stopwatcher.ElapsedTicks >= NextExecutionTime);
}
}
// 如果已经超过了计划时间，立即执行并重新校准
if (Stopwatcher.ElapsedTicks >= NextExecutionTime + CycleInTicks)
{
//检测是否发生了严重延迟(超过一个周期)。如果当前时间已经超过了下一次计划时间，则说明系统负载过高或其他原因导致无法按时执行，
//此时重置NextExecutionTime为当前时间，避免连续的延迟累积
// 严重延迟，重新校准
NextExecutionTime = Stopwatcher.ElapsedTicks;
Console.WriteLine("定时发送延迟过大，重新校准时间");
}
// 使用Stopwatch记录实际的执行间隔，而不是DateTime
//Console.WriteLine($"--实际间隔(ms): {(Stopwatcher.ElapsedTicks - lastTicks) / TicksPerMs:F3}, 目标: {SendCycle}");
//lastTicks = Stopwatcher.ElapsedTicks;
//Console.WriteLine($"--当前时间(毫秒): {DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}");
// 执行发送CAN逻辑
{
var GroupMsg = CmdData.GroupBy(x => x.MsgName);
USB2CANFD.CANFD_MSG[] CanMsg = new USB2CANFD.CANFD_MSG[GroupMsg.Count()];
for (int i = 0; i < GroupMsg.Count(); i++)
{
CanMsg[i] = new USB2CANFD.CANFD_MSG();
CanMsg[i].Data = new Byte[64];
}
IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG)));
int Index = 0;
//循环给MSG赋值数据
foreach (var itemMsg in GroupMsg)
{
foreach (var itemSignal in itemMsg)
{
DBCParserByFD.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
}
DBCParserByFD.DBC_SyncValueToCANFDMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend);
CanMsg[Index] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CANFD.CANFD_MSG));
Index++;
}
//通过DBC写入数据后生成CanMsg
//将信号值填入CAN消息里面
//释放申请的临时缓冲区
Marshal.FreeHGlobal(msgPtSend);
//CanMsg[0].Flags = 5;
//发送CAN数据
int SendedNum = USB2CANFD.CANFD_SendMsg(DevHandle, WriteCANIndex, CanMsg, (Int32)CanMsg.Length);
if (SendedNum >= 0)
{
//Console.WriteLine("Success send frames:{0}", SendedNum);
IsSendOk = true;
}
else
{
//Console.WriteLine("Send CAN data failed! {0}", SendedNum);
IsSendOk = false;
}
}
}
catch (TaskCanceledException)
{
// 任务被取消，正常退出
break;
}
catch (Exception ex)
{
LogService.Error(ex.Message);
Console.WriteLine($"CAN周期发送异常: {ex.Message}");
// 短暂暂停避免异常情况下CPU占用过高
await Task.Delay(10, token);
}
}
}
catch (Exception ex)
{
// 确保在任何情况下（正常退出、异常、取消）都会停止计时器
Stopwatcher.Stop();
LogService.Error(ex.Message);
// 清理其他可能的资源
Console.WriteLine("CAN周期发送任务已结束，资源已清理");
}
finally
{
// 确保在任何情况下（正常退出、异常、取消）都会停止计时器
Stopwatcher.Stop();
}
}, token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
}
/// <summary>
/// 获取CAN消息数组中指定位置的数据
/// </summary>
/// <param name="sourceCanMsg">源CAN消息数组</param>
/// <param name="index">要获取的数据索引位置</param>
/// <returns>返回指定位置数据的新数组</returns>
private USB2CANFD.CANFD_MSG[] GetCanMsg(USB2CANFD.CANFD_MSG[] sourceCanMsg, int index)
{
// 参数检查
if (sourceCanMsg == null || sourceCanMsg.Length == 0 || index < 0 || index >= sourceCanMsg.Length)
{
return new USB2CANFD.CANFD_MSG[0];
}
// 创建单个元素的新数组
USB2CANFD.CANFD_MSG[] targetMsg = new USB2CANFD.CANFD_MSG[1];
targetMsg[0] = sourceCanMsg[index];
// 由于CANFD_MSG包含数组字段,需要手动初始化数据数组
targetMsg[0].Data = new byte[64];
// 复制数据
Array.Copy(sourceCanMsg[index].Data, targetMsg[0].Data, sourceCanMsg[index].Data.Length);
return targetMsg;
}
/// <summary>
/// 修改停止发送的方法
/// </summary>
public void StopCycleSendMsg()
{
IsCycleSend = false;
CycleSendCts?.Cancel();
}
#endregion
private bool _IsCycleRevice;
/// <summary>
/// 是否循环接收数据
/// </summary>
public bool IsCycleRevice
{
get { return _IsCycleRevice; }
set { _IsCycleRevice = value; RaisePropertyChanged(); }
}
private bool _IsCycleSend;
/// <summary>
/// 是否循环发送数据
/// </summary>
public bool IsCycleSend
{
get { return _IsCycleSend; }
set { _IsCycleSend = value; RaisePropertyChanged(); }
}
/// <summary>
/// 循环发送数据
/// </summary>
public ushort SendCycle { get; set; } = 200;
/// <summary>
/// 循环接受数据
/// </summary>
public ushort ReviceCycle { get; set; } = 200;
/// <summary>
/// CycleRevice 扫描Task
/// </summary>
private static Task CycleReviceTask { get; set; }
/// <summary>
/// CycleSend 扫描Task
/// </summary>
private static Task CycleSendTask { get; set; }
StringBuilder ValueSb = new StringBuilder(16);
double[] ValueDouble = new double[5];
private bool _IsSendOk;
/// <summary>
/// 发送报文是否OK
/// </summary>
public bool IsSendOk
{
get { return _IsSendOk; }
set
{
if (_IsSendOk != value)
{
RaisePropertyChanged();
_IsSendOk = value;
}
}
}
/// <summary>
/// 要发送的数据
/// </summary>
public List<CanCmdData> CmdData { get; set; } = new List<CanCmdData>();
/// <summary>
/// 循环获取CAN消息
/// </summary>
public void StartCycleReviceCanMsg()
{
CycleReviceTask = Task.Run(async () =>
{
//var ret = USB2CANFD.CANFD_StartGetMsg(DevHandle, ReadCANIndex);
while (IsCycleRevice)
{
await Task.Delay(ReviceCycle);
try
{
//另外一个CAN通道读取数据
USB2CANFD.CANFD_MSG[] CanMsgBuffer = new USB2CANFD.CANFD_MSG[128];
IntPtr msgPtRead = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG)) * CanMsgBuffer.Length);
int CanNum = USB2CANFD.CANFD_GetMsg(DevHandle, ReadCANIndex, msgPtRead, CanMsgBuffer.Length);
if (CanNum > 0)
{
Console.WriteLine("Read CanMsgNum = {0}", CanNum);
for (int i = 0; i < CanNum; i++)
{
CanMsgBuffer[i] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure((IntPtr)(msgPtRead + i * Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG))), typeof(USB2CANFD.CANFD_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].DLC; j++)
{
Console.Write("{0} ", CanMsgBuffer[i].Data[j].ToString("X2"));
}
Console.WriteLine("");
//报文给高速记录的服务
HighSpeedDataService.AppendOrUpdateMsg(new Models.HighSpeed.CommMsg()
{
Category = "CANFD",
MsgInfo = "0x" + CanMsgBuffer[i].ID.ToString("X8"),
MsgData = BitConverter.ToString(CanMsgBuffer[i].Data),
Time = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
});
}
}
else if (CanNum == 0)
{
Console.WriteLine("No CAN data!");
}
else
{
Console.WriteLine("Get CAN data error!");
}
Console.WriteLine("");
//将CAN消息数据填充到信号里面
DBCParserByFD.DBC_SyncCANFDMsgToValue(DBCHandle, msgPtRead, CanNum);
//循环获取消息的数据
foreach (var item in ListCanFdDbcModel)
{
//有配置的名称的，认为是有用的，则需要读取数据
//if (!string.IsNullOrEmpty(item.Name))
//{
//CAN_DBCParser.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;
item.SignalRtValue = ValueDouble[0].ToString();
//Console.Write(ValueSb.ToString());
//}
}
//释放数据缓冲区，必须释放，否则程序运行一段时间后会报内存不足
Marshal.FreeHGlobal(msgPtRead);
Thread.Sleep(10);
////获取信号值并打印出来
//StringBuilder ValueStr = new StringBuilder(32);
//DBCParserByFD.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("TX1"), new StringBuilder("COM_current_Power"), ValueStr);
//Console.WriteLine("COM_current_Power = {0}", ValueStr);
//DBCParserByFD.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("TX1"), new StringBuilder("COM_Curr_dc"), ValueStr);
//Console.WriteLine("COM_Curr_dc = {0}", ValueStr);
}
catch (Exception ex)
{
LogService.Error(ex.Message);
//LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
}
}
});
}
/// <summary>
/// 接受CAN消息
/// </summary>
public void ReciveCanMsg()
{
//另外一个CAN通道读取数据
USB2CANFD.CANFD_MSG[] CanMsgBuffer = new USB2CANFD.CANFD_MSG[10];
msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG)) * CanMsgBuffer.Length);
int CanNum = USB2CANFD.CANFD_GetMsg(DevHandle, ReadCANIndex, msgPt, CanMsgBuffer.Length);
if (CanNum > 0)
{
Console.WriteLine("Read CanMsgNum = {0}", CanNum);
for (int i = 0; i < CanNum; i++)
{
CanMsgBuffer[i] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure((IntPtr)(msgPt + i * Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG))), typeof(USB2CANFD.CANFD_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].DLC; 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消息数据填充到信号里面
DBCParserByFD.DBC_SyncCANFDMsgToValue(DBCHandle, msgPt, CanNum);
//获取信号值并打印出来
StringBuilder ValueStr = new StringBuilder(32);
DBCParserByFD.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), ValueStr);
Console.WriteLine("moto_speed = {0}", ValueStr);
DBCParserByFD.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), ValueStr);
Console.WriteLine("oil_pressure = {0}", ValueStr);
DBCParserByFD.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), ValueStr);
Console.WriteLine("speed_can = {0}", ValueStr);
}
/// <summary>
/// 关闭设备
/// </summary>
public void CloseDevice()
{
//关闭设备
USB_DEVICEByFD.USB_CloseDevice(DevHandle);
OpenState = false;
DbcParserState = false;
IsCycleRevice = false;
IsCycleSend = false;
}
}
}

0
CapMachine.Wpf/CanDrive/USB2CANFD.cs → CapMachine.Wpf/CanDrive/CanFD/USB2CANFD.cs
View File

143
CapMachine.Wpf/CanDrive/CanFD/USB_DEVICEByFD.cs Normal file
View File

@@ -0,0 +1,143 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace CapMachine.Wpf.CanDrive.CanFD
{
/// <summary>
/// 和USB_DEVICE一样，但用于处理USB设备的CAN FD协议。
/// </summary>
public class USB_DEVICEByFD
{
//定义电压输出值
public const Byte POWER_LEVEL_NONE = 0; //不输出
public const Byte POWER_LEVEL_1V8 = 1; //输出1.8V
public const Byte POWER_LEVEL_2V5 = 2; //输出2.5V
public const Byte POWER_LEVEL_3V3 = 3; //输出3.3V
public const Byte POWER_LEVEL_5V0 = 4; //输出5.0V
//设备信息定义
public struct DEVICE_INFO
{
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
public Byte[] FirmwareName; //固件名称字符串
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
public Byte[] BuildDate; //固件编译时间字符串
public UInt32 HardwareVersion;//硬件版本号
public UInt32 FirmwareVersion;//固件版本号
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public UInt32[] SerialNumber; //适配器序列号
public UInt32 Functions; //适配器当前具备的功能
}
//方法定义
/**
* @brief 初始化USB设备，并扫描设备连接数，必须调用
* @param pDevHandle 每个设备的设备号存储地址
* @retval 扫描到的设备数量
*/
[DllImport("USB2XXX.dll")]
public static extern Int32 USB_ScanDevice(Int32[] pDevHandle);
/**
* @brief 打开设备，必须调用
* @param DevHandle 设备索引号
* @retval 打开设备的状态
*/
[DllImport("USB2XXX.dll")]
public static extern bool USB_OpenDevice(Int32 DevHandle);
/**
* @brief 关闭设备
* @param DevHandle 设备索引号
* @retval 关闭设备的状态
*/
[DllImport("USB2XXX.dll")]
public static extern bool USB_CloseDevice(Int32 DevHandle);
/**
* @brief 复位设备程序，复位后需要重新调用USB_ScanDevice，USB_OpenDevice函数
* @param DevHandle 设备索引号
* @retval 复位设备的状态
*/
[DllImport("USB2XXX.dll")]
public static extern bool USB_ResetDevice(Int32 DevHandle);
/**
* @brief 检测到USB断开连接后，重新连接设备
* @param DevHandle 设备号
* @retval 重连状态
*/
[DllImport("USB2XXX.dll")]
public static extern bool USB_RetryConnect(Int32 DevHandle);
/**
* @brief 获取设备信息，比如设备名称，固件版本号，设备序号，设备功能说明字符串等
* @param DevHandle 设备索引号
* @param pDevInfo 设备信息存储结构体指针
* @param pFunctionStr 设备功能说明字符串
* @retval 获取设备信息的状态
*/
[DllImport("USB2XXX.dll")]
public static extern bool DEV_GetDeviceInfo(Int32 DevHandle, ref DEVICE_INFO pDevInfo, StringBuilder pFunctionStr);
/**
* @brief 擦出用户区数据
* @param DevHandle 设备索引号
* @retval 用户区数据擦出状态
*/
[DllImport("USB2XXX.dll")]
public static extern bool DEV_EraseUserData(Int32 DevHandle);
/**
* @brief 向用户区域写入用户自定义数据，写入数据之前需要调用擦出函数将数据擦出
* @param DevHandle 设备索引号
* @param OffsetAddr 数据写入偏移地址，起始地址为0x00，用户区总容量为0x10000字节，也就是64KBye
* @param pWriteData 用户数据缓冲区首地址
* @param DataLen 待写入的数据字节数
* @retval 写入用户自定义数据状态
*/
[DllImport("USB2XXX.dll")]
public static extern bool DEV_WriteUserData(Int32 DevHandle, Int32 OffsetAddr, byte[] pWriteData, Int32 DataLen);
/**
* @brief 从用户自定义数据区读出数据
* @param DevHandle 设备索引号
* @param OffsetAddr 数据写入偏移地址，起始地址为0x00，用户区总容量为0x10000字节，也就是64KBye
* @param pReadData 用户数据缓冲区首地址
* @param DataLen 待读出的数据字节数
* @retval 读出用户自定义数据的状态
*/
[DllImport("USB2XXX.dll")]
public static extern bool DEV_ReadUserData(Int32 DevHandle, Int32 OffsetAddr, byte[] pReadData, Int32 DataLen);
/**
* @brief 设置可变电压输出引脚输出电压值
* @param DevHandle 设备索引号
* @param PowerLevel 输出电压值
* @retval 设置输出电压状态
*/
[DllImport("USB2XXX.dll")]
public static extern bool DEV_SetPowerLevel(Int32 DevHandle, byte PowerLevel);
/**
* @brief 或者CAN或者LIN的时间戳原始值
* @param DevHandle 设备索引号
* @param pTimestamp 时间戳指针
* @retval 获取时间戳状态
*/
[DllImport("USB2XXX.dll")]
public static extern bool DEV_GetTimestamp(Int32 DevHandle, byte BusType, Int32[] pTimestamp);
/**
* @brief 复位CAN/LIN时间戳，需要在初始化CAN/LIN之后调用
* @param DevHandle 设备索引号
* @retval 复位时间戳状态
*/
[DllImport("USB2XXX.dll")]
public static extern bool DEV_ResetTimestamp(Int32 DevHandle);
/**
* @brief 获取dll编译日期
* @param pDateTime 输出DLL编译日期字符串
* @retval 获取dll编译日期字符串
*/
[DllImport("USB2XXX.dll")]
public static extern bool DEV_GetDllBuildTime(StringBuilder pDateTime);
}
}

511
CapMachine.Wpf/CanDrive/ToomossCanFD.cs
View File

@@ -1,511 +0,0 @@
using CapMachine.Wpf.Models.Tag;
using NPOI.OpenXmlFormats.Wordprocessing;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Windows.Interop;
namespace CapMachine.Wpf.CanDrive
{
/// <summary>
/// Toomoss CAN
/// </summary>
public class ToomossCanFD : BindableBase
{
/// <summary>
/// 实例化函数
/// </summary>
public ToomossCanFD()
{
}
/// <summary>
/// 开始CAN的驱动
/// </summary>
public void StartCanDrive()
{
IsExistsDllFile();
ScanDevice();
OpenDevice();
GetDeviceInfo();
GetCANConfig();
InitCAN();
}
/// <summary>
/// 开始Dbc文件写入
/// </summary>
public void StartDbc(string DbcPath)
{
DBC_Parser(DbcPath);
}
/// <summary>
/// Dbc消息集合
/// </summary>
public ObservableCollection<CanDbcModel> ListCanDbcModel { get; set; } = new ObservableCollection<CanDbcModel>();
#region 公共变量
/// <summary>
/// 设备固件信息
/// </summary>
public USB_DEVICE.DEVICE_INFO DevInfo = new USB_DEVICE.DEVICE_INFO();
/// <summary>
/// CAN Config
/// </summary>
USB2CANFD.CANFD_INIT_CONFIG CANConfig = new USB2CANFD.CANFD_INIT_CONFIG();
/// <summary>
/// DBC Handle
/// </summary>
public UInt64 DBCHandle { get; set; }
/// <summary>
/// 扫描设备Handle集合
/// </summary>
public Int32[] DevHandles { get; set; } = new Int32[20];
/// <summary>
/// 扫描设备Handle
/// </summary>
public Int32 DevHandle { get; set; } = 0;
/// <summary>
/// Write CAN Index
/// </summary>
public Byte WriteCANIndex { get; set; } = 0;
/// <summary>
/// Read CAN Index
/// </summary>
public Byte ReadCANIndex { get; set; } = 1;
private bool _OpenState;
/// <summary>
/// 打开设备的状态
/// </summary>
public bool OpenState
{
get { return _OpenState; }
set { _OpenState = value; RaisePropertyChanged(); }
}
/// <summary>
/// 扫描到设备个数
/// </summary>
public Int32 DevNum { get; set; }
public Int32 ret { get; set; }
public string dllFilePath { get; set; } = "USB2XXX.dll";
/// <summary>
/// 消息值Pt
/// </summary>
public IntPtr msgPt { get; set; }
#endregion
/// <summary>
/// ******************【1】*********************
/// 是否存在Dll文件
/// </summary>
/// <returns></returns>
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></returns>
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()
{
//获取CAN波特率参数
ret = USB2CANFD.CANFD_GetCANSpeedArg(DevHandle, ref CANConfig, 500000, 2000000);
if (ret != USB2CANFD.CANFD_SUCCESS)
{
Console.WriteLine("Get CAN Speed failed!");
return;
}
else
{
Console.WriteLine("Get CAN Speed Success!");
}
}
/// <summary>
/// ******************【6】*********************
/// 初始化CAN
/// </summary>
public void InitCAN()
{
//初始化CAN
ret = USB2CANFD.CANFD_Init(DevHandle, WriteCANIndex, ref CANConfig);
if (ret != USB2CANFD.CANFD_SUCCESS)
{
Console.WriteLine("Config CAN failed!");
return;
}
else
{
Console.WriteLine("WriteCANIndex Config CAN Success!");
}
ret = USB2CANFD.CANFD_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>
public void DBC_Parser(string Path)
{
//解析DBC文件
DBCHandle = CANFD_DBCParser.DBC_ParserFile(DevHandle, new StringBuilder(Path));
if (DBCHandle == 0)
{
Console.WriteLine("Parser DBC File error!");
return;
}
else
{
Console.WriteLine("Parser DBC File success!");
}
ListCanDbcModel.Clear();
//打印DBC里面报文和信号相关信息
int DBCMsgNum = CANFD_DBCParser.DBC_GetMsgQuantity(DBCHandle);
for (int i = 0; i < DBCMsgNum; i++)
{
StringBuilder MsgName = new StringBuilder(32);
CANFD_DBCParser.DBC_GetMsgName(DBCHandle, i, MsgName);
Console.WriteLine("Msg.Name = {0}", MsgName);
int DBCSigNum = CANFD_DBCParser.DBC_GetMsgSignalQuantity(DBCHandle, MsgName);
StringBuilder Publisher = new StringBuilder(32);
CANFD_DBCParser.DBC_GetMsgPublisher(DBCHandle, MsgName, Publisher);
Console.Write("Signals:");
for (int j = 0; j < DBCSigNum; j++)
{
StringBuilder SigName = new StringBuilder(32);
CANFD_DBCParser.DBC_GetMsgSignalName(DBCHandle, MsgName, j, SigName);
Console.Write("{0} ", SigName);
//增加信息数据
ListCanDbcModel.Add(new CanDbcModel()
{
MsgName = MsgName.ToString(),
MsgId = "",
SignalName = SigName.ToString(),
SignalDesc = "",
SignalUnit = "",
SignalRtValue = "",
Publisher = Publisher.ToString()
});
}
Console.WriteLine("");
}
}
/// <summary>
/// 发送CAN数据
/// </summary>
public void SendCanMsg(List<CanCmdData> CmdData)
{
var GroupMsg = CmdData.GroupBy(x => x.MsgName);
USB2CANFD.CANFD_MSG[] CanMsg = new USB2CANFD.CANFD_MSG[GroupMsg.Count()];
for (int i = 0; i < GroupMsg.Count(); i++)
{
CanMsg[i] = new USB2CANFD.CANFD_MSG();
CanMsg[i].Data = new Byte[64];
}
IntPtr msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG)));
int Index = 0;
//循环给MSG赋值数据
foreach (var itemMsg in GroupMsg)
{
foreach (var itemSignal in itemMsg)
{
CANFD_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
}
CANFD_DBCParser.DBC_SyncValueToCANFDMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPt);
CanMsg[Index] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPt, typeof(USB2CANFD.CANFD_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消息里面
//IntPtr msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG)));
//DBCParser.DBC_SyncValueToCANFDMsg(DBCHandle, new StringBuilder("msg_moto_speed"), msgPt);
//CanMsg[0] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPt, typeof(USB2CANFD.CANFD_MSG));
//DBCParser.DBC_SyncValueToCANFDMsg(DBCHandle, new StringBuilder("msg_oil_pressure"), msgPt);
//CanMsg[1] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPt, typeof(USB2CANFD.CANFD_MSG));
//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数据
int SendedNum = USB2CANFD.CANFD_SendMsg(DevHandle, WriteCANIndex, CanMsg, (Int32)CanMsg.Length);
if (SendedNum >= 0)
{
Console.WriteLine("Success send frames:{0}", SendedNum);
}
else
{
Console.WriteLine("Send CAN data failed! {0}", SendedNum);
}
}
/// <summary>
/// 是否循环接收数据
/// </summary>
public bool IsCycleRevice { get; set; }
/// <summary>
/// CycleRevice扫描Task
/// </summary>
private static Task CycleReviceTask { get; set; }
/// <summary>
/// 循环获取CAN消息
/// </summary>
public void StartCycleReviceCanMsg()
{
CycleReviceTask = Task.Run(async () =>
{
while (IsCycleRevice)
{
await Task.Delay(1000);
try
{
//另外一个CAN通道读取数据
USB2CANFD.CANFD_MSG[] CanMsgBuffer = new USB2CANFD.CANFD_MSG[10];
msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG)) * CanMsgBuffer.Length);
int CanNum = USB2CANFD.CANFD_GetMsg(DevHandle, ReadCANIndex, msgPt, CanMsgBuffer.Length);
if (CanNum > 0)
{
Console.WriteLine("Read CanMsgNum = {0}", CanNum);
for (int i = 0; i < CanNum; i++)
{
CanMsgBuffer[i] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure((IntPtr)(msgPt + i * Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG))), typeof(USB2CANFD.CANFD_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].DLC; 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消息数据填充到信号里面
CANFD_DBCParser.DBC_SyncCANFDMsgToValue(DBCHandle, msgPt, CanNum);
//获取信号值并打印出来
StringBuilder ValueStr = new StringBuilder(32);
CANFD_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("TX1"), new StringBuilder("COM_current_Power"), ValueStr);
Console.WriteLine("COM_current_Power = {0}", ValueStr);
CANFD_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("TX1"), new StringBuilder("COM_Curr_dc"), ValueStr);
Console.WriteLine("COM_Curr_dc = {0}", ValueStr);
}
catch (Exception ex)
{
//LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
}
}
});
}
/// <summary>
/// 接受CAN消息
/// </summary>
public void ReciveCanMsg()
{
//另外一个CAN通道读取数据
USB2CANFD.CANFD_MSG[] CanMsgBuffer = new USB2CANFD.CANFD_MSG[10];
msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG)) * CanMsgBuffer.Length);
int CanNum = USB2CANFD.CANFD_GetMsg(DevHandle, ReadCANIndex, msgPt, CanMsgBuffer.Length);
if (CanNum > 0)
{
Console.WriteLine("Read CanMsgNum = {0}", CanNum);
for (int i = 0; i < CanNum; i++)
{
CanMsgBuffer[i] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure((IntPtr)(msgPt + i * Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG))), typeof(USB2CANFD.CANFD_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].DLC; 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消息数据填充到信号里面
CANFD_DBCParser.DBC_SyncCANFDMsgToValue(DBCHandle, msgPt, CanNum);
//获取信号值并打印出来
StringBuilder ValueStr = new StringBuilder(32);
CANFD_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), ValueStr);
Console.WriteLine("moto_speed = {0}", ValueStr);
CANFD_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), ValueStr);
Console.WriteLine("oil_pressure = {0}", ValueStr);
CANFD_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), ValueStr);
Console.WriteLine("speed_can = {0}", ValueStr);
}
/// <summary>
/// 关闭设备
/// </summary>
public void CloseDevice()
{
//关闭设备
USB_DEVICE.USB_CloseDevice(DevHandle);
OpenState = false;
}
}
}

77
CapMachine.Wpf/Dtos/CANFdConfigExdDto.cs Normal file
View File

@@ -0,0 +1,77 @@
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CapMachine.Wpf.Dtos
{
public class CANFdConfigExdDto : BindableBase
{
/// <summary>
/// 主键
/// </summary>
public long Id { get; set; }
private int _DataBaudRate;
/// <summary>
/// 数据波特率
/// </summary>
public int DataBaudRate
{
get { return _DataBaudRate; }
set { _DataBaudRate = value; RaisePropertyChanged(); }
}
private int _ArbBaudRate;
/// <summary>
/// 仲裁波特率
/// </summary>
public int ArbBaudRate
{
get { return _ArbBaudRate; }
set { _ArbBaudRate = value; RaisePropertyChanged(); }
}
private bool _ISOEnable;
/// <summary>
/// ISO 使能
/// </summary>
public bool ISOEnable
{
get { return _ISOEnable; }
set { _ISOEnable = value; RaisePropertyChanged(); }
}
private bool _ResEnable;
/// <summary>
/// 终端电阻使能
/// </summary>
public bool ResEnable
{
get { return _ResEnable; }
set { _ResEnable = value; RaisePropertyChanged(); }
}
private int _Cycle;
/// <summary>
/// 周期
/// </summary>
public int Cycle
{
get { return _Cycle; }
set { _Cycle = value; RaisePropertyChanged(); }
}
private string? _DbcPath;
/// <summary>
/// Dbc文件路径
/// </summary>
public string? DbcPath
{
get { return _DbcPath; }
set { _DbcPath = value; RaisePropertyChanged(); }
}
}
}

19
CapMachine.Wpf/MapperProfile/CANFdConfigExdProfile.cs Normal file
View File

@@ -0,0 +1,19 @@
using AutoMapper;
using CapMachine.Model.CANLIN;
using CapMachine.Wpf.Dtos;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CapMachine.Wpf.MapperProfile
{
public class CANFdConfigExdProfile : Profile
{
public CANFdConfigExdProfile()
{
CreateMap<CANFdConfigExd, CANFdConfigExdDto>().ReverseMap();
}
}
}

4
CapMachine.Wpf/Models/CanLinRunStateModel.cs
View File

@@ -33,6 +33,10 @@ namespace CapMachine.Wpf.Models
SelectedCanLinMsg = "CAN";
CanLinRunState=true;
break;
case CanLinEnum.CANFD:
SelectedCanLinMsg = "CANFD";
CanLinRunState = true;
break;
case CanLinEnum.Lin:
SelectedCanLinMsg = "LIN";
CanLinRunState = true;

5
CapMachine.Wpf/Models/ComEnum.cs
View File

@@ -79,6 +79,11 @@ namespace CapMachine.Wpf.Models
/// Lin
/// </summary>
Lin = 2,
/// <summary>
/// CAN FD
/// </summary>
CANFD = 3,
}
}
}

415
CapMachine.Wpf/Services/CanFdDriveService.cs Normal file
View File

@@ -0,0 +1,415 @@
using CapMachine.Model.CANLIN;
using CapMachine.Wpf.CanDrive;
using CapMachine.Wpf.Models;
using CapMachine.Wpf.Models.ProModelPars;
using ImTools;
using Prism.Ioc;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CapMachine.Wpf.Services
{
/// <summary>
/// Can FD驱动服务
/// </summary>
public class CanFdDriveService : BindableBase
{
public HighSpeedDataService HighSpeedDataService { get; }
public LogicRuleService LogicRuleService { get; }
/// <summary>
/// 实例化函数
/// </summary>
public CanFdDriveService(HighSpeedDataService highSpeedDataService, IContainerProvider containerProvider, LogicRuleService logicRuleService)
{
ToomossCanFDDrive = new ToomossCanFD(containerProvider);
//高速数据服务
HighSpeedDataService = highSpeedDataService;
LogicRuleService = logicRuleService;
//ToomossCanFDDrive.StartCanDrive();
}
/// <summary>
/// 当前选中的CanLinConfigPro 程序
/// </summary>
public CanLinConfigPro SelectedCanLinConfigPro { get; set; }
/// <summary>
/// 图莫斯 CAN Drive
/// ToomossCanFDDrive
/// </summary>
public ToomossCanFD ToomossCanFDDrive { get; set; }
/// <summary>
/// Dbc消息集合
/// 包括读取的实时值和数据
/// </summary>
public ObservableCollection<CanDbcModel> ListCanDbcModel { get; set; } = new ObservableCollection<CanDbcModel>();
/// <summary>
/// 初始化CAN的配置信息
/// </summary>
public void InitCanConfig(CanLinConfigPro selectedCanLinConfigPro)
{
//赋值配置数据
SelectedCanLinConfigPro = selectedCanLinConfigPro;
//为DBC实时数据关联配置的名称
foreach (var item in SelectedCanLinConfigPro.CanLinConfigContents)
{
var FindData = ListCanDbcModel.FindFirst(a => a.SignalName == item.SignalName);
if (FindData != null)
{
FindData.Name = item.Name;
}
}
}
/// <summary>
/// 开始DBC 配置文件 加载
/// </summary>
/// <returns></returns>
public ObservableCollection<CanDbcModel> StartDbc(string Path)
{
ListCanDbcModel = ToomossCanFDDrive.StartDbc(Path);
return ListCanDbcModel;
}
#region 程序驱动CAN
/// <summary>
/// 转速 指令数据 实例
/// </summary>
private CanCmdData SpeedCanCmdData { get; set; }
/// <summary>
/// 功率限制 指令数据 实例
/// </summary>
private CanCmdData PwLimitCanCmdData { get; set; }
/// <summary>
/// 使能 指令数据 实例
/// </summary>
private CanCmdData EnableCanCmdData { get; set; }
/// <summary>
/// PTC使能 指令数据 实例
/// </summary>
private CanCmdData PTCEnableCanCmdData { get; set; }
/// <summary>
/// PTC功率 指令数据 实例
/// </summary>
private CanCmdData PTCPwCanCmdData { get; set; }
/// <summary>
/// PTC水流量 指令数据 实例
/// </summary>
private CanCmdData PTCFlowCanCmdData { get; set; }
/// <summary>
/// PTC水温 指令数据 实例
/// </summary>
private CanCmdData PTCWaterTempCanCmdData { get; set; }
/// <summary>
/// 要发送的CAN指令数据
/// 在程序配置好后就确定要发送哪些数据
/// </summary>
public List<CanCmdData> CmdData { get; set; } = new List<CanCmdData>();
/// <summary>
/// 增加发送的指令数据
/// </summary>
/// <param name="canCmdData"></param>
public void AddCmdData(CanCmdData SendCanCmdData)
{
//提取常用的实例数据
switch (SendCanCmdData.ConfigName)
{
case "转速":
SpeedCanCmdData = SendCanCmdData;
break;
case "功率限制":
PwLimitCanCmdData = SendCanCmdData;
break;
case "使能":
EnableCanCmdData = SendCanCmdData;
break;
case "Anti_Sleep":
//SpeedCanCmdData = SendCanCmdData;
break;
case "PTC使能":
PTCEnableCanCmdData = SendCanCmdData;
break;
case "PTC功率":
PTCPwCanCmdData = SendCanCmdData;
break;
case "PTC水流量":
PTCFlowCanCmdData = SendCanCmdData;
break;
case "PTC水温":
PTCWaterTempCanCmdData = SendCanCmdData;
break;
default:
break;
}
//添加到发送数据集合
CmdData.Add(SendCanCmdData);
}
/// <summary>
/// 更新速度信息
/// 默认是启动
/// </summary>
/// <param name="canCmdData"></param>
public void UpdateSpeedCmdData(double SpeedData)
{
if (SpeedCanCmdData != null)
{
if (SpeedCanCmdData.LogicRuleDto == null)
{
//没有启动逻辑规则处理
SpeedCanCmdData.SignalCmdValue = SpeedData;
return;
}
SpeedCanCmdData.SignalCmdValue = LogicRuleService.ApplyExpressionFast(SpeedData, SpeedCanCmdData.LogicRuleDto);
}
//if (EnableCanCmdData != null)
//{
// EnableCanCmdData.SignalCmdValue = 1;
//}
}
/// <summary>
/// 更新压缩机使能数据
/// </summary>
/// <param name="IsEnable"></param>
public void UpdateCapEnableCmdData(bool IsEnable)
{
if (EnableCanCmdData != null)
{
EnableCanCmdData.SignalCmdValue = IsEnable ? 1 : 0;
}
}
/// <summary>
/// 更新压缩机的功率限制
/// </summary>
/// <param name="IsEnable"></param>
public void UpdateCapPwLimitCmdData(double PwLimit)
{
if (PwLimitCanCmdData != null)
{
if (PwLimitCanCmdData.LogicRuleDto == null)
{
PwLimitCanCmdData.SignalCmdValue = PwLimit;
return;
}
PwLimitCanCmdData.SignalCmdValue = LogicRuleService.ApplyExpressionFast(PwLimit, PwLimitCanCmdData.LogicRuleDto!);
}
}
/// <summary>
/// 更新 PTC使能信号
/// </summary>
/// <param name="IsEnable"></param>
public void UpdateCapPTCEnableCmdData(bool IsEnable)
{
if (PTCEnableCanCmdData != null)
{
PTCEnableCanCmdData.SignalCmdValue = IsEnable ? 1 : 0;
}
}
/// <summary>
/// 更新 PTC功率 信号
/// </summary>
/// <param name="IsEnable"></param>
public void UpdateCapPTCPwCmdData(double PTCPw)
{
if (PTCPwCanCmdData != null)
{
if (PTCPwCanCmdData.LogicRuleDto == null)
{
PTCPwCanCmdData.SignalCmdValue = PTCPw;
return;
}
PTCPwCanCmdData.SignalCmdValue = LogicRuleService.ApplyExpressionFast(PTCPw, PTCPwCanCmdData.LogicRuleDto!);
}
}
/// <summary>
/// 更新 PTC水流量 信号
/// </summary>
/// <param name="IsEnable"></param>
public void UpdateCapPTCFlowCmdData(double Flow)
{
if (PTCFlowCanCmdData != null)
{
if (PTCFlowCanCmdData.LogicRuleDto == null)
{
PTCFlowCanCmdData.SignalCmdValue = Flow;
return;
}
PTCFlowCanCmdData.SignalCmdValue = LogicRuleService.ApplyExpressionFast(Flow, PTCFlowCanCmdData.LogicRuleDto!);
}
}
/// <summary>
/// 更新 PTC水温 信号
/// </summary>
/// <param name="IsEnable"></param>
public void UpdateCapPTCWaterTempCmdData(double WaterTemp)
{
if (PTCWaterTempCanCmdData != null)
{
if (PTCWaterTempCanCmdData.LogicRuleDto == null)
{
PTCWaterTempCanCmdData.SignalCmdValue = WaterTemp;
return;
}
PTCWaterTempCanCmdData.SignalCmdValue = LogicRuleService.ApplyExpressionFast(WaterTemp, PTCWaterTempCanCmdData.LogicRuleDto!);
}
}
/// <summary>
/// 发送消息给CAN 驱动
/// </summary>
public void SendMsgToCanDrive(double SpeedData)
{
if (ToomossCanFDDrive.OpenState)
{
if (CmdData.Count > 0)
{
//更新速度信息
UpdateSpeedCmdData(SpeedData);
ToomossCanFDDrive.SendCanMsg(CmdData);
}
else
{
System.Windows.MessageBox.Show("未发现配置的数据内容", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
}
}
else
{
System.Windows.MessageBox.Show("未打开CAN通信，无法发送数据", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
}
}
/// <summary>
/// 循环发送数据到CAN
/// </summary>
public void CycleSendMsg()
{
if (ToomossCanFDDrive.OpenState)
{
if (ToomossCanFDDrive.IsCycleSend == false)
{
if (CmdData.Count > 0)
{
ToomossCanFDDrive.IsCycleSend = true;
ToomossCanFDDrive.CmdData = CmdData;
//ToomossCanFDDrive.StartCycleSendMsg();
ToomossCanFDDrive.StartPrecisionCycleSendMsg();
}
else
{
System.Windows.MessageBox.Show("未发现配置的数据内容", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
}
}
else
{
ToomossCanFDDrive.IsCycleSend = false;
}
}
}
/// <summary>
///循环接收数据
/// </summary>
public void CycleReciveMsg()
{
if (ToomossCanFDDrive.OpenState)
{
if (ToomossCanFDDrive.IsCycleRevice == false)
{
if (ListCanDbcModel.Count > 0)
{
ToomossCanFDDrive.IsCycleRevice = true;
ToomossCanFDDrive.StartCycleReviceCanMsg();
}
else
{
System.Windows.MessageBox.Show("未发现配置的数据内容", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
}
}
else
{
ToomossCanFDDrive.IsCycleRevice = false;
}
}
}
/// <summary>
/// 获取数据值
/// 从DBC中获取数据给数据中心集合
/// </summary>
/// <param name="Name"></param>
/// <returns></returns>
public double GetDbcValueByName(string Name)
{
if (!ToomossCanFDDrive.IsCycleRevice) return 0;
if (ListCanDbcModel.Any(a => a.Name == Name))
{
//double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue, out double Result1);
return double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue.Split(" ")[0], out double Result) == true ? Result : 0;
//return 12.3;
}
return 0;
}
/// <summary>
/// 速度的数据的获取
/// 获取速度数据值
/// 从DBC中获取Speed数据给数据中心集合
/// </summary>
/// <param name="Name"></param>
/// <returns></returns>
public double GetDbcSpeedValueBySpeedName(string Name)
{
if (!ToomossCanFDDrive.IsCycleRevice) return 0;
if (ListCanDbcModel.Any(a => a.Name == Name))
{
//double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue, out double Result1);
//return double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue.Split(" ")[0], out double Result) == true ? Result : 0;
return double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue.Split(" ")[0], out double Result) == true ? Result : 0;
//return 2300;
}
return 0;
}
#endregion
}
}

31
CapMachine.Wpf/Services/MachineRtDataService.cs
View File

@@ -42,6 +42,7 @@ namespace CapMachine.Wpf.Services
public ConfigService ConfigService { get; }
public LogicRuleService LogicRuleService { get; }
public CanDriveService CanDriveService { get; }
public CanFdDriveService CanFdDriveService { get; }
public LinDriveService LinDriveService { get; }
public SysRunService SysRunService { get; }
@@ -135,7 +136,7 @@ namespace CapMachine.Wpf.Services
/// </summary>
/// <param name="eventAggregator"></param>
public MachineRtDataService(IEventAggregator eventAggregator, AlarmService alarmService, ConfigService configService, LogicRuleService logicRuleService,
CanDriveService canDriveService, LinDriveService linDriveService, SysRunService sysRunService)//, AlarmService alarmService
CanDriveService canDriveService, CanFdDriveService canFdDriveService, LinDriveService linDriveService, SysRunService sysRunService)//, AlarmService alarmService
{
//ConcurrentDictionary<DateTime, RecordInfo> keyValuePairs = new ConcurrentDictionary<DateTime, RecordInfo>();
@@ -153,6 +154,7 @@ namespace CapMachine.Wpf.Services
ConfigService = configService;
LogicRuleService = logicRuleService;
CanDriveService = canDriveService;
CanFdDriveService = canFdDriveService;
LinDriveService = linDriveService;
SysRunService = sysRunService;
@@ -2604,6 +2606,15 @@ namespace CapMachine.Wpf.Services
//pVModel.EngSrcValue = 0;
}
break;
case CanLinEnum.CANFD:
//通信转速 Dbc中间配置名称的转速数据读取出来 给PLC 取消XXX
if (TagManger.TryGetPVModel(itemCanLinGroup.Key, out MeterValueAttrCell? CanpFDVModel))
{
CanpFDVModel!.EngValue = CanDriveService.GetDbcSpeedValueBySpeedName("通讯转速");
SiemensDrive.Write(CanpFDVModel!.Address!.Replace("W", ""), (short)CanFdDriveService.GetDbcSpeedValueBySpeedName("通讯转速"));
//pVModel.EngSrcValue = 0;
}
break;
case CanLinEnum.Lin:
//通信转速 Dbc中间配置名称的转速数据读取出来 给PLC 取消XXX
if (TagManger.TryGetPVModel(itemCanLinGroup.Key, out MeterValueAttrCell? LinpVModel))
@@ -2633,6 +2644,12 @@ namespace CapMachine.Wpf.Services
//写入到PLC中
SiemensDrive.Write(pVModel!.Address!.Replace("W", ""), (short)(CanDriveService.GetDbcValueByName(itemCanLinGroup.Value.NameNoUnit) * itemCanLinGroup.Value.Precision));
break;
case CanLinEnum.CANFD:
//取得压缩机的CANLIN数据到数据集合中
pVModel!.EngValue = CanDriveService.GetDbcValueByName(itemCanLinGroup.Value.NameNoUnit);
//写入到PLC中
SiemensDrive.Write(pVModel!.Address!.Replace("W", ""), (short)(CanFdDriveService.GetDbcValueByName(itemCanLinGroup.Value.NameNoUnit) * itemCanLinGroup.Value.Precision));
break;
case CanLinEnum.Lin:
//取得压缩机的CANLIN数据
pVModel!.EngValue = LinDriveService.GetLdfValueByName(itemCanLinGroup.Value.NameNoUnit);
@@ -3100,6 +3117,9 @@ namespace CapMachine.Wpf.Services
case CanLinEnum.Can:
CanDriveService.UpdateCapEnableCmdData((bool)itemStepExd.Value!);
break;
case CanLinEnum.CANFD:
CanFdDriveService.UpdateCapEnableCmdData((bool)itemStepExd.Value!);
break;
case CanLinEnum.Lin:
LinDriveService.UpdateCapEnableCmdData((bool)itemStepExd.Value!);
break;
@@ -3183,6 +3203,15 @@ namespace CapMachine.Wpf.Services
CanDriveService.UpdateSpeedCmdData(SpeedSv);
}
//itemTag.Value.EngPvValue = 0;
break;
case CanLinEnum.CANFD:
//获取PLC的SV数据 更新SV的速度值到压缩机
if (CanDriveService.CanAutoHand)//自动时步骤的数据可以赋值数据
{
CanFdDriveService.UpdateSpeedCmdData(SpeedSv);
}
//itemTag.Value.EngPvValue = 0;
break;
case CanLinEnum.Lin:

1
CapMachine.Wpf/Services/NavigationMenuService.cs
View File

@@ -73,6 +73,7 @@ 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("", "LIN配置", "LINConfigView"));
MenuItems.Add(new NavigationItem("", "工艺参数", "ProConfigView"));
MenuItems.Add(new NavigationItem("", "工艺曲线", "RealTimeChartView"));

1423
CapMachine.Wpf/ViewModels/CANFDConfigViewModel.cs Normal file
View File

File diff suppressed because it is too large Load Diff

10
CapMachine.Wpf/ViewModels/MonitorViewModel.cs
View File

@@ -27,7 +27,7 @@ namespace CapMachine.Wpf.ViewModels
/// <param name="machineRtDataService"></param>
/// <param name="dialogService"></param>
public MonitorViewModel(ConfigService configService, IEventAggregator eventAggregator,
DataRecordService dataRecordService, SysRunService sysRunService, AlarmService alarmService, PPCService pPCService, CanDriveService canDriveService, LinDriveService linDriveService,
DataRecordService dataRecordService, CanFdDriveService canFdDriveService, SysRunService sysRunService, AlarmService alarmService, PPCService pPCService, CanDriveService canDriveService, LinDriveService linDriveService,
ProRuntimeService proRuntimeService,
MachineRtDataService machineRtDataService, IDialogService dialogService)
{
@@ -39,6 +39,7 @@ namespace CapMachine.Wpf.ViewModels
AlarmService = alarmService;
PPCService = pPCService;
CanDriveService = canDriveService;
CanFdDriveService = canFdDriveService;
LinDriveService = linDriveService;
ProRuntimeService = proRuntimeService;
MachineRtDataService = machineRtDataService;
@@ -91,6 +92,7 @@ namespace CapMachine.Wpf.ViewModels
public AlarmService AlarmService { get; }
public PPCService PPCService { get; }
public CanDriveService CanDriveService { get; }
public CanFdDriveService CanFdDriveService { get; }
public LinDriveService LinDriveService { get; }
public ProRuntimeService ProRuntimeService { get; }
public MachineRtDataService MachineRtDataService { get; }
@@ -344,6 +346,12 @@ namespace CapMachine.Wpf.ViewModels
CanDriveService.UpdateCapEnableCmdData(false);
//itemTag.Value.EngPvValue = 0;
break;
case CanLinEnum.CANFD:
//获取PLC的SV数据 更新SV的速度值到压缩机
CanFdDriveService.UpdateSpeedCmdData(0);
CanFdDriveService.UpdateCapEnableCmdData(false);
//itemTag.Value.EngPvValue = 0;
break;
case CanLinEnum.Lin:
//获取PLC的SV数据 更新SV的速度值到压缩机
LinDriveService.UpdateSpeedCmdData(0);

1073
CapMachine.Wpf/Views/CANFDConfigView.xaml Normal file
View File

File diff suppressed because it is too large Load Diff

28
CapMachine.Wpf/Views/CANFDConfigView.xaml.cs Normal file
View File

@@ -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
{
/// <summary>
/// CANFDConfigView.xaml 的交互逻辑
/// </summary>
public partial class CANFDConfigView : UserControl
{
public CANFDConfigView()
{
InitializeComponent();
}
}
}