CAN通信

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

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

• 数据帧
  
• 摇控帧
  / x/ k# D& y) ^" a  S& ]; _
• 错误帧
  
• 过载帧
  , \5 [1 \& d, W! c) E# c+ ~
• 帧间隔
  
  " H* U0 d% R' m! d9 K

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

    大部分系统使用的都是数据帧 ，我这里使用的也是数据帧。
    数据帧一般由7个段构成，即：
; Y5 Q! q3 t( d（1） 帧起始。表示数据帧开始的段。
（2） 仲裁段。表示该帧优先级的段。
（3） 控制段。表示数据的字节数及保留位的段。
（4） 数据段。数据的内容，一帧可发送0~8个字节的数据。
（5） CRC段。检查帧的传输错误的段。
（6） ACK段。表示确认正常接收的段。
. P. O6 u3 e* b4 l& y, r8 N（7） 帧结束。表示数据帧结束的段。

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

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

• 1个32位过滤器，包括：STDID[10:0]、EXTID[17:0]、IDE和RTR位
• 2个16位过滤器，包括：STDID[10:0]、IDE、RTR和EXTID[17:15]位
  
  " n4 x! |- P0 [1 c$ ^( T' ?

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

    在屏蔽位模式下，标识符寄存器和屏蔽寄存器一起，指定报文标识符的任何一位，应该按照“必须匹配”或“不用关心”处理。
- r3 o. j6 n5 X2 t. l    而在标识符列表模式下，屏蔽寄存器也被当作标识符寄存器用。因此，不是采用一个标识符加一个屏蔽位的方式，而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟过滤器标识符相同。

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

/ A+ _4 ^3 E& M& z
" c9 O- J, Y2 _, w! F

    在程序中就是：

1. //要过滤的ID高位
   & C# Y# T+ K5 j2 f
2. CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;  
   
3. //要过滤的ID低位                 
   
4. CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF;
   $ J5 x+ d6 _5 u
5. //过滤器屏蔽标识符的高16位值
   
6. CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;   
   : e+ z! Q7 z  j, t4 h# V6 e1 d. X
7. //过滤器屏蔽标识符的低16位值         
   ) }) V/ @1 I" ~8 m5 G
8. CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;

复制代码

    这里的CAN_FilterId和CAN_FilterMaskId是配合使用的，意思是CAN_FilterId指出需要屏蔽ID的什么内容，什么格式；CAN_FilterMaskId是指CAN_FilterId的每一位是否需要过滤，若CAN_FilterMaskId在某位上是1的话，ID对应位上的数值就必须和CAN_FilterId该位上的一样，保持一致，反之则是“不关心”。
0 |1 |1 Y. l: Y4 G% y

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

0 R* l! y. [  T# d& I! x

程序思路

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

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

相关代码

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

从机相关代码

can.c文件：

1. #include "can.h"
   
2. 
   
3. 
   
4. /* 在中断处理函数中返回 */
   " T! }$ e4 v& |4 p# B& n, x7 k
5. //__IO uint32_t ret = 0;
   - T) a2 C$ E- n  a
6. 
   - X. R0 }) C( U7 T6 S0 g; x
7. 
   0 K8 B4 t, T5 W/ Q' @( ]
8. //接收数据缓冲器
   
9. u8 RxBuf[5];
   & Z% n) P& `( n% e& ?' x
10. u8 Rx_flag=0;
    
11. 
    4 K9 H0 t, d/ f! s: o5 E8 Z0 m$ }' z
12. 
    " a, E& U8 R9 N9 s2 \) X+ @
13. void CAN1_Init(void)
    
14. {
    - m% n( L7 x% {" w/ e
15.     GPIO_InitTypeDef GPIO_InitStructure;
    - a9 p# ^7 v+ c$ @# R7 y8 |
16.     NVIC_InitTypeDef NVIC_InitStructure;
    3 v4 S# K$ z9 F' V! U3 w3 v
17.     CAN_InitTypeDef        CAN_InitStructure;
    
18.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    
19. 
    
20. 
    
21.     /* 复用功能和GPIOB端口时钟使能*/   
    
22.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);                                                                     
    6 v9 x  N8 |' `& F
