1、什么是CAN
2 B5 ]3 _, G  ~+ x0 }! w8 z' v        CAN是Controller Area Network 的缩写（简称称CAN），是ISO国际标准化的串行通信协议。由德国电气商博世公司在1986 年率先提出。此后，CAN 通过ISO11898 及ISO11519 进行了标准化。现在在欧洲已是汽车网络的标准协议。ISO11898是针对通信速率为125Kbps~1Mbps的高速通信标准，而ISO11519-2是针对通信速率为125Kbps以下的低速通信标准。现场总线是当今自动化领域技术发展的热点之一，被誉为自动化领域的计算机局域网。
1 z2 S5 O; _# f3 c- W
        CAN 控制器根据两根线上的电位差来判断总线电平。总线电平分为显性电平和隐性电平，二者必居其一。发送方通过使总线电平发生变化，将消息发送给接收方。具有很高的可靠性，广泛应用于：汽车电子、工业自动化、船舶、医疗设备、工业设备等方面。
3 i; V. D5 y& E# N/ `  @$ \
5 A1 }( H4 H4 D1 m

2、CAN协议的特点
4 ~0 O! P0 n) ~/ H7 K        ①多主控制。
5 p  K0 x& |& k* r3 X4 _; `2 r
$ V2 s9 o; R8 i( q  ?        ②系统柔软性。
8 g1 N! Z5 r$ I* O5 ~5 Z( e8 w6 u: |
        ③ 速度快，距离远。
- u# @7 ~% a. S$ r5 b
. O0 s3 N, t1 U        ④ 具有错误检测、错误通知和错误恢复功能。

' p. j( ^$ I+ N5 C0 x! \5 G        ⑤ 故障封闭功能。

        ⑥连接节点多。
. U8 Y  N5 |, M- [! l$ r
: b. R2 d6 n+ u9 w, S3 {3、ISO11898标准下的物理层特征
        CAN 控制器根据CAN_L和CAN_H上的电位差来判断总线电平。总线电平分为显性电平和隐性电平，二者必居其一。发送方通过使总线电平发生变化，将消息发送给接收方。
- s, x1 v# B! `) j' z' C
. [/ v. {5 B" H8 Y7 L        显性电平对应逻辑：0，CAN_H和CAN_L之差为2.5V左右。
  u2 Y. |$ ^! u: ?" Q8 e
        隐性电平对应逻辑：1，CAN_H和CAN_L之差为0V。

        显性电平具有优先权，只要有一个单元输出显性电平，总线上即为显性电平。而隐形电平则具有包容的意味，只有所有的单元都输出隐性电平，总线上才为隐性电平（显性电平比隐性电平更强）。另外，在CAN总线的起止端都有一个120Ω的终端电阻，来做阻抗匹配，以减少回波反射。
: \0 h& l5 L8 X% F
5 \8 W1 G' Z. ^: e4 V  z) Z
1 _; n9 d; t; m6 d$ J0 g
: Z8 \! o8 t: s) _% N4、CAN 协议的5 种类型帧
6 Y, u  M+ z% D9 E- |5 R% q) H
( R% ?7 g/ x. u$ i% d

- i, q$ ?# [( K; N其中，数据帧和遥控帧有标准格式和扩展格式两种格式。

       标准格式有11 个位的标识符（ID），扩展格式有29 个位的ID 。
% K- b" T3 \. r
       其中，最常用，也是最复杂的是数据帧，接着就看看数据帧：

% G2 _5 I  l; \- t; T. T9 w' P7 l数据帧一般由 7 个段构成

（1） 帧起始。表示数据帧开始的段。
（2） 仲裁段。表示该帧优先级的段。
! o: ~% w* {. H0 L! ^5 d' Q: p（3） 控制段。表示数据的字节数及保留位的段。
; y/ L5 G6 w6 k（4） 数据段。数据的内容，一帧可发送 0~8 个字节的数据。
（5） CRC 段。检查帧的传输错误的段。
（6） ACK 段。表示确认正常接收的段。
+ T2 _7 p9 J; o$ i（7） 帧结束。表示数据帧结束的段。
  R# P7 Y; [5 q

. x8 x* d2 b' n: ^* Q: B
4.1、总线仲裁介绍
同时多个单元发送数据时，总线仲裁过程：

, L" J$ j7 w  j) O
3 S, k, v3 i2 v% R- t
        上图中，单元 1 和单元 2 同时开始向总线发送数据，开始部分他们的数据格式是一样的，故无法区分优先级，直到 T 时刻，单元 1 输出隐性电平，而单元 2 输出显性电平，此时单元 1仲裁失利，立刻转入接收状态工作，不再与单元 2 竞争，而单元 2 则顺利获得总线使用权，继续发送自己的数据。这就实现了仲裁，让连续发送显性电平多的单元获得总线使用权.
& g! t' I! q" O& }3 w
        规律：
4 O$ S8 q% k! p5 |8 G
0 `5 J4 Z5 F% q  Z              1，总线空闲时，最先发送的单元获得发送优先权，一但发送，其他单元无法抢占。
5 i- A  c7 m" w, _& c
              2，如果有多个单元同时发送，则连续输出显性电平多的单元，具有较高优先级。

/ H6 k7 Y& O4 B) s3 j' U4.2、位时序
4 i5 ?8 p; Q% O       位速率：由发送单元在非同步的情况下发送的每秒钟的位数称为位速率。一个位一般可以分为如下四段：

7 ^; I, m- E" M; I/ q' @) E            同步段（SS）
! e$ r. N! Y+ W' o& P            传播时间段（PTS）
            相位缓冲段 1（PBS1）
. Y# i7 \3 I7 _+ W! K            相位缓冲段 2（PBS2）

' Q" c4 n* J0 @$ u- r      这些段又由可称为 Time Quantum（以下称为 Tq）的最小时间单位构成，1 位分为 4 个段，每个段又由若干个 Tq 构成，这称为位时序。

: c7 d5 [. `" G! T- e2 }  m+ R) A       位时间=1/波特率，因此，知道位时间，我们就可以知道波特率1 位由多少个 Tq 构成、每个段又由多少个 Tq 构成等，可以任意设定位时序。通过设定位时序，多个单元可同时采样，也可任意设定采样点。各段的作用和 Tq 数如表所示：


9 C1 [. V8 j& ]# b6 ]1 l
/ f7 @- e  x, O1 个位的构成如图所示：



: `$ n1 I  \& g1 E上图的采样点，是指读取总线电平，并将读到的电平作为位值的点。位置在 PBS1 结束处。根据这个位时序，我们就可以计算 CAN 通信的波特率了。图中采样时间加大或减少量的最大值就是SJW。
5 c  B9 I4 _0 [5 u) ^* @( I9 x
5、STM32 CAN控制器简介
2 q' Y3 m( Q8 C- _6 ~; \# {& h       STM32F4 自带的是 bxCAN，即基本扩展 CAN。它支持 CAN 协议 2.0A 和 2.0B。它的设计目标是，以最小的 CPU 负荷来高效处理大量收到的报文。它也支持报文发送的优先级要求(优先级特性可软件配置)。对于安全紧要的应用， bxCAN 提供所有支持时间触发通信模式所需的硬件功能。
STM32F4 的 bxCAN 的主要特点有：
/ W3 b( b# }) |$ G) L          ①支持 CAN 协议 2.0A 和 2.0B 主动模式
          ②波特率最高达 1Mbps
9 {% [7 k6 f; \& b          ③支持时间触发通信
& @4 o* K& M$ X8 H% E6 `5 K- v          ④具有 3 个发送邮箱
          ⑤具有 3 级深度的 2 个接收 FIFO
+ a# S" B1 d0 t          ⑥可变的过滤器组（28 个， CAN1 和 CAN2 共享）
( c7 U! v" K0 ^' c7 Q' W
5 w% N) I2 [( |/ f. b* }

5.1、标识符筛选器
1 H0 T. ^0 V( [. h+ QCAN的标识符不表示目的地址而是表示发送优先级。接收节点根据标识符的值，来决定是否接收对应消息。
STM32 CAN控制器，提供了28个可配置的筛选器组（F1仅互联型才有28个，其他的只有14个），可降低CPU处理CAN通信的开销。
STM32 CAN控制器每个筛选器组由2个32位寄存器组成（CAN_FxR1和CAN_FxR2，x=0~27）。根据位宽不同，每个筛选器组可提供：
) K9 {" j% V4 P( b$ T% A                 ● 1个32位筛选器，包括：STDID[10:0]、EXTID[17:0]、IDE和RTR位
; @+ d$ Y4 E/ h! c" B. F% U
8 |0 K. ^3 C' f/ e7 z( l                 ● 2个16位筛选器，包括：STDID[10:0]、IDE、RTR和EXTID[17:15]位
  m' O1 u* S* Q
     4.筛选器可配置为：屏蔽位模式和标识符列表模式。

在屏蔽位模式下，标识符寄存器和屏蔽寄存器一起，指定报文标识符的任何一位，应该按照“必须匹配”或“不用关心”处理。
) \& ^; H& |2 Z/ e$ x
在标识符列表模式下，屏蔽寄存器也被当作标识符寄存器用。因此，不是采用一个标识符加一个屏蔽位的方式，而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟筛选器标识符相同。

' p3 _) W/ l+ J. P# o/ o( J

$ s/ y! C# c; m7 b5 n# M4 D3 c  y为了过滤出一组标识符，应该设置筛选器组工作在屏蔽位模式。
  H. K4 L2 ~) w3 ~; e" ]0 k+ D9 i为了过滤出一个标识符，应该设置过滤器组工作在标识符列表模式。
: X0 Z' l2 B7 B' a' y$ P应用程序不用的筛选器组，应该保持在禁用状态(通过CAN_FA1R设置)。
筛选器组中的每个筛选器，都被编号为(即：筛选器编号)从0开始，到某个最大数值－取决于筛选器组的模式和位宽的设置。
) Q2 X. Q# n; c% c通过CAN_FFA1R的设置，可以将筛选器组关联到FIFO0/FIFO1
5.2、STM32 CAN模式
1）工作模式
) f4 o( p9 ~- x% g% Q
       ①初始化模式（INRQ=1，SLEEP=0）

       ②正常模式（INRQ=0，SLEEP=0）
2 ?/ M- R+ {% ^9 g% i4 f
& s) h3 e) \$ B/ _7 m$ {- L! z       ③睡眠模式（SLEEP=1）

2）测试模式
% o' n; O) N- Q% C
静默模式（ LBKM=0，SILM=1 ）
: M5 v" C; `  D7 Y

$ Q( r' f$ u3 @( l/ d- R
环回模式（ LBKM=1，SILM=0 ）
! R% P) U, \1 J

5 `, l7 s: o8 n! u( \
环回静默模式（LBKM=1，SILM=1）

7 T3 P; i( ~) ^: y8 i! M$ E3 z# ]; V

5 q/ n3 g8 u5 B! [3 e/ L2 a3）调试模式
, z) K% r% B# M" D' Q, l
/ ]$ f  v' P; t$ a0 V5.3、STM32 CAN发送流程
. g7 |; \& P4 }5 A& j      CAN发送流程为：
; D, ]8 G+ l2 J1 c# g
* F' X3 T4 b1 ?0 K1 b3 A1 ]        程序选择1个空置的邮箱（TME=1）--->设置标识符（ID），数据长度和发送数据--->设置CAN_TIxR的TXRQ位为1，请求发送--->邮箱挂号（等待成为最高优先级）--->预定发送（等待总线空闲）--->发送--->邮箱空置。

        还包含了很多其他处理，终止发送（ABRQ=1）和发送失败处理等
7 c0 J& ~0 v7 f' C4 Z) T/ z
: v2 `6 A% Y% w2 L0 a
4 H9 K/ X% c2 C6 h5 y2 j$ o- E
% @! T9 ]4 j& U+ Y; u' E5.4、STM32 CAN接收流程
CAN接收流程为：
- q$ ]4 ~5 }9 h2 K- s: w! u) F
        FIFO空--->收到有效报文--->挂号_1（存入FIFO的一个邮箱，这个由硬件控制，从而节省了 CPU 的处理负荷，简化了软件并保证了数据的一致性）---->收到有效报文---->挂号_2---->收到有效报文---->挂号_3---->收到有效报文à溢出。
