CAN通信

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

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

• 数据帧
  
• 摇控帧
  
• 错误帧
  
• 过载帧
  5 D& X# _  N/ j9 y/ G! y
• 帧间隔
  
  $ l9 b" u( Q. P; \8 U

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

    大部分系统使用的都是数据帧 ，我这里使用的也是数据帧。
. _9 ?) J8 C- ?) z0 I    数据帧一般由7个段构成，即：
& W' i% f5 A! p9 }  V（1） 帧起始。表示数据帧开始的段。
' [! F0 u+ R. K( Y（2） 仲裁段。表示该帧优先级的段。
（3） 控制段。表示数据的字节数及保留位的段。
（4） 数据段。数据的内容，一帧可发送0~8个字节的数据。
( [8 t: M( Y; `2 r: S（5） CRC段。检查帧的传输错误的段。
（6） ACK段。表示确认正常接收的段。
  c3 m) C% c1 {3 ?! I2 O（7） 帧结束。表示数据帧结束的段。

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

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

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

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

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

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

4 ^3 S! s! N' R) Y' P

    在程序中就是：

1. //要过滤的ID高位
   , J' h6 v4 _4 ?/ _, M* v
2. CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;  
   
3. //要过滤的ID低位                 
   
4. CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF;
   ) B6 j  F$ ~9 B9 o' o4 S) l
5. //过滤器屏蔽标识符的高16位值
   , y$ r/ N7 a# ~  C
6. CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;   
   + x3 g; g6 y5 j; K- k7 W& c
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来区分，分配的标识符是：
) t8 ~. q$ C4 M! }* Z. L- a  P4 A/ O主机：0x1314
从机：0x1311

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

相关代码

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

从机相关代码

can.c文件：

1. 
   / w8 r9 {. b2 F
2. #include "can.h"
   1 H. f! K+ Y3 I( O
3. 
   # y: [0 o* I! D+ c3 R' y' R& W* S# d
4. 
   : d* a6 _5 J; h3 I5 V
5. /* 在中断处理函数中返回 */
   % b. A6 K5 P, ^; `
6. //__IO uint32_t ret = 0;
   
7. 
     j2 B9 r  Z5 c, D) g2 V4 K
8. 
   ! E1 I. N- j9 U3 W% |% q( T/ N% T
9. //接收数据缓冲器
   
10. u8 RxBuf[5];
    1 j* p9 `- U/ T/ o9 Y1 I
11. u8 Rx_flag=0;
    
12. 
    
13. 
    3 Q$ R' x5 I7 B$ q( b# t1 M0 B
14. void CAN1_Init(void)
    
15. {
    
16.     GPIO_InitTypeDef GPIO_InitStructure;
    
17.     NVIC_InitTypeDef NVIC_InitStructure;
    
18.     CAN_InitTypeDef        CAN_InitStructure;
    : D3 D$ `: G" j5 E) m
19.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
      y2 m; N% A. V$ f8 r5 f
20. 
    
21. 
    
22.     /* 复用功能和GPIOB端口时钟使能*/   
    
23.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);                                                                     
    
24. 
    : E( c1 E: X! o+ w7 }3 ~* |, B
25. 
    " C% k- U& _- k, H/ I' }
26.     /* CAN1 模块时钟使能 */
    
27.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    
28. 
    
29. 
    
30.     /* Configure CAN pin: RX */  // PB8
    
31.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    ( M/ E7 u" F0 q
32.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;       //上拉输入
    
33.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    5 G. H" b- S1 b2 u0 a
34. 
    
35. 
    
36.     /* Configure CAN pin: TX */   // PB9
    
37.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    
38.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     //复用推挽输出
    5 r" V! r8 f* D% A+ x
39.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    
40. 
    
41. 
    3 ^& k6 }6 u$ E/ d9 y% F+ K' L/ C& o
42.     //#define GPIO_Remap_CAN    GPIO_Remap1_CAN1 本实验没有用到重映射I/O
    
43.     GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
    , y6 D' Y* G% J: Y  {- p7 e
44. 
    ) H% ]/ P- D* o" O1 `+ R
45. 
    5 k: o0 c2 \. D8 w
