CAN通信
+ G: O9 `3 z- k5 k& }' x$ {; k    CAN 是Controller Area Network 的缩写（以下称为CAN），该通信使用的是ISO11898标准，该标准的物理层特征如下图所示。
8 Q4 P; U5 f% `  Y
9 K$ {% \5 \- o
/ I& {$ S  y8 {, W* o! F5 u
, U2 K; D. T# }% T    CAN协议是通过以下5种类型的帧进行的：
数据帧
+ X2 P8 J* I& e摇控帧
7 b; Z1 u: z" {7 N  H7 h错误帧
过载帧
帧间隔

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

# N( A7 i' `$ B- f- s' q    大部分系统使用的都是数据帧 ，我这里使用的也是数据帧。
    数据帧一般由7个段构成，即：
（1） 帧起始。表示数据帧开始的段。
（2） 仲裁段。表示该帧优先级的段。
: b  M) b6 k- K! L（3） 控制段。表示数据的字节数及保留位的段。
1 A+ K) O0 V1 ^6 f' M$ o( L（4） 数据段。数据的内容，一帧可发送0~8个字节的数据。
（5） CRC段。检查帧的传输错误的段。
$ ^' R, o# S: a3 P（6） ACK段。表示确认正常接收的段。
（7） 帧结束。表示数据帧结束的段。

# C) M' i  q3 j  l' {3 l    明确了数据帧概念，还需要理解一下过滤器的作用。
/ F% E; D1 R: k5 Y; m# r
8 N/ \( c' G/ q9 g    STM32的标识符屏蔽滤波目的是减少了CPU处理CAN通信的开销。STM32的过滤器组最多有28个（互联型），但是STM32F103ZET6只有14个（增强型），每个滤波器组x由2个32为寄存器，CAN_FxR1和CAN_FxR2组成。

    STM32每个过滤器组的位宽都可以独立配置，以满足应用程序的不同需求。根据位宽的不同，每个过滤器组可提供：
0 L2 ?: J2 Q- k. Y; i/ C1个32位过滤器，包括：STDID[10:0]、EXTID[17:0]、IDE和RTR位
: J  C0 b- `# H" K1 b  J) S2个16位过滤器，包括：STDID[10:0]、IDE、RTR和EXTID[17:15]位
; M" }' a. U5 v) f
! i9 V' k* \! q* p    此外过滤器可配置为，屏蔽位模式和标识符列表模式。

8 \+ I  T8 O7 S6 o$ X: g$ [; ^    在屏蔽位模式下，标识符寄存器和屏蔽寄存器一起，指定报文标识符的任何一位，应该按照“必须匹配”或“不用关心”处理。

1 b# q# ]8 L6 c2 {, w% p' p    而在标识符列表模式下，屏蔽寄存器也被当作标识符寄存器用。因此，不是采用一个标识符加一个屏蔽位的方式，而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟过滤器标识符相同。相关文章：CAN总线详解。

; v8 e/ A; ~- C- K( Y3 d$ k    一般也都是使用标识符列表模式，这里使用的也是标识符列表模式。滤波过程举例如下：

' y0 ^: ~% _5 [, x

    在程序中就是：

1. //要过滤的ID高位
   
2. CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;  
   - M. j, Q  T/ \8 y* b! |. V" x
3. //要过滤的ID低位                 
   
4. CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF;
   
5. //过滤器屏蔽标识符的高16位值
   ) `, d1 {3 Z2 O: r
6. CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;   
   0 K2 @3 r1 d5 y  j
7. //过滤器屏蔽标识符的低16位值         
   
8. CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;

复制代码

    这里的CAN_FilterId和CAN_FilterMaskId是配合使用的，意思是CAN_FilterId指出需要屏蔽ID的什么内容，什么格式；CAN_FilterMaskId是指CAN_FilterId的每一位是否需要过滤，若CAN_FilterMaskId在某位上是1的话，ID对应位上的数值就必须和CAN_FilterId该位上的一样，保持一致，反之则是“不关心”。
5 O3 n( T4 y1 Z" p2 S0 O
# g) y! |/ l% i, v, [% ~上述程序的设置的含义就是：只接收来自0x1314的数据，屏蔽其他ID的数据。

程序思路
$ t, F' r6 G* p1 d* f    这里准备做一个主机与从机的通信，主要用扩展标识符ExtId来区分，分配的标识符是：
/ \: f& K) r, p+ N$ h主机：0x1314
+ K# W# v8 H& \9 n! O$ p从机：0x1311
  _% L* z0 t; I$ [' y. Z
" O7 i& }: P% P6 i$ x. `    主机负责接收所有从机的数据，不需要过滤，用扩展标识符ExtId来区分不同从机的数据；主机还可以向不同从机发送信息。而从机则只接收来自主机的数据，同样用扩展标识符ExtId来区分是否是发向自己的数据；同时，也能够向主机发送信息。


相关代码
1 M' ]; g- L1 p, \3 r    代码也是非常简单的，这里贴出了主机和从机的can.c和can.h两个文件。
' ^0 I6 ?/ r5 C& `8 s; F$ f3 ]
从机相关代码
3 w( [! ]: a0 E# d  |( R! Lcan.c文件：

1. #include "can.h"
   
2. 
   6 B( x0 V; d: \" m+ S
3. 
   ) g1 t8 x  v" c# O! W- }4 s% b
4. 
   
5. 
   5 V: B/ p, ~5 D8 u) O4 Z
6. /* 在中断处理函数中返回 */
   
7. //__IO uint32_t ret = 0;
   
8. 
   
9. 
   
10. 
    4 L! O) Z7 F) w
11. 
    
12. //接收数据缓冲器
    % \  g0 \, a! T. e
13. u8 RxBuf[5];
    
14. u8 Rx_flag=0;
    6 \! {$ ~' V2 K* h) O* t, r
15. 
    
16. 
    ! A+ n3 _/ f  H( K: q/ t: x
17. 
    
18. 
      s0 h8 l7 t' O, B/ \9 F, S
19. void CAN1_Init(void)
    . H  w2 e4 U1 B  Z/ U1 X
20. {
    
21.     GPIO_InitTypeDef GPIO_InitStructure;
    
22.     NVIC_InitTypeDef NVIC_InitStructure;
    ) n2 }6 N- w9 r2 l- S
23.     CAN_InitTypeDef        CAN_InitStructure;
    $ R$ \& H* ^0 P
24.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    
25. 
    ; P1 r3 h6 V( S1 C7 N4 i
26. 
    
27. 
      V. p# n2 [5 w) g! A  w
28. 
    
29.     /* 复用功能和GPIOB端口时钟使能*/   
    
30.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);                                                                     
    - I+ W5 g& r0 @) m# F9 t4 r
31. 
    
32. 
    ( L1 V# T4 U! G4 q1 |
33. 
    ( z2 x+ u5 J% |6 c6 m  I
34. 
    
35.     /* CAN1 模块时钟使能 */
    
36.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    
37. 
    2 k% v4 q  X. I% d  x1 C
38. 
    # X; T  K, s5 F3 o
39. 
    7 v. ?: b( i. M9 k$ |0 `  L
40. 
    / M' A8 Z4 k4 ~# c
41.     /* Configure CAN pin: RX */  // PB8
    
42.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    
43.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;       //上拉输入
    ' K# {, c' S/ W3 V. R$ w5 C
44.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    1 v7 K( w% o/ f- ?) ~6 g/ \
45. 
    
46. 
    
47. 
      r1 E" G5 k( n" c2 F) w" t$ f
48. 
    
49.     /* Configure CAN pin: TX */   // PB9
    
50.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    
51.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     //复用推挽输出
    ( F, T$ V' ?2 F( ?( Z( t
52.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    8 |" U! F$ R, y0 @
53. 
    . z# s7 n% `8 Y! q; e# ]: y
54. 
    
55. 
    ) o6 g* v$ n$ d- k. d1 L
56. 
    
57.     //#define GPIO_Remap_CAN    GPIO_Remap1_CAN1 本实验没有用到重映射I/O
    1 r) n; a8 A- v# e+ p: N; V* ?
58.     GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
    . e9 F! B7 u3 T, ]
59. 
    
60. 
    * N+ {: y  e3 c; G8 ^6 V
61. 
    
62. 
    
63.     //CAN_NVIC_Configuration(); //CAN中断初始化   
    
64.     /* Configure the NVIC Preemption Priority Bits */  
    
65.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    
66. 
    3 w1 g$ G  R9 y% J7 z5 i5 C
67. 
    
68. 
    4 }) F, v0 x: X  S. Z/ E
69. 
    
70.     #ifdef  VECT_TAB_RAM  
    
71.       /* Set the Vector Table base location at 0x20000000 */
    7 |7 V' a: y( T) |: L/ ~0 d- I
72.       NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
    5 V! b' G5 d2 f' W6 |
73.     #else  /* VECT_TAB_FLASH  */
    4 B4 h* L5 i% b- N" f0 u& t
74.       /* Set the Vector Table base location at 0x08000000 */
    
75.       NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
    1 `% g. h/ Z+ c+ N
76.     #endif
    
77. 
    
78. 
    
79. 
    1 J' k- U9 w) s2 o) b
80. 
    7 K( N: V+ i: y$ z
81.     /* enabling interrupt */
    ( Y4 Q" r4 E8 h# g& g; B2 `
82.     NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;
    ( B# w" m2 }/ ~4 _( D
83.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    - j5 ^; g0 H5 V( R8 y- v
84.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
85.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    2 k1 t) Z6 m# z! ^. \1 W
86.     NVIC_Init(&NVIC_InitStructure);
    : ^! R6 r: a6 o5 u- P, N  ~
87. 
    
88. 
    # e. g& |# a2 R8 F6 |
89. 
    
90. 
    7 R6 Z1 _% X  [' q
91.     //CAN_INIT();//CA初始化N模块
    , {3 e/ Q9 g& ?
92.     /* CAN register init */
    
93.     CAN_DeInit(CAN1);                       //将外设CAN的全部寄存器重设为缺省值
    
94.     CAN_StructInit(&CAN_InitStructure);     //把CAN_InitStruct中的每一个参数按缺省值填入
    ) k3 L' x5 b' g5 M
95. 
    
96. 
    5 y8 A; ^  l1 v( U4 C/ I. y
97. 
      [' N* M* L' q$ w
98. 
    
99.     /* CAN cell init */
    
100.     CAN_InitStructure.CAN_TTCM=DISABLE;         //没有使能时间触发模式
     , a) {( Q. F" x! D0 C+ A# T: E% c. p3 R
101.     CAN_InitStructure.CAN_ABOM=DISABLE;         //没有使能自动离线管理
     
102.     CAN_InitStructure.CAN_AWUM=DISABLE;         //没有使能自动唤醒模式
     3 G0 s  M9 M% m5 X5 p5 }: d
103.     CAN_InitStructure.CAN_NART=DISABLE;         //没有使能非自动重传模式
     
104.     CAN_InitStructure.CAN_RFLM=DISABLE;         //没有使能接收FIFO锁定模式
     
105.     CAN_InitStructure.CAN_TXFP=DISABLE;         //没有使能发送FIFO优先级
     
106.     CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式
     3 c7 ^) ?9 }& w# B
107.     CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;      //重新同步跳跃宽度1个时间单位
     
108.     CAN_InitStructure.CAN_BS1=CAN_BS1_3tq;      //时间段1为3个时间单位
     / e0 X) c: V3 o1 V: L" U
109.     CAN_InitStructure.CAN_BS2=CAN_BS2_2tq;      //时间段2为2个时间单位
     2 h- A# }/ l, }& C
110.     CAN_InitStructure.CAN_Prescaler=60;         //时间单位长度为60
     
111.     CAN_Init(CAN1,&CAN_InitStructure);          //波特率为：72M/2/60(1+3+2)=0.1 即波特率为100KBPs
     5 L' r  s* Z4 ]- @" q( |
112. 
     # q  B) w3 e" T" v( p
113. 
     . B1 J6 B, w" b, g5 p4 C3 Y
114. 
     * X: s  t6 a$ [+ q  ]
115. 
     , A0 z& _, z7 F3 F' y! @  `1 G
116.     // CAN filter init 过滤器，注意，只接收主机发过来的数据，屏蔽其他数据
     + l6 d& \8 i& ]1 U
117.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
     
118.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
     
119.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
     ! H" V: m5 ]  v1 P- _* Y1 o6 U
120. 
     2 J; B' b6 J5 j! b: U4 _: M4 s2 r
121. 
     0 [+ O9 b" ^  t$ h5 F+ l# E5 Y
122. 
     
123. 
     
124.     //CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16;  
     ) G: I/ J4 }2 b. I( c( X, n4 b
125.     CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;                  //要过滤的ID高位
     
126.     CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位
     
127. 
     8 p5 t$ t1 f3 O8 O
128. 
     
129. 
     
130. 
     
131.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;            //过滤器屏蔽标识符的高16位值
     6 m3 f4 G, Q5 e
132.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;             //过滤器屏蔽标识符的低16位值
     , I, i( p5 V2 f* Z" @. |( o4 E
133.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
     
134.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
     0 ?3 q  V/ f& b0 L0 [4 _
135.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
     
136. 
     
137. 
     
138. 
     8 X4 b: E! i. A, r: t' i$ P# N
139. 
     0 X# [7 s' O8 _" D2 C  T8 x" c
140.     /* CAN FIFO0 message pending interrupt enable */
     
141.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
     . X5 Y2 I5 j# E! P8 [6 t0 f
142. }
       N* t& k1 h4 b3 d" c; \# c
143. 
     & H3 J+ n  F0 r! a
144. 
     
145. 
     , L6 o; r+ u4 m' J) ^
146. 
     
147. /* 发送两个字节的数据*/
     
148. u8 CAN_SetMsg(u8 Data1,u8 Data2)
     + ~/ X+ C" T. L& ~
149. {
     
150.     u8 mbox;
     
151.     u16 i=0;
     
152.     CanTxMsg TxMessage;  
     
153. 
     
154. 
     ) ?2 E6 m& X, Y2 j( g6 h  Y! k
155. 
     
156. 
     
157.     TxMessage.StdId=0x0000;     //标准标识符为0x00
     
158.     TxMessage.ExtId=0x1311;     //扩展标识符0x1311,可以更改该标识符以示区分不同从机
     5 u7 P% }( Q" d# c* a) V: p
159.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
     
160.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
     / O& c; E% n: R
161.     TxMessage.DLC=2;            //消息的数据长度为2个字节
     ; S8 g& o, K- O6 P- B& q
162.     TxMessage.Data[0]=Data1;    //第一个字节数据
     
163.     TxMessage.Data[1]=Data2;    //第二个字节数据
     
164. 
     $ U, ~6 J: s. D+ |
165. 
     . S1 H/ Q  A  |5 I( h7 N2 o
166. 
     
167. 
     0 X) C! m3 h! k2 T+ u
168.     //发送数据
     & w8 m2 H$ I9 G9 }: l& v% p( h# e
169.     mbox= CAN_Transmit(CAN1, &TxMessage);  
     
170.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
     
171.         i++;    //等待发送结束
     / p( `1 \, o4 A7 ^+ v
172.     if(i>=0XFFF)
     . B- {& i- V4 r0 z
173.         return 0;
     
174.     return 1;
       |* Z& C$ K6 E$ U
175. }
     
176. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
     9 z, r5 X4 {: }- J' i, H+ [
177. {
     4 J4 L5 ~- l0 k( G# v! l
178.     if(Rx_flag == 1)//发现数据
     
179.     {
     
180.         *msg1=RxBuf[0];
     
181.         *msg2=RxBuf[1];
     ; x0 N- \" @+ }  T4 N
182.         Rx_flag=0;//数据已经取走，可以更新数据
     
183.         return 1;
     3 Q# F7 Z7 }$ V% x9 k) [: g
184.     }else
     
185.         return 0;
     + d& b/ j$ a* h8 B- c. t
186. }
     2 v( i- F( F1 ]+ S9 r' Y
187. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。*/
     
188. void USB_LP_CAN1_RX0_IRQHandler(void)
     1 n  y/ u! J/ U( Z8 D0 B
189. {
     ; x, F/ s( H$ K3 ]. W
190. 
     
191. 
     
192. 
     
193. 
     
194.   CanRxMsg RxMessage;
     # O) ~9 r! |; @5 g
195. 
     
196. 
     7 i5 [8 e3 W, S7 @
197. 
     - ^/ ~+ B& P# _$ P5 H$ _
198. 
     / v9 H7 o9 ^5 t. A9 }+ v4 _
199.   RxMessage.StdId=0x00;
     9 n& V8 T) h1 f5 s) C
200.   RxMessage.ExtId=0x00;
     
201.   RxMessage.IDE=0;
     
202.   RxMessage.DLC=0;
     
203.   RxMessage.FMI=0;
     2 x+ Z( O# t! ?; |, R6 v2 y2 u
204.   RxMessage.Data[0]=0x00;
     , b* S9 a7 Z! X# m
205.   RxMessage.Data[1]=0x00;   
       C4 p' k" f4 X. M( \, W. u9 D
206. 
     0 Y% R4 B( o: \& Q3 O$ `
207. 
     1 }# m8 F# g. ~% b' }: g2 M7 \  S5 E( M
208. 
     * r! `+ s/ \0 t4 M9 p$ n
209. 
     + ~! h. a9 r. C1 h4 G- f! N, \
210.   CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
     2 r$ i7 q' [; I; N2 G% H8 w: e0 s8 p" j
211. 
     
212. 
     
213. 
     
214. 
     ! H+ f* o; L- n7 V1 y  p. ^
215.   if(Rx_flag == 0)//数据已取走或者缓冲器为空
     : n' g  w" P) _7 `. `: e6 ]/ ^7 B% p
216.     {
     9 h8 J- s/ S7 _& e1 e# E% O7 y
217.         RxBuf[0]=RxMessage.Data[0];
     0 ^3 w$ K6 d5 e) y  x
218.         RxBuf[1]=RxMessage.Data[1];
     
219.         Rx_flag=1;//数据已经备好，等待取走
     
220.     }
     , K. @  @- R8 P* e
221. 
     ' c+ @8 z0 D( B: J9 W( m8 D
222. 
     
223. 
     4 u4 E- B: n7 y0 U1 M% W  E5 V
224. 
     
225. }

复制代码

  M7 q2 T/ ~# lcan.h文件
  [5 e% a* L# q( Z, |

! T/ N( i3 |7 v, T
主机相关代码
! L. ~$ Z) M* c. f) q2 r    这里主机代码大部分是和从机类似的，就只贴出不同的地方了。
can.c文件：
  W* L9 ^- @" E/ ?  n; J6 b

1. #include "can.h"
   4 a( r0 K) Y1 e
2. 
   * c- E+ F0 M* j# j- c; _
3. 
   : g; L9 Y9 E4 Q: _  U1 o6 f% |
4. /* 在中断处理函数中返回 */
   ( m  \3 t8 _% |" y6 }/ i% R0 A' e
5. //__IO uint32_t ret = 0;
   
6. 
   
7. 
   
8. void CAN1_Init(void)
   ) y, P. K6 T5 ^+ J  q
9. {
   
10.     ......//以上与从机部分相同
    - U0 H+ h8 |1 M: V
11. 
    : h4 H9 c. H0 i1 F2 x5 F) c) t
12. 
    ; d( s9 ^# H8 t
13.     //CAN filter init 过滤器，已经设置为任意，可以通过ExtId标识符区分从机代号
    
14.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    3 E; w# }) v/ I' G! v+ G, c  j) i
15.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    ! C( S4 F  r6 J, D9 C
16.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
    9 `4 c, Y, T# m3 n2 f8 \
17.     CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;                //过滤器标识符的高16位值
    
18.     CAN_FilterInitStructure.CAN_FilterIdLow=CAN_ID_EXT|CAN_RTR_DATA;//过滤器标识符的低16位值
    
19.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;            //过滤器屏蔽标识符的高16位值
    " k) f& E, ^$ ?/ l
20.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;             //过滤器屏蔽标识符的低16位值
    
21.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
    
22.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
    # M8 D; b0 l3 C* X/ j1 F& g
23.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
    1 u9 y: Z( g* c- N
24. 
    5 G) y" q; \7 x9 S' u- m
25. 
    - \' A; k7 z( b
26.     /* CAN FIFO0 message pending interrupt enable */
    * S' i! {  Z; C4 s
27.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
    2 b* B$ r3 E) _  ^' Z4 G
28. }
    % w) w/ x9 ]0 ?9 a) M