3 W4 O- G" u# v/ Z* L) [: q; K
, f1 Z, v, n( j/ H8 s5 E' w! J        CAN收到的有效报文，存储在3级邮箱深度的FIFO中。FIFO接收到的报文数，我们可以通过查询CAN_RFxR的FMP寄存器来得到，只要FMP不为0，我们就可以从FIFO读出收到的报文。
$ N- \9 z, ?5 \, Z1 f4 {; K2 E
( v5 H+ W9 |9 c         报文FIFO具有锁定功能(由CAN_MCR，RFLM位控制)，锁定后，新数据将丢弃，不锁定则新数据将替代老数据

1 g# p, J' S' ?- m5 U% X+ V

" B* y# q6 P# r4 p5.5、STM32 CAN位时序
5 B% ?4 M' {4 |+ w7 O2 ^      STM32F4 把传播时间段和相位缓冲段 1（STM32F4 称之为时间段1）合并了，所以 STM32F4 的 CAN 一个位只有 3 段：同步段（SYNC_SEG）、时间段 1（BS1）和时间段 2（BS2）。 STM32F4 的 BS1 段可以设置为 1~16 个时间单元，刚好等于CAN的传播时间段和相位缓冲段 1 之和。
/ K: S$ Z' A; V( y+ r


         图中还给出了 CAN 波特率的计算公式，我们只需要知道 BS1 和 BS2 的设置，以及 APB1的时钟频率（一般为 42Mhz），就可以方便的计算出波特率。

         比如：

3 ]" U1 U+ B% m, V$ j                  STM32F103，设TS1=8、TS2=7、BRP=3，波特率=36000/[(9+8+1)*4]=500Kbps。

0 W1 y) E% O* K( z) {4 v' j+ q                  STM32F407，设TS1=6、TS2=5、BRP=5，波特率=42000/[(7+6+1)*6]=500Kbps。
& d( f5 z; ^# j$ _1 X* M+ @
: ?4 W# v1 {5 A1 y3 d: E3 H6、参考代码

1. #include "can.h"
   + |- H, t. e2 z1 j/ [8 M, t
2. #include "delay.h"
   ) U; E' k. z+ ^6 }6 A- K. s1 G
3. #include "usart.h"
   
4. 
   
5. u8 CAN1_Mode_Init(u8 tsjw,u8 tbs2,u8 tbs1,u16 brp,u8 mode)
   & `: T# Y2 y4 Q4 p8 m6 S7 s
6. {
   
7.           GPIO_InitTypeDef GPIO_InitStructure;
   
8.         CAN_InitTypeDef        CAN_InitStructure;
   
9.           CAN_FilterInitTypeDef  CAN_FilterInitStructure;
   5 |7 X0 O5 T0 \. L, F* G4 A5 l
10. 
    
11.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE)；
    
12.           RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    , h4 x% ^/ H3 [- e: q
13. 
    
14.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11| GPIO_Pin_12;
    
15.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
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);
    ) Y) R/ K1 x" Q$ U% H- m
23.          
    , Q* e4 ?+ E5 N- Z
24.            CAN_InitStructure.CAN_TTCM=DISABLE;
    
25.           CAN_InitStructure.CAN_ABOM=DISABLE;
    ( e& j6 L0 Z/ z+ H& g+ l
26.           CAN_InitStructure.CAN_AWUM=DISABLE;
    
27.           CAN_InitStructure.CAN_NART=ENABLE;
    
28.           CAN_InitStructure.CAN_RFLM=DISABLE;
    
29.           CAN_InitStructure.CAN_TXFP=DISABLE;
    
30.           CAN_InitStructure.CAN_Mode= mode;
    
31.           CAN_InitStructure.CAN_SJW=tsjw;
    
32.           CAN_InitStructure.CAN_BS1=tbs1;
    ( v. m) t5 @$ M1 T
33.           CAN_InitStructure.CAN_BS2=tbs2;
    3 `6 ^* T$ P8 A- G
34.           CAN_InitStructure.CAN_Prescaler=brp;
    
35.           CAN_Init(CAN1, &CAN_InitStructure);
    
36. 
    ) \* b8 W/ G/ t7 E: }" T
37.          CAN_FilterInitStructure.CAN_FilterNumber=0;
      ]) M$ Q! n7 S" q