46.     //CAN_NVIC_Configuration(); //CAN中断初始化   
    
47.     /* Configure the NVIC Preemption Priority Bits */  
    
48.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    9 P0 z/ m  Q8 o: r
49. 
    
50. 
    - d$ M7 z% |0 @7 F
51.     #ifdef  VECT_TAB_RAM  
    4 V  T$ Q- K8 k/ g2 @$ M& K) ~
52.       /* Set the Vector Table base location at 0x20000000 */
    . y& }) l/ H3 I
53.       NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
    
54.     #else  /* VECT_TAB_FLASH  */
    5 [9 `9 f% c5 w8 F% a6 |( S
55.       /* Set the Vector Table base location at 0x08000000 */
    * g8 @+ J  p$ d( F
56.       NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
    
57.     #endif
    - Z6 f2 J/ t4 b$ `4 W/ i
58. 
    
59. 
    
60.     /* enabling interrupt */
    / @( X' U1 X/ H7 o( z9 g+ r
61.     NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;
    
62.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    % ^- n: ]5 o8 p
63.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    / E, |* @* h) v, K
64.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    0 D% V8 W# I, A
65.     NVIC_Init(&NVIC_InitStructure);
    0 P& `& s- B5 M$ q0 g2 ^( E* i# g
66. 
    
67. 
    ) N4 T, B. e: ^/ R$ C( c6 f
68.     //CAN_INIT();//CA初始化N模块
    9 G9 o4 R2 J. e9 G' U; T/ z
69.     /* CAN register init */
    
70.     CAN_DeInit(CAN1);                       //将外设CAN的全部寄存器重设为缺省值
    7 L( H; v6 X8 K/ v$ Z8 ~
71.     CAN_StructInit(&CAN_InitStructure);     //把CAN_InitStruct中的每一个参数按缺省值填入
    
72. 
    5 E. ~! I: N5 @6 @
73. 
    1 y9 i2 a' c4 g7 z( v3 n
74.     /* CAN cell init */
    ! ~+ X( u5 d. n6 O$ z( `) @
75.     CAN_InitStructure.CAN_TTCM=DISABLE;         //没有使能时间触发模式
    & V+ O$ G* R, V5 U; M$ f% F4 v" g
76.     CAN_InitStructure.CAN_ABOM=DISABLE;         //没有使能自动离线管理
    
77.     CAN_InitStructure.CAN_AWUM=DISABLE;         //没有使能自动唤醒模式
    
78.     CAN_InitStructure.CAN_NART=DISABLE;         //没有使能非自动重传模式
    
79.     CAN_InitStructure.CAN_RFLM=DISABLE;         //没有使能接收FIFO锁定模式
    
80.     CAN_InitStructure.CAN_TXFP=DISABLE;         //没有使能发送FIFO优先级
    
81.     CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式
    2 `5 j, W8 |  _& B
82.     CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;      //重新同步跳跃宽度1个时间单位
    ) D; X9 ^: B9 E$ N: O+ ?' g: f
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
    ( x* Y$ g  j7 ^5 `. M
86.     CAN_Init(CAN1,&CAN_InitStructure);          //波特率为：72M/2/60(1+3+2)=0.1 即波特率为100KBPs
    
87. 
    + E" V$ f  g& ]
88. 
    " ^4 h) \& }! H# Z' R, `
89.     // CAN filter init 过滤器，注意，只接收主机发过来的数据，屏蔽其他数据
    9 c0 X* T0 f: Y- M  s, _
90.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    
91.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    
92.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
      }/ O6 C: W) U" E
93. 
    ( ^  X0 |$ e. I- p
94. 
    * Q+ H* s+ J) m$ f! A* a  k$ X, X  N2 A
95.     //CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16;  
    9 o+ t5 J9 n% g. X
96.     CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;                  //要过滤的ID高位
    
97.     CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位
    ; X6 F& P+ z0 s8 J3 v
98. 
    
99. 
    , G! C9 J5 F- \# K( E* N6 y
100.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;            //过滤器屏蔽标识符的高16位值
     
101.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;             //过滤器屏蔽标识符的低16位值
     & ?. Q! D# G5 x
