CAN通信

    CAN 是Controller Area Network 的缩写（以下称为CAN），该通信使用的是ISO11898标准，该标准的物理层特征如下图所示。

    CAN协议是通过以下5种类型的帧进行的：

• 数据帧
  & y2 p5 m2 k$ b) O5 N% n+ _6 c
• 摇控帧
  
• 错误帧
  
• 过载帧
  
• 帧间隔
  
  ; ^/ ^6 w9 q# R8 d2 }. l

    另外，数据帧和遥控帧有标准格式和扩展格式两种格式。标准格式有11 个位的标识符（ID），扩展格式有29 个位的ID。

    大部分系统使用的都是数据帧 ，我这里使用的也是数据帧。
    数据帧一般由7个段构成，即：
（1） 帧起始。表示数据帧开始的段。
) d' C2 J: g4 w, R（2） 仲裁段。表示该帧优先级的段。
5 u) [' j% ]: b  T: w0 h0 j1 |（3） 控制段。表示数据的字节数及保留位的段。
, b9 u8 l3 ~/ a! f7 t3 o（4） 数据段。数据的内容，一帧可发送0~8个字节的数据。
（5） CRC段。检查帧的传输错误的段。
（6） ACK段。表示确认正常接收的段。
0 I& v% O% Z+ w) j; \! A% @（7） 帧结束。表示数据帧结束的段。

    明确了数据帧概念，还需要理解一下过滤器的作用。

    STM32的标识符屏蔽滤波目的是减少了CPU处理CAN通信的开销。STM32的过滤器组最多有28个（互联型），但是STM32F103ZET6只有14个（增强型），每个滤波器组x由2个32为寄存器，CAN_FxR1和CAN_FxR2组成。
