1、什么是CAN
        CAN是Controller Area Network 的缩写（简称称CAN），是ISO国际标准化的串行通信协议。由德国电气商博世公司在1986 年率先提出。此后，CAN 通过ISO11898 及ISO11519 进行了标准化。现在在欧洲已是汽车网络的标准协议。ISO11898是针对通信速率为125Kbps~1Mbps的高速通信标准，而ISO11519-2是针对通信速率为125Kbps以下的低速通信标准。现场总线是当今自动化领域技术发展的热点之一，被誉为自动化领域的计算机局域网。

        CAN 控制器根据两根线上的电位差来判断总线电平。总线电平分为显性电平和隐性电平，二者必居其一。发送方通过使总线电平发生变化，将消息发送给接收方。具有很高的可靠性，广泛应用于：汽车电子、工业自动化、船舶、医疗设备、工业设备等方面。
! Z0 D1 N) v" C$ m5 K  L% Z


4 N0 _& B2 Z! n' p8 z  \. ^! d2、CAN协议的特点
/ |& i- W' a2 W9 N& A% g% E6 D( n4 T        ①多主控制。
5 v' r; ]$ `- |; l% E4 x1 s6 \
        ②系统柔软性。

& k& |' ^( U$ g0 `7 a* J        ③ 速度快，距离远。

$ P9 Q0 r, r7 O( |  u3 h2 Z        ④ 具有错误检测、错误通知和错误恢复功能。
7 M& z* c6 Q" s6 T0 ?  X9 b
$ M  f# J  r: V+ g! \4 `  K        ⑤ 故障封闭功能。

        ⑥连接节点多。
1 S6 C# F* c5 ~5 L" a
* G) N( x8 b8 C' B2 @3、ISO11898标准下的物理层特征
) q# v5 X: ~+ f        CAN 控制器根据CAN_L和CAN_H上的电位差来判断总线电平。总线电平分为显性电平和隐性电平，二者必居其一。发送方通过使总线电平发生变化，将消息发送给接收方。

        显性电平对应逻辑：0，CAN_H和CAN_L之差为2.5V左右。
, @* S: ^3 a: H( g# ?" k
        隐性电平对应逻辑：1，CAN_H和CAN_L之差为0V。
. ~  p( g3 ]$ c( _6 f& ?3 Y5 E
        显性电平具有优先权，只要有一个单元输出显性电平，总线上即为显性电平。而隐形电平则具有包容的意味，只有所有的单元都输出隐性电平，总线上才为隐性电平（显性电平比隐性电平更强）。另外，在CAN总线的起止端都有一个120Ω的终端电阻，来做阻抗匹配，以减少回波反射。
/ e5 j7 E, P! @) B/ |! }- g) ]
# [$ k% N0 e! b* b
  ?" P" b& e( }3 S, a/ r0 O
) P8 W$ R. x6 D( N4、CAN 协议的5 种类型帧

) K) G4 t6 y  ^8 ]
' n6 A0 ~4 v$ L- K  W9 R
/ t' \- }7 D0 }: |+ X8 c* L其中，数据帧和遥控帧有标准格式和扩展格式两种格式。
  G/ w  q+ y  ?# c" w
8 H. w: j7 k) c* R% c       标准格式有11 个位的标识符（ID），扩展格式有29 个位的ID 。
% J" y" h: O7 z) I
       其中，最常用，也是最复杂的是数据帧，接着就看看数据帧：
