CAN通信
    CAN 是Controller Area Network 的缩写（以下称为CAN），该通信使用的是ISO11898标准，该标准的物理层特征如下图所示。
( H( r1 f# e) G& k# r2 m3 w+ r. m
- e2 [: F) O7 D: c
2 `& b% G/ J' e: m, A% b
    CAN协议是通过以下5种类型的帧进行的：
数据帧
) ^3 E3 z6 ]8 w# J7 W1 f4 s摇控帧
错误帧
/ ~" ]$ N4 o+ H% K/ `5 M过载帧
  j9 u: h+ e* \% _帧间隔
5 A- ]8 i3 r( H
$ ?6 Q+ y3 Y) Y5 [6 @3 U    另外，数据帧和遥控帧有标准格式和扩展格式两种格式。标准格式有11 个位的标识符（ID），扩展格式有29 个位的ID。
' [2 m6 f& M, I) U$ q; U
' d" ?: }" A8 I# d$ }    大部分系统使用的都是数据帧 ，我这里使用的也是数据帧。
3 s- E& X: j- X4 {* g    数据帧一般由7个段构成，即：
& V# B: g4 s$ N9 S( I（1） 帧起始。表示数据帧开始的段。
（2） 仲裁段。表示该帧优先级的段。
（3） 控制段。表示数据的字节数及保留位的段。
+ v) f6 M% c6 H* H* \5 w  i（4） 数据段。数据的内容，一帧可发送0~8个字节的数据。
7 X: Y$ v8 L3 s3 q7 h, k- c（5） CRC段。检查帧的传输错误的段。
9 w( k# d) ~2 V（6） ACK段。表示确认正常接收的段。
/ c0 {8 |. S  _6 B: o（7） 帧结束。表示数据帧结束的段。
2 T7 @1 ?' f. c+ y
    明确了数据帧概念，还需要理解一下过滤器的作用。
6 T0 j2 A3 l+ t/ F" L, a
    STM32的标识符屏蔽滤波目的是减少了CPU处理CAN通信的开销。STM32的过滤器组最多有28个（互联型），但是STM32F103ZET6只有14个（增强型），每个滤波器组x由2个32为寄存器，CAN_FxR1和CAN_FxR2组成。
  M# o: R  \9 j- Q' f% z: q; |
# _! a% c3 T6 I2 Q( l. H* X    STM32每个过滤器组的位宽都可以独立配置，以满足应用程序的不同需求。根据位宽的不同，每个过滤器组可提供：
1个32位过滤器，包括：STDID[10:0]、EXTID[17:0]、IDE和RTR位
! p8 R6 Z3 d, i: T" [2个16位过滤器，包括：STDID[10:0]、IDE、RTR和EXTID[17:15]位
& Z8 q& r& J8 O( d- M
    此外过滤器可配置为，屏蔽位模式和标识符列表模式。
0 T  z# b! |! `0 u/ T( u$ X
- V5 O6 t3 a* L/ q% b- J' T    在屏蔽位模式下，标识符寄存器和屏蔽寄存器一起，指定报文标识符的任何一位，应该按照“必须匹配”或“不用关心”处理。
# U% r# e- L5 v% \
1 ]1 ]) R1 h8 O, o1 O: q3 l    而在标识符列表模式下，屏蔽寄存器也被当作标识符寄存器用。因此，不是采用一个标识符加一个屏蔽位的方式，而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟过滤器标识符相同。相关文章：CAN总线详解。
% R: O/ X% w- F% [
    一般也都是使用标识符列表模式，这里使用的也是标识符列表模式。滤波过程举例如下：

- I0 f" E' h9 d6 w/ x8 h

    在程序中就是：

1. //要过滤的ID高位
   : ~, O) z# _' I; }9 f+ O* V5 n6 p
2. CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;  
   / J/ d1 k. W; p
3. //要过滤的ID低位                 
     Q* N7 \& P5 Q8 V3 p
4. CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF;
   $ x$ [" _2 N0 B* X; ?( B
5. //过滤器屏蔽标识符的高16位值
   
6. CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;   
   6 S+ y) k4 t* Y
7. //过滤器屏蔽标识符的低16位值         
   + e; }8 i& i) \, \& s
8. CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;

复制代码

& l/ N- s& q8 E$ B2 `" w, U6 z; Z    这里的CAN_FilterId和CAN_FilterMaskId是配合使用的，意思是CAN_FilterId指出需要屏蔽ID的什么内容，什么格式；CAN_FilterMaskId是指CAN_FilterId的每一位是否需要过滤，若CAN_FilterMaskId在某位上是1的话，ID对应位上的数值就必须和CAN_FilterId该位上的一样，保持一致，反之则是“不关心”。

上述程序的设置的含义就是：只接收来自0x1314的数据，屏蔽其他ID的数据。
9 z: i3 V& i" s6 c4 O% V
程序思路
/ }8 \5 b+ i3 M: ^. S* T    这里准备做一个主机与从机的通信，主要用扩展标识符ExtId来区分，分配的标识符是：
  h/ w) A3 N, ]主机：0x1314
从机：0x1311

4 g% B9 [! y8 ?& h8 o+ A) e& p    主机负责接收所有从机的数据，不需要过滤，用扩展标识符ExtId来区分不同从机的数据；主机还可以向不同从机发送信息。而从机则只接收来自主机的数据，同样用扩展标识符ExtId来区分是否是发向自己的数据；同时，也能够向主机发送信息。
( y1 B$ u9 S% Q$ e9 k
# c$ l* h* A# B1 z( y( T1 S
- P3 i, P: p$ e+ j) v相关代码
    代码也是非常简单的，这里贴出了主机和从机的can.c和can.h两个文件。
! `4 ]: E: s' C/ D9 A
4 @% Q* V3 h: K& c" S6 s! K$ c从机相关代码
5 i/ Q0 l1 {+ z2 I0 R# B( tcan.c文件：

1. #include "can.h"
   
2. 
   & _" M) k! V# R9 ^) M" F& C
3. 
   + H0 W/ p8 V% a
4. 
   ) h  x( ^, }  {. y; t* y4 Z8 J
5. 
   
6. /* 在中断处理函数中返回 */
   + s' W4 f/ e5 R; k9 _% g/ J
7. //__IO uint32_t ret = 0;
   
8. 
   ; E( `3 X- P8 U4 {; Y
9. 
   
10. 
      ~" s) \( f- c2 S
11. 
    ; t" [7 c( ~5 Q/ B6 m
12. //接收数据缓冲器
    
13. u8 RxBuf[5];
    
14. u8 Rx_flag=0;
    2 Z4 y; M: u* ]7 A
15. 
    
16. 
    
17. 
    
18. 
    
19. void CAN1_Init(void)
    
20. {
    % M5 |( s) d$ z& d2 I% k
21.     GPIO_InitTypeDef GPIO_InitStructure;
    . K. a% P! n& t$ U6 E  s9 t
22.     NVIC_InitTypeDef NVIC_InitStructure;
    
23.     CAN_InitTypeDef        CAN_InitStructure;
    0 [# o4 Z6 L: Y
24.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    
25. 
    / u8 |: }" T" q7 Y
26. 
    
27. 
    / l; [/ X' ~( Q2 v) M$ F
28. 
    6 \9 F: Y! o- S, ^4 w
29.     /* 复用功能和GPIOB端口时钟使能*/   
    0 u7 U3 f4 z$ z
30.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);                                                                     
    
31. 
      p& X7 A- f; Y) L. Y
32. 
    4 ~2 Y% O/ m5 J
33. 
    
34. 
    
35.     /* CAN1 模块时钟使能 */
    9 l, \5 N9 }2 n2 w' y: ]% Y
36.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    2 J* v0 }8 }3 K2 V- C& y
37. 
    , r5 O; E% u' P0 R/ a
38. 
    - J9 J3 \  f! N8 o+ |: {; D
39. 
    
40. 
    
41.     /* Configure CAN pin: RX */  // PB8
    
42.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    
43.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;       //上拉输入
    8 R5 V7 @, l$ }2 G4 D! q- {$ r  x
44.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    ) R) n3 e" ~; t
45. 
      n( s3 |' s2 C
46. 
    4 n( p# E. C/ ]5 Q$ K7 L! d
47. 
    % z3 m4 \2 B  ?4 U, ]
48. 
    
49.     /* Configure CAN pin: TX */   // PB9
    ) g2 h4 D- L+ a! c
50.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    
51.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     //复用推挽输出
    
52.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    - W: F$ C3 b/ q# D
53. 
    * Z# J5 O. l1 L+ P
54. 
    
55. 
    
56. 
    
57.     //#define GPIO_Remap_CAN    GPIO_Remap1_CAN1 本实验没有用到重映射I/O
    0 Q( ~# p6 t  J' L2 h, @' N& \
58.     GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
    
59. 
    % W' `" R2 G& N- @
60. 
    ; W$ o: M; `# k! j' m
61. 
    
62. 
    % ^6 M( }  ]3 D! f, p
63.     //CAN_NVIC_Configuration(); //CAN中断初始化   
    ! ^' Z2 d* h. m! e$ h0 g. F
64.     /* Configure the NVIC Preemption Priority Bits */  
    0 l* n' e$ I" m* b" K  w
65.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    2 h9 [# K8 f" o; M% x& H$ i
66. 
    5 i, A0 ~6 M0 I
67. 
    ) F0 p5 e0 o: H+ Q- N2 X
68. 
    + t/ K) x' T4 `, o
69. 
    
70.     #ifdef  VECT_TAB_RAM  
    
71.       /* Set the Vector Table base location at 0x20000000 */
    : d4 f. {4 d: U& K9 u% K
72.       NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
    # s* g0 K: T0 ?3 Q  y
73.     #else  /* VECT_TAB_FLASH  */
    
74.       /* Set the Vector Table base location at 0x08000000 */
    ( D9 A9 ~5 G2 l" p8 [! P
75.       NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
    ; R& \$ T+ d+ x3 w! w! J. M6 u% V
76.     #endif
    
77. 
    
78. 
    1 \* a7 M, Z/ H# m
79. 
    2 \/ k1 O5 G$ [  a+ `
80. 
    
81.     /* enabling interrupt */
    % E+ q$ C+ u0 \$ W" U
82.     NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;
    " w( z3 j) z, `6 @6 o: `8 d/ l9 O
83.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    
84.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    9 E- \; W6 }+ g+ m
85.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
86.     NVIC_Init(&NVIC_InitStructure);
    6 j( I# j1 q' r! r) Y) v! c
87. 
    
88. 
    
89. 
    
90. 
    
91.     //CAN_INIT();//CA初始化N模块
    
92.     /* CAN register init */
    
93.     CAN_DeInit(CAN1);                       //将外设CAN的全部寄存器重设为缺省值
    
94.     CAN_StructInit(&CAN_InitStructure);     //把CAN_InitStruct中的每一个参数按缺省值填入
    
95. 
    
96. 
    / v/ l' p( j4 ?+ r3 X6 l' }
97. 
    ) f% r% N2 t8 W0 L
98. 
    3 X2 \% ^- U% s1 {( w% u& f
99.     /* CAN cell init */
    
100.     CAN_InitStructure.CAN_TTCM=DISABLE;         //没有使能时间触发模式
     9 H3 C# Z+ @" |" _# K! @
101.     CAN_InitStructure.CAN_ABOM=DISABLE;         //没有使能自动离线管理
     
102.     CAN_InitStructure.CAN_AWUM=DISABLE;         //没有使能自动唤醒模式
     " o* B: L' i4 ], U
103.     CAN_InitStructure.CAN_NART=DISABLE;         //没有使能非自动重传模式
     4 R5 }5 j# u  l9 U$ d; R
104.     CAN_InitStructure.CAN_RFLM=DISABLE;         //没有使能接收FIFO锁定模式
     
105.     CAN_InitStructure.CAN_TXFP=DISABLE;         //没有使能发送FIFO优先级
     # G# D: \0 w6 Z) |0 \- I1 r- v
106.     CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式
     , ]" @2 @$ ~( z; R3 C- q" U
107.     CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;      //重新同步跳跃宽度1个时间单位
     * A" |/ ?2 o6 ?7 q# L
108.     CAN_InitStructure.CAN_BS1=CAN_BS1_3tq;      //时间段1为3个时间单位
     
109.     CAN_InitStructure.CAN_BS2=CAN_BS2_2tq;      //时间段2为2个时间单位
     
110.     CAN_InitStructure.CAN_Prescaler=60;         //时间单位长度为60
     8 h" Z/ ?0 V+ d( S9 S$ u3 z& y
111.     CAN_Init(CAN1,&CAN_InitStructure);          //波特率为：72M/2/60(1+3+2)=0.1 即波特率为100KBPs
     ' a$ u6 T# w+ n
112. 
     + N; ~" u& x( [- b4 p: u
113. 
     
114. 
     
115. 
     # s* q4 b8 I$ [: l1 q* D4 g
116.     // CAN filter init 过滤器，注意，只接收主机发过来的数据，屏蔽其他数据
     . S! U9 y0 K6 m) N% W. C% y8 y
117.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
     
118.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
     
119.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
     3 z! d. G* l: A
120. 
     
121. 
     : E9 f: u& s& `7 |( Q  |
122. 
     
123. 
     : q& a) j: d& k# l" n2 T
124.     //CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16;  
     
125.     CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;                  //要过滤的ID高位
     3 ?* K* D$ E+ x/ j- B
126.     CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位
     
127. 
     
128. 
     6 e! M! `0 f4 X; v
129. 
     ; `/ r6 g/ e/ p) K# T% Z
130. 
     . ]" T8 x- X- Z) h
131.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;            //过滤器屏蔽标识符的高16位值
     , `, x, b' ?. }3 \" M& y
132.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;             //过滤器屏蔽标识符的低16位值
     ! I+ y% s! ]4 S# f! O! b
133.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
     
134.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
     0 }' C: n. a) L9 y( y- N7 d, m: V
135.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
     
136. 
     3 R: X; X# B8 X6 {8 w$ ?5 t
137. 
     
138. 
     : ?+ K  u+ U) @3 |
139. 
     
140.     /* CAN FIFO0 message pending interrupt enable */
     ' \% v4 W5 v# }* c
141.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
       @8 I* n- b) H) s, e
142. }
     ( q7 L% n" h. K( e# }5 d9 K
143. 
     $ Q% A- H: t& `  @& X0 X% Q
144. 
     
145. 
     2 Y( ^2 b$ B% S: e: d: p6 Y7 P
146. 
     5 h* C  {% m3 C2 `4 I/ {
147. /* 发送两个字节的数据*/
     ! ?  o3 N( g% |# ?) e
148. u8 CAN_SetMsg(u8 Data1,u8 Data2)
     
149. {
     ' T% _: u0 k7 Q& v
150.     u8 mbox;
     / s0 V* A8 D$ b# D; F4 U/ n; U/ I
151.     u16 i=0;
     
152.     CanTxMsg TxMessage;  
     . G5 U8 [2 g: z+ L! R
153. 
     
154. 
     
155. 
     8 \8 E' J3 z# ^' j
156. 
     
157.     TxMessage.StdId=0x0000;     //标准标识符为0x00
     / l5 q9 g3 I  l( c" M
158.     TxMessage.ExtId=0x1311;     //扩展标识符0x1311,可以更改该标识符以示区分不同从机
     ' X% c) v5 y/ k
159.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
     
160.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
     9 i% B' q- P+ Y+ ~  y
161.     TxMessage.DLC=2;            //消息的数据长度为2个字节
     
162.     TxMessage.Data[0]=Data1;    //第一个字节数据
     " T/ V5 Y  ~9 u* p' V+ e
163.     TxMessage.Data[1]=Data2;    //第二个字节数据
     
164. 
     
165. 
     
166. 
     1 t; _5 H3 n6 `0 Z$ y% I" o
167. 
     8 i- N6 v$ O7 B0 Y- O& c: B
168.     //发送数据
     
169.     mbox= CAN_Transmit(CAN1, &TxMessage);  
     # s: e2 x( w* v! C9 z  |8 d
170.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
     / D! j* X9 r' J6 _& `0 h
171.         i++;    //等待发送结束
     
172.     if(i>=0XFFF)
     + o6 j' y/ l. V3 X% p
173.         return 0;
     
174.     return 1;
     - j' D  l3 ]# ^( ]* @6 \% ~. ]8 v
175. }
     
176. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
     
177. {
     
178.     if(Rx_flag == 1)//发现数据
     
179.     {
     2 H/ A+ E* b. \
180.         *msg1=RxBuf[0];
     
181.         *msg2=RxBuf[1];
     
182.         Rx_flag=0;//数据已经取走，可以更新数据
     4 T# c! B; e, g+ B0 Q2 l8 J: T& t
183.         return 1;
     7 I/ @& t( Z/ x8 ~
184.     }else
     ' w+ A& T6 E; |6 b) E& {: g- t
185.         return 0;
     # X1 L; k' d0 x( ?8 T  i
186. }
     
187. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。*/
     # {$ _' A8 ]& U- _$ o
188. void USB_LP_CAN1_RX0_IRQHandler(void)
     
189. {
     
190. 
     
191. 
     8 `8 F/ g4 O7 _  k1 R  J6 Y5 d7 W7 u+ q
192. 
     
193. 
     1 q7 w( n8 V$ p/ _& |4 o
194.   CanRxMsg RxMessage;
     
195. 
     
196. 
     % `5 A% q) Q6 K/ c
197. 
     & a" L  \8 W- v4 V. S
198. 
     
199.   RxMessage.StdId=0x00;
     
200.   RxMessage.ExtId=0x00;
     ( c. {# f: q, _- K
201.   RxMessage.IDE=0;
     
202.   RxMessage.DLC=0;
     
203.   RxMessage.FMI=0;
     
204.   RxMessage.Data[0]=0x00;
     5 c2 L2 Y6 h. C. n  I/ h
205.   RxMessage.Data[1]=0x00;   
     1 |/ r/ v3 E9 {2 n! Y/ O! [
206. 
     
207. 
     
208. 
     
209. 
     
210.   CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
     
211. 
     * d. [2 ]/ F" q4 y4 n; v9 [8 s
212. 
     5 u8 T% K9 _/ L& F# |. I
213. 
     , E6 ^3 V( x3 T* Z
214. 
     8 o3 X, n+ P& a, e9 O' I* h3 n
215.   if(Rx_flag == 0)//数据已取走或者缓冲器为空
     
216.     {
     
217.         RxBuf[0]=RxMessage.Data[0];
     ' T1 a5 z( [3 f
218.         RxBuf[1]=RxMessage.Data[1];
     
219.         Rx_flag=1;//数据已经备好，等待取走
     : S. Y& v$ I% ?) e
220.     }
     ) x/ Y) [+ ^: s; O0 l( w
221. 
     1 f6 l& {8 U/ o
222. 
     2 S2 d1 u, j2 L
223. 
     ) X% p% I8 q' S) b& W- G- v( l( t
224. 
     ! j! @$ P9 U8 }- O2 M1 ?
225. }

复制代码

$ U% K0 ~. E0 c3 A7 m. M. ecan.h文件

" N! R3 k4 b. F0 U* I4 @! I2 D7 g
! b- o' d! C/ C% _' R
) E, \2 ]7 I+ q. W/ Y) z主机相关代码
4 d& z. u+ X& @( D& K, _    这里主机代码大部分是和从机类似的，就只贴出不同的地方了。
  v! `! r5 _9 |( ], a/ H6 ^7 x. kcan.c文件：

1. #include "can.h"
   + I& X7 a$ C/ d+ S7 x
2. 
   
3. 
   
4. /* 在中断处理函数中返回 */
   
5. //__IO uint32_t ret = 0;
   
6. 
   + w7 |, C2 r) a1 o1 E: R! j
7. 
   
8. void CAN1_Init(void)
   
9. {
   
10.     ......//以上与从机部分相同
    9 k' Q# A- N* D7 F  W' e
11. 
    ) ?2 R* i& O" K5 z
12. 
    
13.     //CAN filter init 过滤器，已经设置为任意，可以通过ExtId标识符区分从机代号
    
14.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    2 Y+ y9 D) Y) ]+ T
15.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    
16.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
    
17.     CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;                //过滤器标识符的高16位值
    
18.     CAN_FilterInitStructure.CAN_FilterIdLow=CAN_ID_EXT|CAN_RTR_DATA;//过滤器标识符的低16位值
    5 X7 `4 }! K4 l# c/ e7 A
19.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;            //过滤器屏蔽标识符的高16位值
    
20.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;             //过滤器屏蔽标识符的低16位值
    
21.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
    7 [- t7 I& P/ N
22.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
      E) V4 p- K! ^, u0 P3 A* p8 {
23.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
    : s  q; `; I( {- k
24. 
    9 q% _3 D5 {( N( S" |
25. 
    
26.     /* CAN FIFO0 message pending interrupt enable */
    
27.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
    
28. }
    3 j& R$ t9 o! W% W3 o
29. 
    : [/ @: s1 h1 ]# n
30. 
    , d9 w5 a6 B3 @
31. //接收数据缓冲器
    2 c* E& ]% M" z* b2 x9 V
32. u8 CAN_RX_BUF[CAN_RX_LEN]={0};     //接收缓冲,最大USART_REC_LEN个字节.
    
33. //接收标志位
    
34. u8 Rx_flag=0;
    
35. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
    
36. void USB_LP_CAN1_RX0_IRQHandler(void)
    
37. {
    
38.     u8 i=0;
    3 T0 U% ~, {: L* o4 E, r- A- B+ @0 t6 O
39.     CanRxMsg RxMessage;
    0 y7 [) ~" b; X% m3 j* Q
40. 
    
41. 
    0 G1 D& ?7 F% j2 w* r
42.     RxMessage.StdId=0x00;
    
43.     RxMessage.ExtId=0x00;
    ! U+ ?- \; s1 m
44.     RxMessage.IDE=0;
    
45.     RxMessage.DLC=0;
    
46.     RxMessage.FMI=0;
    ' O: V; u0 b. r: I! @6 j7 F0 r
47. 
    ' e$ u. F( l- X1 c% E7 c6 a' E
48. 
    
49.     CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
    9 i& `9 m6 |# _9 x" O0 N$ b1 R
50. 
    # [- i6 u' {+ i9 L
51. 
    
52.     if(Rx_flag == 0)//数据已取走或者缓冲器为空
    5 q1 m. i% @; R9 K9 s$ _
53.     {
    
54.         if((RxMessage.DLC) == 2)//是否收到2位字节数据
    
55.         {
    , v' ~& v6 a8 a# [, _
56.              CAN_RX_BUF[0]=RxMessage.Data[0];
    8 V) ?+ A6 I% n
57.              CAN_RX_BUF[1]=RxMessage.Data[1];     
    
58.         }
    7 w$ [4 F& G6 q& n
59.     }
    ; Z4 T8 U: L) O- e9 `& t9 d
60. 
    
61. 
    
62. }
    ) Y  \) m8 G3 m9 ^+ F3 g* N
63. 
    1 v8 S& x7 w; V; B5 ]: Y" C1 @
64. 
    ! e5 W, A) Z8 O. N( Z
65. /* 发送两个字节的数据*/
    
66. u8 CAN_SendMsg(u8* data1, u8* data2)
    
67. {
    
68.     u8 mbox;
    $ {* g5 b% T7 l* t7 H" A- d
69.     u16 i=0;
    
70.     CanTxMsg TxMessage;  
    
71. 
    
72. 
    
73.     TxMessage.StdId=0x0000;     //标准标识符为0x00
    
74.     TxMessage.ExtId=0x1314;     //扩展标识符0x0000
    
75.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
    
76.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
    , [# @: a3 g1 B; T' s, W/ E& K6 A; Q
77.     TxMessage.DLC=2;            //消息的数据长度为2个字节
    " C. x  }2 T, M, g6 J1 j# i0 t+ L4 W
78.     TxMessage.Data[0]=Data1;    //第一个字节数据
    
79.     TxMessage.Data[1]=Data2;    //第二个字节数据
    3 S& L/ _/ v$ [& L: o
80. 
    . h8 m" W1 s; f& n! F" o
81. 
    
82.     //发送数据
    
83.     mbox= CAN_Transmit(CAN1, &TxMessage);  
    & A5 F  ?6 ~0 f9 m: f- Y
84.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
    
85.         i++;    //等待发送结束
    
86.     if(i>=0XFFF)
      {  g4 F8 Z+ Q& V1 T  m
87.         return 0;//发送失败
    0 @7 f* }8 _/ y2 }
88.     return 1;//发送成功
    + U; z0 U) \/ U* @  R
89. }
    : f0 y+ _# ^' }: R6 M# P
90. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
    
91. {
    
92.     if(Rx_flag == 1)//发现数据
    
93.     {
    4 {* E/ T4 D' k! {$ g
94.         *msg1=CAN_RX_BUF[0];
    # I/ T% S" u8 Z) b1 p. M
95.         *msg2=CAN_RX_BUF[1];
    2 Z% P0 Z8 c7 P. v/ ^2 R/ \9 G
96.         Rx_flag=0;//数据已经取走，可以更新数据
    , Z2 z: [; K% [. G
97.         return 1;
    : x( N0 W& S- Z) u" C
98.     }else
    8 S8 T& K! j' c
99.         return 0;
    & C: y+ U* c" ?- J# G4 s+ B* X
100. }
     $ O& K- F! W- o( H  o
101. void Clear_canBuffer(void)
     
102. {
     * D8 p. e3 y5 u+ v+ b
103.     Rx_flag=0;//清楚接收标志位
     . t) j  E0 I2 |: q. s5 p* {2 O
104.     memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区
     
105. }
     
106. u8 Check_canRX(void)
     & B5 ~: U6 b2 m/ _- T
107. {
     
108.     return (Rx_flag == 6);
     
109. }

复制代码

) u8 z, [% r$ h; Q4 U& o  ?5 D8 zcan.h文件：

1. #ifndef __CAN_H
   $ z$ X3 ]/ N( l) _  X/ f/ ]
2. #define __CAN_H
   
3. 
   7 q0 t# m" O  A$ V2 s- ?+ a
4. 
   
5. #include "sys.h"
   . t6 @8 S1 ?  f7 W8 F
6. #include "string.h"
   
7. 
   4 t1 O7 t7 d4 }6 `4 m: o
8. 
   
9. #define CAN_RX_LEN          30          //定义最大接收字节数
   % B7 _7 t' a* }# O- H4 E& n) P4 T
10. 
    . W- K! I' Q# m
11. 
    
12. extern u8  CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    
13. 
    
14. 
    3 [3 M5 ~$ ~0 r: V  f9 S
15. void CAN1_Init(void);
    . y2 t. s! _: C
16. u8 CAN_SendMsg(u8* data1, u8* data2);
    ! V/ v- C5 J- N3 l& P
17. u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
    * h. {- T" R4 S2 U
18. 
    
19. 
    % V6 Q* v/ ~; W0 {
20. #endif /* __CAN_H */
    ( C. @! |# x& @1 y, r, M! i

复制代码

& C- O5 k* d) H. @+ {
转载自：单片机与嵌入式

如有侵权请联系删除

+ R1 n1 H3 d9 A; X4 u' l4 Z. u
8 \' o6 W1 k2 o
' M+ |' u/ k& k- C
6 \( v; a0 r* y