$ G( q' Y  K  H. G" h    STM32每个过滤器组的位宽都可以独立配置，以满足应用程序的不同需求。根据位宽的不同，每个过滤器组可提供：

• 1个32位过滤器，包括：STDID[10:0]、EXTID[17:0]、IDE和RTR位
• 2个16位过滤器，包括：STDID[10:0]、IDE、RTR和EXTID[17:15]位
  
  

    此外过滤器可配置为，屏蔽位模式和标识符列表模式。

    在屏蔽位模式下，标识符寄存器和屏蔽寄存器一起，指定报文标识符的任何一位，应该按照“必须匹配”或“不用关心”处理。
9 h- i1 U; i5 H( s& R+ G% I    而在标识符列表模式下，屏蔽寄存器也被当作标识符寄存器用。因此，不是采用一个标识符加一个屏蔽位的方式，而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟过滤器标识符相同。相关文章：CAN总线详解。

    一般也都是使用标识符列表模式，这里使用的也是标识符列表模式。滤波过程举例如下：

    在程序中就是：

1. //要过滤的ID高位
   
2. CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;  
   
3. //要过滤的ID低位                 
   
4. CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF;
   
5. //过滤器屏蔽标识符的高16位值
   
6. CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;   
   
7. //过滤器屏蔽标识符的低16位值         
   
8. CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;

复制代码

' C2 E5 l; ~* P2 s; j4 U6 `

    这里的CAN_FilterId和CAN_FilterMaskId是配合使用的，意思是CAN_FilterId指出需要屏蔽ID的什么内容，什么格式；CAN_FilterMaskId是指CAN_FilterId的每一位是否需要过滤，若CAN_FilterMaskId在某位上是1的话，ID对应位上的数值就必须和CAN_FilterId该位上的一样，保持一致，反之则是“不关心”。
# |9 L* x* q" U- J# a$ [5 T5 K" w

上述程序的设置的含义就是：只接收来自0x1314的数据，屏蔽其他ID的数据。

程序思路

    这里准备做一个主机与从机的通信，主要用扩展标识符ExtId来区分，分配的标识符是：
主机：0x1314
从机：0x1311

    主机负责接收所有从机的数据，不需要过滤，用扩展标识符ExtId来区分不同从机的数据；主机还可以向不同从机发送信息。而从机则只接收来自主机的数据，同样用扩展标识符ExtId来区分是否是发向自己的数据；同时，也能够向主机发送信息。

相关代码

    代码也是非常简单的，这里贴出了主机和从机的can.c和can.h两个文件。

从机相关代码

can.c文件：

1. 
   
2. #include "can.h"
   
3. 
   $ z/ i# E3 O. N/ P% w
4. 
   , q  |( I) Y, O  R1 P$ I( n' n
5. /* 在中断处理函数中返回 */
   
6. //__IO uint32_t ret = 0;
   3 Q2 s0 j& Q  m' Q) A5 C+ V: |" H
7. 
   ) i0 o! n& z% Z& b# G) ]0 h
8. 
   
9. //接收数据缓冲器
   
10. u8 RxBuf[5];
    4 V0 o# C! z2 L# T2 d* `
11. u8 Rx_flag=0;
    ' D5 L" G% C2 O* q; ^, R
12. 
    ! I  L8 e: f+ a& B
13. 
    
14. void CAN1_Init(void)
    / ^  h; X$ Z1 D
15. {
    
16.     GPIO_InitTypeDef GPIO_InitStructure;
    , `: m1 M, K: z
17.     NVIC_InitTypeDef NVIC_InitStructure;
    
18.     CAN_InitTypeDef        CAN_InitStructure;
      L. c# I+ Z( K( `" w/ C& m- E/ N6 X
19.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    2 C$ C( A4 W7 d
20. 
    
21. 
    
22.     /* 复用功能和GPIOB端口时钟使能*/   
    , S' h. ~- ~, _9 `# @. x" |
23.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);                                                                     
    7 S$ l9 d: e) `& `7 w/ e
24. 
    
25. 
    
26.     /* CAN1 模块时钟使能 */
    & ^' X9 t" n+ v  q/ @# y
27.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    
28. 
    - B$ U+ Z% \: x5 @+ H6 f% R
29. 
    , M+ C- ?$ Y5 |; M' S5 W
30.     /* Configure CAN pin: RX */  // PB8
    : c. G9 L& s; ^! S0 {
31.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    
32.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;       //上拉输入
    
33.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    : @7 F, v# `. Y1 \
34. 
    1 S; W; Y2 x# U1 d, ]1 h
35. 
    1 ~, U# P& R/ H8 S
36.     /* Configure CAN pin: TX */   // PB9
    
37.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    . R$ q/ h" q* {9 p, h% y% J
38.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     //复用推挽输出
    
39.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    2 d5 x4 o4 e: ]8 {
40. 
    
41. 
    
42.     //#define GPIO_Remap_CAN    GPIO_Remap1_CAN1 本实验没有用到重映射I/O
    % B+ b' J+ X% y7 \. ?( ^, N( C
43.     GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
    
44. 
    
45. 
    
46.     //CAN_NVIC_Configuration(); //CAN中断初始化   
    
47.     /* Configure the NVIC Preemption Priority Bits */  
    
48.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    * f! B! i# U* b5 P
49. 
    + F" K3 ]9 h  f+ _% N* F! N- ~! C
50. 
    % r% B( p+ B  c
51.     #ifdef  VECT_TAB_RAM  
    8 [* R8 x7 Z$ f+ L$ z: M! K3 \. k
52.       /* Set the Vector Table base location at 0x20000000 */
    $ ]  k! v* O% _& b5 Q
53.       NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
    
54.     #else  /* VECT_TAB_FLASH  */
    
55.       /* Set the Vector Table base location at 0x08000000 */
    " ~5 o& e9 P2 D! G# ~
56.       NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
    
57.     #endif
    
58. 
    
59. 
    ; c! b3 ]  k0 |' F# H: [4 J
60.     /* enabling interrupt */
    ; g8 i, }: B+ o$ V3 k4 @
61.     NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;
    
62.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    1 @4 n" x+ D$ }2 ~7 {- B- O
63.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    & H  N, A$ z. c3 ]
64.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    5 X: f7 Z- j1 X# H8 _
65.     NVIC_Init(&NVIC_InitStructure);
    
66. 
    3 H) M0 j7 \( H* T2 x6 t5 V
67. 
    
68.     //CAN_INIT();//CA初始化N模块
    
69.     /* CAN register init */
    
70.     CAN_DeInit(CAN1);                       //将外设CAN的全部寄存器重设为缺省值
    
71.     CAN_StructInit(&CAN_InitStructure);     //把CAN_InitStruct中的每一个参数按缺省值填入
    & C/ Y$ D3 e; m2 h6 D* N
72. 
    & n9 m9 U1 o) r1 x; J) B