29. 
    ' U" |" [/ O, a) {0 F
30. 
    $ |$ ?1 h  }, c& {, f2 T
31. //接收数据缓冲器
    
32. u8 CAN_RX_BUF[CAN_RX_LEN]={0};     //接收缓冲,最大USART_REC_LEN个字节.
    
33. //接收标志位
    0 L6 w3 h+ n% b$ i
34. u8 Rx_flag=0;
    $ e6 n5 p- v+ v! u" c
35. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
    
36. void USB_LP_CAN1_RX0_IRQHandler(void)
    
37. {
    
38.     u8 i=0;
    " ^1 M8 Q/ Q4 T: X! a1 E: q
39.     CanRxMsg RxMessage;
    0 E( x. |& ^2 P5 q+ K+ N
40. 
    
41. 
      u$ M; p$ ~/ `9 s0 Z
42.     RxMessage.StdId=0x00;
    
43.     RxMessage.ExtId=0x00;
    
44.     RxMessage.IDE=0;
    
45.     RxMessage.DLC=0;
    
46.     RxMessage.FMI=0;
    9 }  }( X" ?) F. e* X* V9 E) o
47. 
    ' ~) B' A8 y2 Q: u
48. 
    
49.     CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
    
50. 
    
51. 
    
52.     if(Rx_flag == 0)//数据已取走或者缓冲器为空
    1 L- @' w) |) d  z4 P. f
53.     {
    8 V8 B+ n3 T6 a  h. B) y9 S. D9 q
54.         if((RxMessage.DLC) == 2)//是否收到2位字节数据
    
55.         {
    * E1 s: [+ S/ ^3 X+ x2 T' E
56.              CAN_RX_BUF[0]=RxMessage.Data[0];
    
57.              CAN_RX_BUF[1]=RxMessage.Data[1];     
    8 ?2 |+ M! r& T8 i6 {
58.         }
    5 i, G) J+ ]  g/ p
59.     }
    
60. 
    & P  ~; M; f1 I$ K  A
61. 
    
62. }
    
63. 
    
64. 
    4 ]3 q0 C5 r' W9 N: ~+ G8 T+ |
65. /* 发送两个字节的数据*/
    + j+ J1 h" W, o& i, f& R
66. u8 CAN_SendMsg(u8* data1, u8* data2)
    1 ?. a  C9 o, w; @! z
67. {
    
68.     u8 mbox;
    
69.     u16 i=0;
    
70.     CanTxMsg TxMessage;  
    
71. 
    
72. 
    , A1 q- t6 L: [. j7 s- q# E" X6 u1 B
73.     TxMessage.StdId=0x0000;     //标准标识符为0x00
    2 M* Q7 S) A# _9 O% p  j4 h: c4 [2 [# q  ?3 ]
74.     TxMessage.ExtId=0x1314;     //扩展标识符0x0000
    " E4 W) N4 N  ~
75.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
    1 I4 F, O7 F- W9 m* D7 Y
76.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
    
77.     TxMessage.DLC=2;            //消息的数据长度为2个字节
    ' w5 V4 ?& T. ^' d
78.     TxMessage.Data[0]=Data1;    //第一个字节数据
    
79.     TxMessage.Data[1]=Data2;    //第二个字节数据
    
80. 
    
81. 
    
82.     //发送数据
    ! Y) [$ H3 Q4 d5 N
83.     mbox= CAN_Transmit(CAN1, &TxMessage);  
    
84.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
    ! J0 [; `, L( L+ D# O
85.         i++;    //等待发送结束
    5 X5 q7 ~# Q1 G- E6 w. l& h
86.     if(i>=0XFFF)
      D8 [( C: N! u  K
87.         return 0;//发送失败
    
88.     return 1;//发送成功
    # _, T% F8 f5 P% z6 X
89. }
    5 W" z& M) f3 V/ P0 [
90. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
    
91. {
    
92.     if(Rx_flag == 1)//发现数据
    
93.     {
    
94.         *msg1=CAN_RX_BUF[0];
    
95.         *msg2=CAN_RX_BUF[1];
    : ]5 b( O9 {3 Z+ ^7 Z% C7 M$ @
96.         Rx_flag=0;//数据已经取走，可以更新数据
    " ~+ D$ t( B: U  G1 z2 Y% [4 T+ m
97.         return 1;
    % U% ]" n( z7 Z. q# a5 ]7 _9 z' c4 m
98.     }else
    
99.         return 0;
    
100. }
     5 }1 e# ?/ V# ^. O3 B4 {' J* z
101. void Clear_canBuffer(void)
     8 ?) U+ l1 E+ b2 q# s
102. {
     $ z: Y" J' R9 ]  }* V( |  r
103.     Rx_flag=0;//清楚接收标志位
     3 u& G+ Q4 H0 u2 \( X0 {: `
104.     memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区
     3 k! T6 @$ j' a& W8 V# t0 c
105. }
     ; ?8 z4 H. `: G( K6 n  Y/ E
106. u8 Check_canRX(void)
     
107. {
     # }  E( h" \7 X, _5 a: g5 L6 w
108.     return (Rx_flag == 6);
     
109. }

复制代码

$ v0 V! M2 o1 f8 H$ g3 T+ T
can.h文件：
. w0 d; ~6 C& |- J/ |8 H: H( W

1. #ifndef __CAN_H
   
2. #define __CAN_H
   ' ~3 T1 Y  ?7 m5 y. M. Y
3. 
   8 U/ ?& Q% D4 W' e# d1 U( O
4. 
   
5. #include "sys.h"
   8 Z) d6 v9 Q' ?, v8 {( R
6. #include "string.h"
   6 ~$ r' e  a- t
7. 
   
8. 
   
9. #define CAN_RX_LEN          30          //定义最大接收字节数
   : E3 B3 [, A7 Y8 Q2 H; t, @
10. 
    
11. 
    ( P+ q$ V' r, t0 T. @
12. extern u8  CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    
13. 
    
14. 
    + P) K- \; }( K1 k$ L, ~# j
15. void CAN1_Init(void);
    ) |+ k- h2 _  P* ^3 s2 j+ [
16. u8 CAN_SendMsg(u8* data1, u8* data2);
    
17. u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
    7 d7 L( ?4 N2 ^1 [
18. 
    
19. 
    
20. #endif /* __CAN_H */
    

复制代码

转载自：单片机与嵌入式
  x( \* g$ ]4 @* i+ d
如有侵权请联系删除
' E) P0 k$ k& [0 N+ c7 F
7 l  r3 V+ @3 R& D
0 |9 S. s* r, t$ w  e

- `7 m2 |& D% H$ v) a. G% v