2 o8 d$ Q. Z  v8 d- t  g
% _6 `' N1 V  I0 [1 y数据帧一般由 7 个段构成
& A, l7 O  O6 v+ w3 o1 r
（1） 帧起始。表示数据帧开始的段。
（2） 仲裁段。表示该帧优先级的段。
（3） 控制段。表示数据的字节数及保留位的段。
（4） 数据段。数据的内容，一帧可发送 0~8 个字节的数据。
（5） CRC 段。检查帧的传输错误的段。
（6） ACK 段。表示确认正常接收的段。
（7） 帧结束。表示数据帧结束的段。
; T  @( K+ H. W  ]
+ q. Y4 T. j, _* d

4.1、总线仲裁介绍
同时多个单元发送数据时，总线仲裁过程：

- [3 Q& X7 N, U- d/ }
' W$ ^7 _5 L: y6 r" F1 r! n3 [
        上图中，单元 1 和单元 2 同时开始向总线发送数据，开始部分他们的数据格式是一样的，故无法区分优先级，直到 T 时刻，单元 1 输出隐性电平，而单元 2 输出显性电平，此时单元 1仲裁失利，立刻转入接收状态工作，不再与单元 2 竞争，而单元 2 则顺利获得总线使用权，继续发送自己的数据。这就实现了仲裁，让连续发送显性电平多的单元获得总线使用权.

        规律：
9 W& O& h! W0 l, S' N7 G
' M5 O! X; S2 H, J/ j$ e7 Z" d              1，总线空闲时，最先发送的单元获得发送优先权，一但发送，其他单元无法抢占。
4 I" S# j5 q& J, r
              2，如果有多个单元同时发送，则连续输出显性电平多的单元，具有较高优先级。
  B% R# P5 g2 K% q4 J
4.2、位时序
* a' D$ m: A" e& P4 y/ z( h7 ~( P: N       位速率：由发送单元在非同步的情况下发送的每秒钟的位数称为位速率。一个位一般可以分为如下四段：

            同步段（SS）
            传播时间段（PTS）
            相位缓冲段 1（PBS1）
% k' H% J- ?/ [' P            相位缓冲段 2（PBS2）
5 V: P* E2 Q7 t0 H
      这些段又由可称为 Time Quantum（以下称为 Tq）的最小时间单位构成，1 位分为 4 个段，每个段又由若干个 Tq 构成，这称为位时序。
: t0 ?  s  k) b/ i
       位时间=1/波特率，因此，知道位时间，我们就可以知道波特率1 位由多少个 Tq 构成、每个段又由多少个 Tq 构成等，可以任意设定位时序。通过设定位时序，多个单元可同时采样，也可任意设定采样点。各段的作用和 Tq 数如表所示：

- `1 r) ?# }+ J9 O  B" M
& L: P7 q( \8 _! d
5 o0 I$ ^1 {2 G) e& T1 个位的构成如图所示：
0 _) j4 g# B0 B8 Z


. s' d2 h3 w, {- Z) t/ c9 b+ @上图的采样点，是指读取总线电平，并将读到的电平作为位值的点。位置在 PBS1 结束处。根据这个位时序，我们就可以计算 CAN 通信的波特率了。图中采样时间加大或减少量的最大值就是SJW。
# y# c1 b9 I1 n1 }( W
5、STM32 CAN控制器简介
       STM32F4 自带的是 bxCAN，即基本扩展 CAN。它支持 CAN 协议 2.0A 和 2.0B。它的设计目标是，以最小的 CPU 负荷来高效处理大量收到的报文。它也支持报文发送的优先级要求(优先级特性可软件配置)。对于安全紧要的应用， bxCAN 提供所有支持时间触发通信模式所需的硬件功能。