73. 
      w& T4 H9 F9 y2 B! R$ g0 G
74.     /* CAN cell init */
    # Y0 W" g+ i1 X! f
75.     CAN_InitStructure.CAN_TTCM=DISABLE;         //没有使能时间触发模式
    
76.     CAN_InitStructure.CAN_ABOM=DISABLE;         //没有使能自动离线管理
    
77.     CAN_InitStructure.CAN_AWUM=DISABLE;         //没有使能自动唤醒模式
    
78.     CAN_InitStructure.CAN_NART=DISABLE;         //没有使能非自动重传模式
    
79.     CAN_InitStructure.CAN_RFLM=DISABLE;         //没有使能接收FIFO锁定模式
    
80.     CAN_InitStructure.CAN_TXFP=DISABLE;         //没有使能发送FIFO优先级
    9 u9 a8 A  @( X/ y; @( }
81.     CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式
    
82.     CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;      //重新同步跳跃宽度1个时间单位
    
83.     CAN_InitStructure.CAN_BS1=CAN_BS1_3tq;      //时间段1为3个时间单位
    
84.     CAN_InitStructure.CAN_BS2=CAN_BS2_2tq;      //时间段2为2个时间单位
    8 F% h1 M* |. ?2 _, W& q( R
85.     CAN_InitStructure.CAN_Prescaler=60;         //时间单位长度为60
    
86.     CAN_Init(CAN1,&CAN_InitStructure);          //波特率为：72M/2/60(1+3+2)=0.1 即波特率为100KBPs
    
87. 
    
88. 
      c0 H, t+ i: G9 F5 r. N4 N
89.     // CAN filter init 过滤器，注意，只接收主机发过来的数据，屏蔽其他数据
    ' c5 z4 u1 @% b& V5 ?
90.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    
91.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    
92.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
    
93. 
    
94. 
    
95.     //CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16;  
    
96.     CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;                  //要过滤的ID高位
    ! ?2 \- o& {" P
97.     CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位
    - ^$ P% r7 M4 J% W* x9 W. l% l, C
98. 
    ) E! j$ a/ c0 i
99. 
    
100.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;            //过滤器屏蔽标识符的高16位值
     
101.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;             //过滤器屏蔽标识符的低16位值
     
102.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
     ) ?+ N  @$ a$ j; g
103.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
     
104.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
     0 q/ E' u+ o" S4 g3 Z: w6 C, M
105. 
     0 c9 k5 i+ B- |/ J( d) c$ t' K3 D
106. 
     
107.     /* CAN FIFO0 message pending interrupt enable */
     
108.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
     8 x7 e( @$ H  m! ~3 d" r5 d
109. }
     
110. 
     
111. 
     " x4 T1 r! f  t1 e3 l" x( g
112. /* 发送两个字节的数据*/
     
113. u8 CAN_SetMsg(u8 Data1,u8 Data2)
     7 b" L  _$ F1 V2 _9 J" o/ R2 }
114. {
     
115.     u8 mbox;
     
116.     u16 i=0;
     ( g/ h& u, f6 w( e$ P, v
117.     CanTxMsg TxMessage;  
     $ @. q' C( s8 h& X
118. 
     " c, O1 N" b3 g
119. 
     
120.     TxMessage.StdId=0x0000;     //标准标识符为0x00
     
121.     TxMessage.ExtId=0x1311;     //扩展标识符0x1311,可以更改该标识符以示区分不同从机
     0 Q; \6 ?3 G; k$ T# K& @
122.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
     # Z. R* ]" c! m2 [, Z0 s1 c
123.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
     ) ?) a1 u( `" U$ F: V6 O# ~
124.     TxMessage.DLC=2;            //消息的数据长度为2个字节
     
125.     TxMessage.Data[0]=Data1;    //第一个字节数据
     ) k# }2 z# H, b  T  t! ?* J
126.     TxMessage.Data[1]=Data2;    //第二个字节数据
     2 W% ^* Y8 i) L, \+ ~
127. 
     
128. 
     . {* ]: Q, Q( p( r2 o
129.     //发送数据
     
130.     mbox= CAN_Transmit(CAN1, &TxMessage);  
     
131.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
     
132.         i++;    //等待发送结束
     * Z7 n, S  M# M" L$ `
133.     if(i>=0XFFF)
     
134.         return 0;
     $ Y( `, K5 }0 h$ p$ I9 H
135.     return 1;
     
136. }
     
137. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
     
138. {
     $ _' p% X$ C- g" C4 y
139.     if(Rx_flag == 1)//发现数据
     2 n( q8 F$ Z+ A: N2 G
140.     {
     $ b3 B1 b) J: a* N2 Y
141.         *msg1=RxBuf[0];
     
142.         *msg2=RxBuf[1];
     , v- {* O3 z) r4 Q# Q, q
143.         Rx_flag=0;//数据已经取走，可以更新数据
     & m  S7 Y3 c+ v( S" _4 Q
144.         return 1;
     
145.     }else
     
146.         return 0;
     " G  X( B% {7 o  W! D' M  k
147. }
     ( B9 B: N3 Q# C& ~
148. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
     / r9 `3 y" A( V
149. void USB_LP_CAN1_RX0_IRQHandler(void)
     7 T0 E: i+ O  l! R+ B8 _
150. {
     6 \! U3 W. n& _4 |$ \7 ]% D# J
151. 
     
152. 
     
153.   CanRxMsg RxMessage;
     
154. 
     
155. 
     # ^! z* C7 H: W/ J
156.   RxMessage.StdId=0x00;
     
157.   RxMessage.ExtId=0x00;
     
158.   RxMessage.IDE=0;
     6 |% C  k9 s2 L3 ~6 ]& h5 j
159.   RxMessage.DLC=0;
     
160.   RxMessage.FMI=0;
     ' @$ ~6 k  T! p$ O, z# x: q. b
161.   RxMessage.Data[0]=0x00;
     
162.   RxMessage.Data[1]=0x00;   
     8 m* W7 W0 m) `5 Q' d- L
163. 
       }6 G1 W  y- _) E
164. 
     
165.   CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
     $ q" X% e3 H- g2 Z) t6 f
166. 
     2 b& C( {" X$ l2 @9 Y! a
167. 
     0 \+ |) g$ [. ?: N, O. P
168.   if(Rx_flag == 0)//数据已取走或者缓冲器为空
     
169.     {
     $ z$ X7 d* d1 R* \
170.         RxBuf[0]=RxMessage.Data[0];
     
171.         RxBuf[1]=RxMessage.Data[1];
     5 M4 v) y) [! }& n9 H( L' D+ n4 k
172.         Rx_flag=1;//数据已经备好，等待取走
     
173.     }
     ) l5 G0 d0 O' W6 ]4 t
174. 
     , A* x" S5 V% D7 ?: n* ^
175. 
     % g! F" W3 [" `3 O
176. }

复制代码

! p* w/ i+ p$ A" O/ s. i7 |+ S

can.h文件

主机相关代码

    这里主机代码大部分是和从机类似的，就只贴出不同的地方了。
7 u2 ]" y4 s8 Pcan.c文件：

