CAN通信

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

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

• 数据帧
  
• 摇控帧
  3 P. s3 V; |3 n0 o" G4 }5 O
• 错误帧
  * t7 i6 {0 ^5 T" K2 H- N: F
• 过载帧
  
• 帧间隔
  
  

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

    大部分系统使用的都是数据帧 ，我这里使用的也是数据帧。
. [5 U! ~1 ^& D5 e: H6 v, [7 [; d  G    数据帧一般由7个段构成，即：
+ @8 ?" d5 u# z$ o5 p) h（1） 帧起始。表示数据帧开始的段。
0 ^$ Q4 n8 L; [3 {' @（2） 仲裁段。表示该帧优先级的段。
7 _/ e  [- G- F7 `- p/ R（3） 控制段。表示数据的字节数及保留位的段。
（4） 数据段。数据的内容，一帧可发送0~8个字节的数据。
* o) A" K# C% B% V& v（5） CRC段。检查帧的传输错误的段。
（6） ACK段。表示确认正常接收的段。
（7） 帧结束。表示数据帧结束的段。

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

    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]位
  
  

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

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

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

  s4 o; z( o. o% |0 @# h7 R

    在程序中就是：

1. //要过滤的ID高位
   
2. CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;  
   
3. //要过滤的ID低位                 
   * m( }2 L; N" F! v8 q9 s
4. CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF;
   $ w; @2 S0 N+ L
5. //过滤器屏蔽标识符的高16位值
   " _8 ~, B/ x$ }/ N) Z
6. CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;   
   0 \/ k) b: M9 ?3 ^& X
7. //过滤器屏蔽标识符的低16位值         
   ( {3 W; \/ B: Y: j8 {  ?
8. CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;

复制代码

4 S. ^8 m$ i0 c% {

    这里的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. 
   * s1 {  ^3 j5 X% t
2. #include "can.h"
   
3. 
   , W3 a! S2 J. E: U0 R3 {
4. 
   ' w. ~1 ?& C; R% N6 M: c! A" j2 |
5. /* 在中断处理函数中返回 */
   
6. //__IO uint32_t ret = 0;
   
7. 
   $ |2 e9 ?  C5 @3 j5 ]
8. 
   4 K5 n" Y& f- M7 h
9. //接收数据缓冲器
   
10. u8 RxBuf[5];
    
11. u8 Rx_flag=0;
    
12. 
    
13. 
    ) y# V' F, w; y2 |5 @. v* [
14. void CAN1_Init(void)
    
15. {
    
16.     GPIO_InitTypeDef GPIO_InitStructure;
    
17.     NVIC_InitTypeDef NVIC_InitStructure;
    
18.     CAN_InitTypeDef        CAN_InitStructure;
    
19.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    
20. 
    % t% S0 F7 U5 H8 X% h
21. 
    
22.     /* 复用功能和GPIOB端口时钟使能*/   
    
23.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);                                                                     
    
24. 
    7 Y8 s& T2 K# B4 e5 E' y8 S6 x
25. 
      n+ ?+ ~; O. K
26.     /* CAN1 模块时钟使能 */
    
27.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    9 j* r- e$ T( \8 Y: Y7 S
28. 
    9 \1 b( ?. {2 k- h  C
29. 
    
30.     /* Configure CAN pin: RX */  // PB8
    8 a! N6 ^1 Q0 O- r# m$ M9 G8 M  Y
31.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    + }7 z* q! e0 c0 ^( N' ~
32.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;       //上拉输入
    
33.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    
34. 
    2 U$ T  j5 N1 h1 y  [! s
35. 
    
36.     /* Configure CAN pin: TX */   // PB9
    
37.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    
38.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     //复用推挽输出
    
39.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    
40. 
    ; a% ?6 R3 M' ]! S" X' p7 f, j+ |
41. 
    3 H$ l. A' M, t- T6 K6 H: v8 W; C) H7 |
42.     //#define GPIO_Remap_CAN    GPIO_Remap1_CAN1 本实验没有用到重映射I/O
    , R8 m7 j# h' i* h9 i
43.     GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
    
44. 
    
45. 
    
46.     //CAN_NVIC_Configuration(); //CAN中断初始化   
    
47.     /* Configure the NVIC Preemption Priority Bits */  
    # q. {+ o8 }, Z* \' `6 R4 ]+ D
48.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    
49. 
    & Z3 G# x. ?/ S+ _
50. 
    ! c- h  E: G5 N$ }  _6 h  j. b
51.     #ifdef  VECT_TAB_RAM  
    2 }' x/ {( ]; @8 K, W
52.       /* Set the Vector Table base location at 0x20000000 */
    
53.       NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
    ; y6 |; S# b, f0 ?5 [/ L  |
54.     #else  /* VECT_TAB_FLASH  */
    * o1 s5 Y7 g1 |9 k+ P
55.       /* Set the Vector Table base location at 0x08000000 */
    ) j8 u5 X1 A, m. h7 l4 F* `0 X
56.       NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
    # z& v4 U  b: P! w
57.     #endif
    ) n2 b* ?# c1 e) k: R: |( N
58. 
    " p9 h  }8 q+ J8 p8 P. Z0 p# u
59. 
    # b  |) o! }6 d6 K: v: D/ [
60.     /* enabling interrupt */
    
61.     NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;
    
62.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    1 O( C! _2 _! j3 Q! |2 s8 o
63.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
64.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    / z/ g( @* l# o9 N. _( @$ ?1 R
65.     NVIC_Init(&NVIC_InitStructure);
    
66. 
    
67. 
    ) Y4 y1 L' C& M# A
68.     //CAN_INIT();//CA初始化N模块
    7 E* {% \) m: d  W: Y, `
69.     /* CAN register init */
    
70.     CAN_DeInit(CAN1);                       //将外设CAN的全部寄存器重设为缺省值
    9 h0 s8 G7 I$ ?) T' A
71.     CAN_StructInit(&CAN_InitStructure);     //把CAN_InitStruct中的每一个参数按缺省值填入
    3 Y3 G9 E* p9 N1 I) D& z' o( j) H" g9 p
72. 
    # m; Y! p+ [/ ~+ q5 @7 J
73. 
    ) B0 `2 f# E' x! _6 j& P5 P; V
74.     /* CAN cell init */
    
75.     CAN_InitStructure.CAN_TTCM=DISABLE;         //没有使能时间触发模式
    ( u) d$ R4 S- i5 _. u9 z
76.     CAN_InitStructure.CAN_ABOM=DISABLE;         //没有使能自动离线管理
    
77.     CAN_InitStructure.CAN_AWUM=DISABLE;         //没有使能自动唤醒模式
    5 ^/ _: I$ _1 T
78.     CAN_InitStructure.CAN_NART=DISABLE;         //没有使能非自动重传模式
    ' E* ~  g1 k9 ~/ ~3 `7 D