, i. r( ?$ W' V- lSTM32F4 的 bxCAN 的主要特点有：
& A8 P* g3 W; e4 |3 c          ①支持 CAN 协议 2.0A 和 2.0B 主动模式
& x( c6 }3 y* m0 @9 T          ②波特率最高达 1Mbps
# ^+ F* x$ W$ a$ S! a5 I3 o          ③支持时间触发通信
4 O1 T& u, w8 p          ④具有 3 个发送邮箱
4 x2 F9 B- Q3 k          ⑤具有 3 级深度的 2 个接收 FIFO
, B& j+ n8 U; ^2 x. v          ⑥可变的过滤器组（28 个， CAN1 和 CAN2 共享）
) D" `, b5 R- V& g# P/ Q- |
' s3 a, O- q* s/ h
- U( y! g. z3 |3 j: C, w6 @# I+ @
5.1、标识符筛选器
CAN的标识符不表示目的地址而是表示发送优先级。接收节点根据标识符的值，来决定是否接收对应消息。
STM32 CAN控制器，提供了28个可配置的筛选器组（F1仅互联型才有28个，其他的只有14个），可降低CPU处理CAN通信的开销。
STM32 CAN控制器每个筛选器组由2个32位寄存器组成（CAN_FxR1和CAN_FxR2，x=0~27）。根据位宽不同，每个筛选器组可提供：
                 ● 1个32位筛选器，包括：STDID[10:0]、EXTID[17:0]、IDE和RTR位

4 N1 K/ @& {% T1 b* Y                 ● 2个16位筛选器，包括：STDID[10:0]、IDE、RTR和EXTID[17:15]位

; b* B6 n2 [. }( J     4.筛选器可配置为：屏蔽位模式和标识符列表模式。

) F5 H. q5 B5 t$ o$ g" a' L6 G在屏蔽位模式下，标识符寄存器和屏蔽寄存器一起，指定报文标识符的任何一位，应该按照“必须匹配”或“不用关心”处理。
2 [# N" E8 c+ S
  }- O$ j! P! B. X1 C在标识符列表模式下，屏蔽寄存器也被当作标识符寄存器用。因此，不是采用一个标识符加一个屏蔽位的方式，而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟筛选器标识符相同。


1 Z) R7 M! b7 T7 i9 e
为了过滤出一组标识符，应该设置筛选器组工作在屏蔽位模式。
' ?( _. e; D! ]为了过滤出一个标识符，应该设置过滤器组工作在标识符列表模式。
4 N( r/ a3 d# T, U( H3 e应用程序不用的筛选器组，应该保持在禁用状态(通过CAN_FA1R设置)。
' x7 W6 p# f! Z5 Z( |+ l: M1 v% e筛选器组中的每个筛选器，都被编号为(即：筛选器编号)从0开始，到某个最大数值－取决于筛选器组的模式和位宽的设置。
通过CAN_FFA1R的设置，可以将筛选器组关联到FIFO0/FIFO1
% t, F( y1 y, `# t* s" q: u5.2、STM32 CAN模式
1）工作模式

       ①初始化模式（INRQ=1，SLEEP=0）
3 l/ y! y2 k8 o' ?. e" b* J3 c
       ②正常模式（INRQ=0，SLEEP=0）

       ③睡眠模式（SLEEP=1）

5 M+ A. D. b$ r& o2）测试模式

( ]% Z( \5 ?* f; ^# s  E  X静默模式（ LBKM=0，SILM=1 ）
6 {" o) t' }; y, G/ s
  _% v5 ]* \# e  |- \* j
! U1 m' U' ^) ~
2 \7 S; a5 e" L环回模式（ LBKM=1，SILM=0 ）
* c9 X8 @3 V- m. P  {0 s$ c

# D7 O1 C) D1 F  t* a8 z* i- @
$ q! h. v3 n$ i0 P! m环回静默模式（LBKM=1，SILM=1）
6 J5 Q* ^0 y; i5 S8 c

4 Q3 p  i% ^; s! b. @% V
3）调试模式
/ F1 t2 n1 u' E6 x7 G9 v
5.3、STM32 CAN发送流程
      CAN发送流程为：
+ g% i2 t; c% v! c7 Z
        程序选择1个空置的邮箱（TME=1）--->设置标识符（ID），数据长度和发送数据--->设置CAN_TIxR的TXRQ位为1，请求发送--->邮箱挂号（等待成为最高优先级）--->预定发送（等待总线空闲）--->发送--->邮箱空置。

, A' x- s$ y- k2 f2 t        还包含了很多其他处理，终止发送（ABRQ=1）和发送失败处理等

0 l$ k1 X' t7 _$ N' x

2 a! z# |- _& M9 k. s5.4、STM32 CAN接收流程
/ n8 ~8 c! ]/ Y3 q9 pCAN接收流程为：

, @0 x9 t1 C; f6 ^. J2 d9 I        FIFO空--->收到有效报文--->挂号_1（存入FIFO的一个邮箱，这个由硬件控制，从而节省了 CPU 的处理负荷，简化了软件并保证了数据的一致性）---->收到有效报文---->挂号_2---->收到有效报文---->挂号_3---->收到有效报文à溢出。

+ [( M  B6 ^% R. d0 r* N2 h        CAN收到的有效报文，存储在3级邮箱深度的FIFO中。FIFO接收到的报文数，我们可以通过查询CAN_RFxR的FMP寄存器来得到，只要FMP不为0，我们就可以从FIFO读出收到的报文。
5 z7 G  `& L9 s: h
         报文FIFO具有锁定功能(由CAN_MCR，RFLM位控制)，锁定后，新数据将丢弃，不锁定则新数据将替代老数据
2 k3 P5 O; w, e, c& F* o5 R, u
2 m4 l1 p1 x# g) b

/ Q% A% q* J& c5.5、STM32 CAN位时序
      STM32F4 把传播时间段和相位缓冲段 1（STM32F4 称之为时间段1）合并了，所以 STM32F4 的 CAN 一个位只有 3 段：同步段（SYNC_SEG）、时间段 1（BS1）和时间段 2（BS2）。 STM32F4 的 BS1 段可以设置为 1~16 个时间单元，刚好等于CAN的传播时间段和相位缓冲段 1 之和。
% Q4 X" d9 W# ~- f8 Z

1 G; \1 g: s0 C* V1 T
2 I2 b- Y0 R5 I4 }         图中还给出了 CAN 波特率的计算公式，我们只需要知道 BS1 和 BS2 的设置，以及 APB1的时钟频率（一般为 42Mhz），就可以方便的计算出波特率。

         比如：

7 L( {+ }* g5 R; \+ C/ b                  STM32F103，设TS1=8、TS2=7、BRP=3，波特率=36000/[(9+8+1)*4]=500Kbps。

                  STM32F407，设TS1=6、TS2=5、BRP=5，波特率=42000/[(7+6+1)*6]=500Kbps。
8 w' {, P: _! s3 q  g( a: j
5 a0 N) K0 g# _6、参考代码
, E6 c2 R- d. w5 g9 L

1. #include "can.h"
   ! d- B# b- f) o' I0 K
2. #include "delay.h"
   
3. #include "usart.h"
   . J) {4 P4 }: z5 v4 {
4. 
   
5. u8 CAN1_Mode_Init(u8 tsjw,u8 tbs2,u8 tbs1,u16 brp,u8 mode)
   
6. {
   . d4 a4 `" w8 h$ ]2 e
7.           GPIO_InitTypeDef GPIO_InitStructure;
   
8.         CAN_InitTypeDef        CAN_InitStructure;
   6 J7 ]* X( ^6 t# D
9.           CAN_FilterInitTypeDef  CAN_FilterInitStructure;
   
10. 
      D  X9 x) G' |, [5 f5 H
11.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE)；
    
12.           RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    ) I) Z# F. H8 M& P
13. 
    
14.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11| GPIO_Pin_12;
    
15.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    3 a3 `: O! b* I. w- z+ Y/ F
16.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
17.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    
18.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    
19.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    
20. 
    
21.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource11,GPIO_AF_CAN1);
    
22.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource12,GPIO_AF_CAN1);
    ; p6 C5 D. Q5 V+ n  b/ z
23.          
    / X, |# K( L  B# `( l
24.            CAN_InitStructure.CAN_TTCM=DISABLE;
    ) ?* N4 y, ?5 U/ c% e# L- Z% S
