CAN通信

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

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

• 数据帧
  
• 摇控帧
  
• 错误帧
  ; \) C- z/ U" k' ~" w8 g
• 过载帧
  & f) ?7 C# l3 r2 V0 ~3 r1 @
• 帧间隔
  
  

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

    大部分系统使用的都是数据帧 ，我这里使用的也是数据帧。
. h/ F+ l( V0 O( a+ B7 ?    数据帧一般由7个段构成，即：
（1） 帧起始。表示数据帧开始的段。
$ \8 h* W3 n- |) ]  _（2） 仲裁段。表示该帧优先级的段。
2 W2 g, z6 d! s2 G5 G+ w（3） 控制段。表示数据的字节数及保留位的段。
; b5 Z! X" u7 l0 ^（4） 数据段。数据的内容，一帧可发送0~8个字节的数据。
（5） CRC段。检查帧的传输错误的段。
9 m, v, q$ S+ L, j" p: }2 j（6） ACK段。表示确认正常接收的段。
6 t2 z  y1 X! y$ K8 `) r% r- M$ d8 z（7） 帧结束。表示数据帧结束的段。

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

    STM32的标识符屏蔽滤波目的是减少了CPU处理CAN通信的开销。STM32的过滤器组最多有28个（互联型），但是STM32F103ZET6只有14个（增强型），每个滤波器组x由2个32为寄存器，CAN_FxR1和CAN_FxR2组成。
; i/ C" n& o" v) |( n% ?, h( ~    STM32每个过滤器组的位宽都可以独立配置，以满足应用程序的不同需求。根据位宽的不同，每个过滤器组可提供：

• 1个32位过滤器，包括：STDID[10:0]、EXTID[17:0]、IDE和RTR位
• 2个16位过滤器，包括：STDID[10:0]、IDE、RTR和EXTID[17:15]位
  
  

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

    在屏蔽位模式下，标识符寄存器和屏蔽寄存器一起，指定报文标识符的任何一位，应该按照“必须匹配”或“不用关心”处理。
: b/ b4 M/ [( y  o3 p2 K$ d- S    而在标识符列表模式下，屏蔽寄存器也被当作标识符寄存器用。因此，不是采用一个标识符加一个屏蔽位的方式，而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟过滤器标识符相同。相关文章：CAN总线详解。

    一般也都是使用标识符列表模式，这里使用的也是标识符列表模式。滤波过程举例如下：
' A0 o) k, i6 O6 a

) W/ u) t# M5 f: k

    在程序中就是：

1. //要过滤的ID高位
   8 o8 @; Z2 U( a; a. s9 ^9 I6 o
2. CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;  
   
3. //要过滤的ID低位                 
   
4. CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF;
   
5. //过滤器屏蔽标识符的高16位值
   9 q: X( y- t- G! M8 H. r6 u6 X2 Q
6. CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;   
   + k3 L7 w. }0 t' W& @
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的数据。

程序思路

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

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

相关代码

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

从机相关代码

can.c文件：

1. 
   
2. #include "can.h"
   2 p  O, J2 A7 V, W9 i
3. 
   4 n7 Z+ t7 t8 ]" n
4. 
     b" m7 Q5 c2 X- M$ g6 \( U1 k9 G
5. /* 在中断处理函数中返回 */
   / @9 A4 h) y2 p% P3 @; n- [. Q  O
6. //__IO uint32_t ret = 0;
   * z) f3 w9 U5 Z& P6 `
7. 
   ' y1 B3 N1 V& K3 |& {7 m8 @
8. 
   
9. //接收数据缓冲器
   
10. u8 RxBuf[5];
    
11. u8 Rx_flag=0;
    
12. 
    8 [# T8 s; p( q; b- d2 G$ t
13. 
    
14. void CAN1_Init(void)
    1 Z5 M, w: ^+ Y% H5 B6 D! L  x2 E
15. {
    
16.     GPIO_InitTypeDef GPIO_InitStructure;
    
17.     NVIC_InitTypeDef NVIC_InitStructure;
    
18.     CAN_InitTypeDef        CAN_InitStructure;
    0 X9 c- {' k: j& G
19.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    3 ]0 {+ _1 w- s# H1 u* A: w" j) v
20. 
    
21. 
    
22.     /* 复用功能和GPIOB端口时钟使能*/   
    
23.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);                                                                     
    
24. 
      g8 L" z% z" H; k* E* d: L
25. 
    
26.     /* CAN1 模块时钟使能 */
    
27.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    
28. 
    ) I- a1 R+ g) _4 z3 P) H% K