23. 
    ( p" c& f& p& ]2 x& M9 \7 L
24. 
    7 T4 v7 o% }! i2 ^3 i0 E- [: O
25.     /* CAN1 模块时钟使能 */
    
26.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    
27. 
    
28. 
    ! W9 F' v5 n. Y4 ]6 F! m. ]
29.     /* Configure CAN pin: RX */  // PB8
    7 s0 X$ R  W6 A* S  b" o5 m/ Q
30.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    ; }2 ]6 \- ~: Q2 x& a
31.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;       //上拉输入
    
32.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    . a3 a  @1 a( z7 C% j
33. 
    
34. 
    
35.     /* Configure CAN pin: TX */   // PB9
    ; Z5 l  t% d+ I5 W0 T1 y
36.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    0 N1 y9 x" [- G/ r2 R# y
37.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     //复用推挽输出
    ' g1 m; e$ z8 \" a1 `
38.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    
39. 
    
40. 
    ! g7 o7 d# w: V  R- C
41.     //#define GPIO_Remap_CAN    GPIO_Remap1_CAN1 本实验没有用到重映射I/O
    
42.     GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
    6 E* u& V4 L) t; y! O
43. 
    
44. 
    
45.     //CAN_NVIC_Configuration(); //CAN中断初始化   
    % G: i$ \( g+ \% v2 ?5 S
46.     /* Configure the NVIC Preemption Priority Bits */  
    
47.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    3 v2 w/ `6 Y3 ?
48. 
    # `+ N! c1 c1 Q* Y' [9 k
49. 
    
50.     #ifdef  VECT_TAB_RAM  
    
51.       /* Set the Vector Table base location at 0x20000000 */
    
52.       NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
    : j' c  {# q% y$ A( m
53.     #else  /* VECT_TAB_FLASH  */
    * w& y9 \' q/ L% ~7 E% ?# a
54.       /* Set the Vector Table base location at 0x08000000 */
    4 `! N1 `( J% N0 ]2 W$ q
55.       NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
    3 c! H# l$ Z# N. i
56.     #endif
    ; Q$ W/ |! O0 M) N# F- ]" h
57. 
    
58. 
    - M$ C, T& e  y
59.     /* enabling interrupt */
    
60.     NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;
    
61.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    ) o  e, D, g4 }* I0 y3 ~; a- ^
62.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    0 z6 K' I; K  l! E
63.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    & E" }4 s8 H1 x* n% \: t# m
64.     NVIC_Init(&NVIC_InitStructure);
    / s5 i, ?7 P. R4 d! p3 G
65. 
    
66. 
    
67.     //CAN_INIT();//CA初始化N模块
    4 n* s1 d! B9 G9 ~' y# @
68.     /* CAN register init */
    
69.     CAN_DeInit(CAN1);                       //将外设CAN的全部寄存器重设为缺省值
    
70.     CAN_StructInit(&CAN_InitStructure);     //把CAN_InitStruct中的每一个参数按缺省值填入
    5 M# X. s" `2 ~) m, \; a0 z
71. 
    
72. 
    
73.     /* CAN cell init */
    
74.     CAN_InitStructure.CAN_TTCM=DISABLE;         //没有使能时间触发模式
    
75.     CAN_InitStructure.CAN_ABOM=DISABLE;         //没有使能自动离线管理
    
76.     CAN_InitStructure.CAN_AWUM=DISABLE;         //没有使能自动唤醒模式
    
77.     CAN_InitStructure.CAN_NART=DISABLE;         //没有使能非自动重传模式
    
78.     CAN_InitStructure.CAN_RFLM=DISABLE;         //没有使能接收FIFO锁定模式
    
79.     CAN_InitStructure.CAN_TXFP=DISABLE;         //没有使能发送FIFO优先级
    
80.     CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式
    
81.     CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;      //重新同步跳跃宽度1个时间单位
    ; E$ V; g5 Q0 R7 J; }
82.     CAN_InitStructure.CAN_BS1=CAN_BS1_3tq;      //时间段1为3个时间单位
    
83.     CAN_InitStructure.CAN_BS2=CAN_BS2_2tq;      //时间段2为2个时间单位
    
84.     CAN_InitStructure.CAN_Prescaler=60;         //时间单位长度为60
    