1. 
   " u9 d" E6 H! u+ q" g  U
2. #include "can.h"
   
3. 
   5 K" b- u; G0 Z  g: a2 ~# d
4. 
   
5. /* 在中断处理函数中返回 */
   
6. //__IO uint32_t ret = 0;
   
7. 
   + E( x9 U; E3 f
8. 
   
9. void CAN1_Init(void)
     \, d# R  c9 ~$ y: J
10. {
    * j0 M" v$ ^5 [! v" \7 j
11.     ......//以上与从机部分相同
    ' d$ y* j2 w4 P& G
12. 
    
13. 
    
14.     //CAN filter init 过滤器，已经设置为任意，可以通过ExtId标识符区分从机代号
    8 @: m! Z* u9 ~" j/ A. O9 a/ t
15.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    
16.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    7 g% M* @* \3 v' u- ^' u+ ~' J
17.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
    ' f4 W# h: i0 E( n
18.     CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;                //过滤器标识符的高16位值
    ; j) w1 v" x8 V
19.     CAN_FilterInitStructure.CAN_FilterIdLow=CAN_ID_EXT|CAN_RTR_DATA;//过滤器标识符的低16位值
    4 C+ p  A, [( N! a4 F9 f! u
20.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;            //过滤器屏蔽标识符的高16位值
    ' o% n% L$ `; f! ]% W# ]$ H9 h! T
21.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;             //过滤器屏蔽标识符的低16位值
    
22.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
    ; C0 M  x; R& p
23.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
    
24.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
    6 _) b& _3 n4 v: v
25. 
    
26. 
    
27.     /* CAN FIFO0 message pending interrupt enable */
    
28.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
    
29. }
    
30. 
    
31. 
    0 u9 k  F% U- [+ u7 Z) m
32. //接收数据缓冲器
    + k7 ?3 L+ D1 F1 ]2 u
