930 lines
41 KiB
C#
930 lines
41 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Drawing;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Runtime.InteropServices;
|
||
using System.Security.Cryptography.X509Certificates;
|
||
using System.Text;
|
||
using System.Threading;
|
||
|
||
using ZLGAPI;
|
||
|
||
namespace USBCANFD
|
||
{
|
||
|
||
internal class Program
|
||
{
|
||
public static IntPtr devHandle = IntPtr.Zero; // 设备句柄
|
||
public static IntPtr[] chnHandle = new IntPtr[10]; // 通道句柄
|
||
public static int chn_max = 2; // 最大通道数量
|
||
public static volatile bool isRunning = true; // 线程标志
|
||
public static uint isMerge = 0; // 合并接收标志
|
||
public static uint isBusload = 0; // 通道利用率使能
|
||
|
||
// 线程传递参数
|
||
class ThreadParams
|
||
{
|
||
public IntPtr dev { get; set; } // 设备句柄
|
||
public IntPtr chn { get; set; } // 通道句柄
|
||
public int chnNum { get; set; } // 通道号
|
||
}
|
||
class ThreadBusload
|
||
{
|
||
public IntPtr dev { get; set; } // 设备句柄
|
||
public int chnNum { get; set; } // 通道号
|
||
}
|
||
|
||
static void Main(string[] args)
|
||
{
|
||
uint ret; // 返回值
|
||
|
||
// 打开设备 方式一：通过索引顺序打开设备
|
||
Program.devHandle = ZLGCAN.ZCAN_OpenDevice(ZLGCAN.ZCAN_USBCANFD_200U, 0, 0);
|
||
if (Program.devHandle == IntPtr.Zero)
|
||
{
|
||
Console.WriteLine("打开设备失败");
|
||
Console.ReadKey();
|
||
return;
|
||
}
|
||
else
|
||
Console.WriteLine("打开设备成功");
|
||
|
||
// 打开设备 方式二：通过自定义序列号打开设备，需要首先执行SN_test函数设置自定义序列号
|
||
//Program.devHandle = ZLGCAN.ZCAN_OpenDeviceByName(ZLGCAN.ZCAN_USBCANFD_200U, "C#01");
|
||
//if (Program.devHandle == IntPtr.Zero)
|
||
//{
|
||
// Console.WriteLine("打开设备失败");
|
||
// Console.ReadKey();
|
||
// return;
|
||
//}
|
||
//else
|
||
// Console.WriteLine("打开设备成功");
|
||
|
||
//// 获取设备信息
|
||
//ZLGCAN.ZCAN_DEVICE_INFO info = new ZLGCAN.ZCAN_DEVICE_INFO();
|
||
//IntPtr P2Info = Marshal.AllocHGlobal(Marshal.SizeOf(info));
|
||
//if (1 == ZLGCAN.ZCAN_GetDeviceInf(Program.devHandle, P2Info))
|
||
//{
|
||
// info = (ZLGCAN.ZCAN_DEVICE_INFO)Marshal.PtrToStructure(P2Info, typeof(ZLGCAN.ZCAN_DEVICE_INFO));
|
||
// Console.WriteLine("设备型号 {0}，设备固件版本 {1:X}", new string(info.str_hw_Type).TrimEnd('\0'), info.fw_Version);
|
||
//}
|
||
|
||
//// 自定义序列号
|
||
//SN_test(Program.devHandle);
|
||
|
||
// 该函数用于检测设备是否在线
|
||
//uint status = ZLGCAN.ZCAN_IsDeviceOnLine(Program.devHandle);
|
||
//Console.WriteLine("设备状态{0}",
|
||
// status == 0 ? "ERR" :
|
||
// status == 1 ? "OK" :
|
||
// status == 2 ? "ONLINE" :
|
||
// status == 3 ? "OFFLINE" :
|
||
// status == 4 ? "UNSUPPORTED" :
|
||
// status == 5 ? "BUFFER_TOO_SMALL" : "UNKNOW");
|
||
|
||
// 初始化并打开通道
|
||
for (int i = 0; i < Program.chn_max; i++)
|
||
{
|
||
Program.chnHandle[i] = Init_chn_USBCANFD(Program.devHandle, i); // 必须初始化完一个通道，再走另外一个通道！！！
|
||
if (Program.chnHandle[i] == IntPtr.Zero)
|
||
return;
|
||
}
|
||
|
||
// 接收线程处理
|
||
if (Program.isMerge == 1) // 合并接收
|
||
{
|
||
// 设置合并接收
|
||
ret = ZLGCAN.ZCAN_SetValue(Program.devHandle, "0/set_device_recv_merge", "1");
|
||
if (ret != 1)
|
||
{
|
||
Console.WriteLine("设置合并接收失败");
|
||
Console.ReadKey();
|
||
}
|
||
ThreadParams parameters = new ThreadParams
|
||
{
|
||
dev = Program.devHandle,
|
||
chnNum = 0
|
||
};
|
||
Thread workerThread = new Thread(ReceiveThread_Merge);
|
||
workerThread.IsBackground = true; // 设置为后台线程，不需要join
|
||
workerThread.Start(parameters); // 启动线程
|
||
}
|
||
else // 普通接收
|
||
{
|
||
// 关闭合并接收
|
||
ret = ZLGCAN.ZCAN_SetValue(Program.devHandle, "0/set_device_recv_merge", "0");
|
||
if (ret != 1)
|
||
{
|
||
Console.WriteLine("关闭合并接收失败");
|
||
Console.ReadKey();
|
||
}
|
||
for (int i = 0; i < Program.chn_max; i++)
|
||
{
|
||
ThreadParams parameters = new ThreadParams
|
||
{
|
||
chn = Program.chnHandle[i],
|
||
chnNum = i
|
||
};
|
||
Thread workerThread = new Thread(ReceiveThread); // 每通道独立线程接收
|
||
workerThread.IsBackground = true; // 设置为后台线程，不需要join
|
||
workerThread.Start(parameters); // 启动线程
|
||
}
|
||
}
|
||
|
||
if (Program.isBusload == 1) // 通道利用率
|
||
{
|
||
ThreadBusload Busload = new ThreadBusload
|
||
{
|
||
dev = Program.devHandle,
|
||
chnNum = 0
|
||
};
|
||
Thread ThreadBusload = new Thread(Thread_Busload);
|
||
ThreadBusload.IsBackground = true; // 设置为后台线程，不需要join
|
||
ThreadBusload.Start(Busload); // 启动线程
|
||
}
|
||
|
||
// 发送示例
|
||
Send_test(Program.chnHandle[0]);
|
||
//Send_test_Merge(Program.devHandle);
|
||
|
||
//// 定时发送
|
||
//AutoSend_test(Program.devHandle, 0);
|
||
|
||
//// 队列发送
|
||
//QueueSend_test(Program.devHandle, Program.chnHandle[0]);
|
||
|
||
// 阻塞等待
|
||
Console.ReadKey();
|
||
Program.isRunning = false;
|
||
|
||
// 关闭通道
|
||
for (int i = 0; i < Program.chn_max; i++)
|
||
{
|
||
ret = ZLGCAN.ZCAN_ResetCAN(Program.chnHandle[i]);
|
||
if (ret != 1)
|
||
Console.WriteLine("关闭通道{0}失败", i);
|
||
}
|
||
|
||
// 关闭设备
|
||
ret = ZLGCAN.ZCAN_CloseDevice(Program.devHandle);
|
||
if (ret != 1)
|
||
{
|
||
Console.WriteLine("关闭设备失败");
|
||
Console.ReadKey();
|
||
return;
|
||
}
|
||
}
|
||
|
||
// 初始化CAN通道
|
||
static IntPtr Init_chn_USBCANFD(IntPtr dev, int chn_idx)
|
||
{
|
||
IntPtr temp = IntPtr.Zero;
|
||
uint ret; // 返回值
|
||
|
||
// 仲裁域波特率
|
||
string path = String.Format("{0}/canfd_abit_baud_rate", chn_idx);
|
||
ret = ZLGCAN.ZCAN_SetValue(dev, path, "500000"); // 500k
|
||
if (ret != 1)
|
||
{
|
||
Console.WriteLine("设置仲裁域波特率失败");
|
||
Console.ReadKey();
|
||
return IntPtr.Zero;
|
||
}
|
||
|
||
// 数据域波特率
|
||
path = String.Format("{0}/canfd_dbit_baud_rate", chn_idx);
|
||
ret = ZLGCAN.ZCAN_SetValue(dev, path, "2000000"); // 2M
|
||
if (ret != 1)
|
||
{
|
||
Console.WriteLine("设置数据域波特率失败");
|
||
Console.ReadKey();
|
||
return IntPtr.Zero;
|
||
}
|
||
|
||
// 终端电阻
|
||
path = String.Format("{0}/initenal_resistance", chn_idx);
|
||
string resistance = "1";//1-使能 0-禁能
|
||
ret = ZLGCAN.ZCAN_SetValue(dev, path, resistance);
|
||
if (ret != 1)
|
||
{
|
||
Console.WriteLine("设置终端电阻失败");
|
||
Console.ReadKey();
|
||
return IntPtr.Zero;
|
||
}
|
||
|
||
// 初始化通道
|
||
ZLGCAN.ZCAN_CHANNEL_INIT_CONFIG InitConfig = new ZLGCAN.ZCAN_CHANNEL_INIT_CONFIG(); // 结构体
|
||
InitConfig.can_type = 1; // 1 - CANFD (USBCANFD 只能选择CANFD模式)
|
||
InitConfig.config.canfd.mode = 0; // 0 - 正常模式，1 - 只听模式
|
||
|
||
IntPtr P2InitConfig = Marshal.AllocHGlobal(Marshal.SizeOf(InitConfig));
|
||
Marshal.StructureToPtr(InitConfig, P2InitConfig, true); // 转成指针
|
||
temp = ZLGCAN.ZCAN_InitCAN(dev, (uint)chn_idx, P2InitConfig);
|
||
Marshal.FreeHGlobal(P2InitConfig); // 释放内存
|
||
if (temp == IntPtr.Zero)
|
||
{
|
||
Console.WriteLine("初始化通道失败");
|
||
Console.ReadKey();
|
||
return IntPtr.Zero;
|
||
}
|
||
Console.WriteLine("初始化通道成功");
|
||
|
||
//// 设置滤波
|
||
//value = "0"; // 0-标准帧 1-扩展帧
|
||
// path = String.Format("{0}/filter_mode", chn_idx);
|
||
// ret = ZLGCAN.ZCAN_SetValue(deviceHandle, path, value);
|
||
|
||
// value = "0x731"; // 起始 ID
|
||
// path = String.Format("{0}/filter_start", chn_idx);
|
||
// ret = ZLGCAN.ZCAN_SetValue(deviceHandle, path, value);
|
||
|
||
// value = "0x7DF"; // 结束 ID
|
||
// path = String.Format("{0}/filter_end", chn_idx);
|
||
// ret = ZLGCAN.ZCAN_SetValue(deviceHandle, path, value);
|
||
|
||
// value = "0"; // 使能滤波
|
||
// path = String.Format("{0}/filter_ack", chn_idx);
|
||
// ret = ZLGCAN.ZCAN_SetValue(deviceHandle, path, value);
|
||
// if (ret != 1)
|
||
// {
|
||
// Console.WriteLine("使能滤波失败");
|
||
// Console.ReadKey();
|
||
// return IntPtr.Zero;
|
||
// }
|
||
|
||
if (Program.isBusload == 1) // 通道利用率
|
||
{
|
||
// 通道利用率上报
|
||
path = String.Format("{0}/set_bus_usage_enable", chn_idx);
|
||
ret = ZLGCAN.ZCAN_SetValue(dev, path, "1");
|
||
|
||
// 总线利用率上报周期
|
||
path = String.Format("{0}/set_bus_usage_period", chn_idx);
|
||
ret = ZLGCAN.ZCAN_SetValue(dev, path, "500");
|
||
}
|
||
|
||
//打开通道
|
||
uint Ret = ZLGCAN.ZCAN_StartCAN(temp);
|
||
if (Ret != 1)
|
||
{
|
||
Console.WriteLine("打开通道失败");
|
||
Console.ReadKey();
|
||
return IntPtr.Zero;
|
||
}
|
||
Console.WriteLine("打开通道成功");
|
||
return temp;
|
||
}
|
||
|
||
// 总线利用率
|
||
static void Thread_Busload(object obj)
|
||
{
|
||
ThreadBusload parameters = (ThreadBusload)obj;
|
||
while (Program.isRunning)
|
||
{
|
||
IntPtr pUse = ZLGCAN.ZCAN_GetValue(Program.devHandle, parameters.chnNum +"/get_bus_usage/1" );
|
||
if (pUse != IntPtr.Zero)
|
||
{
|
||
ZLGCAN.BusUsage busUsage = (ZLGCAN.BusUsage)Marshal.PtrToStructure(pUse, typeof(ZLGCAN.BusUsage));
|
||
Console.WriteLine("总线利用率: {0}%，{1}帧/秒", busUsage.nBusUsage / 100, busUsage.nFrameCount);
|
||
}
|
||
Thread.Sleep(500);
|
||
}
|
||
}
|
||
|
||
// 接收线程
|
||
static void ReceiveThread(object obj)
|
||
{
|
||
ThreadParams parameters = obj as ThreadParams;
|
||
if (parameters == null) return;
|
||
|
||
// 配置缓冲区大小
|
||
const int BUFFER_SIZE = 100;
|
||
|
||
// 预计算结构体大小
|
||
int canStructSize = Marshal.SizeOf(typeof(ZLGCAN.ZCAN_Receive_Data));
|
||
int canfdStructSize = Marshal.SizeOf(typeof(ZLGCAN.ZCAN_ReceiveFD_Data));
|
||
|
||
// 分配非托管内存（循环外一次分配，复用避免频繁申请释放）
|
||
IntPtr pCanBuffer = Marshal.AllocHGlobal(canStructSize * BUFFER_SIZE); // CAN接收缓冲区
|
||
IntPtr pCanfdBuffer = Marshal.AllocHGlobal(canfdStructSize * BUFFER_SIZE); // CANFD接收缓冲区
|
||
|
||
try
|
||
{
|
||
while (Program.isRunning)
|
||
{
|
||
uint recNum = ZLGCAN.ZCAN_GetReceiveNum(parameters.chn, 0); // 0-CAN
|
||
if (recNum > 0)
|
||
{
|
||
// 限制接收数量不超过缓冲区大小（双重保险）
|
||
uint actualReceive = ZLGCAN.ZCAN_Receive(
|
||
parameters.chn,
|
||
pCanBuffer, // 传入非托管缓冲区指针（C风格）
|
||
BUFFER_SIZE,
|
||
10
|
||
);
|
||
|
||
if (actualReceive > 0)
|
||
{
|
||
for (int i = 0; i < actualReceive; i++)
|
||
{
|
||
// 计算当前CAN数据的指针
|
||
IntPtr pCurrentCan = (IntPtr)(pCanBuffer.ToInt64() + i * canStructSize);
|
||
|
||
// 非托管内存转换为C#结构体
|
||
ZLGCAN.ZCAN_Receive_Data recData = (ZLGCAN.ZCAN_Receive_Data)Marshal.PtrToStructure(
|
||
pCurrentCan,
|
||
typeof(ZLGCAN.ZCAN_Receive_Data)
|
||
);
|
||
|
||
// 可选：ID过滤
|
||
// uint canId = recData.frame.can_id & 0x1FFFFFFF;
|
||
// if (canId != 0x731 && canId != 0x7B1)
|
||
// continue;
|
||
|
||
// 通道号和时间戳
|
||
Console.Write(String.Format("CHN:{0} [{1}] CAN ", parameters.chnNum, recData.timestamp));
|
||
|
||
// 帧类型（标准/扩展）
|
||
Console.Write((recData.frame.can_id & (1 << 31)) != 0 ? "扩展帧 " : "标准帧 ");
|
||
|
||
// 方向（Tx/Rx）
|
||
Console.Write((recData.frame.__pad & 0x20) == 0x20 ? "Tx " : "Rx ");
|
||
|
||
// 数据长度校验
|
||
int dataLen = Math.Min(recData.frame.can_dlc, recData.frame.data != null ? recData.frame.data.Length : 0);
|
||
|
||
// ID和数据（保留原格式）
|
||
Console.WriteLine(String.Format("ID:{0:X} {1}",
|
||
recData.frame.can_id & 0x1FFFFFFF,
|
||
Program.b_array2string(recData.frame.data, dataLen)
|
||
));
|
||
}
|
||
}
|
||
}
|
||
|
||
recNum = ZLGCAN.ZCAN_GetReceiveNum(parameters.chn, 1); // 1-CANFD
|
||
if (recNum > 0)
|
||
{
|
||
uint actualReceive = ZLGCAN.ZCAN_ReceiveFD(
|
||
parameters.chn,
|
||
pCanfdBuffer, // CANFD非托管缓冲区指针
|
||
BUFFER_SIZE,
|
||
10
|
||
);
|
||
|
||
if (actualReceive > 0)
|
||
{
|
||
for (int i = 0; i < actualReceive; i++)
|
||
{
|
||
// 计算当前CANFD数据的指针
|
||
IntPtr pCurrentCanfd = (IntPtr)(pCanfdBuffer.ToInt64() + i * canfdStructSize);
|
||
// 非托管内存转换为C#结构体
|
||
ZLGCAN.ZCAN_ReceiveFD_Data recFDData = (ZLGCAN.ZCAN_ReceiveFD_Data)Marshal.PtrToStructure(
|
||
pCurrentCanfd,
|
||
typeof(ZLGCAN.ZCAN_ReceiveFD_Data)
|
||
);
|
||
|
||
// 通道号和时间戳
|
||
Console.Write(String.Format("CHN:{0} [{1}] CANFD", parameters.chnNum, recFDData.timestamp));
|
||
|
||
// CANFD加速标志
|
||
if ((recFDData.frame.flags & 0x01) == 0x01)
|
||
Console.Write("加速");
|
||
|
||
// 帧类型（标准/扩展）
|
||
Console.Write((recFDData.frame.can_id & (1 << 31)) != 0 ? " 扩展帧" : " 标准帧");
|
||
|
||
// 方向（Tx/Rx）
|
||
Console.Write((recFDData.frame.flags & 0x20) == 0x20 ? " Tx " : " Rx ");
|
||
|
||
// 数据长度校验
|
||
int dataLen = Math.Min(recFDData.frame.len, recFDData.frame.data != null ? recFDData.frame.data.Length : 0);
|
||
|
||
// ID和数据
|
||
Console.WriteLine(String.Format("ID:{0:X} {1}",
|
||
recFDData.frame.can_id & 0x1FFFFFFF,
|
||
Program.b_array2string(recFDData.frame.data, dataLen)
|
||
));
|
||
}
|
||
}
|
||
}
|
||
|
||
ZLGAPI.ZLGCAN.ZCAN_CHANNEL_ERR_INFO errData = new ZLGAPI.ZLGCAN.ZCAN_CHANNEL_ERR_INFO{
|
||
error_code = 0,
|
||
passive_ErrData = new byte[3],
|
||
arLost_ErrData = 0
|
||
};
|
||
uint ret = ZLGAPI.ZLGCAN.ZCAN_ReadChannelErrInfo(parameters.chn, ref errData);
|
||
Analyze_err_frame(errData);
|
||
|
||
Thread.Sleep(10);
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
// 确保非托管内存必释放
|
||
Marshal.FreeHGlobal(pCanfdBuffer);
|
||
Marshal.FreeHGlobal(pCanBuffer);
|
||
}
|
||
}
|
||
|
||
// 接收线程（合并接收）
|
||
static void ReceiveThread_Merge(object obj)
|
||
{
|
||
ThreadParams parameters = (ThreadParams)obj;
|
||
|
||
// 预计算结构体大小
|
||
int dataObjSize = Marshal.SizeOf(typeof(ZLGCAN.ZCANDataObj));
|
||
int canfdSize = Marshal.SizeOf(typeof(ZLGCAN.ZCANCANFDData));
|
||
int linSize = Marshal.SizeOf(typeof(ZLGCAN.ZCANLINData));
|
||
|
||
// 分配非托管内存（循环外分配，复用避免频繁申请释放）
|
||
IntPtr pDataObjs = Marshal.AllocHGlobal(dataObjSize * 100); // 写死100个最大，可以面对绝大部分情况，如果是动态长度容易崩溃
|
||
IntPtr pCanfdBuffer = Marshal.AllocHGlobal(canfdSize);
|
||
IntPtr pLinBuffer = Marshal.AllocHGlobal(linSize);
|
||
try
|
||
{
|
||
while (Program.isRunning)
|
||
{
|
||
// 获取待接收数据量，无数据则休眠后继续
|
||
uint recvNum = ZLGCAN.ZCAN_GetReceiveNum(parameters.dev, 2);
|
||
if (recvNum == 0)
|
||
{
|
||
Thread.Sleep(10);
|
||
continue;
|
||
}
|
||
|
||
// 接收数据
|
||
uint actualRecv = ZLGCAN.ZCAN_ReceiveData(parameters.dev, pDataObjs, 100, 10);
|
||
if (actualRecv == 0)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 遍历处理每个接收的数据
|
||
for (int i = 0; i < actualRecv; i++)
|
||
{
|
||
// 计算当前数据对象指针
|
||
IntPtr pCurrentData = (IntPtr)(pDataObjs.ToInt64() + i * dataObjSize);
|
||
ZLGCAN.ZCANDataObj dataObj = (ZLGCAN.ZCANDataObj)Marshal.PtrToStructure(pCurrentData, typeof(ZLGCAN.ZCANDataObj));
|
||
|
||
// 根据数据类型处理
|
||
switch (dataObj.dataType)
|
||
{
|
||
case 1: // CAN/CANFD
|
||
|
||
// 复制data到非托管缓冲区
|
||
Marshal.Copy(dataObj.data, 0, pCanfdBuffer, canfdSize);
|
||
ZLGCAN.ZCANCANFDData canfdData = (ZLGCAN.ZCANCANFDData)Marshal.PtrToStructure(pCanfdBuffer, typeof(ZLGCAN.ZCANCANFDData));
|
||
|
||
//// 可选：ID过滤（调试用）
|
||
//uint canId = canfdData.frame.can_id & 0x1FFFFFFF;
|
||
//if (canId != 0x731 && canId != 0x7B1)
|
||
// continue;
|
||
|
||
// 通道和时间戳
|
||
Console.Write(String.Format("CHN:{0} [{1}] ", dataObj.chnl, canfdData.timeStamp));
|
||
|
||
// CAN/CANFD类型 + 加速标志
|
||
if ((canfdData.flag & 1) == 0)
|
||
Console.Write("CAN");
|
||
else
|
||
{
|
||
Console.Write("CANFD");
|
||
if ((canfdData.frame.flags & 1) == 1)
|
||
Console.Write("加速");
|
||
}
|
||
|
||
// 帧类型（标准/扩展）
|
||
Console.Write((canfdData.frame.can_id & (1 << 31)) != 0 ? " 扩展帧 " : " 标准帧 ");
|
||
// 方向（TX/RX）
|
||
Console.Write((canfdData.flag & (1 << 9)) != 0 ? "TX " : "RX ");
|
||
// ID
|
||
Console.Write(String.Format("ID:{0:X} ", canfdData.frame.can_id & 0x1FFFFFFF));
|
||
|
||
// 打印数据
|
||
int canDataLen = Math.Min(canfdData.frame.len, canfdData.frame.data != null ? canfdData.frame.data.Length : 0);
|
||
for (int j = 0; j < canDataLen; j++)
|
||
Console.Write(String.Format("{0:X2} ", canfdData.frame.data[j]));
|
||
Console.WriteLine();
|
||
break;
|
||
|
||
case 4: // LIN
|
||
// 校验数据长度足够，避免越界复制
|
||
if (dataObj.data.Length < linSize)
|
||
break;
|
||
|
||
// 直接复制data到非托管缓冲区
|
||
Marshal.Copy(dataObj.data, 0, pLinBuffer, linSize);
|
||
ZLGCAN.ZCANLINData linData = (ZLGCAN.ZCANLINData)Marshal.PtrToStructure(pLinBuffer, typeof(ZLGCAN.ZCANLINData));
|
||
|
||
// 拼接打印信息
|
||
Console.Write(String.Format("CHN:{0} [{1}] PID:{2:X} ",
|
||
dataObj.chnl, linData.rxData.timeStamp, linData.pid.rawVal & 0x3F));
|
||
|
||
// 方向（TX/RX）
|
||
Console.Write(linData.rxData.dir == 1 ? "TX Data: " : "RX Data: ");
|
||
|
||
// 打印数据
|
||
int linDataLen = Math.Min(linData.rxData.datalen, linData.rxData.data != null ? linData.rxData.data.Length : 0);
|
||
for (int j = 0; j < linDataLen; j++)
|
||
Console.Write(String.Format("{0:X2} ", linData.rxData.data[j]));
|
||
Console.WriteLine();
|
||
break;
|
||
|
||
case 6: // LIN错误
|
||
Console.WriteLine("LIN 错误");
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
// 确保非托管内存必释放（避免泄漏）
|
||
Marshal.FreeHGlobal(pLinBuffer);
|
||
Marshal.FreeHGlobal(pCanfdBuffer);
|
||
Marshal.FreeHGlobal(pDataObjs);
|
||
}
|
||
}
|
||
|
||
// 发送示例
|
||
static void Send_test(IntPtr chnHandle)
|
||
{
|
||
// CAN
|
||
ZLGCAN.ZCAN_Transmit_Data[] can_data = new ZLGCAN.ZCAN_Transmit_Data[10];
|
||
IntPtr p2CanData = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZLGCAN.ZCAN_Transmit_Data)) * 10);
|
||
byte[] sourceData = new byte[] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 ,0x77,0x88};
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
can_data[i].frame = new ZLGCAN.can_frame();
|
||
can_data[i].transmit_type = 0; // 0-正常发送
|
||
can_data[i].frame.can_id = MakeCanId((uint)0x10, 0, 0, 0); // ID
|
||
can_data[i].frame.can_dlc = 8; // 数据长度
|
||
can_data[i].frame.__pad |= 0x20; // 发送回显
|
||
can_data[i].frame.data = new byte[8]; // 此成员必须new8个字节，否则无法运行，数据长度修改frame.can_dlc成员即可
|
||
Array.Copy(sourceData, can_data[i].frame.data, Math.Min(8, sourceData.Length));
|
||
Marshal.StructureToPtr(can_data[i], (IntPtr)(p2CanData + i * Marshal.SizeOf(typeof(ZLGCAN.ZCAN_Transmit_Data))), true);
|
||
}
|
||
|
||
uint ret = ZLGCAN.ZCAN_Transmit(chnHandle, p2CanData, 10);
|
||
Console.WriteLine("发送 {0} 帧CAN报文", ret);
|
||
|
||
// CANFD
|
||
ZLGCAN.ZCAN_TransmitFD_Data[] canfd_data = new ZLGCAN.ZCAN_TransmitFD_Data[10];
|
||
IntPtr p2CanFDData = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZLGCAN.ZCAN_TransmitFD_Data)) * 10);
|
||
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
canfd_data[i].frame = new ZLGCAN.canfd_frame();
|
||
canfd_data[i].transmit_type = 0; // 0-正常发送
|
||
canfd_data[i].frame.can_id = MakeCanId((uint)0x10, 0, 0, 0); // ID
|
||
canfd_data[i].frame.len = 64; // 数据长度
|
||
canfd_data[i].frame.flags |= 0x20; // 发送回显
|
||
canfd_data[i].frame.data = new byte[64]; // 此成员必须new64个字节，否则无法运行，数据长度修改frame.len成员即可
|
||
for (int j = 0; j < canfd_data[i].frame.len; j++)
|
||
canfd_data[i].frame.data[j] = (byte)j;
|
||
Marshal.StructureToPtr(canfd_data[i], (IntPtr)(p2CanFDData + i * Marshal.SizeOf(typeof(ZLGCAN.ZCAN_TransmitFD_Data))), true);
|
||
}
|
||
|
||
uint retfd = ZLGCAN.ZCAN_TransmitFD(chnHandle, p2CanFDData, 10);
|
||
Console.WriteLine("发送 {0} 帧CANFD报文", retfd);
|
||
|
||
Marshal.FreeHGlobal(p2CanData);
|
||
Marshal.FreeHGlobal(p2CanFDData);
|
||
}
|
||
|
||
// 合并发送
|
||
static void Send_test_Merge(IntPtr dev)
|
||
{
|
||
const int FRAME_COUNT = 10; // 发送帧数量
|
||
ZLGCAN.ZCANDataObj[] dataObjs = new ZLGCAN.ZCANDataObj[FRAME_COUNT];
|
||
IntPtr pDataObjs = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZLGCAN.ZCANDataObj)) * FRAME_COUNT);
|
||
|
||
// canfd_frame
|
||
var baseFrame = new ZLGCAN.canfd_frame
|
||
{
|
||
can_id = MakeCanId(0x10, 0, 0, 0), // ID
|
||
len = 64, // 长度
|
||
flags = 0x01, // 1-CANFD加速
|
||
data = new byte[64]
|
||
};
|
||
for (int i = 0; i < baseFrame.data.Length; i++)
|
||
{
|
||
baseFrame.data[i] = (byte)(i % 0xFF); // 数据
|
||
}
|
||
|
||
for (int i = 0; i < FRAME_COUNT; i++)
|
||
{
|
||
// ZCANCANFDData
|
||
var canfdData = new ZLGCAN.ZCANCANFDData
|
||
{
|
||
timeStamp = 0, // 普通发送时 timeStamp 字段无意义
|
||
flag = 0,
|
||
extraData = new byte[4],
|
||
frame = baseFrame,
|
||
frameType = 1, // 0-CAN 1-CANFD
|
||
txEchoRequest = 1 // 1-发送回显
|
||
};
|
||
|
||
// ZCANDataObj
|
||
dataObjs[i] = new ZLGCAN.ZCANDataObj
|
||
{
|
||
dataType = 1, // 1-CAN/CANFD
|
||
chnl = 0, // 通道
|
||
flag = 0, // 未使用
|
||
data = new byte[92]
|
||
};
|
||
|
||
// 结构体转字节数组
|
||
IntPtr pCanFd = Marshal.AllocHGlobal(Marshal.SizeOf(canfdData));
|
||
try
|
||
{
|
||
Marshal.StructureToPtr(canfdData, pCanFd, false);
|
||
Marshal.Copy(pCanFd, dataObjs[i].data, 0, Marshal.SizeOf(canfdData));
|
||
}
|
||
finally
|
||
{
|
||
Marshal.FreeHGlobal(pCanFd);
|
||
}
|
||
|
||
// 拷贝到非托管内存
|
||
Marshal.StructureToPtr(dataObjs[i], IntPtr.Add(pDataObjs, i * Marshal.SizeOf(typeof(ZLGCAN.ZCANDataObj))), true);
|
||
}
|
||
|
||
// 发送
|
||
uint sentCount = ZLGCAN.ZCAN_TransmitData(dev, pDataObjs, (uint)FRAME_COUNT);
|
||
Console.WriteLine("合并发送 {0} 帧报文", sentCount);
|
||
|
||
Marshal.FreeHGlobal(pDataObjs);
|
||
}
|
||
|
||
// 定时发送
|
||
static void AutoSend_test(IntPtr dev, int chn_idx)
|
||
{
|
||
// 第一条定时任务，CAN
|
||
ZLGCAN.ZCAN_Transmit_Data can_data = new ZLGCAN.ZCAN_Transmit_Data();
|
||
can_data.frame = new ZLGCAN.can_frame();
|
||
can_data.transmit_type = 0; // 0-正常发送
|
||
can_data.frame.can_id = MakeCanId((uint)0x10, 0, 0, 0); // ID
|
||
can_data.frame.can_dlc = 8; // 数据长度
|
||
can_data.frame.__pad |= 0x20; // 发送回显
|
||
can_data.frame.data = new byte[8];
|
||
for (int j = 0; j < can_data.frame.can_dlc; j++)
|
||
can_data.frame.data[j] = (byte)j;
|
||
|
||
ZLGCAN.ZCAN_AUTO_TRANSMIT_OBJ auto_can = new ZLGCAN.ZCAN_AUTO_TRANSMIT_OBJ
|
||
{
|
||
index = 0,
|
||
enable = 1,
|
||
interval = 500,
|
||
obj = new ZLGCAN.ZCAN_Transmit_Data()
|
||
};
|
||
auto_can.obj = can_data;
|
||
|
||
string path = String.Format("{0}/auto_send", chn_idx);
|
||
uint ret = ZLGCAN.ZCAN_SetValue(dev, path, ref auto_can); // 设置
|
||
if (ret != 1)
|
||
{
|
||
Console.WriteLine("设置定时发送失败");
|
||
}
|
||
|
||
|
||
//// 第二条定时任务，CANFD
|
||
//ZLGCAN.ZCAN_TransmitFD_Data canfd_data = new ZLGCAN.ZCAN_TransmitFD_Data();
|
||
//canfd_data.frame = new ZLGCAN.canfd_frame();
|
||
//canfd_data.transmit_type = 0; // 0-正常发送
|
||
//canfd_data.frame.can_id = MakeCanId((uint)0x20, 0, 0, 0); // ID
|
||
//canfd_data.frame.len = 64; // 数据长度
|
||
//canfd_data.frame.flags |= 0x20; // 发送回显
|
||
//canfd_data.frame.data = new byte[64];
|
||
//for (int j = 0; j < canfd_data.frame.len; j++)
|
||
// canfd_data.frame.data[j] = (byte)j;
|
||
|
||
//ZLGCAN.ZCANFD_AUTO_TRANSMIT_OBJ auto_canfd = new ZLGCAN.ZCANFD_AUTO_TRANSMIT_OBJ
|
||
//{
|
||
// index = 1,
|
||
// enable = 1,
|
||
// interval = 500,
|
||
// obj = new ZLGCAN.ZCAN_TransmitFD_Data()
|
||
//};
|
||
//auto_canfd.obj = canfd_data;
|
||
|
||
//path = String.Format("{0}/auto_send_canfd", chn_idx);
|
||
//ret = ZLGCAN.ZCAN_SetValue(dev, path, ref auto_canfd); // 设置
|
||
//if (ret != 1)
|
||
//{
|
||
// Console.WriteLine("设置定时发送失败");
|
||
//}
|
||
|
||
// 启动通道定时任务
|
||
path = String.Format("{0}/apply_auto_send", chn_idx);
|
||
ret = ZLGCAN.ZCAN_SetValue(dev, path, "0");
|
||
if (ret != 1)
|
||
{
|
||
Console.WriteLine("启动定时发送失败");
|
||
}
|
||
|
||
|
||
// 覆盖第一条定时任务
|
||
Thread.Sleep(2000);
|
||
can_data.frame.can_id = MakeCanId((uint)0x222, 0, 0, 0); // 新ID
|
||
auto_can.obj = can_data;
|
||
|
||
path = String.Format("{0}/auto_send", chn_idx);
|
||
ret = ZLGCAN.ZCAN_SetValue(dev, path, ref auto_can);
|
||
if (ret != 1)
|
||
{
|
||
Console.WriteLine("第二次设置定时发送失败");
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("覆盖定时发送成功");
|
||
}
|
||
|
||
Thread.Sleep(5000);
|
||
|
||
// 清空定时发送
|
||
path = String.Format("{0}/clear_auto_send", 0);
|
||
ret = ZLGCAN.ZCAN_SetValue(dev, path, "0");
|
||
if (ret != 1)
|
||
{
|
||
Console.WriteLine("清空定时发送失败");
|
||
}
|
||
}
|
||
|
||
// 设置队列发送，and队列发送示例
|
||
static void QueueSend_test(IntPtr dev, IntPtr chnHandle)
|
||
{
|
||
//// 使能队列发送
|
||
//uint ret = ZLGCAN.ZCAN_SetValue(Program.dev, "0/set_send_mode", "1"); // USBCANFD V1.01版本的才需要配置
|
||
//if (ret != 1)
|
||
//{
|
||
// Console.WriteLine("设置队列发送失败");
|
||
// Console.ReadKey();
|
||
//}
|
||
|
||
uint ret = 0;
|
||
const int FRAME_COUNT = 100; // 发送帧数量
|
||
|
||
// CAN
|
||
ZLGCAN.ZCAN_Transmit_Data[] can_data = new ZLGCAN.ZCAN_Transmit_Data[100];
|
||
IntPtr p2CanData = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZLGCAN.ZCAN_Transmit_Data)) * FRAME_COUNT);
|
||
|
||
for (int i = 0; i < FRAME_COUNT; i++)
|
||
{
|
||
can_data[i].frame = new ZLGCAN.can_frame();
|
||
can_data[i].transmit_type = 0; // 0-正常发送
|
||
can_data[i].frame.can_id = MakeCanId((uint)0x10, 0, 0, 0); // ID
|
||
can_data[i].frame.can_dlc = 8; // 数据长度
|
||
can_data[i].frame.__pad |= 0x20; // 发送回显
|
||
can_data[i].frame.__pad |= 0x80; // 设置队列发送 0x80单位ms,0xC0单位100us
|
||
can_data[i].frame.__res0 = 0xA; // res1 和 res0两个字节存储时间间隔
|
||
can_data[i].frame.__res1 = 0x0;
|
||
can_data[i].frame.data = new byte[8];
|
||
for (int j = 0; j < can_data[i].frame.can_dlc; j++)
|
||
can_data[i].frame.data[j] = (byte)j;
|
||
Marshal.StructureToPtr(can_data[i], (IntPtr)(p2CanData + i * Marshal.SizeOf(typeof(ZLGCAN.ZCAN_Transmit_Data))), true);
|
||
}
|
||
|
||
// 获取队列发送缓存
|
||
IntPtr free_count_p = ZLGCAN.ZCAN_GetValue(dev, "0/get_device_available_tx_count/1");
|
||
int free_count = Marshal.ReadInt32(free_count_p);
|
||
Console.WriteLine("队列缓存剩余：{0} 帧", free_count);
|
||
if (free_count > FRAME_COUNT)
|
||
{
|
||
ret = ZLGCAN.ZCAN_Transmit(chnHandle, p2CanData, 100); // 下发给设备
|
||
Console.WriteLine("发送 {0} 帧CAN报文", ret);
|
||
}
|
||
|
||
// CANFD
|
||
ZLGCAN.ZCAN_TransmitFD_Data[] canfd_data = new ZLGCAN.ZCAN_TransmitFD_Data[FRAME_COUNT];
|
||
IntPtr p2CanFDData = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ZLGCAN.ZCAN_TransmitFD_Data)) * FRAME_COUNT);
|
||
for (int i = 0; i < FRAME_COUNT; i++)
|
||
{
|
||
canfd_data[i].frame = new ZLGCAN.canfd_frame();
|
||
canfd_data[i].transmit_type = 0; // 0-正常发送
|
||
canfd_data[i].frame.can_id = MakeCanId((uint)0x11, 0, 0, 0); // ID
|
||
canfd_data[i].frame.len = 64; // 数据长度
|
||
canfd_data[i].frame.flags |= 0x20; // 发送回显
|
||
canfd_data[i].frame.flags |= 0x80; // 设置队列发送 0x80单位ms,0xC0单位100us
|
||
canfd_data[i].frame.__res0 = 0x14;
|
||
canfd_data[i].frame.__res1 = 0x0;
|
||
canfd_data[i].frame.data = new byte[64];
|
||
for (int j = 0; j < canfd_data[i].frame.len; j++)
|
||
canfd_data[i].frame.data[j] = (byte)j;
|
||
Marshal.StructureToPtr(canfd_data[i], (IntPtr)(p2CanFDData + i * Marshal.SizeOf(typeof(ZLGCAN.ZCAN_TransmitFD_Data))), true);
|
||
}
|
||
|
||
// 获取队列发送缓存
|
||
free_count_p = ZLGCAN.ZCAN_GetValue(dev, "0/get_device_available_tx_count/1");
|
||
free_count = Marshal.ReadInt32(free_count_p);
|
||
Console.WriteLine("队列缓存剩余：{0} 帧", free_count);
|
||
if (free_count > FRAME_COUNT)
|
||
{
|
||
uint retfd = ZLGCAN.ZCAN_TransmitFD(chnHandle, p2CanFDData, 10);
|
||
Console.WriteLine("发送 {0} 帧CANFD报文", retfd);
|
||
}
|
||
|
||
Thread.Sleep(2000); // 发送2秒后清空
|
||
ret = ZLGCAN.ZCAN_SetValue(dev, "0/clear_delay_send_queue", "0"); // 清空队列缓存
|
||
if (ret != 1)
|
||
{
|
||
Console.WriteLine("清空队列缓存失败");
|
||
}
|
||
|
||
Marshal.FreeHGlobal(p2CanData);
|
||
Marshal.FreeHGlobal(p2CanFDData);
|
||
}
|
||
|
||
// 错误帧解析
|
||
static void Analyze_err_frame(ZLGAPI.ZLGCAN.ZCAN_CHANNEL_ERR_INFO errData)
|
||
{
|
||
// 错误码非0时，先输出错误码（替换$为string.Format）
|
||
if (errData.error_code != 0x0)
|
||
{
|
||
Console.Write(string.Format("错误码：{0}，", errData.error_code));
|
||
}
|
||
|
||
// 匹配错误码逻辑（与C++ switch完全一致）
|
||
switch (errData.error_code)
|
||
{
|
||
case 0x1:
|
||
Console.WriteLine("CAN 控制器内部FIFO溢出");
|
||
break;
|
||
case 0x2:
|
||
Console.WriteLine("CAN 控制器错误报警");
|
||
break;
|
||
case 0x4:
|
||
Console.Write("CAN 控制器消极错误，");
|
||
// 替换$为string.Format，多个参数按顺序占位
|
||
Console.WriteLine(string.Format("Rx ErrNUM: {0}，Tx ErrNUM: {1}",
|
||
errData.passive_ErrData[1], errData.passive_ErrData[2]));
|
||
break;
|
||
case 0x8:
|
||
Console.WriteLine("CAN 控制器仲裁丢失");
|
||
break;
|
||
case 0x10:
|
||
Console.WriteLine("CAN 控制器总线错误");
|
||
break;
|
||
case 0x20:
|
||
Console.WriteLine("CAN 控制器总线关闭");
|
||
break;
|
||
case 0x40:
|
||
Console.WriteLine("CAN 缓存溢出");
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 自定义序列号
|
||
static void SN_test(IntPtr dev)
|
||
{
|
||
// 设置自定义sn号
|
||
if (0 == ZLGCAN.ZCAN_SetValue(dev, "0/set_cn", "C#01"))
|
||
{
|
||
Console.WriteLine("设置自定义序列号失败");
|
||
Console.ReadKey();
|
||
}
|
||
|
||
// 获取自定义sn号
|
||
IntPtr P2CN = ZLGCAN.ZCAN_GetValue(dev, "0/get_cn/1");
|
||
string CN = Marshal.PtrToStringAnsi(P2CN);
|
||
Console.WriteLine("设备的自定义序列号：{0}", CN);
|
||
}
|
||
|
||
// 构造CANID
|
||
static uint MakeCanId(uint id, int eff, int rtr, int err)
|
||
{
|
||
uint ueff = (uint)(!!(Convert.ToBoolean(eff)) ? 1 : 0); // 0 标准帧，1 扩展帧
|
||
uint urtr = (uint)(!!(Convert.ToBoolean(rtr)) ? 1 : 0); // 0 数据帧，1 远程帧
|
||
uint uerr = (uint)(!!(Convert.ToBoolean(err)) ? 1 : 0); // 0 CAN帧，1 错误帧（目前只能设置为 0）
|
||
return id | ueff << 31 | urtr << 30 | uerr << 29;
|
||
}
|
||
|
||
// byte[] -> string
|
||
public static string b_array2string(byte[] ByteIn, int LEN)
|
||
{
|
||
// 空值校验（避免空引用/越界异常）
|
||
if (ByteIn == null || ByteIn.Length == 0 || LEN == 0)
|
||
return "";
|
||
|
||
// 限制实际处理长度
|
||
int actualLen = Math.Min(LEN, ByteIn.Length);
|
||
|
||
// 用StringBuilder优化拼接
|
||
System.Text.StringBuilder sb = new System.Text.StringBuilder(actualLen * 3); // 预分配容量（每个字节占3字符：XX + 空格）
|
||
|
||
for (int i = 0; i < actualLen; i++)
|
||
{
|
||
sb.Append(ByteIn[i].ToString("X2")); // 大写十六进制
|
||
if (i < actualLen - 1) // 最后一个字节后不添加空格
|
||
sb.Append(" ");
|
||
}
|
||
|
||
return sb.ToString();
|
||
}
|
||
}
|
||
} |