25.           CAN_InitStructure.CAN_ABOM=DISABLE;
    
26.           CAN_InitStructure.CAN_AWUM=DISABLE;
    " P: S$ c0 Y$ Z/ Q' t, ~- k
27.           CAN_InitStructure.CAN_NART=ENABLE;
    
28.           CAN_InitStructure.CAN_RFLM=DISABLE;
    
29.           CAN_InitStructure.CAN_TXFP=DISABLE;
    ' r$ j2 z# ?0 h; w" A3 v7 V  Z
30.           CAN_InitStructure.CAN_Mode= mode;
    
31.           CAN_InitStructure.CAN_SJW=tsjw;
    
32.           CAN_InitStructure.CAN_BS1=tbs1;
    1 L6 b$ \# }: Z
33.           CAN_InitStructure.CAN_BS2=tbs2;
    0 @% A( o2 n: `, T3 n
34.           CAN_InitStructure.CAN_Prescaler=brp;
    + `1 z# F  q( v5 M7 |) F
35.           CAN_Init(CAN1, &CAN_InitStructure);
    ( D/ V6 ^! a3 Y* R/ i& r8 O, t$ W
36. 
    
37.          CAN_FilterInitStructure.CAN_FilterNumber=0;
    9 G5 Y% J  X1 g. a/ A/ n, i' g
38.           CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
    
39.           CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
    
40.           CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;
    
41.           CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
    1 R' ]4 _% M. a' ?& s
42.           CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
    / @: P9 _/ Q* J! C% U
43.           CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
    
44.            CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0;
    2 G8 k8 W$ s$ Q0 r
45.           CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
    
46.           CAN_FilterInit(&CAN_FilterInitStructure);
    
47.                
    8 q6 m) f2 i2 z
48.         CAN_ITConfig(CAN1,CAN_IT_FMP0,ENABLE);            
    
49. 
    
50.           NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX0_IRQn;
    
51.           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;   
    
52.           NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;           
    
53.           NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    , _2 ^  c& R# @* t1 j- T% X
54.           NVIC_Init(&NVIC_InitStructure);
    , r  V# S8 x7 I) B5 m7 g/ ]
55. 
    
56.         return 0;
    ) F/ Y  j9 @1 l2 z, x' ?