85.     CAN_Init(CAN1,&CAN_InitStructure);          //波特率为：72M/2/60(1+3+2)=0.1 即波特率为100KBPs
    & I2 F: w7 Q4 {7 `( z
86. 
    - _0 ~4 R9 i6 I: \* O
87. 
    
88.     // CAN filter init 过滤器，注意，只接收主机发过来的数据，屏蔽其他数据
    
89.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    % ]% a1 K% ?7 ]" ~) a$ Y$ A
90.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    6 f5 Y1 M- z+ a: @# h
91.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
    
92. 
    7 Y1 G' f! ]6 }8 K2 [
93. 
    0 T+ s% K3 F( i
94.     //CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16;  
    
95.     CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;                  //要过滤的ID高位
    
96.     CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位
    
97. 
    8 u  j9 {2 d5 e- r
98. 
    
99.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;            //过滤器屏蔽标识符的高16位值
    ) k1 N& J+ G3 p! H5 E: ^
100.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;             //过滤器屏蔽标识符的低16位值
     
101.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
     , `4 J4 u+ [. i
102.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
     
103.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
     
104. 
     ) r8 q2 Z7 A1 [, S6 G8 H
105. 
     
106.     /* CAN FIFO0 message pending interrupt enable */
     ) V$ T* [" L: X0 Z' G$ k4 u3 M
107.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
     
108. }
     4 R! H9 n$ l0 q* ~. t1 b; t" U
109. 
     
110. 
     - \; T7 e8 Z" [% O- |
111. /* 发送两个字节的数据*/
     
112. u8 CAN_SetMsg(u8 Data1,u8 Data2)
     
113. {
     ; s' r, d. I$ x/ A! f4 v* c
114.     u8 mbox;
     
115.     u16 i=0;
     
116.     CanTxMsg TxMessage;  
     5 H6 m, t7 g+ N: t8 z+ B! K
117. 
     
118. 
     
119.     TxMessage.StdId=0x0000;     //标准标识符为0x00
     
120.     TxMessage.ExtId=0x1311;     //扩展标识符0x1311,可以更改该标识符以示区分不同从机
     
121.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
     
122.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
     
123.     TxMessage.DLC=2;            //消息的数据长度为2个字节
     & k9 A4 _& K* R9 b6 L4 Z
124.     TxMessage.Data[0]=Data1;    //第一个字节数据
     / C9 z; M) Q  S5 b& Y) v
125.     TxMessage.Data[1]=Data2;    //第二个字节数据
     % m# o% v" c% w# k8 Z8 n
126. 
     
127. 
     
128.     //发送数据
     2 x; {2 V5 |5 W/ }4 L. `. d
129.     mbox= CAN_Transmit(CAN1, &TxMessage);  
     
130.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
     
131.         i++;    //等待发送结束
     
132.     if(i>=0XFFF)
     
133.         return 0;
     
134.     return 1;
     
135. }
     
136. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
     
137. {
     
138.     if(Rx_flag == 1)//发现数据
     
139.     {
     
140.         *msg1=RxBuf[0];
     
141.         *msg2=RxBuf[1];
     
142.         Rx_flag=0;//数据已经取走，可以更新数据
     
143.         return 1;
     + w( F" o+ K' Q2 P% ^3 F5 a! ]" J
144.     }else
     
145.         return 0;
       j( }. i8 C8 v
146. }
     " E' g, _. G4 J
147. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
     1 [/ B  K$ b: ?9 L4 T; \) j
148. void USB_LP_CAN1_RX0_IRQHandler(void)
     9 B- `2 C+ z' Y9 c$ Q7 k5 c