79.     CAN_InitStructure.CAN_RFLM=DISABLE;         //没有使能接收FIFO锁定模式
    
80.     CAN_InitStructure.CAN_TXFP=DISABLE;         //没有使能发送FIFO优先级
    " a/ d# T+ e1 ~5 ^& F7 u
81.     CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式
    8 o; h2 l& U, h3 I7 P! u$ S% z! `$ {
82.     CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;      //重新同步跳跃宽度1个时间单位
    9 I+ ?4 b9 M" x9 |: w
83.     CAN_InitStructure.CAN_BS1=CAN_BS1_3tq;      //时间段1为3个时间单位
    
84.     CAN_InitStructure.CAN_BS2=CAN_BS2_2tq;      //时间段2为2个时间单位
    - a: Z5 M# B$ n7 }: H* B
85.     CAN_InitStructure.CAN_Prescaler=60;         //时间单位长度为60
    
86.     CAN_Init(CAN1,&CAN_InitStructure);          //波特率为：72M/2/60(1+3+2)=0.1 即波特率为100KBPs
    
87. 
    
88. 
    
89.     // CAN filter init 过滤器，注意，只接收主机发过来的数据，屏蔽其他数据
    
90.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    
91.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    " n5 h) x: s3 l# A, }* ?
92.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
    
93. 
    
94. 
    
95.     //CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16;  
    * S  I4 `( e9 s: K# s% v
96.     CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;                  //要过滤的ID高位
    
97.     CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位
    6 m& D  ~/ \* z3 \7 C; \, Y
98. 
    + o) t8 g* g/ P4 k, @
99. 
    1 i* i6 ~, x7 c8 q' J
100.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;            //过滤器屏蔽标识符的高16位值
     : w$ g2 o1 }" D* I/ ]' ?8 C