33. u8 CAN_RX_BUF[CAN_RX_LEN]={0};     //接收缓冲,最大USART_REC_LEN个字节.
    5 s. d: P3 U" r9 S
34. //接收标志位
      a" J6 u7 }- O$ u
35. u8 Rx_flag=0;
    
36. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
    
37. void USB_LP_CAN1_RX0_IRQHandler(void)
    
38. {
    ( i/ L# |9 F, g: m& s
39.     u8 i=0;
    
40.     CanRxMsg RxMessage;
    
41. 
    
42. 
    ( M) F! T6 J0 C/ N. u6 o% @
43.     RxMessage.StdId=0x00;
    ) x" F" d3 u; i6 n, d! ~
44.     RxMessage.ExtId=0x00;
    3 r# S) a8 J# m0 Q" O. h( I" |
45.     RxMessage.IDE=0;
    , G4 t2 X$ k. z* @
46.     RxMessage.DLC=0;
    : a4 x& z% M0 P2 x
47.     RxMessage.FMI=0;
    0 X: R. o8 N, I6 J* [- q! Y& C
48. 
    
49. 
    
50.     CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
    
51. 
    
52. 
    
53.     if(Rx_flag == 0)//数据已取走或者缓冲器为空
    
54.     {
    ! M, s; f% k& g5 S) R
55.         if((RxMessage.DLC) == 2)//是否收到2位字节数据
    ' V# z) R" Z  \# ]5 [( h
56.         {
    $ y  m; \& g! z
57.              CAN_RX_BUF[0]=RxMessage.Data[0];
    
58.              CAN_RX_BUF[1]=RxMessage.Data[1];     
    9 ?2 l' m( b. i4 s3 U
59.         }
    
60.     }
    
61. 
    
62. 
    . G9 L8 J- J$ Z/ t. t6 h# }
63. }
    $ I6 c) ^9 H* E9 I! Z9 L
