CAN通信
    CAN 是Controller Area Network 的缩写（以下称为CAN），该通信使用的是ISO11898标准，该标准的物理层特征如下图所示。
2 `! L: s7 H2 ^. b$ e


& d0 N: {# b$ F    CAN协议是通过以下5种类型的帧进行的：
5 [  X# a" E' e# i+ H3 y4 a, @7 {数据帧
摇控帧
错误帧
过载帧
8 S  X5 t' m. K# Q& A帧间隔

    另外，数据帧和遥控帧有标准格式和扩展格式两种格式。标准格式有11 个位的标识符（ID），扩展格式有29 个位的ID。
' K' J% E2 Q- J) i7 g9 ^2 X4 M# L
. ], C; L6 X0 F$ d( X0 s) a    大部分系统使用的都是数据帧 ，我这里使用的也是数据帧。
9 T/ k5 R6 H* W) h; w$ M    数据帧一般由7个段构成，即：
( O# d+ n6 ]: D! }9 S( e（1） 帧起始。表示数据帧开始的段。
（2） 仲裁段。表示该帧优先级的段。
（3） 控制段。表示数据的字节数及保留位的段。
: m4 L( }, Y. e! e4 \- x8 Y（4） 数据段。数据的内容，一帧可发送0~8个字节的数据。
, R  o# V6 W7 V（5） CRC段。检查帧的传输错误的段。
（6） ACK段。表示确认正常接收的段。
（7） 帧结束。表示数据帧结束的段。
" o. Z/ U! b  J: e' r
    明确了数据帧概念，还需要理解一下过滤器的作用。
& t( `/ A( w: H8 H$ h1 a1 m
    STM32的标识符屏蔽滤波目的是减少了CPU处理CAN通信的开销。STM32的过滤器组最多有28个（互联型），但是STM32F103ZET6只有14个（增强型），每个滤波器组x由2个32为寄存器，CAN_FxR1和CAN_FxR2组成。

    STM32每个过滤器组的位宽都可以独立配置，以满足应用程序的不同需求。根据位宽的不同，每个过滤器组可提供：
1个32位过滤器，包括：STDID[10:0]、EXTID[17:0]、IDE和RTR位
2个16位过滤器，包括：STDID[10:0]、IDE、RTR和EXTID[17:15]位
# _; ]6 b$ I' q4 h6 T
    此外过滤器可配置为，屏蔽位模式和标识符列表模式。

  C7 h6 K4 C9 d+ v' Q# g    在屏蔽位模式下，标识符寄存器和屏蔽寄存器一起，指定报文标识符的任何一位，应该按照“必须匹配”或“不用关心”处理。
( d$ R2 Y7 M$ C* x( T& f+ ^0 a7 R
    而在标识符列表模式下，屏蔽寄存器也被当作标识符寄存器用。因此，不是采用一个标识符加一个屏蔽位的方式，而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟过滤器标识符相同。相关文章：CAN总线详解。
/ V4 Q3 X- f# p# L9 c
9 Z  o, X2 V5 x' B% W! X    一般也都是使用标识符列表模式，这里使用的也是标识符列表模式。滤波过程举例如下：



3 b% A7 E+ }/ u# o! J  s& V4 X3 i    在程序中就是：

1. //要过滤的ID高位
   $ ?" {( `! o2 W/ Z5 x8 [
2. CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;  
   
3. //要过滤的ID低位                 
   2 D; A! Q* c# K
4. CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF;
   . D7 ^6 a4 f" w9 Z! S6 }
5. //过滤器屏蔽标识符的高16位值
   
6. CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;   
   
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该位上的一样，保持一致，反之则是“不关心”。

上述程序的设置的含义就是：只接收来自0x1314的数据，屏蔽其他ID的数据。
3 E% V7 A  g9 |' A
5 u" Z$ i5 x1 W程序思路
    这里准备做一个主机与从机的通信，主要用扩展标识符ExtId来区分，分配的标识符是：
8 g" ~; X6 Y1 R+ [主机：0x1314
. J: _8 X8 r; T, `) C! j; U从机：0x1311

* m0 l/ ]& h* W# s2 s( t    主机负责接收所有从机的数据，不需要过滤，用扩展标识符ExtId来区分不同从机的数据；主机还可以向不同从机发送信息。而从机则只接收来自主机的数据，同样用扩展标识符ExtId来区分是否是发向自己的数据；同时，也能够向主机发送信息。
/ o, H  o3 N6 _

相关代码
    代码也是非常简单的，这里贴出了主机和从机的can.c和can.h两个文件。
6 ^) j, l  H6 B0 H
从机相关代码
can.c文件：

1. #include "can.h"
   
2. 
   0 [$ Z5 ^+ }& y" D3 v8 a
3. 
   , H4 C7 D$ [1 _! }
4. 
   
5. 
   ! b, n; n, ]7 E7 ?: V; v, |- }
6. /* 在中断处理函数中返回 */
   
7. //__IO uint32_t ret = 0;
   - \5 f  N& E- f# I
8. 
   
9. 
   ' E9 k) X& S4 r4 z9 u
10. 
    
11. 
    
12. //接收数据缓冲器
    
13. u8 RxBuf[5];
    
14. u8 Rx_flag=0;
    
15. 
    
16. 
    
17. 
    
18. 
    
19. void CAN1_Init(void)
    + v" y- C2 `1 X' [
20. {
    6 N; m+ W" d7 I2 A# C+ q! B, u
21.     GPIO_InitTypeDef GPIO_InitStructure;
    & _1 M3 u' k- `
22.     NVIC_InitTypeDef NVIC_InitStructure;
    $ v* ]  a# ]' b
23.     CAN_InitTypeDef        CAN_InitStructure;
    
24.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    
25. 
    
26. 
    * p+ H1 J8 b8 Z- k
27. 
    
28. 
    
29.     /* 复用功能和GPIOB端口时钟使能*/   
    
30.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);                                                                     
    
31. 
    ; b% ^2 [/ s7 q. E
32. 
    
33. 
    $ y0 }1 h7 }$ |0 f2 b) {0 |) ^
