CAN总线开发实例

1. 在本例中，有两个进程，其中一个进程负责报文的发送(标识符为0x11和0x22)，另一个进程负责报文的接收和过滤(只接收标识符为0x11的
2. 报文)。
   
3. 
   
4. /* 1.报文发送程序 */  
5. #include <stdio.h> 
6. #include <stdlib.h> 
7. #include <string.h> 
8. #include <unistd.h> 
9. #include <net/if.h> 
10. #include <sys/ioctl.h> 
11. #include <sys/socket.h> 
12. #include <linux/can.h> 
13. #include <linux/can/raw.h> 
14. int main()  
15. {  
16.     int s, nbytes;  
17. struct sockaddr_can addr;  
18. struct ifreq ifr;  
19. struct can_frame frame[2] = {{0}};  
20. s = socket(PF_CAN, SOCK_RAW, CAN_RAW);      //创建套接字  
21. strcpy(ifr.ifr_name, "can0" );  
22. ioctl(s, SIOCGIFINDEX, &ifr);                   //指定can0设备  
23. addr.can_family = AF_CAN;  
24. addr.can_ifindex = ifr.ifr_ifindex;  
25. bind(s, (struct sockaddr *)&addr, sizeof(addr));            //将套接字与can0绑定  
26. //禁用过滤规则，本进程不接收报文，只负责发送  
27.         setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);  
28.         //生成两个报文  
29. frame[0].can_id = 0x11;  
30. frame[0]. can_dlc = 1;  
31. frame[0].data[0] = 'Y';  
32. frame[0].can_id = 0x22;  
33. frame[0]. can_dlc = 1;  
34. frame[0].data[0] = 'N';  
35. //循环发送两个报文  
36. while(1) {  
37. nbytes = write(s, &frame[0], sizeof(frame[0]));     //发送frame[0]  
38. if (nbytes != sizeof(frame[0])) {  
39.                 printf("Send Error frame[0]\n!");  
40.                 break;                              //发送错误，退出  
41. }  
42.     sleep(1);  
43. nbytes = write(s, &frame[1], sizeof(frame[1]));     //发送frame[1]  
44. if (nbytes != sizeof(frame[0])) {  
45.                 printf("Send Error frame[1]\n!");  
46.                 break;  
47. }  
48.     sleep(1);  
49. }  
50. close(s);  
51. return 0;  
52. }  
53. /* 2. 报文过滤接收程序 */  
54. #include <stdio.h> 
55. #include <stdlib.h> 
56. #include <string.h> 
57. #include <unistd.h> 
58. #include <net/if.h> 
59. #include <sys/ioctl.h> 
60. #include <sys/socket.h> 
61. #include <linux/can.h> 
62. #include <linux/can/raw.h> 
63. int main()  
64. {  
65. int s, nbytes;  
66. struct sockaddr_can addr;  
67. struct ifreq ifr;  
68. struct can_frame frame;  
69. struct can_filter rfilter[1];  
70. s = socket(PF_CAN, SOCK_RAW, CAN_RAW);      //创建套接字  
71. strcpy(ifr.ifr_name, "can0" );  
72. ioctl(s, SIOCGIFINDEX, &ifr);                   //指定can0设备  
73. addr.can_family = AF_CAN;  
74. addr.can_ifindex = ifr.ifr_ifindex;  
75. bind(s, (struct sockaddr *)&addr, sizeof(addr));            //将套接字与can0绑定  
76.         //定义接收规则，只接收表示符等于0x11的报文  
77. rfilter[0].can_id   = 0x11;  
78. rfilter[0].can_mask = CAN_SFF_MASK;  
79. //设置过滤规则  
80. setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter));   
81.         while(1) {  
82.             nbytes = read(s, &frame, sizeof(frame));            //接收报文  
83.             //显示报文  
84. if (nbytes > 0) {  
85. printf(“ID=0x%X DLC=%d data[0]=0x%X\n”, frame.can_id,  
86. frame.can_dlc, frame.data[0]);  
87. }  
88. }  
89. close(s);  
90. return 0;  
91. }