101.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;             //过滤器屏蔽标识符的低16位值
     . f7 ~/ R/ q" o, }! ?7 O2 R
102.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
     + V9 ~: V# k. y" b
103.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
     
104.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
     " n8 F( z. |0 J- Q; O  C3 Q0 [
105. 
     6 V6 D; n7 X, R& ~: ~- f2 [0 q
106. 
     
107.     /* CAN FIFO0 message pending interrupt enable */
     
108.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
     
109. }
     
110. 
     
111. 
     4 J7 j6 u8 g2 y3 ^# g, Z
112. /* 发送两个字节的数据*/
     1 |7 A. m/ ~$ ?8 \* b6 g% ]& ~
113. u8 CAN_SetMsg(u8 Data1,u8 Data2)
     
114. {
     3 m2 h- E6 ^; ?! v- B8 O! I
115.     u8 mbox;
     0 H2 c8 `- P5 b0 H0 B7 ^5 B; E- k' q
116.     u16 i=0;
     - @( _9 L) E$ q  B. g& Y# z- d
117.     CanTxMsg TxMessage;  
     ; E8 b" X! t, W6 w( X
118. 
     / U( p0 h/ P! j  y
119. 
     
120.     TxMessage.StdId=0x0000;     //标准标识符为0x00
     $ ]# @/ P3 T; _. V4 s) v
121.     TxMessage.ExtId=0x1311;     //扩展标识符0x1311,可以更改该标识符以示区分不同从机
     
122.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
     9 D- `8 ]% K) l( W: o3 o
123.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
     
124.     TxMessage.DLC=2;            //消息的数据长度为2个字节
     3 U  U. D' g9 r& W# K* j$ `
125.     TxMessage.Data[0]=Data1;    //第一个字节数据
     
126.     TxMessage.Data[1]=Data2;    //第二个字节数据
     / W# q& z& g7 o0 l' {5 Z
127. 
     
128. 
       \# V5 x, ?' {. {, s0 p9 Q# n
129.     //发送数据
     5 e4 ~& ?! U( ?9 R: \; Q4 C9 o
130.     mbox= CAN_Transmit(CAN1, &TxMessage);  
     : j& M2 q! J; V& q% ~" u7 E
131.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
     $ K8 x# z$ j# X; j' w6 \
132.         i++;    //等待发送结束
     
133.     if(i>=0XFFF)
     ) ~: {+ g9 p5 M& A
134.         return 0;
     8 P8 f: U) e- y5 O
135.     return 1;
     ( H( K4 e5 n: y1 Z, G9 t
136. }
     6 I* t) F& r5 i; ?
137. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
     ! g% B# ?, n! j8 P+ b( r- S0 U
138. {
     0 n6 E$ }/ W9 M3 b% C/ j
139.     if(Rx_flag == 1)//发现数据
     
140.     {
     8 c- b/ p; C( n) q0 P% X
141.         *msg1=RxBuf[0];
     9 c7 p' F9 E- I
142.         *msg2=RxBuf[1];
     
143.         Rx_flag=0;//数据已经取走，可以更新数据
     # e, O  a7 h$ H4 _
144.         return 1;
     
145.     }else
     
146.         return 0;
     ( q) Z: `6 a. J( c) U1 V4 e
147. }
     
148. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
     ' o. m) W* v/ o+ S! s) W; k& I' j
149. void USB_LP_CAN1_RX0_IRQHandler(void)
     , b* G1 A  t. \* h& l8 N  \: o
150. {
     4 u+ A$ V+ F, J/ C0 U
151. 
     
152. 
     
153.   CanRxMsg RxMessage;
     * T# a6 q* S+ G- r: A7 \$ K  G! [* S
154. 
     5 c/ o7 t* P: d: ]; b
155. 
     
156.   RxMessage.StdId=0x00;
     
157.   RxMessage.ExtId=0x00;
     5 w2 C" I& J3 L, Q
158.   RxMessage.IDE=0;
     . h% h' q# ^1 [( q6 T
159.   RxMessage.DLC=0;
     
160.   RxMessage.FMI=0;
     0 \, w- ^( H' e
161.   RxMessage.Data[0]=0x00;
     & Q5 V9 _; t; N/ u* o9 ]
162.   RxMessage.Data[1]=0x00;   
     
163. 
     4 h1 c9 `" P: o
164. 
     
165.   CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
     
166. 
     ! h7 g, h- W! ^
167. 
     2 Y, @& J7 w2 h) V, N. i5 _2 c