34. 
    ) ~5 H$ {: r  N& v) |- ?
35.     /* CAN1 模块时钟使能 */
    ) ~7 b1 k( u  N7 j% s+ @
36.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    
37. 
    
38. 
    
39. 
    : A9 P* h! U9 W" S8 \4 [
40. 
    
41.     /* Configure CAN pin: RX */  // PB8
    ' `# m4 c1 }8 @) V
42.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    
43.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;       //上拉输入
    
44.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    
45. 
    
46. 
    
47. 
    
48. 
    # N' K( N  N% Z
49.     /* Configure CAN pin: TX */   // PB9
    
50.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    ! {3 J& g$ X$ G* t) T) u5 @
51.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     //复用推挽输出
    
52.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    
53. 
    $ r* B9 u0 Q* _* B
54. 
    . f( N# S, U, d
55. 
    
56. 
    
57.     //#define GPIO_Remap_CAN    GPIO_Remap1_CAN1 本实验没有用到重映射I/O
    
58.     GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
    8 I& x( `2 R5 B9 x) q" w) O2 c6 a
59. 
    
60. 
    * f7 d% A5 q2 R
61. 
    
62. 
    1 O7 t4 g, S: I# D9 ?4 g3 T
63.     //CAN_NVIC_Configuration(); //CAN中断初始化   
    , }4 {/ ^. ^; g1 R- R' J
64.     /* Configure the NVIC Preemption Priority Bits */  
    
65.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    
66. 
    : q5 _; c4 N! z* o) a
67. 
    % z* T4 G# }1 Q6 _7 u; O
68. 
    
69. 
    ! ^2 u5 [2 e$ w+ o* `( a
70.     #ifdef  VECT_TAB_RAM  
    ; J' @! D) L* E3 w) c
71.       /* Set the Vector Table base location at 0x20000000 */
    ! L7 ^' o9 C" a$ V% I8 H  k# v
72.       NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
    6 c8 ~" b/ c* Q! Z0 _
73.     #else  /* VECT_TAB_FLASH  */
    
74.       /* Set the Vector Table base location at 0x08000000 */
    ! V1 `- |" J0 p+ ?; S0 \
75.       NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
    
76.     #endif
    
77. 
    5 D% d) O: e9 w& K" N( H
78. 
      L  e$ I, s9 x$ x
79. 
    
80. 
    
81.     /* enabling interrupt */
    
82.     NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;
    ' l( J  Z+ I# g+ F( z4 T
83.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    % Y) r7 C, |# z
84.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    ( t9 V! d" u, w; C# a! G
85.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    / _+ E# g3 h6 w* x" ?
86.     NVIC_Init(&NVIC_InitStructure);
    
87. 
    2 H7 @2 _# F; K. z; \
88. 
    : s! Y" \+ Z) I* c( Y+ \
89. 
    
90. 
    3 M. `( l" w6 h, v
91.     //CAN_INIT();//CA初始化N模块
    " l5 T2 l3 N, u2 B7 T1 d) X5 U
92.     /* CAN register init */
    3 g) x/ w. J1 q, \1 e- H
93.     CAN_DeInit(CAN1);                       //将外设CAN的全部寄存器重设为缺省值
    
94.     CAN_StructInit(&CAN_InitStructure);     //把CAN_InitStruct中的每一个参数按缺省值填入
    9 P7 |* Y* A* B; `- y, ?
95. 
    . j. L* d& B" C& c% F
96. 
    / O/ }1 A1 S0 b5 |; }% f3 |% \
97. 
    
98. 
    , _7 _6 E5 ?/ k- h
99.     /* CAN cell init */
    
100.     CAN_InitStructure.CAN_TTCM=DISABLE;         //没有使能时间触发模式
     0 _# Z8 u9 _6 v8 h# U8 J& `
101.     CAN_InitStructure.CAN_ABOM=DISABLE;         //没有使能自动离线管理
     1 m- f9 d8 v0 \7 p. S. t+ d9 Y
102.     CAN_InitStructure.CAN_AWUM=DISABLE;         //没有使能自动唤醒模式
     ; H! X( Y9 n% @; j: a
103.     CAN_InitStructure.CAN_NART=DISABLE;         //没有使能非自动重传模式
     ! A& @8 T/ `" X" y
104.     CAN_InitStructure.CAN_RFLM=DISABLE;         //没有使能接收FIFO锁定模式
     3 \7 h4 W, O( Z9 ~
105.     CAN_InitStructure.CAN_TXFP=DISABLE;         //没有使能发送FIFO优先级
     
106.     CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式
     , A9 W0 B/ H4 ]5 m% X5 k" h
107.     CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;      //重新同步跳跃宽度1个时间单位
     6 P1 Z5 S8 i+ o5 \8 n
108.     CAN_InitStructure.CAN_BS1=CAN_BS1_3tq;      //时间段1为3个时间单位
     + e  V, F! p  C. E( T
109.     CAN_InitStructure.CAN_BS2=CAN_BS2_2tq;      //时间段2为2个时间单位
     * a* V( A/ j3 k. b  n  B. Q5 q
110.     CAN_InitStructure.CAN_Prescaler=60;         //时间单位长度为60
     ! f3 w9 z! _% h6 p
111.     CAN_Init(CAN1,&CAN_InitStructure);          //波特率为：72M/2/60(1+3+2)=0.1 即波特率为100KBPs
     
112. 
     # B  p# ]/ n: Z
113. 
     " f' f1 N* M1 W" U% s9 v1 G
114. 
     : c9 g$ w- d5 T# X- Z
115. 
       d- V$ U' p. w' Y5 k5 E# I
116.     // CAN filter init 过滤器，注意，只接收主机发过来的数据，屏蔽其他数据
     ( d/ F+ D( `" X& k
117.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
     
118.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
     & {% \# ^. o) o( U4 E
119.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
     # _3 v7 M0 \5 L; a/ k7 P; y4 N* o+ j$ W
120. 
     / V+ T; ?+ i+ e* T4 n( }/ H3 h
121. 
     3 W% W: g2 M3 v, x& W1 ]7 }! z4 \" W
122. 
     
123. 
     
124.     //CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16;  
     
125.     CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;                  //要过滤的ID高位
     
126.     CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位
     4 K) C+ O: J/ S/ a9 j
127. 
     ' O8 }. g  v, H8 {8 D+ A7 ]
128. 
     - r7 q6 F* Z' _8 V
129. 
     % l5 ^1 q" ?  V$ q; E
130. 
     
131.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;            //过滤器屏蔽标识符的高16位值
       {3 h$ o* r- H
132.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;             //过滤器屏蔽标识符的低16位值
     
133.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
     
134.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
     ) B$ I: v! `, y/ l$ y" j% q
135.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
     " f3 u- R5 l$ n
136. 
     8 F! ]8 n2 m( B2 m
137. 
     
138. 
     : A$ f# A* I, Y& A5 w- {8 H, I1 A) Z
139. 
     
140.     /* CAN FIFO0 message pending interrupt enable */
     
141.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
     ; h5 J3 i1 K! z' x" r; a# b# f
142. }
     
143. 
     
144. 
     
145. 
     & [$ b7 U8 ?0 B8 x
146. 
     
147. /* 发送两个字节的数据*/
     9 f9 f$ f* c4 s0 V+ k8 @. Y  J
148. u8 CAN_SetMsg(u8 Data1,u8 Data2)
     ; Y% p9 [! n! F; J% U0 u
149. {
     6 Z" U7 F7 K/ E' w; v6 |+ [9 X
150.     u8 mbox;
       e% E2 w% E# ]1 g% |  z
151.     u16 i=0;
     : ^, _- `" _6 g2 r) y: n
152.     CanTxMsg TxMessage;  
     
153. 
     + z7 f" U; }: l7 x8 ~+ Q3 s
154. 
     
155. 
     - g, g* h* l) m9 S) R7 _4 \7 N