29. 
    
30.     /* Configure CAN pin: RX */  // PB8
    7 g1 b5 R9 E" ~9 }! Q
31.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    6 c6 s$ [' S% R! P1 V4 m! h+ n
32.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;       //上拉输入
    
33.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    
34. 
    
35. 
    
36.     /* Configure CAN pin: TX */   // PB9
    
37.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
      r0 I2 ]+ _1 g& S) ~7 O3 I; L; _# b
38.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     //复用推挽输出
    % E0 j$ ^3 d8 V  R9 W
39.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    8 X9 c! {8 B$ v  n, V! _
40. 
    
41. 
    4 Z1 o$ S1 O# K! Y: t
42.     //#define GPIO_Remap_CAN    GPIO_Remap1_CAN1 本实验没有用到重映射I/O
    
43.     GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
    6 N( R$ K( j% t9 {* I& _
44. 
    4 i, ^1 h3 G" U9 ?" P
45. 
    5 Y$ D* c1 x/ T4 p1 _
46.     //CAN_NVIC_Configuration(); //CAN中断初始化   
    
47.     /* Configure the NVIC Preemption Priority Bits */  
    ' \* G7 @* ^% _% K# X; N3 t8 ^
48.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    
49. 
    
50. 
    
51.     #ifdef  VECT_TAB_RAM  
    ; ]! B. w2 `( d  y. Z  H
52.       /* Set the Vector Table base location at 0x20000000 */
    * |1 ?- u. c8 H. b. R8 C7 Y7 I
53.       NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
    
54.     #else  /* VECT_TAB_FLASH  */
    
55.       /* Set the Vector Table base location at 0x08000000 */
    
56.       NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
    
57.     #endif
    
58. 
    
59. 
    , v2 R) I" W1 r$ L7 F
60.     /* enabling interrupt */
    2 n0 ]  y+ J$ s+ d# C  i
61.     NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;
    
62.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    ) ^9 _/ h. J; e' ^* i* A
63.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    % B; P3 K' h6 P8 N- E
64.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
65.     NVIC_Init(&NVIC_InitStructure);
    
66. 
    4 P$ E: w* Y8 o: b) e% X
67. 
    * ]4 m! ?6 p5 C
68.     //CAN_INIT();//CA初始化N模块
    6 }6 I; ^. a# V; K
69.     /* CAN register init */
    
70.     CAN_DeInit(CAN1);                       //将外设CAN的全部寄存器重设为缺省值
    
71.     CAN_StructInit(&CAN_InitStructure);     //把CAN_InitStruct中的每一个参数按缺省值填入
    8 }6 m/ z' `  x# V) j
72. 
    # L6 O% l1 P6 o3 `
73. 
    
74.     /* CAN cell init */
    
75.     CAN_InitStructure.CAN_TTCM=DISABLE;         //没有使能时间触发模式
    6 L0 U) t/ j$ ~# P9 z% o; t1 E
76.     CAN_InitStructure.CAN_ABOM=DISABLE;         //没有使能自动离线管理
    
77.     CAN_InitStructure.CAN_AWUM=DISABLE;         //没有使能自动唤醒模式
    
78.     CAN_InitStructure.CAN_NART=DISABLE;         //没有使能非自动重传模式
    ' J8 t  {5 j( m: ~2 B5 n
79.     CAN_InitStructure.CAN_RFLM=DISABLE;         //没有使能接收FIFO锁定模式
    
80.     CAN_InitStructure.CAN_TXFP=DISABLE;         //没有使能发送FIFO优先级
    
81.     CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式
    
82.     CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;      //重新同步跳跃宽度1个时间单位
    1 m9 p/ z8 {% ]* Q1 R' Y6 w
83.     CAN_InitStructure.CAN_BS1=CAN_BS1_3tq;      //时间段1为3个时间单位
    
84.     CAN_InitStructure.CAN_BS2=CAN_BS2_2tq;      //时间段2为2个时间单位
    
85.     CAN_InitStructure.CAN_Prescaler=60;         //时间单位长度为60
    7 w* R- R; b8 ^# z2 B
86.     CAN_Init(CAN1,&CAN_InitStructure);          //波特率为：72M/2/60(1+3+2)=0.1 即波特率为100KBPs
    , q  J7 X! Z7 k9 {( n1 N) K# }
87. 
    4 \. Y( m8 V3 h
88. 
    ! W8 W" Z/ P) z  d
89.     // CAN filter init 过滤器，注意，只接收主机发过来的数据，屏蔽其他数据
    : ~+ q% |. L" w3 E, Q4 e" g
90.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    
91.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    & x* ]/ t  V, }0 n0 [8 g
92.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
    
93. 
    
94. 
    
95.     //CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16;  
    
96.     CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;                  //要过滤的ID高位
    # X% h: c* r2 c% H$ n% \+ ]
97.     CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位
      V7 w% N- e- `& v$ f
98. 
    
99. 
    
100.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;            //过滤器屏蔽标识符的高16位值
     , n4 ~: j" W5 U8 I; w, l% l4 h
101.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;             //过滤器屏蔽标识符的低16位值
     
102.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
     
103.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
     
104.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
     
105. 
     & p& J* z3 G5 ~. ?8 q4 A% f
106. 
     4 z# l7 V! v1 g6 [0 p, t- y7 o
107.     /* CAN FIFO0 message pending interrupt enable */
     
108.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
       u8 ]5 E& @6 |
109. }
     
110. 
     * k9 F/ J- A8 I5 J6 c3 g
111. 
     
112. /* 发送两个字节的数据*/
     
113. u8 CAN_SetMsg(u8 Data1,u8 Data2)
     ' c( W9 t: g  a
114. {
     8 N0 I" b( C- [1 L1 L% M/ |+ O+ X
115.     u8 mbox;
     5 R$ a  b! f4 P* K
116.     u16 i=0;
     # d- H2 K$ W& `1 q1 h+ |* _
117.     CanTxMsg TxMessage;  
     1 q( @2 @: k2 D! S. g+ a
118. 
     - w, Q0 K  z7 x1 k
119. 
     
120.     TxMessage.StdId=0x0000;     //标准标识符为0x00
     0 g* X3 S5 r( p* v( T9 t
121.     TxMessage.ExtId=0x1311;     //扩展标识符0x1311,可以更改该标识符以示区分不同从机
     
122.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
     
123.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
     , e, {6 p% W5 b: C
124.     TxMessage.DLC=2;            //消息的数据长度为2个字节
     
125.     TxMessage.Data[0]=Data1;    //第一个字节数据
     
126.     TxMessage.Data[1]=Data2;    //第二个字节数据
     
127. 
     
128. 
     
129.     //发送数据
     
130.     mbox= CAN_Transmit(CAN1, &TxMessage);  
     
131.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
     
132.         i++;    //等待发送结束
     
133.     if(i>=0XFFF)
     
134.         return 0;
     . x  d: u6 K; u; m) U3 `# t
135.     return 1;
       w0 N5 b/ ^  J* [. I0 N( U2 {! U
136. }
     " V6 J4 w& B2 C
137. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
     ' N& `+ c0 ^( P* z
138. {
     + M7 s# D0 I3 V
139.     if(Rx_flag == 1)//发现数据
     9 b& |$ o2 t8 ~$ k
140.     {
     5 C+ A/ b  L8 D6 e3 s  D
141.         *msg1=RxBuf[0];
       r* M2 N" w9 S2 `
142.         *msg2=RxBuf[1];
     , B8 Z. {! T# X- |" v
143.         Rx_flag=0;//数据已经取走，可以更新数据
     4 |' B, y2 u' f# Y8 s. }% {
144.         return 1;
     
145.     }else
     ' e0 B/ v0 d* r8 l
146.         return 0;
     4 w* z( f6 d4 f: m
147. }
     2 [; i9 Y' E2 g( j. P' U
148. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
       g6 D" S, [& T: a
149. void USB_LP_CAN1_RX0_IRQHandler(void)
     
150. {
     
151. 
     8 C+ W1 G6 I: F& z
152. 
     . B( |8 z/ S& H
153.   CanRxMsg RxMessage;
     . I1 Y7 z' v7 N- y
154. 
     ) N% `: {/ T' x; j  \
155. 
     & a% v3 x/ f2 }
156.   RxMessage.StdId=0x00;
     7 s$ \, b/ |5 j; U, B9 Q
157.   RxMessage.ExtId=0x00;
     
158.   RxMessage.IDE=0;
     0 ]- D; D4 \1 s$ ?2 N& [
159.   RxMessage.DLC=0;
     
160.   RxMessage.FMI=0;
     
161.   RxMessage.Data[0]=0x00;
     7 H3 Y$ t* l" v# y+ h1 P
162.   RxMessage.Data[1]=0x00;   
     
163. 
     
164. 
     ' y( s8 H4 T- l( J
165.   CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
     
166. 
     # m: v- f! o7 G  V9 f( v! ~/ i) r
167. 
     9 x) d  w3 {0 f- W; [, m; E) w
168.   if(Rx_flag == 0)//数据已取走或者缓冲器为空
     ! o% _9 K0 ?/ ~0 ]4 }
169.     {
     
170.         RxBuf[0]=RxMessage.Data[0];
     + |/ _* n+ t' `$ j% R* G" {4 s3 G
171.         RxBuf[1]=RxMessage.Data[1];
     
172.         Rx_flag=1;//数据已经备好，等待取走
     
173.     }
     / a; ?$ n2 B, h/ x; r; v' \3 n7 @
174. 
     
175. 
     4 m% G3 e+ G5 J, \: Y
176. }

复制代码

can.h文件

主机相关代码

    这里主机代码大部分是和从机类似的，就只贴出不同的地方了。
$ n8 J1 y, ~! E+ ncan.c文件：

1. 
   
2. #include "can.h"
   
3. 
   0 U( {" ^3 p1 q6 M) t- ~/ P
4. 
   
5. /* 在中断处理函数中返回 */
   0 x8 n1 k% m: N, Q% V: \8 K
6. //__IO uint32_t ret = 0;
   , e; a' ^7 T/ j; ~6 s+ F
7. 
   " B$ @& d, }) t3 ]2 r
8. 
   + a+ o8 T8 c$ [, l6 J8 |
9. void CAN1_Init(void)
   9 m" R' a% s7 ~. @
10. {
    % W- l4 m3 f/ L: H
11.     ......//以上与从机部分相同
    * H4 r: D; y# t6 W! l
12. 
    
13. 
    2 _/ U0 _% x+ k( g0 m
14.     //CAN filter init 过滤器，已经设置为任意，可以通过ExtId标识符区分从机代号
    2 e) a& m  S5 ?" s) S
15.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    
16.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    , W- m. c1 X1 |; w4 c
17.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
    
18.     CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;                //过滤器标识符的高16位值
    
19.     CAN_FilterInitStructure.CAN_FilterIdLow=CAN_ID_EXT|CAN_RTR_DATA;//过滤器标识符的低16位值
    + c5 v4 N+ _8 V+ z
20.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;            //过滤器屏蔽标识符的高16位值
    
21.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;             //过滤器屏蔽标识符的低16位值
    / T$ M! h3 \: M$ A6 h. f: E
22.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
    
23.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
    
24.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
    
25. 
    ( T: C( g# ]+ v! w3 c/ r& d, Y
26. 
    
27.     /* CAN FIFO0 message pending interrupt enable */
    
28.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
    
29. }
    ; I& T  A2 Y, P! j( ]* j2 O% ]
30. 
    
31. 
    
32. //接收数据缓冲器
    
33. u8 CAN_RX_BUF[CAN_RX_LEN]={0};     //接收缓冲,最大USART_REC_LEN个字节.
    
34. //接收标志位
    * t' ^7 I7 [% P
35. u8 Rx_flag=0;
    . f- s; `. t; f7 f0 e
36. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
    
37. void USB_LP_CAN1_RX0_IRQHandler(void)
    7 f# f/ j5 h# F
38. {
    0 }8 F' J" n2 f: ~$ |/ k9 B
39.     u8 i=0;
    
40.     CanRxMsg RxMessage;
    
41. 
    & h3 S6 X, r1 l0 Q8 {& [
42. 
    " Z: v, L5 E( |" d  k/ |, L1 i5 d
43.     RxMessage.StdId=0x00;
      S: [0 L6 [+ b9 {9 ~. H
44.     RxMessage.ExtId=0x00;
    
45.     RxMessage.IDE=0;
    
46.     RxMessage.DLC=0;
    
47.     RxMessage.FMI=0;
    + [: i# P/ j! u. f3 _
48. 
    
49. 
    8 v! `/ ~! K# k# D# A# V' x' t
50.     CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
    
51. 
    
52. 
    
53.     if(Rx_flag == 0)//数据已取走或者缓冲器为空
    
54.     {
    
55.         if((RxMessage.DLC) == 2)//是否收到2位字节数据
    ' h4 J  J9 I: D( |
56.         {
    
57.              CAN_RX_BUF[0]=RxMessage.Data[0];
    
58.              CAN_RX_BUF[1]=RxMessage.Data[1];     
    : l. ^( p; V0 O8 r6 v  y6 O; w4 y
59.         }
    
60.     }
    
61. 
    
62. 
    # z( }; X+ T6 `: q! S( K: T
63. }
    4 g9 Z% p4 O0 i4 T" u* ^
64. 
    
65. 
    : N, o6 s" Z/ Y2 j* b/ M
66. /* 发送两个字节的数据*/
    
67. u8 CAN_SendMsg(u8* data1, u8* data2)
    6 P* B, Q1 m3 A- W8 Q
68. {
    
69.     u8 mbox;
    * D2 {# H/ f" F; x
70.     u16 i=0;
    7 {, P8 ?2 b: H) I3 |0 F
71.     CanTxMsg TxMessage;  
    
72. 
    
73. 
    
74.     TxMessage.StdId=0x0000;     //标准标识符为0x00
    5 w, D. y) q+ m/ r+ [# R
75.     TxMessage.ExtId=0x1314;     //扩展标识符0x0000
    1 i$ r& ~. Z5 q4 X, z
76.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
    
77.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
    ' M* t: ]+ N6 I+ d
78.     TxMessage.DLC=2;            //消息的数据长度为2个字节
    . o% o+ f* V- k8 r. b
79.     TxMessage.Data[0]=Data1;    //第一个字节数据
    # _, L, W! F0 x# B5 m5 ^
80.     TxMessage.Data[1]=Data2;    //第二个字节数据
    
81. 
    
82. 
    3 W- V# I' q) U7 b) i- `
83.     //发送数据
    ( b" @2 H7 [! q# x
84.     mbox= CAN_Transmit(CAN1, &TxMessage);  
    9 f( S/ h, v( M% v: I
85.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
    , p* m; M5 p) N: Y
86.         i++;    //等待发送结束
    , L4 Q2 ]/ a7 U
87.     if(i>=0XFFF)
    
88.         return 0;//发送失败
    
89.     return 1;//发送成功
    
90. }
    1 z  l. t% e: g3 n: X
91. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
    
92. {
    3 J5 o1 q# Z& [( e& `7 U" r. u
93.     if(Rx_flag == 1)//发现数据
    
94.     {
    
95.         *msg1=CAN_RX_BUF[0];
    
96.         *msg2=CAN_RX_BUF[1];
    * f. Y; i: ?# c7 _" p
97.         Rx_flag=0;//数据已经取走，可以更新数据
    ( ]8 ]3 }( C3 O# Z2 P* S! h2 t
98.         return 1;
    $ q: {6 Z& j  ]8 |* Y( F
99.     }else
    & x/ A# w9 A9 u# J
100.         return 0;
     
101. }
     9 m1 |" q+ A7 _  ~
102. void Clear_canBuffer(void)
     
103. {
     
104.     Rx_flag=0;//清楚接收标志位
     
105.     memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区
     
106. }
     
107. u8 Check_canRX(void)
     1 q, V/ l% e5 S" L6 ?
108. {
     / K# I: n* v+ H7 i. Q
109.     return (Rx_flag == 6);
     : Z% c( W; Q* b  J, y
110. }

复制代码

! T/ x) n9 y! o0 Y2 `! k+ B

can.h文件：

1. 
   . N; A- ?9 f& U  I. `4 R$ \
2. #ifndef __CAN_H
   7 w' B0 T) k% I3 ]6 p% s
3. #define __CAN_H
   
4. 
   
5. 
   ) B# \3 k+ r& Q4 ]* t+ ^$ v# J
6. #include "sys.h"
   
7. #include "string.h"
   
8. 
   , k4 E" ?: C9 o+ d: ?/ `/ g( q
9. 
   , T: _; Q4 ?! M4 X
10. #define CAN_RX_LEN          30          //定义最大接收字节数
    6 X( n/ Q1 P- I  q. c
11. 
    # R; f* I5 w$ y$ e" _7 x
12. 
    # {( W; d% H5 W( a; }
13. extern u8  CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    3 Q0 c/ a/ I* @" h
14. 
    
15. 
    ) P" f: ~& f& O- T
16. void CAN1_Init(void);
    
17. u8 CAN_SendMsg(u8* data1, u8* data2);
    - e. v% k: v, I& Y, t- O
18. u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
    
19. 
    6 a. Y7 M  e! d( [; H
20. 
    
21. #endif /* __CAN_H */

复制代码

* j( P  x, I; W# K7 A1 ]0 r