CAN通信
2 d& J# Y/ |1 |    CAN 是Controller Area Network 的缩写（以下称为CAN），该通信使用的是ISO11898标准，该标准的物理层特征如下图所示。
+ T- |2 S4 L3 A
0 ]! l/ `- o$ x

  ~/ g, e6 `$ M2 {; [- o    CAN协议是通过以下5种类型的帧进行的：
数据帧
摇控帧
错误帧
' r$ R( m* ]* R! f. P+ `8 O" Z过载帧
) U( w* |6 E! H; F9 e帧间隔

# U6 D8 f7 a- a' s* F' W; `# R    另外，数据帧和遥控帧有标准格式和扩展格式两种格式。标准格式有11 个位的标识符（ID），扩展格式有29 个位的ID。
$ q  I0 o) X/ R! S+ c
# v  z' v- j+ ?! u2 U; r4 d$ m    大部分系统使用的都是数据帧 ，我这里使用的也是数据帧。
0 u0 Y7 _" d1 t& A9 {/ h    数据帧一般由7个段构成，即：
（1） 帧起始。表示数据帧开始的段。
（2） 仲裁段。表示该帧优先级的段。
  y- p3 V8 V" S$ c（3） 控制段。表示数据的字节数及保留位的段。
  `% u* E$ t' J7 u$ X2 h（4） 数据段。数据的内容，一帧可发送0~8个字节的数据。
（5） CRC段。检查帧的传输错误的段。
. ]0 W7 N1 D; m& A  v（6） ACK段。表示确认正常接收的段。
（7） 帧结束。表示数据帧结束的段。
4 ?. @+ G$ ]8 L: H; z7 h; ^! t
4 |6 c& G, p4 P# G' v$ P    明确了数据帧概念，还需要理解一下过滤器的作用。
9 z2 v; K6 T& B( ~, J  _
" E& ~3 Q$ [- e  L    STM32的标识符屏蔽滤波目的是减少了CPU处理CAN通信的开销。STM32的过滤器组最多有28个（互联型），但是STM32F103ZET6只有14个（增强型），每个滤波器组x由2个32为寄存器，CAN_FxR1和CAN_FxR2组成。
) S. x4 H8 R" K) P5 H
    STM32每个过滤器组的位宽都可以独立配置，以满足应用程序的不同需求。根据位宽的不同，每个过滤器组可提供：
9 v8 l$ {5 G7 c) e( Z1个32位过滤器，包括：STDID[10:0]、EXTID[17:0]、IDE和RTR位
2个16位过滤器，包括：STDID[10:0]、IDE、RTR和EXTID[17:15]位

% l* [& f- z. b  I* Z6 m" Z( L6 o    此外过滤器可配置为，屏蔽位模式和标识符列表模式。
; b7 s& z- h0 e( x  ~
0 T$ F7 M& ~  D    在屏蔽位模式下，标识符寄存器和屏蔽寄存器一起，指定报文标识符的任何一位，应该按照“必须匹配”或“不用关心”处理。
& I% l, F4 e& h& ^
    而在标识符列表模式下，屏蔽寄存器也被当作标识符寄存器用。因此，不是采用一个标识符加一个屏蔽位的方式，而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟过滤器标识符相同。相关文章：CAN总线详解。

- }$ E6 L) V; }0 m    一般也都是使用标识符列表模式，这里使用的也是标识符列表模式。滤波过程举例如下：

* R* T( u' ]2 F* j' k0 h
5 S# P, `# t( G9 \( [9 x
% y* L# [8 f$ F* v0 a! c    在程序中就是：
2 J& H( W* q4 \% Q' N  v: P

1. //要过滤的ID高位
   ' L, a, C. p; T* p
2. CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;  
   
3. //要过滤的ID低位                 
   6 |, s$ v' z" Q" ~5 X* h) y* N
4. CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF;
   
5. //过滤器屏蔽标识符的高16位值
   8 y7 m4 O2 N* x: ^
6. CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;   
   # E8 n8 x( \9 x9 y9 y/ p: w/ X9 @
7. //过滤器屏蔽标识符的低16位值         
   
8. CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;

复制代码

4 @$ s- R) J9 G- x; a    这里的CAN_FilterId和CAN_FilterMaskId是配合使用的，意思是CAN_FilterId指出需要屏蔽ID的什么内容，什么格式；CAN_FilterMaskId是指CAN_FilterId的每一位是否需要过滤，若CAN_FilterMaskId在某位上是1的话，ID对应位上的数值就必须和CAN_FilterId该位上的一样，保持一致，反之则是“不关心”。

上述程序的设置的含义就是：只接收来自0x1314的数据，屏蔽其他ID的数据。
3 }3 d5 i# Z3 r7 |
1 T3 g  f- T$ J$ V程序思路
7 G1 R; n. J1 ?5 p* @    这里准备做一个主机与从机的通信，主要用扩展标识符ExtId来区分，分配的标识符是：
% p6 Q& C: N  y' L/ X主机：0x1314
) [/ n' J- }( @" g4 p( i从机：0x1311

9 _8 M  O. E. p9 U; \  y, L    主机负责接收所有从机的数据，不需要过滤，用扩展标识符ExtId来区分不同从机的数据；主机还可以向不同从机发送信息。而从机则只接收来自主机的数据，同样用扩展标识符ExtId来区分是否是发向自己的数据；同时，也能够向主机发送信息。
0 i/ d. h: C6 b8 ?

- \( P4 B# O2 c" k$ x- g* [, m相关代码
0 w# N4 q3 w0 C, {5 W, d' A6 F    代码也是非常简单的，这里贴出了主机和从机的can.c和can.h两个文件。

1 S) j# L# H' T5 C9 s2 @2 s从机相关代码
6 G# M  i3 e3 w. ?) {can.c文件：
; m- |  T% u9 d( |5 i. k

1. #include "can.h"
   ( K9 g' c, q' Z3 m# H: g: i
2. 
   & c1 V) O1 Q, K
3. 
   4 x& G8 J4 \( S1 c- J/ n* B
4. 
   
5. 
   
6. /* 在中断处理函数中返回 */
   
7. //__IO uint32_t ret = 0;
   
8. 
   # ]* V" s, m% g6 o/ I( k
9. 
   
10. 
    
11. 
    
12. //接收数据缓冲器
    
13. u8 RxBuf[5];
    ! X* n4 P7 K5 j' u8 ], Z# g
14. u8 Rx_flag=0;
    
15. 
    ) l0 T; B* E" v% Z" {( }
16. 
    9 ?( S1 `0 J& {' |3 H
17. 
    
18. 
    
19. void CAN1_Init(void)
    & H) p! z5 ?/ L4 r1 M
20. {
    # ]& \9 C6 s8 ]& I" K6 k
21.     GPIO_InitTypeDef GPIO_InitStructure;
    - e8 z% Q; W6 R
22.     NVIC_InitTypeDef NVIC_InitStructure;
    + a" b, J' ~4 [( K; ~9 J+ c
23.     CAN_InitTypeDef        CAN_InitStructure;
    
24.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    
25. 
    
26. 
    
27. 
    
28. 
    6 _& ?  ~0 C6 D9 @; T: J+ r- C" u
29.     /* 复用功能和GPIOB端口时钟使能*/   
    
30.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);                                                                     
    + D0 g/ b) \# V  v
31. 
    ; l2 i; n. e, _
32. 
    
33. 
    
34. 
    
35.     /* CAN1 模块时钟使能 */
    " V" `, B2 O# o. @& m4 ~, J( U
36.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    
37. 
    ! t: s: @, w- D8 L1 @/ H
38. 
    
39. 
    
40. 
    5 v) y) `- C- j: q; X* ]7 w
41.     /* Configure CAN pin: RX */  // PB8
    
42.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    
43.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;       //上拉输入
    
44.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    2 w; q, L: U9 \% o$ n
45. 
    ( j5 Z: A. N* V
46. 
    
47. 
    
48. 
    
49.     /* Configure CAN pin: TX */   // PB9
    
50.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    
51.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     //复用推挽输出
    1 U5 l' w( b8 `: T5 r5 z
52.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    + g4 g+ o# h$ v3 M  F
53. 
    
54. 
    
55. 
    5 Y  f' b7 i" H. W4 }
56. 
    
57.     //#define GPIO_Remap_CAN    GPIO_Remap1_CAN1 本实验没有用到重映射I/O
    " G3 c) V- f3 d
58.     GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
    # L0 R$ I) d  b& j  R5 N  z
59. 
    4 x3 Z( R8 q& L
60. 
    ! I3 ^/ P- r# S+ [: {
61. 
    
62. 
    
63.     //CAN_NVIC_Configuration(); //CAN中断初始化   
    & M! h' A5 k. R. P
64.     /* Configure the NVIC Preemption Priority Bits */  
    
65.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    / c- Y' i0 C* F2 o4 t1 {; u  g  v# i
66. 
    
67. 
    0 O( w" N3 l/ J- y* K3 ^
68. 
    
69. 
    - P2 L( ]: C) ]( t7 C0 V5 [
70.     #ifdef  VECT_TAB_RAM  
    4 i/ j- ?9 o8 e: y7 W
71.       /* Set the Vector Table base location at 0x20000000 */
    ! O7 F& A1 k- z4 R% E
72.       NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
    
73.     #else  /* VECT_TAB_FLASH  */
    ! s- `1 w& c5 O. ]8 x" n
74.       /* Set the Vector Table base location at 0x08000000 */
    
75.       NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
    , F+ S9 b6 B& M; ~+ t
76.     #endif
    ) x& ]$ d$ f  [! t
77. 
    
78. 
    
79. 
    * H/ s+ [  D4 N
80. 
    8 k; i  h5 O/ J- P6 R% F! {& j
81.     /* enabling interrupt */
    & f) f0 Q  O, M$ h/ @/ z
82.     NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;
    9 m2 \6 t' ~" s/ f, m& t
83.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    2 X, v3 k4 k# O$ j
84.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
85.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    2 m% |! _5 L. C
86.     NVIC_Init(&NVIC_InitStructure);
    
87. 
    + ?5 X6 E# P6 s1 A$ a0 N8 C
88. 
    
89. 
    ' T/ s' n" t6 |, z3 c
90. 
    6 A. I' Q5 R* S
91.     //CAN_INIT();//CA初始化N模块
    & U" ?; [! P; Z; v7 j
92.     /* CAN register init */
    
93.     CAN_DeInit(CAN1);                       //将外设CAN的全部寄存器重设为缺省值
    
94.     CAN_StructInit(&CAN_InitStructure);     //把CAN_InitStruct中的每一个参数按缺省值填入
    
95. 
    # w: G' Z, L8 K* S& K
96. 
    4 ~# l. P: [0 M, m1 \, v3 K
97. 
    : P- M1 q( T- g- V/ r7 P
98. 
    8 ~/ p& d* o7 S4 {' X7 u
99.     /* CAN cell init */
    
100.     CAN_InitStructure.CAN_TTCM=DISABLE;         //没有使能时间触发模式
     
101.     CAN_InitStructure.CAN_ABOM=DISABLE;         //没有使能自动离线管理
     
102.     CAN_InitStructure.CAN_AWUM=DISABLE;         //没有使能自动唤醒模式
     
103.     CAN_InitStructure.CAN_NART=DISABLE;         //没有使能非自动重传模式
     
104.     CAN_InitStructure.CAN_RFLM=DISABLE;         //没有使能接收FIFO锁定模式
     
105.     CAN_InitStructure.CAN_TXFP=DISABLE;         //没有使能发送FIFO优先级
     . v. r- H7 P' `$ Z8 F# p
106.     CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式
     0 W$ y, a- [& [) n" k- y
107.     CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;      //重新同步跳跃宽度1个时间单位
     - H+ Y1 S" `5 a
108.     CAN_InitStructure.CAN_BS1=CAN_BS1_3tq;      //时间段1为3个时间单位
       z. ~* @4 L, N/ _* d
109.     CAN_InitStructure.CAN_BS2=CAN_BS2_2tq;      //时间段2为2个时间单位
     3 }8 p( Q, Y* O! R, i1 K/ t. R8 s
110.     CAN_InitStructure.CAN_Prescaler=60;         //时间单位长度为60
     
111.     CAN_Init(CAN1,&CAN_InitStructure);          //波特率为：72M/2/60(1+3+2)=0.1 即波特率为100KBPs
     & H' d, A  s# }$ n
112. 
     
113. 
     
114. 
     
115. 
     
116.     // CAN filter init 过滤器，注意，只接收主机发过来的数据，屏蔽其他数据
     
117.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
     
118.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
     
119.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
     
120. 
     , I+ @  P# [/ Y, `" ^
121. 
     3 y, x9 |/ O. w+ P& {
122. 
     
123. 
     
124.     //CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16;  
     ! E: P: k2 v3 C2 e
125.     CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;                  //要过滤的ID高位
     
126.     CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位
     % q3 I8 R; b2 t+ Z/ [; i
127. 
     - N+ Q7 D  ^: C" W, p! s( l
128. 
     
129. 
     
130. 
     7 A5 L* M1 r* m
131.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;            //过滤器屏蔽标识符的高16位值
     
132.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;             //过滤器屏蔽标识符的低16位值
     
133.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
     & g' m' j! n1 O0 |3 ]5 \% L
134.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
     
135.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
     7 ]: l5 c( r! c/ p$ `: E( k8 A
136. 
     ! e9 H, ^* w5 M2 I6 H" B% D8 Z- s
137. 
     
138. 
     : A5 k; T6 p& L8 F: b( V2 g
139. 
     ) l" V, {# E( n4 }7 v, \$ u
140.     /* CAN FIFO0 message pending interrupt enable */
     9 W, Y! W+ ?+ O0 a$ W. E" V
141.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
     5 Y7 ~& c1 A" g* s0 F
142. }
     8 \+ }# _9 X7 L+ Q
143. 
     8 D# `' E7 m/ ~6 ^: m, b
144. 
     
145. 
     / R- \( v, t( B8 Q
146. 
     + |" R3 A" E: `! X' [4 n
147. /* 发送两个字节的数据*/
     0 @$ k4 k$ D# ?
148. u8 CAN_SetMsg(u8 Data1,u8 Data2)
     
149. {
     3 h$ c  F: x5 U7 W2 Z
150.     u8 mbox;
     7 ?( l  B5 N9 [* \6 M
151.     u16 i=0;
     9 U+ Y% ~* e" X) P8 L7 Z
152.     CanTxMsg TxMessage;  
     & T" i7 K- c5 \7 w1 {( o
153. 
     $ k; o4 [5 X; {. ~
154. 
     
155. 
     , r# H0 N/ T& x: N9 ]% j
156. 
     2 m1 z8 g, I" i9 _  o( `7 T3 M- w2 Y
157.     TxMessage.StdId=0x0000;     //标准标识符为0x00
     
158.     TxMessage.ExtId=0x1311;     //扩展标识符0x1311,可以更改该标识符以示区分不同从机
     : Y3 H" R, _0 q6 |
159.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
     
160.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
     " n* A$ |# O6 x  C4 p
161.     TxMessage.DLC=2;            //消息的数据长度为2个字节
     
162.     TxMessage.Data[0]=Data1;    //第一个字节数据
     ( m+ Z2 p3 j9 B- v- l# A
163.     TxMessage.Data[1]=Data2;    //第二个字节数据
     $ E2 Y6 @, z5 O/ ?0 B' X2 u- e, W
164. 
     9 q: [3 Q+ u+ N  U
165. 
     % Q# s* B/ L' o4 |
166. 
     6 o0 Y+ X/ L4 o. n; f
167. 
     
168.     //发送数据
     / _3 f1 B" M  D6 D4 `* c3 G& w: ?
169.     mbox= CAN_Transmit(CAN1, &TxMessage);  
     + Y+ w5 `& U! E- t# n
170.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
     6 q! c/ A5 J3 e4 `& L
171.         i++;    //等待发送结束
     
172.     if(i>=0XFFF)
     
173.         return 0;
     4 b6 U& E; g# ?3 \: g; G
174.     return 1;
     
175. }
       b3 o4 J. V) |: k( i% r2 e$ X
176. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
     / Q+ U7 [9 _6 \  t
177. {
     
178.     if(Rx_flag == 1)//发现数据
     * ]6 I" g+ v& G$ M9 ]6 p
179.     {
     
180.         *msg1=RxBuf[0];
     
181.         *msg2=RxBuf[1];
     
182.         Rx_flag=0;//数据已经取走，可以更新数据
     
183.         return 1;
     
184.     }else
     & `; v6 P% I8 ]9 O3 z
185.         return 0;
     3 q- v2 A; x& q( p8 s% w
186. }
     " d( g6 Z3 W; U) h
187. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。*/
     
188. void USB_LP_CAN1_RX0_IRQHandler(void)
     9 C9 d4 E5 M5 V
189. {
     
190. 
     
191. 
     * Y6 @2 Z5 B% r! [( Z+ T
192. 
     
193. 
     
194.   CanRxMsg RxMessage;
     
195. 
     * \8 {" I6 W7 ]9 k
196. 
     . c' `# k2 C6 f0 R. a! f" B8 G
197. 
     ! H6 S# F: }  \) A9 h6 {  U" A
198. 
     
199.   RxMessage.StdId=0x00;
     
200.   RxMessage.ExtId=0x00;
     
201.   RxMessage.IDE=0;
     
202.   RxMessage.DLC=0;
       R+ s5 e1 f, Y  i( g
203.   RxMessage.FMI=0;
       B* S" @+ g0 K  U( _6 t+ q
204.   RxMessage.Data[0]=0x00;
     
205.   RxMessage.Data[1]=0x00;   
     , {8 q1 i5 `0 Q! D+ v
206. 
     
207. 
     
208. 
     - E: X: p6 c* w6 n! P! l
209. 
     ! D% D$ A. h/ T, @+ e
210.   CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
     
211. 
     5 f% e" e- R! w0 t  l# S
212. 
     7 w, s9 d* T) ~$ `+ B. f% C
213. 
     ! v" u/ {5 [8 H. o+ w: K7 k' \# h
214. 
     
215.   if(Rx_flag == 0)//数据已取走或者缓冲器为空
     
216.     {
     . F% Q( K) Y$ W; n/ B/ M8 t
217.         RxBuf[0]=RxMessage.Data[0];
     / K* n  I. Y" e5 K- @. Q2 P/ S( j
218.         RxBuf[1]=RxMessage.Data[1];
     9 \9 y# f2 c: W
219.         Rx_flag=1;//数据已经备好，等待取走
     
220.     }
     
221. 
     - K4 Y3 M  ~8 Z# b7 R: C' j& [
222. 
     
223. 
     3 C3 ?' u2 I6 d8 c  G
224. 
     
225. }

复制代码

3 Z0 {- Q; g9 i; B* Vcan.h文件

1 {: o% A( R8 _2 c* k

% d6 j; E6 M* g- [主机相关代码
    这里主机代码大部分是和从机类似的，就只贴出不同的地方了。
- n7 K0 E6 h5 w" ^( O( xcan.c文件：
$ j% l( B9 }$ Y/ I$ f* J( D1 P+ s

1. #include "can.h"
   
2. 
   . g, v0 y- k8 k. ^. V" d
3. 
   
4. /* 在中断处理函数中返回 */
   
5. //__IO uint32_t ret = 0;
   5 C5 Z" q* c, h+ _
6. 
   
7. 
   
8. void CAN1_Init(void)
   ; ^1 v) ~- A4 q' N1 D: W
9. {
   
10.     ......//以上与从机部分相同
    
11. 
    3 B  V- u, y/ d  E. x
12. 
    ; M- \0 `+ n: x
13.     //CAN filter init 过滤器，已经设置为任意，可以通过ExtId标识符区分从机代号
    
14.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    
15.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    # z) P2 T& V  W) v/ L6 o
16.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
    
17.     CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;                //过滤器标识符的高16位值
    ! k$ G8 x0 d/ V- {5 V& q
18.     CAN_FilterInitStructure.CAN_FilterIdLow=CAN_ID_EXT|CAN_RTR_DATA;//过滤器标识符的低16位值
    : s1 }$ v% `) Y
19.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;            //过滤器屏蔽标识符的高16位值
    
20.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;             //过滤器屏蔽标识符的低16位值
    4 ~$ N* v0 z+ ]. q5 E- a) z2 x
21.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
    6 s. ]; O$ G1 X/ j/ t4 z9 |$ ^
22.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
    
23.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
    
24. 
    
25. 
    
26.     /* CAN FIFO0 message pending interrupt enable */
    % O% r5 y% \. S5 I/ ]* S
27.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
    
28. }
    % l9 e: u: |0 K) `' O
29. 
    , G* g. }  m# Y* M) z* S' T
30. 
    + v9 L1 Q( i; c0 a
31. //接收数据缓冲器
    
32. u8 CAN_RX_BUF[CAN_RX_LEN]={0};     //接收缓冲,最大USART_REC_LEN个字节.
    $ k" s- d; p  k) W7 M% k- s
33. //接收标志位
    
34. u8 Rx_flag=0;
    $ @% @: y3 ~8 W# C2 h
35. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
    
36. void USB_LP_CAN1_RX0_IRQHandler(void)
    
37. {
    
38.     u8 i=0;
    : }% Q7 e3 N5 {- w2 F2 s' X6 p
39.     CanRxMsg RxMessage;
    ; M8 R% r8 V1 x. F# h. y  s
40. 
    5 J& I( D+ I  B. O" E) p
41. 
    3 D8 l* [6 x7 w6 U; \3 j5 A
42.     RxMessage.StdId=0x00;
    6 M) U# |4 L" {3 h- F- g! g
43.     RxMessage.ExtId=0x00;
    " z$ ^0 k" m$ N9 b1 s
44.     RxMessage.IDE=0;
    9 P- r8 u' Z6 D
45.     RxMessage.DLC=0;
    " w1 _& C# q( E
46.     RxMessage.FMI=0;
    
47. 
    9 F, H6 G3 l. y4 e& N% Q  q
48. 
    
49.     CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
    / b4 E+ n' `1 d, }  P# h# y
50. 
    
51. 
    
52.     if(Rx_flag == 0)//数据已取走或者缓冲器为空
    ; {( n/ @7 ]& t+ @
53.     {
    - y* L- }8 f$ n8 f9 E" D+ ]
54.         if((RxMessage.DLC) == 2)//是否收到2位字节数据
    
55.         {
    
56.              CAN_RX_BUF[0]=RxMessage.Data[0];
    
57.              CAN_RX_BUF[1]=RxMessage.Data[1];     
    $ I* }7 q2 |8 J2 s: Q
58.         }
    ( ?1 t7 h4 U, I+ R" Q
59.     }
    0 M4 t1 W* t% T
60. 
    
61. 
      O  s# A4 d# X2 n  d* Y& X
62. }
    - B1 z4 I& ]7 b, t
63. 
    
64. 
    , R* C5 S2 `8 Z3 v) g  i
65. /* 发送两个字节的数据*/
    - J- e* e! R* h3 T7 H! c+ _
66. u8 CAN_SendMsg(u8* data1, u8* data2)
    
67. {
    6 C$ `+ J- H% f& p7 ]# B' I  [$ F
68.     u8 mbox;
    
69.     u16 i=0;
    
70.     CanTxMsg TxMessage;  
    
71. 
    
72. 
    
73.     TxMessage.StdId=0x0000;     //标准标识符为0x00
    2 s9 o; V3 H/ E  Z3 ~
74.     TxMessage.ExtId=0x1314;     //扩展标识符0x0000
    ! H6 s8 b: x8 T/ E3 a
75.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
    
76.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
    
77.     TxMessage.DLC=2;            //消息的数据长度为2个字节
    5 W! {! K# \4 s. }5 u
78.     TxMessage.Data[0]=Data1;    //第一个字节数据
    
79.     TxMessage.Data[1]=Data2;    //第二个字节数据
    
80. 
    
81. 
    ; k" _% x& ]+ B& ^. j' O& b
82.     //发送数据
    
83.     mbox= CAN_Transmit(CAN1, &TxMessage);  
    
84.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
    
85.         i++;    //等待发送结束
    
86.     if(i>=0XFFF)
    , G' W2 O% W% _5 `: |
87.         return 0;//发送失败
    
88.     return 1;//发送成功
    % I1 S3 m2 s+ A& j& w% V) R
89. }
    
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];
    9 E" }. M2 K5 w; n2 [- t
96.         Rx_flag=0;//数据已经取走，可以更新数据
    
97.         return 1;
    
98.     }else
    + a- i- E/ k4 E8 [. g
99.         return 0;
    
100. }
     3 u2 e2 z! x$ M& z) T, m
101. void Clear_canBuffer(void)
     9 V9 g( N$ [' Y; r& E
102. {
     & M' W7 ~( u( R* ]- q! e
103.     Rx_flag=0;//清楚接收标志位
     - y$ l4 C# e; W' ^5 r/ h3 |6 a
104.     memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区
     " {. U6 g9 U( ^
105. }
     / [, Y, z! F$ y0 @* `4 o8 M
106. u8 Check_canRX(void)
     
107. {
     
108.     return (Rx_flag == 6);
     
109. }

复制代码

- Y6 ?1 ~+ S: `3 H- ?can.h文件：
* v3 M% |" W2 ~8 u

1. #ifndef __CAN_H
   
2. #define __CAN_H
   
3. 
   
4. 
   
5. #include "sys.h"
   
6. #include "string.h"
   
7. 
   
8. 
   0 h7 f! J* ^/ D" C9 e, K, }
9. #define CAN_RX_LEN          30          //定义最大接收字节数
   
10. 
    
11. 
    ( g! y0 G, p* J& _. H3 I
12. extern u8  CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    
13. 
    
14. 
    
15. void CAN1_Init(void);
    5 b* g# ~1 V6 m1 Z% w* Y" u0 S" i0 n
16. u8 CAN_SendMsg(u8* data1, u8* data2);
    
17. u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
      T2 r# k! k2 z) s+ ^
18. 
    - `$ @5 z1 @) C0 e7 Q. X! S" ?
19. 
    
20. #endif /* __CAN_H */
    

复制代码

2 r: C7 `1 I3 Y& \( C0 E( n
4 k2 t+ ~" E: g转载自：单片机与嵌入式

( v3 G5 M' [" e; v如有侵权请联系删除

4 m% P9 }- v, G  `( W( L

5 m6 g  U6 X, D/ F1 i
2 {, @& V% B! [' g6 |: {* ^; l' \