156. 
     ' [: U* w* k6 @! l
157.     TxMessage.StdId=0x0000;     //标准标识符为0x00
     
158.     TxMessage.ExtId=0x1311;     //扩展标识符0x1311,可以更改该标识符以示区分不同从机
     
159.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
     , U+ ~# y: i* x# |7 X+ q
160.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
     
161.     TxMessage.DLC=2;            //消息的数据长度为2个字节
     
162.     TxMessage.Data[0]=Data1;    //第一个字节数据
     
163.     TxMessage.Data[1]=Data2;    //第二个字节数据
     & ]( K! L# U4 F( D6 P  L7 ]& {0 S
164. 
     ) p0 Z8 K$ X& C# M4 Q
165. 
     4 F2 u" \3 Q+ ~9 M# i
166. 
     ' ~! h- h. T; k7 Z) C
167. 
     & m) `  G. K, C4 S
168.     //发送数据
     
169.     mbox= CAN_Transmit(CAN1, &TxMessage);  
     4 g0 N5 K3 I' M+ u" ~- P" u; D' H
170.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
     
171.         i++;    //等待发送结束
     
172.     if(i>=0XFFF)
     & r! F/ d% P* v, x& R. H
173.         return 0;
     ; s0 y2 w. k  ~# E# c
174.     return 1;
     5 ?4 I/ Z) u) B6 v0 v
175. }
     * F, I/ ?4 W& J8 G2 Z* b1 f
176. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
     
177. {
     
178.     if(Rx_flag == 1)//发现数据
     . f) D! |3 F  v: R8 {0 K* y
179.     {
     
180.         *msg1=RxBuf[0];
     
181.         *msg2=RxBuf[1];
     
182.         Rx_flag=0;//数据已经取走，可以更新数据
     
183.         return 1;
     ( E2 f6 G$ d  X8 K) X
184.     }else
     
185.         return 0;
     
186. }
     
187. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。*/
     
188. void USB_LP_CAN1_RX0_IRQHandler(void)
     9 H* R' G2 Y& H% _! a- i1 ~
189. {
     # p  Z; j' `0 Q3 y0 ], @& B2 ]