38.           CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
    ; g3 b& M- Z" x0 M# N- [, s; F
39.           CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
    
40.           CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;
    
41.           CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
    
42.           CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
    + \# D9 Z! B/ ^. Z* S
43.           CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
    
44.            CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0;
    
45.           CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
      z# I8 S5 ?, }* _$ z
46.           CAN_FilterInit(&CAN_FilterInitStructure);
    
47.                
    : C9 b* @  I1 ?7 p
48.         CAN_ITConfig(CAN1,CAN_IT_FMP0,ENABLE);            
    
49. 
    
50.           NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX0_IRQn;
    
51.           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;   
    0 ^. Q, V* c- z
52.           NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;           
    ' \. G0 G( s* ]& F4 r/ z: x4 t
53.           NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    ' V8 W5 F, \4 L% M1 O  j
54.           NVIC_Init(&NVIC_InitStructure);
    ( w4 }9 ?, A1 P: Q
55. 
    
56.         return 0;
    
57. }   
    
58. 
    
59.                     
    + P0 K0 v6 u6 R/ F  i% `
60. void CAN1_RX0_IRQHandler(void)
    
61. {
    
62.           CanRxMsg RxMessage;
    ! p& ?8 ~* _, Y& ]
63.         int i=0;
    3 j' @8 |, E- L* h( [0 G2 m) ]( K
64.     CAN_Receive(CAN1, 0, &RxMessage);
    " \0 A* w2 r) D. N0 x( F; [, Z! p
65.         for(i=0;i<8;i++)
    
66.         printf("rxbuf[%d]:%d\r\n",i,RxMessage.Data<i>);
    % n. k9 f6 d8 d. J1 e7 w
67. }
    
68. 
    
69. 
    9 B3 ?& a) x' L: N* {0 _0 c# y
70. u8 CAN1_Send_Msg(u8* msg,u8 len)
    
71. {        
    2 C; d0 B" a/ a1 c
72.   u8 mbox;
    + y9 C1 p4 O( m( V" e. B; `; u
