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

增加了初始弹窗，但是没有成功

Browse Source 
更改了CAN和LIN协调
更改了配置程序的名称顺序
This commit is contained in:
Tyrone CT
2025-01-11 12:04:34 +08:00
parent 620c5e8178
commit e49a48fb25
53 changed files with 5118 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
CapMachine.Wpf/LinDrive/LDFParser.cs Normal file
View File

@@ -0,0 +1,73 @@
using System.Runtime.InteropServices;
using System.Text;
namespace CapMachine.Wpf.LinDrive
{
/// <summary>
/// LDF文件解析
/// </summary>
public class LDFParser
{
public const Int32 LDF_PARSER_OK = 0;//没有错误
public const Int32 LDF_PARSER_FILE_OPEN = (-1);//打开文件出错
public const Int32 LDF_PARSER_FILE_FORMAT = (-2);//文件格式错误
public const Int32 LDF_PARSER_DEV_DISCONNECT = (-3);//设备未连接
public const Int32 LDF_PARSER_HANDLE_ERROR = (-4);//LDF Handle错误
public const Int32 LDF_PARSER_GET_INFO_ERROR = (-5);//获取解析后的数据出错
public const Int32 LDF_PARSER_DATA_ERROR = (-6);//数据处理错误
public const Int32 LDF_PARSER_SLAVE_NACK = (-7);//从机未响应数据
[DllImport("USB2XXX.dll")]
public static extern UInt64 LDF_ParserFile(int DevHandle, int LINIndex, byte isMaster, StringBuilder pLDFFileName);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetProtocolVersion(UInt64 LDFHandle);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetLINSpeed(UInt64 LDFHandle);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetFrameQuantity(UInt64 LDFHandle);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetFrameName(UInt64 LDFHandle, int index, StringBuilder pFrameName);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetFrameSignalQuantity(UInt64 LDFHandle, StringBuilder pFrameName);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetFrameSignalName(UInt64 LDFHandle, StringBuilder pFrameName, int index, StringBuilder pSignalName);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_SetSignalValue(UInt64 LDFHandle, StringBuilder pFrameName, StringBuilder pSignalName, double Value);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetSignalValue(UInt64 LDFHandle, StringBuilder pFrameName, StringBuilder pSignalName, double[] pValue);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetSignalValueStr(UInt64 LDFHandle, StringBuilder pFrameName, StringBuilder pSignalName, StringBuilder pValueStr);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_SetFrameRawValue(UInt64 LDFHandle, StringBuilder pFrameName, StringBuilder pRawData);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetFrameRawValue(UInt64 LDFHandle, StringBuilder pFrameName, StringBuilder pRawData);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetFramePublisher(UInt64 LDFHandle, StringBuilder pFrameName, StringBuilder pPublisher);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetMasterName(UInt64 LDFHandle, StringBuilder pMasterName);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetSchQuantity(UInt64 LDFHandle);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetSchName(UInt64 LDFHandle, int index, StringBuilder pSchName);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetSchFrameQuantity(UInt64 LDFHandle, StringBuilder pSchName);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_GetSchFrameName(UInt64 LDFHandle, StringBuilder pSchName, int index, StringBuilder pFrameName);
/// <summary>
///将帧数据发送到LIN总线，或者向从机读取数据，内部会根据主机名称和帧发布者自动判断是发送数据还是读取数据，发送数据校验模式是通过协议版本号自动判断的。
// 若是发送数据给从机，需要先调用LDF_SetSignalValue函数设置该帧里面每个信号的值。
//若是向从机读数据，调用该函数后，可以通过调用LDF_GetSignalValue函数获取读到的值。
/// LDFHandle ldf文件解析句柄，通过LDF_ParserFile函数获取 。
/// pFrameName 帧名称。
/// </summary>
/// <param name="LDFHandle"></param>
/// <param name="pFrameName"></param>
/// <param name="FillBitValue"></param>
/// <returns></returns>
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_ExeFrameToBus(UInt64 LDFHandle, StringBuilder pFrameName, byte FillBitValue);
[DllImport("USB2XXX.dll")]
public static extern Int32 LDF_ExeSchToBus(UInt64 LDFHandle, StringBuilder pSchName, byte FillBitValue);
}
}