168.   if(Rx_flag == 0)//数据已取走或者缓冲器为空
     / |0 Z+ D4 d3 [$ K! D! N" H
169.     {
     
170.         RxBuf[0]=RxMessage.Data[0];
     
171.         RxBuf[1]=RxMessage.Data[1];
     
172.         Rx_flag=1;//数据已经备好，等待取走
     . ]. l( b% p) s  q3 i* \
173.     }
     
174. 
     
175. 
     
176. }

复制代码

can.h文件

主机相关代码

    这里主机代码大部分是和从机类似的，就只贴出不同的地方了。
7 {, H% ^/ K& h" ecan.c文件：

1. 
   : N7 v1 u! }, l5 s3 p5 z  q7 c& e
2. #include "can.h"
   
3. 
   ! }$ M2 z: T6 ^9 J$ z) x8 X
4. 
   0 b: }, ~5 y1 q7 I4 V
5. /* 在中断处理函数中返回 */
   ' l; y: Z  j( ?8 j- T
6. //__IO uint32_t ret = 0;
   
7. 
   2 C/ Z0 H5 L; n$ A1 Z! K
8. 
   # Z) @; z7 P* e' R2 [2 k
9. void CAN1_Init(void)
   
10. {
    
11.     ......//以上与从机部分相同
    8 U& N' k. J; L# \2 [, A
12. 
    
13. 
    
14.     //CAN filter init 过滤器，已经设置为任意，可以通过ExtId标识符区分从机代号
    8 O, @* n% J3 h
15.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    
16.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    
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位值
    ) V. V" E+ q3 }+ u* j) e* O' b
20.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;            //过滤器屏蔽标识符的高16位值
    
21.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;             //过滤器屏蔽标识符的低16位值
    . b& X+ w. C# n( e- `" ~
22.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
    : C) z' ^$ t) M$ W- w/ y6 d+ W2 i
