Linux CAN 编程详解

1

int

s;

2

struct

sockaddr_can addr;

3

struct

ifreq ifr;

4

s = socket(PF_CAN, SOCK_RAW, CAN_RAW);

//创建 SocketCAN 套接字

5

strcpy

(ifr.ifr_name, 

"can0"

);

6

ioctl(s, SIOCGIFINDEX, &ifr);

//指定 can0 设备

7

addr.can_family = AF_CAN;

8

addr.can_ifindex = ifr.ifr_ifindex;

9

bind(s, (

struct

sockaddr *)&addr, 

sizeof

(addr)); 

//将套接字与 can0 绑定

1

struct

can_frame {

2

canid_t can_id;

//CAN 标识符

3

__u8 can_dlc;

//数据场的长度

4

__u8 data[8];

//数据

5

};

1

#define CAN_EFF_FLAG 0x80000000U //扩展帧的标识

2

#define CAN_RTR_FLAG 0x40000000U //远程帧的标识

3

#define CAN_ERR_FLAG 0x20000000U //错误帧的标识，用于错误检查

1

struct

can_frame frame;

2

frame.can_id = 0x123;

//如果为扩展帧，那么 frame.can_id = CAN_EFF_FLAG | 0x123;

3

frame.can_dlc = 1; 

//数据长度为 1

4

frame.data[0] = 0xAB; 

//数据内容为 0xAB

5

int

nbytes = write(s, &frame, 

sizeof

(frame)); 

//发送数据

6

if

(nbytes != 

sizeof

(frame)) 

//如果 nbytes 不等于帧长度，就说明发送失败

7

printf

(

"Error\n!"

);

1

struct

can_frame frame;

2

frame.can_id = CAN_RTR_FLAG | 0x123;

3

write(s, &frame, 

sizeof

(frame));

1

struct

can_frame frame;

2

int

nbytes = read(s, &frame, 

sizeof

(frame));

1

struct

can_filter {

2

canid_t can_id;

3

canid_t can_mask;

4

};

1

struct

can_filter rfilter[2];

2

rfilter[0].can_id = 0x123;

3

rfilter[0].can_mask = CAN_SFF_MASK; 

//#define CAN_SFF_MASK 0x000007FFU

4

rfilter[1].can_id = 0x200;

5

rfilter[1].can_mask = 0x700;

6

setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, 

sizeof

(rfilter));

//设置规则

1

setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0); 

//禁用过滤规则

1

can_err_mask_t err_mask = ( CAN_ERR_TX_TIMEOUT | CAN_ERR_BUSOFF );

2

setsockopt(s, SOL_CAN_RAW, CAN_RAW_ERR_FILTER, err_mask, 

sizeof

(err_mask));

1

int

loopback = 0; 

// 0 表示关闭, 1 表示开启( 默认)

2

setsockopt(s, SOL_CAN_RAW, CAN_RAW_LOOPBACK, &loopback, 

sizeof

(loopback));

1

int

ro = 1; 

// 0 表示关闭( 默认), 1 表示开启

2

setsockopt(s, SOL_CAN_RAW, CAN_RAW_RECV_OWN_MSGS, &ro, 

sizeof

(ro));

01

/* 1. 报文发送程序 */

02

#include <stdio.h>

03

#include <stdlib.h>

04

#include <string.h>

05

#include <unistd.h>

06

#include <net/if.h>

07

#include <sys/ioctl.h>

08

#include <sys/socket.h>

09

#include <linux/can.h>

10

#include <linux/can/raw.h>

11

12

int

main()

13

{

14

int

s, nbytes;

15

struct

sockaddr_can addr;

16

struct

ifreq ifr;

17

struct

can_frame frame[2] = {{0}};

18

s = socket(PF_CAN, SOCK_RAW, CAN_RAW);

//创建套接字

19

strcpy

(ifr.ifr_name, 

"can0"

);

20

ioctl(s, SIOCGIFINDEX, &ifr); 

//指定 can0 设备

21

addr.can_family = AF_CAN;

22

addr.can_ifindex = ifr.ifr_ifindex;

23

bind(s, (

struct

sockaddr *)&addr, 

sizeof

(addr));

//将套接字与 can0 绑定

24

//禁用过滤规则，本进程不接收报文，只负责发送

25

setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);

26

//生成两个报文

27

frame[0].can_id = 0x11;

28

frame[0]. can_dlc = 1;

29

frame[0].data[0] = 

'Y'

;

30

frame[0].can_id = 0x22;

31

frame[0]. can_dlc = 1;

32

frame[0].data[0] = 

'N'

;

33

//循环发送两个报文

34

while

(1)

35

{

36

nbytes = write(s, &frame[0], 

sizeof

(frame[0])); 

//发送 frame[0]

37

if

(nbytes != 

sizeof

(frame[0]))

38

{

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

{

46

printf

(

"Send Error frame[1]\n!"

);

47

break

;

48

}

49

sleep(1);

50

}

51

close(s);

52

return

0;

53

}

01

/* 2. 报文过滤接收程序 */

02

#include <stdio.h>

03

#include <stdlib.h>

04

#include <string.h>

05

#include <unistd.h>

06

#include <net/if.h>

07

#include <sys/ioctl.h>

08

#include <sys/socket.h>

09

#include <linux/can.h>

10

#include <linux/can/raw.h>

11

12

int

main()

13

{

14

int

s, nbytes;

15

struct

sockaddr_can addr;

16

struct

ifreq ifr;

17

struct

can_frame frame;

18

struct

can_filter rfilter[1];

19

s = socket(PF_CAN, SOCK_RAW, CAN_RAW); 

//创建套接字

20

strcpy

(ifr.ifr_name, 

"can0"

);

21

ioctl(s, SIOCGIFINDEX, &ifr); 

//指定 can0 设备

22

addr.can_family = AF_CAN;

23

addr.can_ifindex = ifr.ifr_ifindex;

24

bind(s, (

struct

sockaddr *)&addr, 

sizeof

(addr)); 

//将套接字与 can0 绑定

25

//定义接收规则，只接收表示符等于 0x11 的报文

26

rfilter[0].can_id = 0x11;

27

rfilter[0].can_mask = CAN_SFF_MASK;

28

//设置过滤规则

29

setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, 

sizeof

(rfilter));

30

while

(1)

31

{

32

nbytes = read(s, &frame, 

sizeof

(frame)); 

//接收报文

33

//显示报文

34

if

(nbytes > 0)

35

{

36

printf

(“ID=0x%X DLC=%d data[0]=0x%X\n”, frame.can_id,

37

frame.can_dlc, frame.data[0]);

38

}

39

}

40

close(s);

41

return

0;

42

}