64. 
    ( p4 e  @" h" `7 P$ Q. T) m9 j
65. 
    
66. /* 发送两个字节的数据*/
    
67. u8 CAN_SendMsg(u8* data1, u8* data2)
    
68. {
    . p$ x  S! N4 m" R/ f9 n; N
69.     u8 mbox;
    
70.     u16 i=0;
    6 o- V: D" v8 G7 }, H
71.     CanTxMsg TxMessage;  
    
72. 
    " w9 V, ]! J5 {7 \( a. N
73. 
    5 P6 S* ?- }# f1 g
74.     TxMessage.StdId=0x0000;     //标准标识符为0x00
    
75.     TxMessage.ExtId=0x1314;     //扩展标识符0x0000
    
76.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
    5 X2 G8 J) d& O$ \& }2 x
77.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
    1 f# m6 I  w& C4 f+ q
78.     TxMessage.DLC=2;            //消息的数据长度为2个字节
    3 u1 d" q5 v' G" g% J* x" S; L
79.     TxMessage.Data[0]=Data1;    //第一个字节数据
    
80.     TxMessage.Data[1]=Data2;    //第二个字节数据
    
81. 
    ; T0 d$ S8 b$ o$ f, c' L8 Z! }
82. 
    3 T1 [) b2 s2 u' e
83.     //发送数据
    3 K7 l6 `7 V6 o2 t! q
84.     mbox= CAN_Transmit(CAN1, &TxMessage);  
    
85.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
    * \  K2 T  \+ L: c, F9 }, l- g! D9 F
86.         i++;    //等待发送结束
    
87.     if(i>=0XFFF)
    
88.         return 0;//发送失败
    
89.     return 1;//发送成功
      [2 u& |* x9 L1 S
90. }
    
91. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
    
92. {
    
93.     if(Rx_flag == 1)//发现数据
    + W6 o! X& W4 E  }: k6 s5 l- W
94.     {
    
95.         *msg1=CAN_RX_BUF[0];
    
96.         *msg2=CAN_RX_BUF[1];
    
97.         Rx_flag=0;//数据已经取走，可以更新数据
    
98.         return 1;
    
99.     }else
    / {' U- y& n8 D  I
100.         return 0;
     - t3 I, g/ ~" y$ c  c: ]3 I
101. }
     
102. void Clear_canBuffer(void)
     3 ]+ I' ?0 p, c0 m5 R& p1 M
103. {
     
104.     Rx_flag=0;//清楚接收标志位
     
105.     memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区
     
106. }
     
107. u8 Check_canRX(void)
     # b6 H7 R# |8 Y4 t
108. {
     7 I' R- D2 S" c# ]
109.     return (Rx_flag == 6);
     
110. }

复制代码

can.h文件：

1. 
   . I# R) g" }& y6 p" {2 G
2. #ifndef __CAN_H
   4 E! a% N3 q) [; _- B
3. #define __CAN_H
   1 d: L0 ~0 Y2 `. k8 _
4. 
   
5. 
   
6. #include "sys.h"
   
7. #include "string.h"
   
8. 
   
9. 
   
10. #define CAN_RX_LEN          30          //定义最大接收字节数
    
11. 
    
12. 
    
13. extern u8  CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    
14. 
    
15. 
    : E! N  @3 T$ w+ m! e: G/ p# s7 D
16. void CAN1_Init(void);
    2 P  O2 C; @$ X6 [& }$ O  Q. N% E
17. u8 CAN_SendMsg(u8* data1, u8* data2);
    
18. u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
    % H( Y* f8 h+ G) p
19. 
    4 l1 h. {& k; d7 m
20. 
    + j, }' t$ u, H* n: d
21. #endif /* __CAN_H */

复制代码