35
CapMachine.Wpf/LinDrive/LinCmdData.cs Normal file
View File

@@ -0,0 +1,35 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CapMachine.Wpf.LinDrive
{
/// <summary>
/// Lin指令数据
/// </summary>
public class LinCmdData
{
/// <summary>
/// 配置项名称-比如转速、功率限制等
/// </summary>
public string? ConfigName { get; set; }
/// <summary>
/// 消息名称/Frame名称/帧名称
/// </summary>
public string? MsgName { get; set; }
/// <summary>
/// 信号名称
/// </summary>
public string? SignalName { get; set; }
/// <summary>
/// 指令值
/// 没有的话，则给默认值
/// </summary>
public double SignalCmdValue { get; set; }
}
}

93
CapMachine.Wpf/LinDrive/LinLdfModel.cs Normal file
View File

@@ -0,0 +1,93 @@
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CapMachine.Wpf.LinDrive
{
/// <summary>
/// LDF消息
/// </summary>
public class LinLdfModel : BindableBase
{
/// <summary>
/// 消息Id
/// </summary>
public string? MsgId { get; set; }
/// <summary>
/// 配置的中文名称：速度，转速限制，使能等常用的信息数据
/// 但不是所有的SignalName都会配置一个Name，只是需要时才会配置名称
/// 但是CanDbcModel集合会包括所有的SignalName名称的
/// </summary>
public string? Name { get; set; }
/// <summary>
/// 消息名称/Frame名称/帧名称
/// </summary>
public string? MsgName { get; set; }
/// <summary>
/// 信号名称
/// </summary>
public string? SignalName { get; set; }
/// <summary>
/// 信号描述
/// </summary>
public string? SignalDesc { get; set; }
/// <summary>
/// 信号单位
/// </summary>
public string? SignalUnit { get; set; }
private string? _SignalRtValue = "--";
/// <summary>
/// 信号实时值
/// </summary>
public string? SignalRtValue
{
get { return _SignalRtValue; }
set
{
if (_SignalRtValue != value)
{
_SignalRtValue = value;
RaisePropertyChanged();
}
}
}
private StringBuilder _SignalRtValueSb = new StringBuilder(10);
/// <summary>
/// 信号实时值 StringBuilder
/// </summary>
public StringBuilder SignalRtValueSb
{
get { return _SignalRtValueSb; }
set
{
//if (_SignalRtValueSb != value)
//{
SignalRtValue = value.ToString();
_SignalRtValueSb = value;
//}
}
}
/// <summary>
/// 发布者
/// </summary>
public string? Publisher { get; set; }
/// <summary>
/// 是否主机帧
/// </summary>
public string? IsMasterFrame { get; set; }
}
}

423
CapMachine.Wpf/LinDrive/ToomossLin.cs Normal file
View File