102.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
     
103.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
     % |5 A  t! R) _
104.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
     5 C0 H6 t7 F* V8 M9 G7 T! x
105. 
     ( m3 j4 X4 D9 C! S$ R7 ]/ P
106. 
     ! @6 C- H9 |% z: S
107.     /* CAN FIFO0 message pending interrupt enable */
     
108.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
     
109. }
     ) s4 \1 }& E7 m% [7 a/ Z) S# z" P
110. 
       o( O4 J" a" F$ y3 u
111. 
     
112. /* 发送两个字节的数据*/
     
113. u8 CAN_SetMsg(u8 Data1,u8 Data2)
     
114. {
     
115.     u8 mbox;
     
116.     u16 i=0;
     
117.     CanTxMsg TxMessage;  
     
118. 
     7 A7 `' v" O7 G) |, v
119. 
     
120.     TxMessage.StdId=0x0000;     //标准标识符为0x00
     
121.     TxMessage.ExtId=0x1311;     //扩展标识符0x1311,可以更改该标识符以示区分不同从机
     
122.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
     ' P% y7 h. r: x/ ^# M6 P$ G2 [  b
123.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
     
124.     TxMessage.DLC=2;            //消息的数据长度为2个字节
     
125.     TxMessage.Data[0]=Data1;    //第一个字节数据
     4 y! c& N* b! c# Z2 ~& J9 o
126.     TxMessage.Data[1]=Data2;    //第二个字节数据
     4 k! K# K& {2 z0 x
127. 
     
128. 
     - {6 ~8 }) W# ~* V& e
129.     //发送数据
     
130.     mbox= CAN_Transmit(CAN1, &TxMessage);  
       u/ B3 x1 {2 Y6 O( H. c2 v/ C
131.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
     8 W2 S; r0 V* e/ J$ Y& x' v# d- u
132.         i++;    //等待发送结束
     
133.     if(i>=0XFFF)
     7 a3 T' V4 Z5 w# E9 k
134.         return 0;
     7 ^5 {! _, _* ]6 c1 }' S
135.     return 1;
     
136. }
     
137. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
     
138. {
     / z9 O' Q4 u* }. d- ]
139.     if(Rx_flag == 1)//发现数据
     
140.     {
     
141.         *msg1=RxBuf[0];
     & L* e- q% u, I! p
142.         *msg2=RxBuf[1];
     % y: S$ K- x! H' J3 V5 z* ?
143.         Rx_flag=0;//数据已经取走，可以更新数据
     7 m2 k% [5 b' w6 [: \
144.         return 1;
     
145.     }else
     
146.         return 0;
     
147. }
     2 i; H6 I' b  p! C
148. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
     ' D) a( \9 w: t8 ^, M! @% _
149. void USB_LP_CAN1_RX0_IRQHandler(void)
     
150. {
     
151. 
     
152. 
     
153.   CanRxMsg RxMessage;
     
154. 
     
155. 
     
156.   RxMessage.StdId=0x00;
     4 y" N3 Y5 M; B* ~
157.   RxMessage.ExtId=0x00;
     / {" X6 i+ T. ?" f' @1 G" C- f
158.   RxMessage.IDE=0;
     5 P( e' `2 _- J/ j, d# ?
159.   RxMessage.DLC=0;
     
160.   RxMessage.FMI=0;
     
161.   RxMessage.Data[0]=0x00;
     
162.   RxMessage.Data[1]=0x00;   
     
163. 
     
164. 
     
165.   CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
     
166. 
     
167. 
     
168.   if(Rx_flag == 0)//数据已取走或者缓冲器为空
     * ~- Q  _. R! L% q* \
169.     {
     
170.         RxBuf[0]=RxMessage.Data[0];
     ( U" a, u3 ?+ k# Q# [. p- j
171.         RxBuf[1]=RxMessage.Data[1];
     6 V) V- P& i2 ^. u+ v
172.         Rx_flag=1;//数据已经备好，等待取走
     
173.     }
     7 |7 k) _; w# X5 D0 Y2 d( M
174. 
     9 G& @8 C7 j" s% L, E2 T3 `
175. 
     ) T1 I0 g! ], W8 ?