57. }   
    
58. 
    
59.                     
    
60. void CAN1_RX0_IRQHandler(void)
    0 h  h  c# A: O0 b
61. {
    " K' N  e/ t- K; f
62.           CanRxMsg RxMessage;
    
63.         int i=0;
    
64.     CAN_Receive(CAN1, 0, &RxMessage);
    
65.         for(i=0;i<8;i++)
    
66.         printf("rxbuf[%d]:%d\r\n",i,RxMessage.Data<i>);
    ) G5 J" i/ |5 [
67. }
    
68. 
    
69. 
    
70. u8 CAN1_Send_Msg(u8* msg,u8 len)
    
71. {        
    ' {' x% `% C1 Q9 n6 \% p
72.   u8 mbox;
    
73.   u16 i=0;
    + R; L/ T$ o* M$ v0 @; X
74.   CanTxMsg TxMessage;
    3 ^5 u% R' s$ J
75.   TxMessage.StdId=0x12;        
    ( t: L+ h+ V, E
76.   TxMessage.ExtId=0x12;
    % ?! Q8 h- g& ^2 Z: z
77.   TxMessage.IDE=0;               
    
78.   TxMessage.RTR=0;        
    
79.   TxMessage.DLC=len;                                                
    8 a$ p5 B2 m& P- |
80.   for(i=0;i<len;i++)
    
81.   TxMessage.Data<i>=msg<i>;                              
    0 Z# l! Z$ h! h  y2 `0 l
82.   mbox= CAN_Transmit(CAN1, &TxMessage);   
    
83.   i=0;
    
84.   while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))i++;
    % I" [' }: ^% X( u2 I! P) r, @6 q
85.   if(i>=0XFFF)return 1;
    
86.   return 0;               
    
87. 
    
88. }
    
89. 
    
90. u8 CAN1_Receive_Msg(u8 *buf)
    : C+ a7 ^) ]+ b1 g# i! t# o
91. {                                      
    
92.          u32 i;
    
93.         CanRxMsg RxMessage;
    . i9 S/ a. X" y8 M+ A7 ?" u& w
94.     if( CAN_MessagePending(CAN1,CAN_FIFO0)==0)return 0;               
      v; R' x5 d9 c  }
95.     CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);
    
96.     for(i=0;i<RxMessage.DLC;i++)
    + P( S6 O7 |1 M
97.     buf<i>=RxMessage.Data<i>;  
    
98.         return RxMessage.DLC;        
    
99. }
    3 X( x8 H$ E8 G3 ?! Q
100. </i></i></i></i></i>

复制代码

: w0 o' }2 J/ {& T. W$ B
- |2 b; @' K+ b1 B) b3 `$ P