190. 
     
191. 
     
192. 
     
193. 
     
194.   CanRxMsg RxMessage;
     
195. 
       S: H/ r: W2 z/ u# O' P
196. 
     
197. 
     
198. 
     
199.   RxMessage.StdId=0x00;
     
200.   RxMessage.ExtId=0x00;
     % M; |' W$ k/ I- Q( V
201.   RxMessage.IDE=0;
     
202.   RxMessage.DLC=0;
     ; @  H3 u! [: G& ~0 I7 f, u1 q7 P
203.   RxMessage.FMI=0;
     
204.   RxMessage.Data[0]=0x00;
     & {" U1 e+ a/ z+ G% C
205.   RxMessage.Data[1]=0x00;   
     * k( K8 C2 M, F0 X1 n- K6 U* E
206. 
     2 j5 u$ D. G" B# q* L2 \; z
207. 
     
208. 
     
209. 
     0 Q% d9 Z) h# a( e
210.   CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
     
211. 
       N& x& V+ V3 `5 _
212. 
     / @5 k. U; \% w& V: S  q7 n
213. 
     & H% g: U. x, r. u7 i
214. 
     . w# p; b( l7 ]& o5 Z
215.   if(Rx_flag == 0)//数据已取走或者缓冲器为空
     1 L# F  @9 W# g8 j5 ?+ L
216.     {
     0 B6 O" n6 P) X+ Y' S  h6 R+ i5 g% U
217.         RxBuf[0]=RxMessage.Data[0];
     
218.         RxBuf[1]=RxMessage.Data[1];
     + m5 `! S  O$ u
219.         Rx_flag=1;//数据已经备好，等待取走
     ( u, o- n" U7 W- [! o* j0 m% Q/ j
220.     }
     0 W5 x% M3 C, p! z, K9 _
221. 
     
222. 
     , v% N) \, o7 n( n6 I
223. 
     
224. 
     ' _3 r6 U1 o+ Y7 e1 g' h/ k
225. }

复制代码

. `* B9 j0 ^8 F) Ccan.h文件
! T% o2 Z' U' e& |3 a


8 Z9 m+ ^4 q8 N) Q4 H# p. U主机相关代码
$ g; Y( ?6 J" S  Q. r( }5 u, `' X$ s    这里主机代码大部分是和从机类似的，就只贴出不同的地方了。
3 t9 U9 S! |( s: w# Q9 Tcan.c文件：
- x1 M; m3 V9 S# ?2 e" t

1. #include "can.h"
   
2. 
   
3. 
   / h+ G+ ]0 O9 ~8 k: x* }; y