149. {
     
150. 
     
151. 
     ; v1 P* U( b) ^/ b7 n; O' v3 M9 D
152.   CanRxMsg RxMessage;
     
153. 
     ' [, p3 \2 }. C
154. 
     
155.   RxMessage.StdId=0x00;
     
156.   RxMessage.ExtId=0x00;
     & r6 I* X, V1 K, V. @! |
157.   RxMessage.IDE=0;
     9 `' B- m, |. B: c7 ?6 o3 Z
158.   RxMessage.DLC=0;
     
159.   RxMessage.FMI=0;
     
160.   RxMessage.Data[0]=0x00;
     0 @* P+ E0 D1 m9 U( y) r
161.   RxMessage.Data[1]=0x00;   
     
162. 
     % e! d2 r0 ]/ A8 K
163. 
     
164.   CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
     
165. 
     
166. 
     . G( ~7 y. D4 a; v
167.   if(Rx_flag == 0)//数据已取走或者缓冲器为空
     
168.     {
     5 \- V( }  T8 b, Y' }" n
169.         RxBuf[0]=RxMessage.Data[0];
     ! L! ^' ^# g9 H; f  R% t
170.         RxBuf[1]=RxMessage.Data[1];
     
171.         Rx_flag=1;//数据已经备好，等待取走
     : r0 ^5 u" @- t  E; ~& u
172.     }
     
173. 
     
174. 
     2 e# s' T# A7 d7 X$ A
175. }

复制代码

. Y: s9 {- L, e( N! _

can.h文件

1. #ifndef __CAN_H
   : Y  k; Q, M" A; w1 e
2. #define __CAN_H
   - Z0 X3 Y, @4 q2 A3 Q4 z# x
3. 
   0 \" o, i0 p! |; l" S; V
4. 
   
5. #include "sys.h"
   
6. 
   
7. 
   
8. void CAN1_Init(void);
   5 N5 R/ L# l" L9 ~9 s5 G( S( s! H
9. u8 CAN_SetMsg(u8 Data1,u8 Data2);
   1 L( j* {  Z/ ?
10. u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
    
11. 
    
12. 
    & p, b* K+ R7 @) t: \5 ?; Y* v
13. #endif /* __CAN_H */

复制代码

& e& I9 I% M. f主机相关代码

    这里主机代码大部分是和从机类似的，就只贴出不同的地方了。
1 ~7 c; C2 h( Q. |can.c文件：

1. #include "can.h"
   
2. 
   
3. 
   8 W9 y5 w: ?/ ^: U. S8 d. O
4. /* 在中断处理函数中返回 */
   5 b( K' N1 }9 G' l" ?" |+ b+ W& F
5. //__IO uint32_t ret = 0;
   
6. 
   
7. 
   
8. void CAN1_Init(void)
   6 D: V4 w% E( @9 U- z; K
9. {
   
10.     ......//以上与从机部分相同
    / c8 K! e4 j' C- {  \* C5 T
11. 
    . D5 n# w. ^% r% O8 F" J
12. 
    
13.     //CAN filter init 过滤器，已经设置为任意，可以通过ExtId标识符区分从机代号
    
14.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    ) D# r  E% A  |
15.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    - J! t( x2 x2 l* M, o
16.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
    
17.     CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;                //过滤器标识符的高16位值
    / Y0 R* d3 e' Q# V
18.     CAN_FilterInitStructure.CAN_FilterIdLow=CAN_ID_EXT|CAN_RTR_DATA;//过滤器标识符的低16位值
    , u; Q7 f: y$ V) f0 P
19.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;            //过滤器屏蔽标识符的高16位值
    
20.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;             //过滤器屏蔽标识符的低16位值
    
21.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
    8 m/ e' v. p! D! K# e
22.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
    / Z9 Y* D  p8 }: k/ Y1 b0 m& Q* ?
23.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
    1 K( r" i+ e; p5 N4 z
24. 
    3 S" A. R+ L6 F. J' Y
25. 
    
26.     /* CAN FIFO0 message pending interrupt enable */
    ! [& N8 o; L/ M* I
27.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
    
28. }
    
29. 
    & F. J: |( R( {; W$ g
30. 
      d3 v( _! `: V6 b
31. //接收数据缓冲器
    
32. u8 CAN_RX_BUF[CAN_RX_LEN]={0};     //接收缓冲,最大USART_REC_LEN个字节.
    " u9 m6 ]" u! `& a' z( p
33. //接收标志位
    
34. u8 Rx_flag=0;
    2 {* |6 ~$ x6 z
35. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
    & o% x9 L+ M5 {% c
36. void USB_LP_CAN1_RX0_IRQHandler(void)
    4 e/ U/ Q, ]) o" k4 a; o
37. {
    & L$ e" P' [8 j7 u( c3 ?: L; x8 w
38.     u8 i=0;
    1 L3 e( A( S1 y& U' @- d+ H
39.     CanRxMsg RxMessage;
    - [7 ]2 Z0 i. b2 Z
40. 
    ) p. v% T0 ]* \4 J/ Q
41. 
    
42.     RxMessage.StdId=0x00;
    
43.     RxMessage.ExtId=0x00;
    
44.     RxMessage.IDE=0;
    
45.     RxMessage.DLC=0;
    
46.     RxMessage.FMI=0;
    
47. 
    
48. 
      K7 y+ g- ^) q
49.     CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
    
50. 
    2 K: N! }5 Z# a3 u" O: t) l  {1 r
51. 
    
52.     if(Rx_flag == 0)//数据已取走或者缓冲器为空
    
53.     {
    5 F* Y; f* I6 E# t7 n
54.         if((RxMessage.DLC) == 2)//是否收到2位字节数据
    
55.         {
    
56.              CAN_RX_BUF[0]=RxMessage.Data[0];
    
57.              CAN_RX_BUF[1]=RxMessage.Data[1];     
    
58.         }
    $ H& S8 `. C- g, w
59.     }
    