23.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
    5 s- O5 q. s  [7 o1 A9 M( l" X
24.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
    ' _# T5 b  h1 \$ W
25. 
    - M! m6 {  s7 P) L% N
26. 
    
27.     /* CAN FIFO0 message pending interrupt enable */
    ! c. q( q3 ^; Z! {2 S2 Z- I
28.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
    
29. }
    4 u8 r1 x& P+ m# C" S
30. 
    
31. 
    / E" A- E2 r" q8 _
32. //接收数据缓冲器
    
33. u8 CAN_RX_BUF[CAN_RX_LEN]={0};     //接收缓冲,最大USART_REC_LEN个字节.
    ) F& l" ]2 C& ]" V0 G8 ^- E
34. //接收标志位
    
35. u8 Rx_flag=0;
    
36. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
    0 U  k7 Q- h0 @9 x0 d
37. void USB_LP_CAN1_RX0_IRQHandler(void)
    ! P( V/ c" r2 k# F+ G! {- s
38. {
    
39.     u8 i=0;
    * L& {+ ^( d( S; g: ]
40.     CanRxMsg RxMessage;
    
41. 
    2 z$ I- Q/ N* m, H. T
42. 
    
43.     RxMessage.StdId=0x00;
    $ o4 F$ Z+ {! }+ l% {. F. o! H
44.     RxMessage.ExtId=0x00;
    5 C; ~2 k* y4 `5 k8 \8 w$ }( n
45.     RxMessage.IDE=0;
    
46.     RxMessage.DLC=0;
    
47.     RxMessage.FMI=0;
    & V7 C9 `/ \! D; k* m( v
48. 
    ( U; c* K2 N- u( u! L
49. 
    
50.     CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
    
51. 
    
52. 
    
53.     if(Rx_flag == 0)//数据已取走或者缓冲器为空
    ' Z* n: [/ c' o9 a
54.     {
    
55.         if((RxMessage.DLC) == 2)//是否收到2位字节数据
    
56.         {
    " z/ E  s1 l9 g* j" d1 m
57.              CAN_RX_BUF[0]=RxMessage.Data[0];
    
58.              CAN_RX_BUF[1]=RxMessage.Data[1];     
    1 D5 u2 f3 X* K
59.         }
    # F' H) U1 E7 E6 e4 y4 W: V/ _, A$ d4 T
60.     }
    
61. 
    
62. 
    " I+ u0 W% E5 r$ q2 R/ d: O
63. }
    $ Q4 b: \) I( x2 c& O. I0 ?* q
64. 
    
65. 
    
66. /* 发送两个字节的数据*/
    3 q5 Z. K4 d* p+ X9 E& T8 v7 J
67. u8 CAN_SendMsg(u8* data1, u8* data2)
    
68. {
    ( _3 F7 V1 \9 B
69.     u8 mbox;
    
70.     u16 i=0;
    # A1 e% _3 M2 I) c* p, K) B
71.     CanTxMsg TxMessage;  
    7 k, M# N" u# x' Q. D- x7 R
72. 
    
73. 
    ! \+ \2 k1 T6 Q7 ~. y
74.     TxMessage.StdId=0x0000;     //标准标识符为0x00
    " Q8 S* ]3 X/ j9 j+ A9 D) @6 Z
75.     TxMessage.ExtId=0x1314;     //扩展标识符0x0000
    ) ?4 M. g% _+ V' o
76.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
    
77.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
    0 P1 o& p  B) D! o. K# v4 x3 z5 p2 i
78.     TxMessage.DLC=2;            //消息的数据长度为2个字节
    ! Y0 {+ t& D7 m4 c/ @" E  x. I
79.     TxMessage.Data[0]=Data1;    //第一个字节数据
    0 p' H1 ]3 I1 c: J/ U+ K" j* l/ n
80.     TxMessage.Data[1]=Data2;    //第二个字节数据
    
81. 
    - z; t  q6 ^( s6 p! j
82. 
    
83.     //发送数据
    
84.     mbox= CAN_Transmit(CAN1, &TxMessage);  
    5 v6 _# C8 L* p# I) @
85.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
    2 b5 b5 V! M1 S! K
86.         i++;    //等待发送结束
    
87.     if(i>=0XFFF)
    % u: {: a5 c; A& G2 r2 s( R
88.         return 0;//发送失败
    
89.     return 1;//发送成功
    7 h1 H/ ?9 N8 ]0 t0 }! T
90. }
    
91. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
    
92. {
    
93.     if(Rx_flag == 1)//发现数据
    3 @. D/ k' i+ _: u6 E# ?
94.     {
    
95.         *msg1=CAN_RX_BUF[0];
    
96.         *msg2=CAN_RX_BUF[1];
    8 A& {- j( j$ r/ w
97.         Rx_flag=0;//数据已经取走，可以更新数据
    + ]  ?9 @5 p' }+ _& x
98.         return 1;
    . @, b4 E/ H: M1 d& A
99.     }else
    / ~7 P  J2 n6 v3 b+ l) u' T
100.         return 0;
     
101. }
     
102. void Clear_canBuffer(void)
     
103. {
     2 `1 Z9 @; K7 k  H# t' f
104.     Rx_flag=0;//清楚接收标志位
     
105.     memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区
     ) h& s) E% r' |1 R
106. }
     
107. u8 Check_canRX(void)
     
108. {
     
109.     return (Rx_flag == 6);
     / h8 @' G2 S5 ^5 w. I. V& I
110. }

复制代码

can.h文件：

1. 
   . U! G9 e- |) D5 R* N
2. #ifndef __CAN_H
   * D1 r( x# v# C' n* R3 |$ }
3. #define __CAN_H
   
4. 
   7 @# }+ s* M. |1 q' m
5. 
   : i- T* f- g/ _) z# d
6. #include "sys.h"
   
7. #include "string.h"
   $ ^/ A( z% U: r6 U# A3 w
8. 
   / p# W$ v# ?, p7 U
9. 
   
10. #define CAN_RX_LEN          30          //定义最大接收字节数
    
11. 
    " m: x# `6 f- C4 y8 S5 M  G. ?/ p- P; f
12. 
    
13. extern u8  CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    ) D; m9 p" U. G: o/ K9 A
14. 
    
15. 
    + d5 o; O* U% N7 U
16. void CAN1_Init(void);
    " v, C; m+ L' Z
17. u8 CAN_SendMsg(u8* data1, u8* data2);
    4 {  B( {/ Z1 Z. l
18. u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
    
19. 
    
20. 
    
21. #endif /* __CAN_H */

复制代码

- U  o' d+ X7 X8 j7 [# W7 L4 R