73.   u16 i=0;
    
74.   CanTxMsg TxMessage;
    
75.   TxMessage.StdId=0x12;        
    
76.   TxMessage.ExtId=0x12;
    
77.   TxMessage.IDE=0;               
    : p# N4 Y2 Z0 D# L( z0 c
78.   TxMessage.RTR=0;        
    3 V1 o9 h  \3 v, N8 G  u) U' t
79.   TxMessage.DLC=len;                                                
    ; i, E6 p+ `& _( f. U% s" W4 @
80.   for(i=0;i<len;i++)
    
81.   TxMessage.Data<i>=msg<i>;                              
    
82.   mbox= CAN_Transmit(CAN1, &TxMessage);   
    ' y3 C( P' H8 E. B- i+ U+ }
83.   i=0;
    
84.   while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))i++;
    
85.   if(i>=0XFFF)return 1;
    
86.   return 0;               
    * h' D3 w" W3 p& p2 h  ]
87. 
    
88. }
    % u& W# U# \  [% |! p
89. 
    
90. u8 CAN1_Receive_Msg(u8 *buf)
    
91. {                                      
    
92.          u32 i;
    ) V* B( K. W/ i: R. F
93.         CanRxMsg RxMessage;
    
94.     if( CAN_MessagePending(CAN1,CAN_FIFO0)==0)return 0;               
    / \# p& w8 T" o+ g  Z5 A0 v; h
95.     CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);
    
96.     for(i=0;i<RxMessage.DLC;i++)
    1 F  I. {- r# V2 X+ L. @* @
97.     buf<i>=RxMessage.Data<i>;  
    
98.         return RxMessage.DLC;        
    & q4 V! ]! z' L- ], H+ b
99. }
    
100. </i></i></i></i></i>

复制代码

2 B  Z& a) Y- o+ s- |& k
, y+ [9 A& C- x' a