176. }

复制代码

can.h文件

主机相关代码

    这里主机代码大部分是和从机类似的，就只贴出不同的地方了。
can.c文件：

1. 
   5 G2 X9 y1 K$ @8 ]9 ]. \0 d2 Y
2. #include "can.h"
   ! M+ {: {1 d) f4 a% q% Q8 e" h
3. 
   8 n2 f. U  T4 x! i2 H9 }
4. 
   ( {/ U5 j- k, q- i
5. /* 在中断处理函数中返回 */
   
6. //__IO uint32_t ret = 0;
   
7. 
   
8. 
   # O& h9 f: U0 O& C& c9 ~
9. void CAN1_Init(void)
   7 a( [0 C/ s  k% ^
10. {
      t: |, {% {6 u( N& s+ a4 a
11.     ......//以上与从机部分相同
      _" b. j" w7 j$ y- o
12. 
    
13. 
    
14.     //CAN filter init 过滤器，已经设置为任意，可以通过ExtId标识符区分从机代号
    
15.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    
16.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    
17.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
    ' f5 Y- @& C9 H7 E0 E' Z2 K6 J, `
18.     CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;                //过滤器标识符的高16位值
    . Q5 Q) o, s8 J; m* E9 ]. m
19.     CAN_FilterInitStructure.CAN_FilterIdLow=CAN_ID_EXT|CAN_RTR_DATA;//过滤器标识符的低16位值
    
20.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;            //过滤器屏蔽标识符的高16位值
    
21.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;             //过滤器屏蔽标识符的低16位值
    & N/ _' t$ j( ?; b8 r. N
22.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
    , |- @: @2 k. i2 W& C# i0 C
23.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
    ) |* |, V, a  D( _+ m7 j- j
24.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
    . ^4 u1 s1 P+ j: e4 j6 y
25. 
    
26. 
    $ h4 }7 w3 k4 Y* i( ?
27.     /* CAN FIFO0 message pending interrupt enable */
    
28.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
    " r. q* @# u3 I5 Z- R! P
29. }
    2 _4 T3 V* u. K5 E, ^
30. 
    
31. 
    9 R( O( {8 `) h+ z. Y
32. //接收数据缓冲器
    
33. u8 CAN_RX_BUF[CAN_RX_LEN]={0};     //接收缓冲,最大USART_REC_LEN个字节.
    
34. //接收标志位
    4 d1 X1 M, l6 h( j) L$ V) U
35. u8 Rx_flag=0;
    7 y! @! h' g2 |5 |
36. /* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
    
37. void USB_LP_CAN1_RX0_IRQHandler(void)
    $ {' B3 \& c- [: I$ l
38. {
    + `0 N! K( z( b, X
39.     u8 i=0;
    
40.     CanRxMsg RxMessage;
    ) d; Z/ D$ G6 i( r( h
41. 
    # b/ ~& [* C* l5 B  l4 d
42. 
    
43.     RxMessage.StdId=0x00;
    
44.     RxMessage.ExtId=0x00;
    ! V0 c) A6 m3 X5 t9 j* o9 p
45.     RxMessage.IDE=0;
    
46.     RxMessage.DLC=0;
    
47.     RxMessage.FMI=0;
    $ ^+ s! i; u, P: T
48. 
    , b0 f' T8 }# `2 E- ]- `, e
49. 
    & [9 q9 R: Q8 a; P
50.     CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
    
51. 
    , Q0 Q0 C; l! X
52. 
    
53.     if(Rx_flag == 0)//数据已取走或者缓冲器为空
    
54.     {
    ; g1 Y: T+ r; V9 I; f, u
55.         if((RxMessage.DLC) == 2)//是否收到2位字节数据
      M% E/ a$ ~; x$ }
56.         {
    
57.              CAN_RX_BUF[0]=RxMessage.Data[0];
    
58.              CAN_RX_BUF[1]=RxMessage.Data[1];     
    
59.         }
    + `/ D& @  {; K* K7 P* i9 o4 o
60.     }
    ! p/ S4 J2 V& Y3 }3 @& R& _
61. 
    7 T/ ]& ~" t' T
62. 
    % ]1 H! ~) v2 g1 F
63. }
    8 I8 \9 E4 I; f$ s
64. 
    
65. 
    
66. /* 发送两个字节的数据*/
    0 `( ]9 E: |2 H  [1 }
67. u8 CAN_SendMsg(u8* data1, u8* data2)
    
68. {
    / v: U0 M, B" m2 l# Z
69.     u8 mbox;
    9 p3 s: V" v( Y* R1 W% ^
70.     u16 i=0;
    + j0 w$ t5 m$ \% _2 S& ^
71.     CanTxMsg TxMessage;  
    
72. 
    
73. 
    
74.     TxMessage.StdId=0x0000;     //标准标识符为0x00
    3 J; r( I6 o) v
75.     TxMessage.ExtId=0x1314;     //扩展标识符0x0000
    
76.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
    
77.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
    8 Q" A$ ^! {" z7 \8 e3 Q/ U
78.     TxMessage.DLC=2;            //消息的数据长度为2个字节
    1 @5 a) b- ~5 N( b4 K8 g. |0 i
79.     TxMessage.Data[0]=Data1;    //第一个字节数据
    
80.     TxMessage.Data[1]=Data2;    //第二个字节数据
    & d$ p) k8 E& ?3 M  |, r
81. 
    6 N% X* c/ I; {2 q
82. 
    
83.     //发送数据
    0 b  a$ D6 u6 f% R! {* h
84.     mbox= CAN_Transmit(CAN1, &TxMessage);  
    
85.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
    % r$ X7 f$ I7 b. X4 E+ g- X
86.         i++;    //等待发送结束
    
87.     if(i>=0XFFF)
    
88.         return 0;//发送失败
    
89.     return 1;//发送成功
    
90. }
    & U3 B" K4 `9 Y6 u% ~  {9 O# _1 I
91. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
    0 ?3 N: x$ O3 i
92. {
    
93.     if(Rx_flag == 1)//发现数据
    
94.     {
    8 z% z4 X3 Z! `  J  M
95.         *msg1=CAN_RX_BUF[0];
    ) g+ x0 T3 Z8 j
96.         *msg2=CAN_RX_BUF[1];
    
97.         Rx_flag=0;//数据已经取走，可以更新数据
    
98.         return 1;
    ; i: O) t2 @# Z8 C. p6 \
99.     }else
    * F. ?; I' m7 Y9 C7 \* R* M0 Y
100.         return 0;
     
101. }
     
102. void Clear_canBuffer(void)
     
103. {
     
104.     Rx_flag=0;//清楚接收标志位
     9 o, x6 F# u" Q" p- Q. C0 t
105.     memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区
     
106. }
     
107. u8 Check_canRX(void)
     
108. {
     
109.     return (Rx_flag == 6);
     ' F8 H. [0 c/ E& f" E
110. }

复制代码

$ }. b, u+ D, W) K1 ^# ]

can.h文件：

1. 
   
2. #ifndef __CAN_H
   6 F  {0 C7 k; d' g4 M: Z% v8 j
3. #define __CAN_H
   
4. 
   ( M8 z0 k4 ~; E- s' U/ ^
5. 
   0 p% w; M3 O- ^/ e' k* K
6. #include "sys.h"
   ( V( T# j- o2 o. J. n! o7 r" Y9 k
7. #include "string.h"
     v) ]7 m' g" a0 `
8. 
   6 Q/ Y! \9 n3 X/ }; T! Q3 d
9. 
   
10. #define CAN_RX_LEN          30          //定义最大接收字节数
    + C* C2 V" w# S
11. 
    
12. 
    
13. extern u8  CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    
14. 
    
15. 
    2 Y2 y8 n* r: C" c& a2 A4 u) X
16. void CAN1_Init(void);
    2 W' D8 G% i5 G8 C% l
17. u8 CAN_SendMsg(u8* data1, u8* data2);
    
18. u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
    3 m& e1 K1 H$ U+ J6 g$ D6 L
19. 
    
20. 
    
21. #endif /* __CAN_H */

复制代码