60. 
    * f3 @  a1 v1 s* J- j) Z# h6 w3 [3 G
61. 
    
62. }
    
63. 
    : N2 q. l9 J1 B. e. l/ d, p# D
64. 
    
65. /* 发送两个字节的数据*/
    
66. u8 CAN_SendMsg(u8* data1, u8* data2)
    # x$ M' d6 C4 r% R
67. {
    
68.     u8 mbox;
    
69.     u16 i=0;
    
70.     CanTxMsg TxMessage;  
      z2 f6 v  R" W& x" @" G" y
71. 
    
72. 
    9 j9 N, {" f1 I: s
73.     TxMessage.StdId=0x0000;     //标准标识符为0x00
    ' y) [! o( c; p
74.     TxMessage.ExtId=0x1314;     //扩展标识符0x0000
    6 u: H& Q6 C3 S, t7 w' Q
75.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
    
76.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
    
77.     TxMessage.DLC=2;            //消息的数据长度为2个字节
    
78.     TxMessage.Data[0]=Data1;    //第一个字节数据
    $ d0 {8 U% `  g( [$ z
79.     TxMessage.Data[1]=Data2;    //第二个字节数据
    
80. 
    
81. 
    1 C5 ?% B, i2 y3 u7 ~" g3 s; i
82.     //发送数据
    
83.     mbox= CAN_Transmit(CAN1, &TxMessage);  
    
84.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
    
85.         i++;    //等待发送结束
    
86.     if(i>=0XFFF)
    1 s" {. B8 k$ e" z* q. J" P
87.         return 0;//发送失败
    ) \3 c) q) S, Z8 G
88.     return 1;//发送成功
    : n0 p9 S; X2 j9 V1 N3 \+ w
89. }
    4 C8 [  V4 l) B
90. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
    # a( k  Y; n/ I# ^: I
91. {
    5 v# z! `1 w! \7 I" L
92.     if(Rx_flag == 1)//发现数据
    & c$ Y$ m: r: [; ?
93.     {
    
94.         *msg1=CAN_RX_BUF[0];
    ; ~1 o2 ]1 X# ?$ ?' Z0 n/ ~$ f
95.         *msg2=CAN_RX_BUF[1];
    
96.         Rx_flag=0;//数据已经取走，可以更新数据
    
97.         return 1;
    # h3 F8 k  s! U7 t4 t+ y
98.     }else
    
99.         return 0;
    
100. }
     7 j6 `) q* W2 x- y4 l3 E8 S6 H9 [$ n
101. void Clear_canBuffer(void)
     " N0 |3 N7 K. |& r  J& H/ P
102. {
     
103.     Rx_flag=0;//清楚接收标志位
     
104.     memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区
     
105. }
     ( }# {/ X$ ^' I# S
106. u8 Check_canRX(void)
     * P. y; N5 k( }+ o( Z" F7 R& S
107. {
     
108.     return (Rx_flag == 6);
     9 k% b+ F. F- r6 A7 N. }
109. }

复制代码

can.h文件：

1. #ifndef __CAN_H
   5 ~3 b& B: c4 U! x$ Y+ q
2. #define __CAN_H
   3 f) X0 ?! c  c9 g( ~+ L% i
3. 
   + r8 Q: p5 L' V0 E1 X
4. 
   
5. #include "sys.h"
   $ a, q8 t( y; e
6. #include "string.h"
   " M! m3 w9 U' T' Y  X' W0 k/ P' ?' n
7. 
   3 a& x  J: z/ X! E1 B! i! r
8. 
     I7 P& r4 V9 I/ g
9. #define CAN_RX_LEN          30          //定义最大接收字节数
   
10. 
    
11. 
    
12. extern u8  CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    + H  }2 H/ o+ i
13. 
    
14. 
    # W$ {0 x7 r9 C
15. void CAN1_Init(void);
    ( O! S% J& u5 @" M# B9 `! H( [; J
16. u8 CAN_SendMsg(u8* data1, u8* data2);
    
17. u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
    
18. 
    
19. 
    5 o% }  _# _1 X- ?2 g
20. #endif /* __CAN_H */

复制代码