4. /* 在中断处理函数中返回 */
   
5. //__IO uint32_t ret = 0;
   $ I: H: l' \7 v4 F# g8 f  \
6. 
   . |: @; E$ J1 r5 r6 u% m
7. 
   3 N. H$ m  j- W/ g
8. void CAN1_Init(void)
   9 A4 B- H! c% H
9. {
   9 x9 H3 X+ M% Q0 |
10.     ......//以上与从机部分相同
    2 X9 H. o- z1 ?& Z
11. 
    ; c! t; a+ l( R& n) }. M
12. 
    ! L, T( p2 T0 s
13.     //CAN filter init 过滤器，已经设置为任意，可以通过ExtId标识符区分从机代号
    ' q; y1 j" u7 b4 A4 K1 G1 \
14.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    9 Y4 R3 t3 Y+ q# E( Y5 ~
15.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    
16.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
    
17.     CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;                //过滤器标识符的高16位值
    ' E! e4 j  _; L* A( o
18.     CAN_FilterInitStructure.CAN_FilterIdLow=CAN_ID_EXT|CAN_RTR_DATA;//过滤器标识符的低16位值
    * h  Y; [7 s! P8 m4 ~& W
19.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;            //过滤器屏蔽标识符的高16位值
    & E6 |/ |# g0 A! I4 ]. f, W6 M/ U
20.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;             //过滤器屏蔽标识符的低16位值
    " G" c8 \7 b7 k
21.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
    
22.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
    , Z/ U+ |( U3 p$ U9 A
23.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
    7 e- O1 b  Y4 |" a5 Q2 S
24. 
    
25. 
    
26.     /* CAN FIFO0 message pending interrupt enable */
    $ Q, }9 W4 O3 g7 [1 V
27.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
    3 u7 f$ D  u; q* v, \  A% \: G# f! i
28. }
    9 R. [5 w4 d" ~( V, z4 c
29. 
    ' s% P0 Q4 `9 |5 ]$ g$ {
30. 
    
31. //接收数据缓冲器
    0 x; x4 ^4 N( e0 q
32. u8 CAN_RX_BUF[CAN_RX_LEN]={0};     //接收缓冲,最大USART_REC_LEN个字节.
    
33. //接收标志位
    0 T9 b6 ~  S  C7 h% O2 w
34. u8 Rx_flag=0;
    * m1 w. r5 P( [0 n1 C) L4 i
35. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
    * l; @# s) N$ K& `( e
36. void USB_LP_CAN1_RX0_IRQHandler(void)
    
37. {
    
38.     u8 i=0;
    
39.     CanRxMsg RxMessage;
    9 @0 G/ ?# w/ h/ O0 S' `( A
40. 
    
41. 
    ' x) C  {5 N' B6 S2 S# `, Z. Q2 F
42.     RxMessage.StdId=0x00;
    
43.     RxMessage.ExtId=0x00;
    
44.     RxMessage.IDE=0;
    
45.     RxMessage.DLC=0;
    - F. I" l- [# u5 ~5 j- Q' K
46.     RxMessage.FMI=0;
    
47. 
    
48. 
    6 M) ~  e# \- `7 ^; C2 N# o7 g9 X
49.     CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
    ) |8 s- c7 N1 G; {: I
50. 
    8 `8 r; R/ l6 U, T! \5 @
51. 
    
52.     if(Rx_flag == 0)//数据已取走或者缓冲器为空
    
53.     {
    $ w: @7 r. o8 B! g8 u; K! |" d
54.         if((RxMessage.DLC) == 2)//是否收到2位字节数据
    4 ]/ g( ]; N  q) i  w4 i
55.         {
    5 t1 r7 a# K' T, u
56.              CAN_RX_BUF[0]=RxMessage.Data[0];
    . V* Q9 ?! m" M+ q) q5 n3 Z
57.              CAN_RX_BUF[1]=RxMessage.Data[1];     
    0 [! K0 ^7 }0 D# c" W) T
58.         }
    
59.     }
    
60. 
    5 j+ K. I6 M3 r
61. 
    3 c; b# c$ Y  m2 C4 B$ Y( }& v% a6 I
62. }
    * b. ]: u! \/ ^3 \& a
63. 
    * R3 Q# U" W# P2 x$ A+ l3 [
64. 
    ( F9 l9 h# g. b  A* s! p+ y7 b
65. /* 发送两个字节的数据*/
    
66. u8 CAN_SendMsg(u8* data1, u8* data2)
    : y5 r. o6 j+ B1 Y9 F3 G! s& t
67. {
    : `: _) r$ W2 N* L# j0 K
68.     u8 mbox;
      [2 Z: X& ?, O2 x$ D  @, Q
69.     u16 i=0;
    5 A' |. D8 M& U
70.     CanTxMsg TxMessage;  
    2 `* |4 ?7 \7 w
71. 
    
72. 
    * A3 [  B& O) \& {- T1 T
73.     TxMessage.StdId=0x0000;     //标准标识符为0x00
    $ ?2 D4 @( X% c5 }3 I7 t, o/ }' q
74.     TxMessage.ExtId=0x1314;     //扩展标识符0x0000
    ! N, I# W; n) {& v) x0 N4 Q
75.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
    4 C4 S6 J2 X  d
76.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
    
77.     TxMessage.DLC=2;            //消息的数据长度为2个字节
    
78.     TxMessage.Data[0]=Data1;    //第一个字节数据
    
79.     TxMessage.Data[1]=Data2;    //第二个字节数据
    
80. 
    
81. 
    
82.     //发送数据
    - h' j3 N6 b# E( W, v8 a
83.     mbox= CAN_Transmit(CAN1, &TxMessage);  
    
84.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
    
85.         i++;    //等待发送结束
    
86.     if(i>=0XFFF)
      `& n, _% t7 j& Q# S4 B
87.         return 0;//发送失败
    
88.     return 1;//发送成功
    
89. }
    $ |) p1 g* ~3 @: P8 x! L
90. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
    4 ?* }  |, U$ {7 c5 }+ R9 f' {1 ^! |$ G& ]; u
91. {
    2 r2 T" ?+ H& l6 n
92.     if(Rx_flag == 1)//发现数据
    & h5 o7 E# G) Z9 Q5 w: p
93.     {
    ) ]/ T" |4 |1 M) c3 Y3 @( _- q
94.         *msg1=CAN_RX_BUF[0];
    * X6 i# K7 F0 S% d3 F
95.         *msg2=CAN_RX_BUF[1];
    
96.         Rx_flag=0;//数据已经取走，可以更新数据
    
97.         return 1;
    
98.     }else
    * g% C4 S' L: q4 `8 T4 l/ e
99.         return 0;
    
100. }
     