@@ -0,0 +1,423 @@
using CapMachine.Wpf.CanDrive;
using CapMachine.Wpf.Services;
using Microsoft.VisualBasic;
using Prism.Ioc;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Security.Cryptography.Xml;
using System.Text;
using System.Threading.Tasks;
namespace CapMachine.Wpf.LinDrive
{
/// <summary>
/// Toomoss 的LIN驱动
/// </summary>
public class ToomossLin : BindableBase
{
/// <summary>
/// 设备Handles集合
/// </summary>
public Int32[] DevHandles { get; set; } = new Int32[20];
/// <summary>
/// 设备Handles
/// 设备句柄，本质为设备序号的低4字节，可以通过调用USB_ScanDevice函数获得
/// </summary>
public Int32 DevHandle { get; set; } = 0;
/// <summary>
/// Lin的Index
/// LIN通道索引号，填0或者1，若只有一个通道LIN，则填0.
/// </summary>
public Byte LINIndex { get; set; } = 0;
/// <summary>
/// Lin的连接State
/// </summary>
public bool state { get; set; }
/// <summary>
/// Lin的连接设备数量
/// </summary>
public Int32 DevNum { get; set; }
/// <summary>
/// Lin的Dll文件的路径
/// </summary>
public string dllFilePath { get; set; } = "USB2XXX.dll";
private readonly IContainerProvider ContainerProvider;
public ToomossLin(IContainerProvider containerProvider)
{
ContainerProvider = containerProvider;
HighSpeedDataService = ContainerProvider.Resolve<HighSpeedDataService>();
}
/// <summary>
/// HighSpeedDataService 实例
/// </summary>
public HighSpeedDataService HighSpeedDataService { get; set; }
/// <summary>
/// 开始LDF文件写入
/// </summary>
public ObservableCollection<LinLdfModel> StartLdf(string LdfPath)
{
LDF_Parser(LdfPath);
return ListLinLdfModel;
}
/// <summary>
/// 开始Lin的驱动
/// </summary>
public void StartLinDrive()
{
IsExistsDllFile();
ScanDevice();
OpenDevice();
}
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; } = 100;
/// <summary>
/// 循环接受数据
/// </summary>
public ushort ReviceCycle { get; set; } = 500;
/// <summary>
/// CycleRevice 扫描Task
/// </summary>
private static Task CycleReviceTask { get; set; }
/// <summary>
/// CycleSend 扫描Task
/// </summary>
private static Task CycleSendTask { get; set; }
private bool _OpenState;
/// <summary>
/// 打开设备的状态
/// </summary>
public bool OpenState
{
get { return _OpenState; }
set { _OpenState = value; RaisePropertyChanged(); }
}
private bool _LdfParserState;
/// <summary>
/// LDF解析的状态
/// </summary>
public bool LdfParserState
{
get { return _LdfParserState; }
set { _LdfParserState = value; RaisePropertyChanged(); }
}
/// <summary>
/// LDFHandle
/// </summary>
public UInt64 LDFHandle { get; set; }
/// <summary>
/// LDF消息集合
/// 包括读取的实时值和数据
/// </summary>
public ObservableCollection<LinLdfModel> ListLinLdfModel { get; set; } = new ObservableCollection<LinLdfModel>();
/// <summary>
/// 要发送的LIN数据
/// </summary>
public List<LinCmdData> CmdData { get; set; } = new List<LinCmdData>();
/// <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】*********************
/// 解析LDF信息
/// </summary>
/// <returns></returns>
public void LDF_Parser(string Path)
{
LDFHandle = LDFParser.LDF_ParserFile(DevHandle, LINIndex, 1, new StringBuilder(Path));
if (LDFHandle == 0)
{
Console.WriteLine("解析LDF文件失败!");
LdfParserState = false;
return;
}
//读取LDF文件信息
Console.WriteLine("ProtocolVersion = {0}", LDFParser.LDF_GetProtocolVersion(LDFHandle));
Console.WriteLine("LINSpeed = {0}", LDFParser.LDF_GetLINSpeed(LDFHandle));
//读取主机名称
StringBuilder MasterName = new StringBuilder(64);
LDFParser.LDF_GetMasterName(LDFHandle, MasterName);
Console.WriteLine("Master Name = {0}", MasterName);
ListLinLdfModel.Clear();
//读取信息
int FrameLen = LDFParser.LDF_GetFrameQuantity(LDFHandle);
for (int i = 0; i < FrameLen; i++)
{
//读取帧名称和发布者
StringBuilder FrameName = new StringBuilder(64);
string IsMasterFrame = "";
if (LDFParser.LDF_PARSER_OK == LDFParser.LDF_GetFrameName(LDFHandle, i, FrameName))
{
StringBuilder PublisherName = new StringBuilder(64);
LDFParser.LDF_GetFramePublisher(LDFHandle, FrameName, PublisherName);
if (MasterName.Equals(PublisherName))
{
IsMasterFrame = "是";
//当前帧为主机发送数据帧
Console.WriteLine("[MW]Frame[{0}].Name={1},Publisher={2}", i, FrameName, PublisherName);
}
else
{
IsMasterFrame = "否";
//当前帧为主机读数据帧
Console.WriteLine("[MR]Frame[{0}].Name={1},Publisher={2}", i, FrameName, PublisherName);
}
//读取信号信息
int SignalNum = LDFParser.LDF_GetFrameSignalQuantity(LDFHandle, FrameName);
for (int j = 0; j < SignalNum; j++)
{
StringBuilder SignalName = new StringBuilder(64);
if (LDFParser.LDF_PARSER_OK == LDFParser.LDF_GetFrameSignalName(LDFHandle, FrameName, j, SignalName))
{
Console.WriteLine("\tSignal[{0}].Name={1}", j, SignalName);
ListLinLdfModel.Add(new LinLdfModel()
{
MsgName = FrameName.ToString(),
Publisher = PublisherName.ToString(),
IsMasterFrame = IsMasterFrame,
SignalName = SignalName.ToString()
});
}
}
}
}
//解析成功
LdfParserState = true;
}
/// <summary>
/// 发送LIN数据
/// 发送一次
/// </summary>
public void SendLinMsg(List<LinCmdData> CmdData)
{
try
{
//防止有多个不同的消息名称/帧，每个帧单独处理发送
var GroupMsg = CmdData.GroupBy(x => x.MsgName);
foreach (var itemMsg in GroupMsg)
{
foreach (var itemSignal in itemMsg)
{
//主机写操作，发送数据给从机
LDFParser.LDF_SetSignalValue(LDFHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
}
LDFParser.LDF_ExeFrameToBus(LDFHandle, new StringBuilder(itemMsg.Key), 1);
}
}
catch (Exception ex)
{
}
}
/// <summary>
/// 读取信号值
/// </summary>
private StringBuilder ReadValueStr = new StringBuilder(64);
/// <summary>
/// 循环
/// 主机读操作，读取从机返回的数据值
/// </summary>
public void StartCycleReviceMsg()
{
CycleReviceTask = Task.Run(async () =>
{
while (IsCycleRevice)
{
await Task.Delay(ReviceCycle);
try
{
//主机读操作，读取从机返回的数据值
foreach (var item in ListLinLdfModel)
{
LDFParser.LDF_ExeFrameToBus(LDFHandle, new StringBuilder(item.MsgName), 1);
LDFParser.LDF_GetSignalValueStr(LDFHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ReadValueStr);
item.SignalRtValueSb = ReadValueStr;
}
//StringBuilder ValueStr = new StringBuilder(64);
//LDFParser.LDF_ExeFrameToBus(LDFHandle, new StringBuilder("ID_DATA"), 1);
//LDFParser.LDF_GetSignalValueStr(LDFHandle, new StringBuilder("ID_DATA"), new StringBuilder("Supplier_ID"), ValueStr);
//Console.WriteLine("ID_DATA.Supplier_ID={0}", ValueStr);
//LDFParser.LDF_GetSignalValueStr(LDFHandle, new StringBuilder("ID_DATA"), new StringBuilder("Machine_ID"), ValueStr);
//Console.WriteLine("ID_DATA.Machine_ID={0}", ValueStr);
//LDFParser.LDF_GetSignalValueStr(LDFHandle, new StringBuilder("ID_DATA"), new StringBuilder("Chip_ID"), ValueStr);
//Console.WriteLine("ID_DATA.Chip_ID={0}", ValueStr);
}
catch (Exception ex)
{
//LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
}
}
});
}
/// <summary>
/// 循环发送数据
/// </summary>
public void StartCycleSendMsg()
{
CycleSendTask = Task.Run(async () =>
{
while (IsCycleSend)
{
await Task.Delay(SendCycle);
try
{
//防止有多个不同的消息名称/帧，每个帧单独处理发送
var GroupMsg = CmdData.GroupBy(x => x.MsgName);
foreach (var itemMsg in GroupMsg)
{
foreach (var itemSignal in itemMsg)
{
//主机写操作，发送数据给从机
LDFParser.LDF_SetSignalValue(LDFHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
}
LDFParser.LDF_ExeFrameToBus(LDFHandle, new StringBuilder(itemMsg.Key), 1);
}
////主机写操作，发送数据给从机
//LDFParser.LDF_SetSignalValue(LDFHandle, new StringBuilder("LIN_CONTROL"), new StringBuilder("Reg_Set_Voltage"), 13.5);
//LDFParser.LDF_SetSignalValue(LDFHandle, new StringBuilder("LIN_CONTROL"), new StringBuilder("Ramp_Time"), 3);
//LDFParser.LDF_SetSignalValue(LDFHandle, new StringBuilder("LIN_CONTROL"), new StringBuilder("Cut_Off_Speed"), 4);
//LDFParser.LDF_SetSignalValue(LDFHandle, new StringBuilder("LIN_CONTROL"), new StringBuilder("Exc_Limitation"), 15.6);
//LDFParser.LDF_SetSignalValue(LDFHandle, new StringBuilder("LIN_CONTROL"), new StringBuilder("Derat_Shift"), 2);
//LDFParser.LDF_SetSignalValue(LDFHandle, new StringBuilder("LIN_CONTROL"), new StringBuilder("MM_Request"), 2);
//LDFParser.LDF_SetSignalValue(LDFHandle, new StringBuilder("LIN_CONTROL"), new StringBuilder("Reg_Blind"), 1);
}
catch (Exception ex)
{
//LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
}
}
});
}
/// <summary>
/// 关闭设备
/// </summary>
public void CloseDevice()
{
//关闭设备
USB_DEVICE.USB_CloseDevice(DevHandle);
OpenState = false;
LdfParserState = false;
IsCycleRevice = false;
IsCycleSend = false;
}
}
}

106
CapMachine.Wpf/LinDrive/USB2LIN_EX.cs Normal file
View File

@@ -0,0 +1,106 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace CapMachine.Wpf.LinDrive
{
//注意：使用这些函数需要1.5.30及以上的固件才支持
public class USB2LIN_EX
{
//定义函数返回错误代码
public const Int32 LIN_EX_SUCCESS = (0); //函数执行成功
public const Int32 LIN_EX_ERR_NOT_SUPPORT = (-1); //适配器不支持该函数
public const Int32 LIN_EX_ERR_USB_WRITE_FAIL = (-2); //USB写数据失败
public const Int32 LIN_EX_ERR_USB_READ_FAIL = (-3); //USB读数据失败
public const Int32 LIN_EX_ERR_CMD_FAIL = (-4); //命令执行失败
public const Int32 LIN_EX_ERR_CH_NO_INIT = (-5); //该通道未初始化
public const Int32 LIN_EX_ERR_READ_DATA = (-6); //LIN读数据失败
//LIN和校验模式
public const Byte LIN_EX_CHECK_STD = 0; //标准校验，不含PID
public const Byte LIN_EX_CHECK_EXT = 1; //增强校验，包含PID
public const Byte LIN_EX_CHECK_USER = 2; //自定义校验类型，需要用户自己计算并传入Check，不进行自动校验
public const Byte LIN_EX_CHECK_NONE = 3; //接收数据校验错误
public const Byte LIN_EX_CHECK_ERROR = 4; //接收数据校验错误
//定义主从模式
public const Byte LIN_EX_MASTER = 1;//主机
public const Byte LIN_EX_SLAVE = 0;//从机
public const Byte LIN_EX_MSG_TYPE_UN = 0; //未知类型
public const Byte LIN_EX_MSG_TYPE_MW = 1; //主机向从机发送数据
public const Byte LIN_EX_MSG_TYPE_MR = 2; //主机从从机读取数据
public const Byte LIN_EX_MSG_TYPE_SW = 3; //从机发送数据
public const Byte LIN_EX_MSG_TYPE_SR = 4; //从机接收数据
public const Byte LIN_EX_MSG_TYPE_BK = 5; //只发送BREAK信号，若是反馈回来的数据，表明只检测到BREAK信号
public const Byte LIN_EX_MSG_TYPE_SY = 6; //表明检测到了BREAK，SYNC信号
public const Byte LIN_EX_MSG_TYPE_ID = 7; //表明检测到了BREAK，SYNC，PID信号
public const Byte LIN_EX_MSG_TYPE_DT = 8; //表明检测到了BREAK，SYNC，PID,DATA信号
public const Byte LIN_EX_MSG_TYPE_CK = 9; //表明检测到了BREAK，SYNC，PID,DATA,CHECK信号
//LIN数据帧格式定义
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct LIN_EX_MSG
{
[MarshalAs(UnmanagedType.U4)]
public UInt32 Timestamp; //时间戳
[MarshalAs(UnmanagedType.U1)]
public Byte MsgType; //帧类型
[MarshalAs(UnmanagedType.U1)]
public Byte CheckType; //校验类型
[MarshalAs(UnmanagedType.U1)]
public Byte DataLen; //LIN数据段有效数据字节数
[MarshalAs(UnmanagedType.U1)]
public Byte Sync; //固定值，0x55
[MarshalAs(UnmanagedType.U1)]
public Byte PID; //帧ID
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8, ArraySubType = UnmanagedType.U1)]
public Byte[] Data; //数据
[MarshalAs(UnmanagedType.U1)]
public Byte Check; //校验,只有校验数据类型为LIN_EX_CHECK_USER的时候才需要用户传入数据
[MarshalAs(UnmanagedType.U1)]
public Byte BreakBits; //该帧的BRAK信号位数，有效值为10到26，若设置为其他值则默认为13位
[MarshalAs(UnmanagedType.U1)]
public Byte Reserve1;
}
//初始化
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_Init(Int32 DevHandle, Byte LINIndex, Int32 BaudRate, Byte MasterMode);
//主机模式操作函数
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_MasterSync(Int32 DevHandle, Byte LINIndex, LIN_EX_MSG[] pInMsg, IntPtr pOutMsg, Int32 MsgLen);
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_MasterBreak(Int32 DevHandle, Byte LINIndex);
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_MasterWrite(Int32 DevHandle, Byte LINIndex, Byte PID, Byte[] pData, Byte DataLen, Byte CheckType);
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_MasterRead(Int32 DevHandle, Byte LINIndex, Byte PID, Byte[] pData);
//从机模式操作函数
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_SlaveSetIDMode(Int32 DevHandle, Byte LINIndex, LIN_EX_MSG[] pLINMsg, Int32 MsgLen);
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_SlaveGetIDMode(Int32 DevHandle, Byte LINIndex, IntPtr pLINMsg);
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_SlaveGetData(Int32 DevHandle, Byte LINIndex, IntPtr pLINMsg);
//电源控制相关函数
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_CtrlPowerOut(Int32 DevHandle, Byte LINIndex, Byte State);
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_GetVbatValue(Int32 DevHandle, Int16[] pBatValue);
//主机模式自动发送数据相关函数
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_MasterStartSch(Int32 DevHandle, Byte LINIndex, LIN_EX_MSG[] pLINMsg, Int32 MsgLen);
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_MasterStopSch(Int32 DevHandle, Byte LINIndex);
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_MasterGetSch(Int32 DevHandle, Byte LINIndex, IntPtr pLINMsg);
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_MasterOfflineSch(Int32 DevHandle, Byte LINIndex, Int32 BaudRate, LIN_EX_MSG[] pLINMsg, Int32 MsgLen);
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_DecodeListFile(string pFileName, Byte CheckType, Int32 BaudRate, Byte[] pReadDataList, Byte ReadDataListLen, Byte[] pCheckTypeList, Byte CheckTypeListLen);
[DllImport("USB2XXX.dll")]
public static extern Int32 LIN_EX_GetListFileMsg(Int32 MsgIndex, Int32 MsgLen, IntPtr pLINMsg);
}
}

140
CapMachine.Wpf/LinDrive/USB_DEVICE.cs Normal file
View File

@@ -0,0 +1,140 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace CapMachine.Wpf.LinDrive
{
public class USB_DEVICE
{
//定义电压输出值
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);
}
}