• CANanlystII 基于linux的二次开发实践

    1. USBCAN分析仪国内现状

    这是目前国内市场上的USBCAN分析仪现状。

    2. 创芯科技产品

            创芯科技的这个红色盒子是我比较下来综合性价比最高的。同时支持windows和linux的设备只要320元左右。你既可以用可视化界面发送/接收报文，也可以二次开发，设置复杂的收发以及数据处理的逻辑。可视化界面操作很简单，我就不赘述了，主要谈谈怎么基于linux二次开发。

    2.1 设备自测

    设备拿到时最好进行自测，判断设备是否可用。

    自测时设备线路连接如下：

    PC上virtualbox安装ubuntu虚拟机的USB接口选择

    执行自测用例

    1. root@zyy-VirtualBox:/home/zyy/controlcan# ls
    2. controlcan.h  hello_cpp  libcontrolcan.so  main_bak.cpp  main.cpp  Makefile
    3. root@zyy-VirtualBox:/home/zyy/controlcan# rm -r hello_cpp 
    4. root@zyy-VirtualBox:/home/zyy/controlcan# make clean
    5. rm -f *.o hello
    6. root@zyy-VirtualBox:/home/zyy/controlcan# make
    7. g++ -o hello_cpp main.cpp /home/zyy/controlcan/libcontrolcan.so  -lpthread 
    8. root@zyy-VirtualBox:/home/zyy/controlcan1# ./hello_cpp 
    9. >>this is hello !
    10. >>USBCAN DEVICE NUM:1 PCS
    11. Device:0
    12. >>Get VCI_ReadBoardInfo success!
    13. >>Serial_Num:31F100016D6
    14. >>hw_Type:CAN-Linux
    15. >>Firmware Version:V3.40
    16. >>
    17. >>
    18. >>
    19. >>open deivce success!
    20. >>Get VCI_ReadBoardInfo success!
    21. >>Serial_Num:31F100016D6
    22. >>hw_Type:CAN-Linux
    23. >>Firmware Version:V3.40
    24. Index:0000  CAN1 TX ID:0x00000000 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07
    25. Index:0001  CAN2 TX ID:0x00000001 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07
    26. Index:0002  CAN2 RX ID:0x00000000 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07 TimeStamp:0x0009D81E
    27. Index:0003  CAN1 TX ID:0x00000002 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07
    28. Index:0004  CAN1 RX ID:0x00000001 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07 TimeStamp:0x0009D85C
    29. Index:0005  CAN2 TX ID:0x00000003 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07
    30. Index:0006  CAN2 RX ID:0x00000002 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07 TimeStamp:0x0009D890
    31. Index:0007  CAN1 TX ID:0x00000004 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07
    32. Index:0008  CAN1 RX ID:0x00000003 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07 TimeStamp:0x0009D8B6
    33. Index:0009  CAN2 TX ID:0x00000005 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07
    34. Index:0010  CAN2 RX ID:0x00000004 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07 TimeStamp:0x0009D8E8
    35. Index:0011  CAN1 TX ID:0x00000006 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07
    36. Index:0012  CAN1 RX ID:0x00000005 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07 TimeStamp:0x0009D912
    37. Index:0013  CAN2 TX ID:0x00000007 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07
    38. Index:0014  CAN2 RX ID:0x00000006 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07 TimeStamp:0x0009D93D
    39. Index:0015  CAN1 TX ID:0x00000008 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07
    40. Index:0016  CAN1 RX ID:0x00000007 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07 TimeStamp:0x0009D96F
    41. Index:0017  CAN2 TX ID:0x00000009 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07
    42. Index:0018  CAN2 RX ID:0x00000008 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07 TimeStamp:0x0009D99F
    43. Index:0019  CAN1 RX ID:0x00000009 Extend    Data   DLC:0x08 data:0x 00 01 02 03 04 05 06 07 TimeStamp:0x0009D9DC
    44. run thread exit

    2.2 基于实际场景的二次开发

    2.2.1 一种测试场景

    将目标ECU的CAN引脚和USBCAN分析仪相连， 目标ECU的电源引脚接到相应电压的供电电源上。

    关于ECU刷写，这篇博客写得比较简洁又清晰

    can例程 ecu_基于CAN的ECU刷写流程_司马各的博客-CSDN博客

    我得测试场景分六步，后续步骤大同小异，可以仿照前几步格式添加。

    1. 进入扩展会话模式，并获得正面响应。

    2. tester向ECU请求seed，并获得seed。

    3. tester根据seed计算key, tester向ECU发送key,并获得正面响应。

    4. 进入编程会话,并获得正面响应

    5.tester向ECU请求seed，并获得seed。

    6.tester根据seed计算key, tester向ECU发送key,并获得正面响应。

    针对ECU刷写的OTA升级的步骤资料可以查阅

    新能源汽车OTA升级中的UDS通信分析_晓翔仔的博客-CSDN博客

    2.2.2 编写代码以及调试

    代码里组装的报文符合UDS协议，UDS描述见：

    统一诊断服务(UDS)_晓翔仔的博客-CSDN博客

    编写代码如下：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include "controlcan.h"
    7.  
    8. #include 
    9. #include 
    10. #include "unistd.h"
    11.  
    12. #define  NO_RES_COUNT_MAX  10   //等待响应的时间（周期）上限
    13.  
    14. VCI_BOARD_INFO pInfo;//用来获取设备信息。
    15. int count=0;//数据列表中，用来存储列表序号。
    16. VCI_BOARD_INFO pInfo1 [50];
    17. int num=0;
    18.  
    19.  
    20. //重要全局变量
    21. //int i;
    22. int STEP=0X01;  //CAN数据发送和接收的步骤，用于控制步骤顺序
    23. int CURRENT_STEP=0x00; //当前所处的CAN数据发送和接收的步骤，“接收线程“会根据”当前步骤”和“CAN数据内容”判断是否是正确响应
    24. unsigned int Ecu_DialogId= 0x000; // ECU的CANID,每个ECU不一样
    25. int Fun_Id = 0x7df; //功能寻址的CANID，固定值
    26. DWORD seed0 =0; //UDS 0X27,ECU返回过来的seed第1位
    27. DWORD seed1 =0; //UDS 0X27,ECU返回过来的seed第2位
    28. DWORD seed2 =0; //UDS 0X27,ECU返回过来的seed第3位（若有）
    29. DWORD seed3 =0; //UDS 0X27,ECU返回过来的seed第4位（若有）
    30. DWORD seed0_tmp;
    31. DWORD seed1_tmp;
    32. DWORD seed2_tmp;
    33. DWORD seed3_tmp;
    34. DWORD seed;// UDS 0X27,ECU返回过来的seed
    35. int Seedsize = 0; // UDS 0X27,ECU返回过来的seed位数，一般是2或者4
    36. DWORD key_tmp;
    37. DWORD key;   //UDS 0X27， 由seed计算出的key，两位或者四位，用于ECU安全解锁
    38. int NoResCount=0; // 未接收响应的等待次数，超过一定数目应当认为测试失败，进入shutdown流程
    39. int LogAllRecv =1; //接收数据是否全打印
    40. int TESTMODE =1; //是否是测试模式，测试模式时,CAN1 CAN2直连。非测试模式时CAN2不使用。
    41.  
    42.  
    43. void *receive_func(void* param)  //接收线程。
    44. {
    45. 	int reclen=0;
    46. 	VCI_CAN_OBJ rec[3000];//接收缓存，设为3000为佳。
    47. 	int i,j;
    48. 	
    49. 	int *run=(int*)param;//线程启动，退出控制。
    50.     int ind_recv=0; //0: CAN1  1:CAN2
    51. 	
    52. 	while((*run)&0x0f)
    53. 	{
    54. 		usleep(300000);//延时300ms。
    55. 		if((reclen=VCI_Receive(VCI_USBCAN2,0,ind_recv,rec,3000,100))>0)//调用接收函数，如果有数据，进行数据处理显示。
    56. 		{
    57. 			for(j=0;j
    58. 			{
    59. 				if(LogAllRecv)
    60. 				{
    61. 					printf("[RECV]Index:%04d  ",count);count++;//序号递增
    62. 					printf("CAN%d RX ID:0x%08X", ind_recv+1, rec[j].ID);//ID
    63. 					if(rec[j].ExternFlag==0) printf(" Standard ");//帧格式：标准帧
    64. 					if(rec[j].ExternFlag==1) printf(" Extend   ");//帧格式：扩展帧
    65. 					if(rec[j].RemoteFlag==0) printf(" Data   ");//帧类型：数据帧
    66. 					if(rec[j].RemoteFlag==1) printf(" Remote ");//帧类型：远程帧
    67. 					printf("DLC:0x%02X",rec[j].DataLen);//帧长度
    68. 					printf(" data:0x");	//数据		
    69. 					for(i = 0; i < rec[j].DataLen; i++)
    70. 					{
    71. 						printf(" %02X", rec[j].Data[i]);
    72. 					}
    73. 					printf(" TimeStamp:0x%08X",rec[j].TimeStamp);//时间标识。
    74. 					printf("\n");
    75. 				}
    76. 				if(0X01 == CURRENT_STEP &&0 == rec[j].ExternFlag && 0x50 == rec[j].Data[1] && 0x03 == rec[j].Data[2])
    77. 				{
    78. 					printf("STEP[0X01] 03 diagConversation resp received!\n");
    79. 					STEP =0x07; //设置全局变量STEP指示下一步tester应该发送什么CAN消息
    80. 				}
    81. 				else if(0X07 == CURRENT_STEP && 0 == rec[j].ExternFlag && 0x06 == rec[j].Data[0]&& 0x67 == rec[j].Data[1] && 0x01 == rec[j].Data[2])
    82. 				{
    83. 					printf("STEP[0X07] ask seed resp 4 seeds received!\n");
    84. 					seed0 =  rec[j].Data[3];
    85. 					seed1 =  rec[j].Data[4];
    86. 					seed2 =  rec[j].Data[5];
    87. 					seed3 =  rec[j].Data[6];
    88. 					Seedsize = 4; //全局变量Seedsize指示，下一步发送CAN消息前应该组装多少位的key
    89. 					STEP = 0X71;	//设置全局变量STEP指示下一步tester应该发送什么CAN消息		
    90. 				}
    91. 				else if(0X07 ==CURRENT_STEP && 0 == rec[j].ExternFlag && 0x04 == rec[j].Data[0]&& 0x67 == rec[j].Data[1] && 0x01 == rec[j].Data[2])
    92. 				{
    93. 					printf("STEP[0X07] ask seed resp 2 seeds received!\n");
    94. 					seed0 =  rec[j].Data[3];
    95. 					seed1 =  rec[j].Data[4];
    96. 					Seedsize = 2;//全局变量Seedsize指示，下一步发送CAN消息前应该组装多少位的key
    97. 					STEP = 0X71;		//设置全局变量STEP指示下一步tester应该发送什么CAN消息	
    98. 				}
    99. 				else if(0X71 == CURRENT_STEP && 0 == rec[j].ExternFlag && 0x67 == rec[j].Data[1] && 0x02 == rec[j].Data[2])
    100. 				{
    101. 					printf("STEP[0X71] send key resp received!\n");	
    102. 					STEP = 0x08;	//设置全局变量STEP指示下一步tester应该发送什么CAN消息		
    103. 				}
    104. 				else if(0X08 == CURRENT_STEP && 0 == rec[j].ExternFlag && 0x50 == rec[j].Data[1] && 0x02 == rec[j].Data[2])
    105. 				{
    106. 					printf("STEP[0X08] enter codeConversation resp received!\n");
    107. 					STEP =0x09;//设置全局变量STEP指示下一步tester应该发送什么CAN消息
    108. 				}
    109. 				else if(0X09 == CURRENT_STEP &&0 == rec[j].ExternFlag && 0x06 == rec[j].Data[0]&& 0x67 == rec[j].Data[1] && 0x01 == rec[j].Data[2])
    110. 				{
    111. 					printf("STEP[0X09] ask seed resp 4 seeds received!\n");
    112. 					seed0 =  rec[j].Data[3];
    113. 					seed1 =  rec[j].Data[4];
    114. 					seed2 =  rec[j].Data[5];
    115. 					seed3 =  rec[j].Data[6];
    116. 					Seedsize = 4;	//全局变量Seedsize指示，下一步发送CAN消息前应该组装多少位的key	
    117. 					STEP = 0x91;		//设置全局变量STEP指示下一步tester应该发送什么CAN消息	
    118. 				}
    119. 				else if(0X09 == CURRENT_STEP &&0 == rec[j].ExternFlag && 0x04 == rec[j].Data[0]&& 0x67 == rec[j].Data[1] && 0x01 == rec[j].Data[2])
    120. 				{
    121. 					printf("STEP[0X07] ask seed resp 2 seeds received!\n");
    122. 					seed0 =  rec[j].Data[3];
    123. 					seed1 =  rec[j].Data[4];
    124. 					Seedsize = 2;//全局变量Seedsize指示，下一步发送CAN消息前应该组装多少位的key
    125. 					STEP = 0X91;	//设置全局变量STEP指示下一步tester应该发送什么CAN消息		
    126. 				}
    127. 				else if(0X91 == CURRENT_STEP &&0 == rec[j].ExternFlag && 0x67 == rec[j].Data[1] && 0x02 == rec[j].Data[2])
    128. 				{
    129. 					printf("STEP[0X91] send key resp resp received!\n");			
    130. 					STEP = 0xFF;	//进入0xFF步骤表示测试成功，即将是进入结束流程		
    131. 				}
    132. 			}
    133. 		}		
    134. 	}
    135. 	printf("run thread exit\n");//退出接收线程	
    136. 	pthread_exit(0);
    137. }
    138.  
    139. int main(int argc, char *argv[])
    140. {
    141.     int i;
    142.     for (i = 0; i < argc; i++)
    143.     {
    144.         printf("argc = %d | argv[%d] %s\n", i, i, argv[i]);
    145.     }
    146. //解析输入参数 	Ecu_DialogId ，并打印
    147.     Ecu_DialogId = atoi(argv[1]);
    148. 	printf("Ecu_DialogId = 0x%04x\n",Ecu_DialogId);
    149.  
    150.  
    151. //设备信息打印	
    152. 	printf(">>this is hello !\r\n");//指示程序已运行
    153. 	num=VCI_FindUsbDevice2(pInfo1);
    154. 	printf(">>USBCAN DEVICE NUM:");printf("%d", num);printf(" PCS");printf("\n");
    155. 	for(int i=0;i
    156. 	{
    157. 		printf("Device:");printf("%d", i);printf("\n");
    158. 		printf(">>Get VCI_ReadBoardInfo success!\n");	
    159.  
    160. 	}
    161. 	if(VCI_OpenDevice(VCI_USBCAN2,0,0)==1)//打开设备
    162. 	{
    163. 		printf(">>open deivce success!\n");//打开设备成功
    164. 	}
    165. 	else
    166. 	{
    167. 		printf(">>open deivce error!\n");
    168. 		exit(1);
    169. 	}
    170. 	if(VCI_ReadBoardInfo(VCI_USBCAN2,0,&pInfo)==1)//读取设备序列号、版本等信息。
    171. 	{
    172. 		printf(">>Get VCI_ReadBoardInfo success!\n");	
    173. 	}
    174. 	else
    175. 	{
    176. 		printf(">>Get VCI_ReadBoardInfo error!\n");
    177. 		exit(1);
    178. 	}
    179.  
    180. 	//初始化参数，严格参数二次开发函数库说明书。
    181. 	VCI_INIT_CONFIG config;
    182. 	config.AccCode= (Ecu_DialogId+8) << 21;
    183. 	printf("config.AccCode:%08X\n",config.AccCode); 
    184. 	config.AccMask=0x00000000;//AccMask的值0x00000000表示所有位均为相关位，AccMask=0xFFFFFFFF表示都接收    
    185. 	
    186. 	config.Filter=1;//1:接收所有帧  2:只接收标准帧 3:只接收扩展帧 
    187. 	config.Timing0=0x00;/*波特率125 Kbps  0x03  0x1C ||| 波特率500 Kbps  0x00  0x1C*/
    188. 	config.Timing1=0x1C;
    189. 	config.Mode=0;//正常模式		
    190.  
    191. //CAN1通道的初始化
    192. 	if(VCI_InitCAN(VCI_USBCAN2,0,0,&config)!=1)
    193. 	{
    194. 		printf(">>Init CAN1 error\n");
    195. 		VCI_CloseDevice(VCI_USBCAN2,0);
    196. 	}
    197.  
    198. 	if(VCI_StartCAN(VCI_USBCAN2,0,0)!=1)
    199. 	{
    200. 		printf(">>Start CAN1 error\n");
    201. 		VCI_CloseDevice(VCI_USBCAN2,0);
    202.  
    203. 	}
    204. //在自测模式下，需要使用CAN2通道，所以进行CAN2通道初始化
    205. 	if(TESTMODE)
    206. 	{
    207. 		if(VCI_InitCAN(VCI_USBCAN2,0,1,&config)!=1)
    208. 		{
    209. 			printf(">>Init can2 error\n");
    210. 			VCI_CloseDevice(VCI_USBCAN2,0);
    211. 		}
    212. 		if(VCI_StartCAN(VCI_USBCAN2,0,1)!=1)
    213. 		{
    214. 			printf(">>Start can2 error\n");
    215. 			VCI_CloseDevice(VCI_USBCAN2,0);
    216. 		}		
    217. 	}
    218.  
    219. 	//创建接收线程，持续接收数据包
    220. 	int m_run0=1;
    221. 	pthread_t threadid;
    222. 	int ret;
    223. 	ret=pthread_create(&threadid,NULL,receive_func,&m_run0);
    224.  
    225. //ID默认设置为CANID， 所有报文都是标准帧,默认填充字符是0x55
    226. 	VCI_CAN_OBJ send[1];
    227. 	
    228. 	while(1)
    229. 	{
    230. 		//每次发送前报文初始化
    231. 		send[0].ID= Ecu_DialogId;
    232. 		send[0].SendType=0;
    233. 		send[0].RemoteFlag=0;
    234. 		send[0].ExternFlag=0;
    235. 		send[0].DataLen=8;
    236. 		for (i=0;i<8;i++)
    237. 		{
    238. 			send[0].Data[i] = 0x55;
    239. 		}
    240. //STEP0x00:还没有收到ECU回复
    241. //step0x01:enter 03 diagConversation
    242. //step0x07:ask seed
    243. //step0x71:send key
    244. //step0x08:enter codeConversation
    245. //step0x09:ask seed
    246. //step0x91:send key
    247. //step0xFF:所有流程结束
    248. 		switch(STEP) //本switch-case里所有的发送都是通过CAN1通道
    249. 		{
    250. //step0x01:enter 03 diagConversation
    251. 		case 0x01:
    252. 			//需要发送的帧，结构体设置
    253. 			send[0].Data[0] = 0x02;
    254. 			send[0].Data[1] = 0x10;
    255. 			send[0].Data[2] = 0x03;			
    256. 			if(VCI_Transmit(VCI_USBCAN2, 0, 0, send, 1) == 1)
    257. 			{
    258. 				printf("STEP[0X%02x] enter 03 diagConversation SEND SUCCESS!Index:%04d   CAN1 TX ID:0x%08X data:0x",STEP,count,send[0].ID);
    259. 				count++;
    260. 				for(i=0;i0].DataLen;i++)
    261. 				{
    262. 					printf(" %02X",send[0].Data[i]);
    263. 				}
    264. 				printf("\n");
    265. 			}
    266. 			else
    267. 			{
    268. 				printf("STEP[%02x] VCI_Transmit failed!",STEP);
    269. 				goto SHUTDOWN;
    270. 			}
    271. 			CURRENT_STEP =STEP;//全局变量CURRENT_STEP是为了记录当前所处步骤(接收线程和自测时的模拟ECU需要这个变量)
    272. 			STEP = 0x00; //tester的CAN消息发送成功后将STEP设置为0x00是为了防止重复发送，也方便计算等待时间，长时间等待不到响应则判定测试失败
    273. 			usleep(200000);//延时200ms
    274. 			break;
    275. //step0x07:ask seed
    276. 		case 0x07:
    277. 			//需要发送的帧，结构体设置
    278. 			send[0].Data[0] = 0x02;
    279. 			send[0].Data[1] = 0x27;
    280. 			send[0].Data[2] = 0x01;
    281. 			if(VCI_Transmit(VCI_USBCAN2, 0, 0, send, 1) == 1)
    282. 			{
    283. 				printf("STEP[0X%02x] ask seed SEND SUCCESS!Index:%04d   CAN1 TX ID:0x%08X data:0x",STEP,count,send[0].ID);
    284. 				count++;
    285. 				for(i=0;i0].DataLen;i++)
    286. 				{
    287. 					printf(" %02X",send[0].Data[i]);
    288. 				}
    289. 				printf("\n");
    290. 			}
    291. 			else
    292. 			{
    293. 				printf("STEP[%02x] VCI_Transmit failed!",STEP);
    294. 				goto SHUTDOWN;
    295. 			}
    296. 			CURRENT_STEP =STEP;//全局变量CURRENT_STEP是为了记录当前所处步骤(接收线程和自测时的模拟ECU需要这个变量)
    297. 			STEP = 0x00;//tester的CAN消息发送成功后将STEP设置为0x00是为了防止重复发送，也方便计算等待时间，长时间等待不到响应则判定测试失败
    298. 			usleep(300000);//延时300ms
    299. 			break;
    300. //step0x71:send key
    301. 		case 0x71:
    302. 			//需要发送的帧，结构体设置
    303. 			//Seedsize有2和4两种可能，分别采取不同的组装CAN报文的形式
    304. 			if(4 == Seedsize)
    305. 			{ 
    306. 				seed0_tmp = seed0 << 3*8;
    307. 				seed1_tmp = seed1 << 2*8;
    308. 				seed2_tmp = seed2 << 8;
    309. 				seed3_tmp = seed3;
    310. 				seed = seed0_tmp + seed1_tmp + seed2_tmp + seed3_tmp;
    311. 				printf("seed is  0x%08x\n",seed);
    312. 				key = seed;//汽车厂自定义安全解锁的算法，这里直接key=seed。
    313. 				printf("key is  0x%08x\n",key);
    314. 				send[0].Data[0] = 0x06;
    315. 				send[0].Data[1] = 0x27;
    316. 				send[0].Data[2] = 0x02;
    317. 				send[0].Data[3] = (key & 0xff000000) >> 3*8;
    318. 				send[0].Data[4]  = (key & 0x00ff0000) >> 2*8;
    319. 				send[0].Data[5] = (key & 0x0000ff00) >> 8;
    320. 				send[0].Data[6] = (key & 0x000000ff);			
    321. 			}
    322. 			else if(2 == Seedsize)
    323. 			{
    324. 				seed0_tmp = seed0 << 1*8;
    325. 				seed1_tmp = seed1;
    326. 				seed = seed0_tmp + seed1_tmp;
    327. 				printf("seed is  0x%04x\n",seed);
    328. 				key_tmp = seed;//汽车厂自定义安全解锁的算法，这里直接key=seed。
    329. 				key = key_tmp & 0xffff;
    330. 				printf("key is  0x%04x\n",key );
    331. 				send[0].Data[0] = 0x04;
    332. 				send[0].Data[1] = 0x27;
    333. 				send[0].Data[2] = 0x02;
    334. 				send[0].Data[3] = (key & 0xff00) >> 1*8;
    335. 				send[0].Data[4]  = (key & 0x00ff);			
    336. 			}
    337. 			else
    338. 			{
    339. 				printf("Seedsize error!");
    340. 				goto SHUTDOWN;
    341. 			}
    342. 		
    343. 			if(VCI_Transmit(VCI_USBCAN2, 0, 0, send, 1) == 1)
    344. 			{
    345. 				printf("STEP[0X%02x] send key SEND SUCCESS!Index:%04d   CAN1 TX ID:0x%08X data:0x",STEP,count,send[0].ID);
    346. 				count++;
    347. 				for(i=0;i0].DataLen;i++)
    348. 				{
    349. 					printf(" %02X",send[0].Data[i]);
    350. 				}
    351. 				printf("\n");
    352. 			}
    353. 			else
    354. 			{
    355. 				printf("STEP[%02x] VCI_Transmit failed!\n",STEP);
    356. 				goto SHUTDOWN;
    357. 			}
    358.  
    359. 			CURRENT_STEP =STEP;//全局变量CURRENT_STEP是为了记录当前所处步骤(接收线程和自测时的模拟ECU需要这个变量)
    360. 			STEP = 0x00;//tester的CAN消息发送成功后将STEP设置为0x00是为了防止重复发送，也方便计算等待时间，长时间等待不到响应则判定测试失败
    361. 			usleep(500000);//延时500ms
    362. 			break;	
    363. //step0x08:enter codeConversation			
    364. 		case 0x08:
    365. 			//需要发送的帧，结构体设置	
    366. 			send[0].Data[0] = 0x02;
    367. 			send[0].Data[1] = 0x10;
    368. 			send[0].Data[2] = 0x02;
    369. 			if(VCI_Transmit(VCI_USBCAN2, 0, 0, send, 1) == 1)
    370. 			{
    371. 				printf("STEP[0X%02x] enter codeConversationng SEND SUCCESS!Index:%04d   CAN1 TX ID:0x%08X data:0x",STEP,count,send[0].ID);
    372. 				count++;
    373. 				for(i=0;i0].DataLen;i++)
    374. 				{
    375. 					printf(" %02X",send[0].Data[i]);
    376. 				}
    377. 				printf("\n");
    378. 			}
    379. 			else
    380. 			{
    381. 				printf("STEP[%02x] VCI_Transmit failed!",STEP);
    382. 				goto SHUTDOWN;
    383. 			}
    384. 			CURRENT_STEP =STEP;//全局变量CURRENT_STEP是为了记录当前所处步骤(接收线程和自测时的模拟ECU需要这个变量)
    385. 			STEP = 0x00;//tester的CAN消息发送成功后将STEP设置为0x00是为了防止重复发送，也方便计算等待时间，长时间等待不到响应则判定测试失败
    386. 			usleep(500000);//延时500ms
    387. 			break;
    388. //step0x09:ask seed
    389. 		case 0x09:
    390. 			//需要发送的帧，结构体设置
    391. 			send[0].Data[0] = 0x02;
    392. 			send[0].Data[1] = 0x27;
    393. 			send[0].Data[2] = 0x01;
    394. 		
    395. 			if(VCI_Transmit(VCI_USBCAN2, 0, 0, send, 1) == 1)
    396. 			{
    397. 				printf("STEP[0X%02x] ask seed SEND SUCCESS!Index:%04d   CAN1 TX ID:0x%08X data:0x",STEP,count,send[0].ID);
    398. 				count++;
    399. 				for(i=0;i0].DataLen;i++)
    400. 				{
    401. 					printf(" %02X",send[0].Data[i]);
    402. 				}
    403. 				printf("\n");
    404. 			}
    405. 			else
    406. 			{
    407. 				printf("STEP[%02x] VCI_Transmit failed!",STEP);
    408. 				goto SHUTDOWN;
    409. 			}
    410. 			CURRENT_STEP =STEP;//全局变量CURRENT_STEP是为了记录当前所处步骤(接收线程和自测时的模拟ECU需要这个变量)
    411. 			STEP = 0x00;//tester的CAN消息发送成功后将STEP设置为0x00是为了防止重复发送，也方便计算等待时间，长时间等待不到响应则判定测试失败
    412. 			usleep(500000);//延时500ms
    413. 			break;
    414. //step0x91:send key
    415. 		case 0x91:
    416. 			//需要发送的帧，结构体设置
    417. 			//Seedsize有2和4两种可能，分别采取不同的组装CAN报文的形式
    418. 			if(4 == Seedsize)
    419. 			{ 
    420. 				seed0_tmp = seed0 << 3*8;
    421. 				seed1_tmp = seed1 << 2*8;
    422. 				seed2_tmp = seed2 << 8;
    423. 				seed3_tmp = seed3;
    424. 				seed = seed0_tmp + seed1_tmp + seed2_tmp + seed3_tmp;
    425. 				printf("seed is  0x%08x\n",seed);
    426. 				key = seed;//汽车厂自定义安全解锁的算法，这里直接key=seed。
    427. 				printf("key is  0x%08x\n",key);
    428. 				send[0].Data[0] = 0x06;
    429. 				send[0].Data[1] = 0x27;
    430. 				send[0].Data[2] = 0x02;
    431. 				send[0].Data[3] = (key & 0xff000000) >> 3*8;
    432. 				send[0].Data[4]  = (key & 0x00ff0000) >> 2*8;
    433. 				send[0].Data[5] = (key & 0x0000ff00) >> 8;
    434. 				send[0].Data[6] = (key & 0x000000ff);			
    435. 			}
    436. 			else if(2 == Seedsize)
    437. 			{
    438. 				seed0_tmp = seed0 << 1*8;
    439. 				seed1_tmp = seed1;
    440. 				seed = seed0_tmp + seed1_tmp;
    441. 				printf("seed is  0x%04x\n",seed);
    442. 				key_tmp = seed;//汽车厂自定义安全解锁的算法，这里直接key=seed。
    443. 				key = key_tmp & 0xffff;
    444. 				printf("key is  0x%04x\n",key );
    445. 				send[0].Data[0] = 0x04;
    446. 				send[0].Data[1] = 0x27;
    447. 				send[0].Data[2] = 0x02;
    448. 				send[0].Data[3] = (key & 0xff00) >> 1*8;
    449. 				send[0].Data[4]  = (key & 0x00ff);			
    450. 			}
    451. 			else
    452. 			{
    453. 				printf("Seedsize error!");
    454. 				goto SHUTDOWN;
    455. 			}
    456. 		
    457. 			if(VCI_Transmit(VCI_USBCAN2, 0, 0, send, 1) == 1)
    458. 			{
    459. 				printf("STEP[0X%02x] send key SEND SUCCESS!Index:%04d   CAN1 TX ID:0x%08X data:0x",STEP,count,send[0].ID);
    460. 				count++;
    461. 				for(i=0;i0].DataLen;i++)
    462. 				{
    463. 					printf(" %02X",send[0].Data[i]);
    464. 				}
    465. 				printf("\n");
    466. 			}
    467. 			else
    468. 			{
    469. 				printf("STEP[%02x] VCI_Transmit failed!\n",STEP);
    470. 				goto SHUTDOWN;
    471. 			}
    472. 			CURRENT_STEP =STEP;//全局变量CURRENT_STEP是为了记录当前所处步骤(接收线程和自测时的模拟ECU需要这个变量)
    473. 			STEP = 0x00;//tester的CAN消息发送成功后将STEP设置为0x00是为了防止重复发送，也方便计算等待时间，长时间等待不到响应则判定测试失败
    474. 			usleep(500000);//延时500ms
    475. 			break;		
    476. 		case 0x00:
    477. 			//还没有收到ECU回复
    478. 			printf("[WAITING RESPONSE]VCI_Receive have not found corresponding ECU response!\n");
    479. 			if(NoResCount < NO_RES_COUNT_MAX)
    480. 			{
    481. 				NoResCount++;
    482. 			}
    483. 			else
    484. 			{
    485. 				printf("VCI_Receive have not found corresponding ECU response > %d times,test failed!!!",NO_RES_COUNT_MAX);
    486. 				goto SHUTDOWN;				
    487. 			}	
    488. 			usleep(1000000);//延时1000ms
    489. 			break;
    490. //step0xFF:所有流程结束
    491. 		case 0xFF:
    492. 			//所有流程结束
    493. 			printf("VCI_Receive have found all corresponding ECU response!\n test SUCESS!!!\n");
    494. 			goto SHUTDOWN;
    495. 			break;
    496. 		default:
    497. 			printf("unknown step\n");
    498. 			goto SHUTDOWN;
    499. 		}
    500. // 自测模式下，以下代码用于CAN2通道模仿ECU给tester回复
    501. 		if(TESTMODE)
    502. 		{	
    503. 			switch(CURRENT_STEP)//根据当前所处步骤决定ECU模拟器回复什么消息,本switch-case里所有的发送都是通过CAN2通道
    504. 			{
    505. 			case 0x01:
    506. 				//需要发送的帧，结构体设置
    507.  
    508. 				send[0].ID= Ecu_DialogId +8; //ECU的响应报文的CANID时ECU_DialogId加8
    509. 				send[0].SendType=0;
    510. 				send[0].RemoteFlag=0;
    511. 				send[0].ExternFlag=0;
    512. 				send[0].DataLen=8;		
    513. 				send[0].Data[0] = 0x06;
    514. 				send[0].Data[1] = 0x50;
    515. 				send[0].Data[2] = 0x03;
    516. 				send[0].Data[3] = 0x00;
    517. 				send[0].Data[4] = 0x32;
    518. 				send[0].Data[5] = 0x01;
    519. 				send[0].Data[6] = 0xf4;
    520. 				send[0].Data[7] = 0xaa;	
    521. 			
    522. 				if(VCI_Transmit(VCI_USBCAN2, 0, 1, send, 1) == 1)
    523. 				{
    524. 				}
    525. 				else
    526. 				{
    527. 					printf("STEP[%02x] VCI_Transmit failed!",STEP);
    528. 					goto SHUTDOWN;
    529. 				}
    530. 				usleep(300000);//延时300ms
    531. 				break;
    532. 			case 0x07:
    533. 				//需要发送的帧，结构体设置
    534.  
    535. 				send[0].ID= Ecu_DialogId + 8;
    536. 				send[0].SendType=0;
    537. 				send[0].RemoteFlag=0;
    538. 				send[0].ExternFlag=0;
    539. 				send[0].DataLen=8;
    540. 				if(0)//设为1，表示seedsize 4, 0表示seedsize2
    541. 				{
    542. 					send[0].Data[0] = 0x06;
    543. 					send[0].Data[1] = 0x67;
    544. 					send[0].Data[2] = 0x01;
    545. 					send[0].Data[3] = 0x88;
    546. 					send[0].Data[4] = 0x88;
    547. 					send[0].Data[5] = 0x88;
    548. 					send[0].Data[6] = 0x88;
    549. 					send[0].Data[7] = 0xaa;					
    550. 				}				
    551. 				else
    552. 				{
    553. 					send[0].Data[0] = 0x04;
    554. 					send[0].Data[1] = 0x67;
    555. 					send[0].Data[2] = 0x01;
    556. 					send[0].Data[3] = 0x88;
    557. 					send[0].Data[4] = 0x88;
    558. 					send[0].Data[5] = 0xaa;
    559. 					send[0].Data[6] = 0xaa;
    560. 					send[0].Data[7] = 0xaa;				
    561. 				}
    562. 				
    563. 			
    564. 				if(VCI_Transmit(VCI_USBCAN2, 0, 1, send, 1) == 1)
    565. 				{
    566. 				}
    567. 				else
    568. 				{
    569. 					printf("STEP[%02x] VCI_Transmit failed!",STEP);
    570. 					goto SHUTDOWN;
    571. 				}
    572. 				usleep(300000);//延时300ms
    573. 				break;
    574. 			case 0x71:
    575. 				//需要发送的帧，结构体设置
    576.  
    577. 				send[0].ID= Ecu_DialogId + 8;
    578. 				send[0].SendType=0;
    579. 				send[0].RemoteFlag=0;
    580. 				send[0].ExternFlag=0;
    581. 				send[0].DataLen=8;			
    582. 				send[0].Data[0] = 0x02;
    583. 				send[0].Data[1] = 0x67;
    584. 				send[0].Data[2] = 0x02;
    585. 				send[0].Data[3] = 0xaa;
    586. 				send[0].Data[4] = 0xaa;
    587. 				send[0].Data[5] = 0xaa;
    588. 				send[0].Data[6] = 0xaa;
    589. 				send[0].Data[7] = 0xaa;	
    590. 			
    591. 				if(VCI_Transmit(VCI_USBCAN2, 0, 1, send, 1) == 1)
    592. 				{
    593. 				}
    594. 				else
    595. 				{
    596. 					printf("STEP[%02x] VCI_Transmit failed!",STEP);
    597. 					goto SHUTDOWN;
    598. 				}
    599. 				usleep(300000);//延时300ms
    600. 				break;
    601. 			case 0x08:
    602. 				//需要发送的帧，结构体设置
    603.  
    604. 				send[0].ID= Ecu_DialogId + 8;
    605. 				send[0].SendType=0;
    606. 				send[0].RemoteFlag=0;
    607. 				send[0].ExternFlag=0;
    608. 				send[0].DataLen=8;	
    609. 				send[0].Data[0] = 0x06;
    610. 				send[0].Data[1] = 0x50;
    611. 				send[0].Data[2] = 0x02;
    612. 				send[0].Data[3] = 0x00;
    613. 				send[0].Data[4] = 0x32;
    614. 				send[0].Data[5] = 0x01;
    615. 				send[0].Data[6] = 0xf4;
    616. 				send[0].Data[7] = 0x00;	
    617. 			
    618. 				if(VCI_Transmit(VCI_USBCAN2, 0, 1, send, 1) == 1)
    619. 				{
    620. 				}
    621. 				else
    622. 				{
    623. 					printf("STEP[%02x] VCI_Transmit failed!",STEP);
    624. 					goto SHUTDOWN;
    625. 				}
    626. 				usleep(300000);//延时300ms
    627. 				break;
    628. 			case 0x09:
    629. 				//需要发送的帧，结构体设置
    630.  
    631. 				send[0].ID= Ecu_DialogId + 8;
    632. 				send[0].SendType=0;
    633. 				send[0].RemoteFlag=0;
    634. 				send[0].ExternFlag=0;
    635. 				send[0].DataLen=8;
    636. 				if(1)//设为1，表示seedsize 4, 0表示seedsize2
    637. 				{
    638. 					send[0].Data[0] = 0x06;
    639. 					send[0].Data[1] = 0x67;
    640. 					send[0].Data[2] = 0x01;
    641. 					send[0].Data[3] = 0x88;
    642. 					send[0].Data[4] = 0x88;
    643. 					send[0].Data[5] = 0x88;
    644. 					send[0].Data[6] = 0x88;
    645. 					send[0].Data[7] = 0xaa;					
    646. 				}				
    647. 				else
    648. 				{
    649. 					send[0].Data[0] = 0x04;
    650. 					send[0].Data[1] = 0x67;
    651. 					send[0].Data[2] = 0x01;
    652. 					send[0].Data[3] = 0x88;
    653. 					send[0].Data[4] = 0x88;
    654. 					send[0].Data[5] = 0xaa;
    655. 					send[0].Data[6] = 0xaa;
    656. 					send[0].Data[7] = 0xaa;				
    657. 				}	
    658. 			
    659. 				if(VCI_Transmit(VCI_USBCAN2, 0, 1, send, 1) == 1)
    660. 				{
    661. 				}
    662. 				else
    663. 				{
    664. 					printf("STEP[%02x] VCI_Transmit failed!",STEP);
    665. 					goto SHUTDOWN;
    666. 				}
    667. 				usleep(300000);//延时300ms
    668. 				break;
    669. //step0x91:send key
    670. 			case 0x91:
    671. 				//需要发送的帧，结构体设置
    672.  
    673. 				send[0].ID= Ecu_DialogId + 8;
    674. 				send[0].SendType=0;
    675. 				send[0].RemoteFlag=0;
    676. 				send[0].ExternFlag=0;
    677. 				send[0].DataLen=8;	
    678. 				send[0].Data[0] = 0x02;
    679. 				send[0].Data[1] = 0x67;
    680. 				send[0].Data[2] = 0x02;
    681. 				send[0].Data[3] = 0xaa;
    682. 				send[0].Data[4] = 0xaa;
    683. 				send[0].Data[5] = 0xaa;
    684. 				send[0].Data[6] = 0xaa;
    685. 				send[0].Data[7] = 0xaa;	
    686. 			
    687. 				if(VCI_Transmit(VCI_USBCAN2, 0, 1, send, 1) == 1)
    688. 				{
    689. 				}
    690. 				else
    691. 				{
    692. 					printf("STEP[%02x] VCI_Transmit failed!",STEP);
    693. 					goto SHUTDOWN;
    694. 				}
    695. 				usleep(300000);//延时300ms
    696. 				break;
    697. 			default:
    698. 				printf("unknown CAN2 step:%02X\n",CURRENT_STEP);
    699. 				goto SHUTDOWN;
    700. 			}
    701. 		}
    702. 	}// while end
    703. 	
    704. SHUTDOWN:
    705. 	m_run0=0;//线程关闭指令。
    706. 	pthread_join(threadid,NULL);//等待线程关闭。
    707. 	usleep(100000);//延时100ms。
    708. 	//VCI_ResetCAN(VCI_USBCAN2, 0, 0);//复位CAN1通道。
    709. 	usleep(100000);//延时100ms。
    710. 	//VCI_CloseDevice(VCI_USBCAN2,0);//关闭设备。
    711. 	//除收发函数外，其它的函数调用前后，最好加个毫秒级的延时，即不影响程序的运行，又可以让USBCAN设备有充分的时间处理指令。
    712. 	//goto ext;
    713. }

    代码执行结果：

    1. └─# ./hello_cpp 1800
    2. argc = 0 | argv[0] ./hello_cpp
    3. argc = 1 | argv[1] 1800
    4. Ecu_DialogId = 0x0708
    5. >>this is hello !
    6. >>USBCAN DEVICE NUM:1 PCS
    7. Device:0
    8. >>Get VCI_ReadBoardInfo success!
    9. >>open deivce success!
    10. >>Get VCI_ReadBoardInfo success!
    11. config.AccCode:E2000000
    12. STEP[0X01] enter 03 diagConversation SEND SUCCESS!Index:0000   CAN1 TX ID:0x00000708 data:0x 02 10 03 55 55 55 55 55
    13. [RECV]Index:0001  CAN1 RX ID:0x00000710 Standard  Data   DLC:0x08 data:0x 06 50 03 00 32 01 F4 AA TimeStamp:0x0033A452
    14. STEP[0X01] 03 diagConversation resp received!
    15. STEP[0X07] ask seed SEND SUCCESS!Index:0002   CAN1 TX ID:0x00000708 data:0x 02 27 01 55 55 55 55 55
    16. [RECV]Index:0003  CAN1 RX ID:0x00000710 Standard  Data   DLC:0x08 data:0x 04 67 01 88 88 AA AA AA TimeStamp:0x0033BC1C
    17. STEP[0X07] ask seed resp 2 seeds received!
    18. seed is  0x8888
    19. key is  0x8888
    20. STEP[0X71] send key SEND SUCCESS!Index:0004   CAN1 TX ID:0x00000708 data:0x 04 27 02 88 88 55 55 55
    21. [RECV]Index:0005  CAN1 RX ID:0x00000710 Standard  Data   DLC:0x08 data:0x 02 67 02 AA AA AA AA AA TimeStamp:0x0033DC85
    22. STEP[0X71] send key resp received!
    23. STEP[0X08] enter codeConversationng SEND SUCCESS!Index:0006   CAN1 TX ID:0x00000708 data:0x 02 10 02 55 55 55 55 55
    24. [RECV]Index:0007  CAN1 RX ID:0x00000710 Standard  Data   DLC:0x08 data:0x 06 50 02 00 32 01 F4 00 TimeStamp:0x0033FC21
    25. STEP[0X08] enter codeConversation resp received!
    26. STEP[0X09] ask seed SEND SUCCESS!Index:0008   CAN1 TX ID:0x00000708 data:0x 02 27 01 55 55 55 55 55
    27. [RECV]Index:0009  CAN1 RX ID:0x00000710 Standard  Data   DLC:0x08 data:0x 06 67 01 88 88 88 88 AA TimeStamp:0x00341BC1
    28. STEP[0X09] ask seed resp 4 seeds received!
    29. seed is  0x88888888
    30. key is  0x88888888
    31. STEP[0X91] send key SEND SUCCESS!Index:0010   CAN1 TX ID:0x00000708 data:0x 06 27 02 88 88 88 88 55
    32. [RECV]Index:0011  CAN1 RX ID:0x00000710 Standard  Data   DLC:0x08 data:0x 02 67 02 AA AA AA AA AA TimeStamp:0x00343B93
    33. STEP[0X91] send key resp resp received!
    34. VCI_Receive have found all corresponding ECU response!
    35.  test SUCESS!!!
    36. run thread exit

    3. 总结

            这款CAN分析仪性价比不错，功能也够强大，如果你想使用，可以参考本博客试试。

  • 相关阅读:
    Ukey连接虚拟前置机，浦银安盛基金用USB Server解决
    论文阅读03（基于人类偏好微调语言模型）
    GTK构件之杂项构件(2)
    什么数据需要存在Redis里?缓存的缺点?怎样进行数据同步?
    Redis三种模式——主从复制，哨兵模式，集群
    1532_AURIX_TriCore内核架构_中断
    diffusers-Tasks
    数字政府一网统管体系下的运维管理软件应用探讨
    树莓派忘记密码重置密码的方法
    1995-2020年全国各省二氧化碳排放量面板数据
  • 原文地址：https://blog.csdn.net/qq_33163046/article/details/126762042