101. void Clear_canBuffer(void)
     
102. {
     9 g& k& i* h4 T7 W7 A+ p
103.     Rx_flag=0;//清楚接收标志位
     
104.     memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区
     1 \9 ^; b0 c1 T" I6 a4 F8 q" ?( m
105. }
     
106. u8 Check_canRX(void)
     
107. {
     
108.     return (Rx_flag == 6);
     6 v7 L+ W% H. w8 U) x) H( C  K
109. }

复制代码

- @: @/ }( L) n, ]7 p
) j6 |, F  e7 k1 j  h8 Mcan.h文件：
. u( j. z/ t2 l7 P2 `

1. #ifndef __CAN_H
   
2. #define __CAN_H
   7 ]6 k4 R) e; M1 I! p
3. 
   
4. 
   
5. #include "sys.h"
   ! Z& I3 i0 z+ Y
6. #include "string.h"
   
7. 
   ( ?, v  j! E: K: v7 h& R. U) F
8. 
   0 k% i& M3 ^. h
9. #define CAN_RX_LEN          30          //定义最大接收字节数
   
10. 
    
11. 
    * C" @" N- o1 y( J2 A& `0 s$ L
12. extern u8  CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    - s9 G/ I, ^$ Q2 J$ T  i
13. 
    . N' ~# |- V" U( z
14. 
    * R# I; h0 e; y* O' [+ l
15. void CAN1_Init(void);
    6 _/ [; G& S, u% D" o! s
16. u8 CAN_SendMsg(u8* data1, u8* data2);
    , K# P% t. z9 f
17. u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
    
18. 
    
19. 
    
20. #endif /* __CAN_H */
    

复制代码

转载自：单片机与嵌入式
* b7 C2 }+ m4 w( A
如有侵权请联系删除

+ f: P" @, V# o; O: w

  U% V3 o. R6 p4 u