1、什么是CAN
+ Z3 c' z$ p1 g! N6 \' Q; ^        CAN是Controller Area Network 的缩写（简称称CAN），是ISO国际标准化的串行通信协议。由德国电气商博世公司在1986 年率先提出。此后，CAN 通过ISO11898 及ISO11519 进行了标准化。现在在欧洲已是汽车网络的标准协议。ISO11898是针对通信速率为125Kbps~1Mbps的高速通信标准，而ISO11519-2是针对通信速率为125Kbps以下的低速通信标准。现场总线是当今自动化领域技术发展的热点之一，被誉为自动化领域的计算机局域网。
; N! O: g! D$ f
6 t; E! A2 _( d1 w! U; ~        CAN 控制器根据两根线上的电位差来判断总线电平。总线电平分为显性电平和隐性电平，二者必居其一。发送方通过使总线电平发生变化，将消息发送给接收方。具有很高的可靠性，广泛应用于：汽车电子、工业自动化、船舶、医疗设备、工业设备等方面。

+ E/ g9 ]. S: q* Y

4 K5 r0 {  w0 w( C2、CAN协议的特点
) [% p$ D. \0 h! I+ [: S- |" C) z' I        ①多主控制。

0 L3 E' J" `* W) x        ②系统柔软性。
! W% k' @" G, F/ _* {) s
6 K% b6 B8 x8 E, L        ③ 速度快，距离远。

, y: W+ D+ v. P9 [6 D        ④ 具有错误检测、错误通知和错误恢复功能。

        ⑤ 故障封闭功能。
, z. F% D2 O" j! {
        ⑥连接节点多。

/ H8 d5 ?( [- z8 r; K3、ISO11898标准下的物理层特征
5 Z' F6 S6 @% w) h6 v+ H        CAN 控制器根据CAN_L和CAN_H上的电位差来判断总线电平。总线电平分为显性电平和隐性电平，二者必居其一。发送方通过使总线电平发生变化，将消息发送给接收方。
/ J8 Q) t2 s4 H* V4 ]; e# U
* O! Z* [0 I: x8 E        显性电平对应逻辑：0，CAN_H和CAN_L之差为2.5V左右。

! Y3 g4 K: Y( T+ M; U        隐性电平对应逻辑：1，CAN_H和CAN_L之差为0V。

9 v- \3 u- @  d. K        显性电平具有优先权，只要有一个单元输出显性电平，总线上即为显性电平。而隐形电平则具有包容的意味，只有所有的单元都输出隐性电平，总线上才为隐性电平（显性电平比隐性电平更强）。另外，在CAN总线的起止端都有一个120Ω的终端电阻，来做阻抗匹配，以减少回波反射。
9 D  l: J0 g) C4 n: q7 @- }( w


4、CAN 协议的5 种类型帧
' s+ k/ x& X  w1 D
, ^' ~9 F6 S  u5 n/ k

7 H5 e7 G$ n- r& ?7 f其中，数据帧和遥控帧有标准格式和扩展格式两种格式。

       标准格式有11 个位的标识符（ID），扩展格式有29 个位的ID 。
* K, e( _! Y8 U0 r, f8 m0 Q
4 Y& G3 S1 h! D4 [       其中，最常用，也是最复杂的是数据帧，接着就看看数据帧：

数据帧一般由 7 个段构成

（1） 帧起始。表示数据帧开始的段。
6 m$ x' J- l# v! Y（2） 仲裁段。表示该帧优先级的段。
) _$ ]/ @& r. C" X, h/ H（3） 控制段。表示数据的字节数及保留位的段。
（4） 数据段。数据的内容，一帧可发送 0~8 个字节的数据。
" R5 e5 z0 v8 E& p（5） CRC 段。检查帧的传输错误的段。
$ p5 _& g$ U$ X* e7 d5 L/ q* ?( u（6） ACK 段。表示确认正常接收的段。
& q; T' ^) I3 t4 d（7） 帧结束。表示数据帧结束的段。

3 F: \+ O- D3 H  f1 S/ r
3 I8 K( M2 ^: p. y. R
4.1、总线仲裁介绍
同时多个单元发送数据时，总线仲裁过程：


5 O$ \' `; H! u% G5 N
        上图中，单元 1 和单元 2 同时开始向总线发送数据，开始部分他们的数据格式是一样的，故无法区分优先级，直到 T 时刻，单元 1 输出隐性电平，而单元 2 输出显性电平，此时单元 1仲裁失利，立刻转入接收状态工作，不再与单元 2 竞争，而单元 2 则顺利获得总线使用权，继续发送自己的数据。这就实现了仲裁，让连续发送显性电平多的单元获得总线使用权.

        规律：
9 ]6 s+ u. N5 X% u4 n
) m9 {& u: Z" ?2 G, @" X  r# w* R              1，总线空闲时，最先发送的单元获得发送优先权，一但发送，其他单元无法抢占。
+ x7 v9 W6 r; R) C) C- c3 f# r% p
              2，如果有多个单元同时发送，则连续输出显性电平多的单元，具有较高优先级。
, L& D" s' A" x, d
% Q+ F8 q3 x- g2 F' k4.2、位时序
       位速率：由发送单元在非同步的情况下发送的每秒钟的位数称为位速率。一个位一般可以分为如下四段：

, U/ @" `! B2 K            同步段（SS）
0 ^/ b# f: h" h  m. J            传播时间段（PTS）
            相位缓冲段 1（PBS1）
$ N, G4 s$ H0 |1 M' h5 z            相位缓冲段 2（PBS2）

3 X3 l) b8 J2 q4 f. b      这些段又由可称为 Time Quantum（以下称为 Tq）的最小时间单位构成，1 位分为 4 个段，每个段又由若干个 Tq 构成，这称为位时序。
; I/ ^1 }7 a- q0 b/ c
3 p; {) M2 o7 e: h       位时间=1/波特率，因此，知道位时间，我们就可以知道波特率1 位由多少个 Tq 构成、每个段又由多少个 Tq 构成等，可以任意设定位时序。通过设定位时序，多个单元可同时采样，也可任意设定采样点。各段的作用和 Tq 数如表所示：
5 u, ?5 ]+ s) ^  C% F

- P; k# r! H  x, P; m& R
6 g( W6 o, U- k% \1 个位的构成如图所示：
% p# _$ Y3 X8 ~, l


' I( \( E& o# W+ n8 b上图的采样点，是指读取总线电平，并将读到的电平作为位值的点。位置在 PBS1 结束处。根据这个位时序，我们就可以计算 CAN 通信的波特率了。图中采样时间加大或减少量的最大值就是SJW。
; P7 u( ]* |/ t' \- I' Q
0 ~" s9 o. o0 y4 r1 _$ a5、STM32 CAN控制器简介
" t9 Z7 C& r9 _0 K/ ^0 B% V; @       STM32F4 自带的是 bxCAN，即基本扩展 CAN。它支持 CAN 协议 2.0A 和 2.0B。它的设计目标是，以最小的 CPU 负荷来高效处理大量收到的报文。它也支持报文发送的优先级要求(优先级特性可软件配置)。对于安全紧要的应用， bxCAN 提供所有支持时间触发通信模式所需的硬件功能。
STM32F4 的 bxCAN 的主要特点有：
0 @1 [2 S& r1 }3 |: |          ①支持 CAN 协议 2.0A 和 2.0B 主动模式
          ②波特率最高达 1Mbps
          ③支持时间触发通信
          ④具有 3 个发送邮箱
          ⑤具有 3 级深度的 2 个接收 FIFO
          ⑥可变的过滤器组（28 个， CAN1 和 CAN2 共享）


- L  a2 y4 H* o$ g: {
5.1、标识符筛选器
$ U) I! U( l# ICAN的标识符不表示目的地址而是表示发送优先级。接收节点根据标识符的值，来决定是否接收对应消息。
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位
& m4 K8 b/ M3 h: s+ i' ?3 x# z
# A. s6 [) d; z' u" f, J4 d                 ● 2个16位筛选器，包括：STDID[10:0]、IDE、RTR和EXTID[17:15]位
0 o6 ~9 O$ O  R
     4.筛选器可配置为：屏蔽位模式和标识符列表模式。
; c& ?/ o+ I: w# a/ F4 P8 Q
在屏蔽位模式下，标识符寄存器和屏蔽寄存器一起，指定报文标识符的任何一位，应该按照“必须匹配”或“不用关心”处理。
& }, S% q7 b5 o, J9 p% U: n
在标识符列表模式下，屏蔽寄存器也被当作标识符寄存器用。因此，不是采用一个标识符加一个屏蔽位的方式，而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟筛选器标识符相同。

. @1 X0 ]4 h# N
, ^( E. z" f2 \  j
为了过滤出一组标识符，应该设置筛选器组工作在屏蔽位模式。
为了过滤出一个标识符，应该设置过滤器组工作在标识符列表模式。
& V  C) @; j. k! @* S0 ?6 I% a7 k应用程序不用的筛选器组，应该保持在禁用状态(通过CAN_FA1R设置)。
- I5 i- @! \# f" C3 o/ w筛选器组中的每个筛选器，都被编号为(即：筛选器编号)从0开始，到某个最大数值－取决于筛选器组的模式和位宽的设置。
& u% v0 p3 R6 v! G* F通过CAN_FFA1R的设置，可以将筛选器组关联到FIFO0/FIFO1
: F5 ^2 z* G9 [3 o7 V5.2、STM32 CAN模式
1）工作模式
4 l) |3 k6 C  g+ V) z) H
       ①初始化模式（INRQ=1，SLEEP=0）
5 F* ?" g6 @* D7 g, e% B) g
3 d( J% z1 a% H) I       ②正常模式（INRQ=0，SLEEP=0）
6 i3 _3 |" P  p; g5 k" ~
       ③睡眠模式（SLEEP=1）

2）测试模式
( P1 W" F( ]+ o3 \1 N
* w) D7 f9 Y8 v3 K: H静默模式（ LBKM=0，SILM=1 ）
5 v! N" C* B4 U) @7 k


# \; M. e7 g# q4 g环回模式（ LBKM=1，SILM=0 ）
6 b1 @- a$ x+ h


6 O4 D% {/ N' H- N7 X环回静默模式（LBKM=1，SILM=1）



3）调试模式

5.3、STM32 CAN发送流程
      CAN发送流程为：

        程序选择1个空置的邮箱（TME=1）--->设置标识符（ID），数据长度和发送数据--->设置CAN_TIxR的TXRQ位为1，请求发送--->邮箱挂号（等待成为最高优先级）--->预定发送（等待总线空闲）--->发送--->邮箱空置。
( d5 G( P/ ?/ A( j# L
1 p0 G! Q2 E3 R& F3 w        还包含了很多其他处理，终止发送（ABRQ=1）和发送失败处理等
" L# w% R! B/ L- |5 D0 g3 X
, r1 B7 @2 I' `% K2 h- D; x3 P  }4 d
8 U4 v" l  o% H$ R3 X( i
5.4、STM32 CAN接收流程
7 s& o: F5 k% H- _' m# P) Q# [# u* JCAN接收流程为：
4 F8 Y6 Y) q; t  J4 M- }+ Q0 h. m
        FIFO空--->收到有效报文--->挂号_1（存入FIFO的一个邮箱，这个由硬件控制，从而节省了 CPU 的处理负荷，简化了软件并保证了数据的一致性）---->收到有效报文---->挂号_2---->收到有效报文---->挂号_3---->收到有效报文à溢出。
- F" f9 S  w) k7 n7 }3 w
        CAN收到的有效报文，存储在3级邮箱深度的FIFO中。FIFO接收到的报文数，我们可以通过查询CAN_RFxR的FMP寄存器来得到，只要FMP不为0，我们就可以从FIFO读出收到的报文。
0 m+ k7 J' Q+ I0 B  Y8 N
  x3 R$ I0 p9 p$ h$ M         报文FIFO具有锁定功能(由CAN_MCR，RFLM位控制)，锁定后，新数据将丢弃，不锁定则新数据将替代老数据



" x1 i" G) D# O8 _3 j, ?+ Z& B9 B7 D5.5、STM32 CAN位时序
4 k* [) t; s: d0 c% A! T8 Q      STM32F4 把传播时间段和相位缓冲段 1（STM32F4 称之为时间段1）合并了，所以 STM32F4 的 CAN 一个位只有 3 段：同步段（SYNC_SEG）、时间段 1（BS1）和时间段 2（BS2）。 STM32F4 的 BS1 段可以设置为 1~16 个时间单元，刚好等于CAN的传播时间段和相位缓冲段 1 之和。

/ |/ k7 C6 ]6 v4 m, X

9 ~) ?) ]; v1 j4 h5 n  J" i$ p         图中还给出了 CAN 波特率的计算公式，我们只需要知道 BS1 和 BS2 的设置，以及 APB1的时钟频率（一般为 42Mhz），就可以方便的计算出波特率。
/ n6 a/ E4 N- L- e6 w
6 S' c# y' u( C: `) c: G         比如：
3 `. t3 k3 Q5 ?: h  K5 x
                  STM32F103，设TS1=8、TS2=7、BRP=3，波特率=36000/[(9+8+1)*4]=500Kbps。
' Z8 b( T% O1 q' N( T
9 H( O: y* x$ r+ M% v                  STM32F407，设TS1=6、TS2=5、BRP=5，波特率=42000/[(7+6+1)*6]=500Kbps。

& d1 c% |6 o" u3 T3 B! f6、参考代码
2 E" L% a9 J8 t

1. #include "can.h"
   # H* u) p1 m9 B3 @0 Q& q
2. #include "delay.h"
   
3. #include "usart.h"
   
4. 
   ( S+ W' `- T3 V, G& @3 v* y- `
5. u8 CAN1_Mode_Init(u8 tsjw,u8 tbs2,u8 tbs1,u16 brp,u8 mode)
   $ R8 ?' t' Y7 `* J, ?2 _! a7 Q8 o; L% t
6. {
   ' _% a" y: Y+ k, S
7.           GPIO_InitTypeDef GPIO_InitStructure;
   
8.         CAN_InitTypeDef        CAN_InitStructure;
   0 k4 p$ c" S5 A" p
9.           CAN_FilterInitTypeDef  CAN_FilterInitStructure;
   
10. 
    . ?% u' Q; r' B+ r' P. X9 e
11.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE)；
    ; E6 m/ e: L, T! {! h
12.           RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    $ B% u! @; [) n* i/ F# v
13. 
    
14.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11| GPIO_Pin_12;
    
15.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    ) b6 p2 v2 E. |, G
16.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    4 C% U3 D5 q5 ~- l
17.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    
18.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
      r: Y- E5 L: O. c
19.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    + C& }/ r6 M  A" }2 z7 Q( C$ S
20. 
    
21.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource11,GPIO_AF_CAN1);
    * S9 `2 ~/ F4 L6 P" H  D( R+ l* m
22.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource12,GPIO_AF_CAN1);
    
23.          
    2 S( m! w1 n8 C  w3 K
24.            CAN_InitStructure.CAN_TTCM=DISABLE;
    
25.           CAN_InitStructure.CAN_ABOM=DISABLE;
    
26.           CAN_InitStructure.CAN_AWUM=DISABLE;
    
27.           CAN_InitStructure.CAN_NART=ENABLE;
    
28.           CAN_InitStructure.CAN_RFLM=DISABLE;
    # \; V8 h. |: F) f
29.           CAN_InitStructure.CAN_TXFP=DISABLE;
    0 }' C7 |0 p3 u! \) q
30.           CAN_InitStructure.CAN_Mode= mode;
    
31.           CAN_InitStructure.CAN_SJW=tsjw;
    & t  e/ X4 X- j0 X& O( c, k
32.           CAN_InitStructure.CAN_BS1=tbs1;
    
33.           CAN_InitStructure.CAN_BS2=tbs2;
    3 M5 ^, `9 q0 }9 o" @- G0 e& ]
34.           CAN_InitStructure.CAN_Prescaler=brp;
    9 f0 z' S; W1 ^! T4 t
35.           CAN_Init(CAN1, &CAN_InitStructure);
    
36. 
    1 [" k/ j/ u) X% U
37.          CAN_FilterInitStructure.CAN_FilterNumber=0;
    - P7 Z& G/ W$ D( p1 |6 @6 U
38.           CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
    
39.           CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
      d+ l: j% Y, \' ]
40.           CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;
    " b3 k0 R1 I# ?& n3 c% i
41.           CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
    6 N. }! S6 ~2 u
42.           CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
    
43.           CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
    ; ^9 o( H7 Q2 J7 I7 [* g% ~
44.            CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0;
    5 I3 W; X- `% l1 a$ ]! e6 u* j
45.           CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
    7 Q3 G4 I7 L  R7 j+ X
46.           CAN_FilterInit(&CAN_FilterInitStructure);
    
47.                
    $ G" O* l+ l0 j8 M0 Q. h
48.         CAN_ITConfig(CAN1,CAN_IT_FMP0,ENABLE);            
    1 L$ U, k8 D* C( Q0 q8 D3 ?3 j' R# i
49. 
    2 P" l1 L% r- o7 q1 @# Y
50.           NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX0_IRQn;
    
51.           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;   
    ) L0 L, c( D! p  {0 x" \
52.           NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;           
    7 A: k% [$ Y: L
53.           NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
54.           NVIC_Init(&NVIC_InitStructure);
    , ~& Q4 i! _( N) O3 \5 j
55. 
    9 J5 u& I+ l% f
56.         return 0;
    
57. }   
    2 g9 L3 V, W; p! g$ V+ q
58. 
    6 {0 i" r) M  V) S$ G; x7 n* ^
59.                     
    
60. void CAN1_RX0_IRQHandler(void)
    
61. {
    9 ~( s! V8 M  [, f' [1 t- k# H
62.           CanRxMsg RxMessage;
    # v& S; l% G. k
63.         int i=0;
    0 r0 q: ~# E5 L* ^
64.     CAN_Receive(CAN1, 0, &RxMessage);
    
65.         for(i=0;i<8;i++)
    
66.         printf("rxbuf[%d]:%d\r\n",i,RxMessage.Data<i>);
    ( _) s, _1 I8 B5 j$ [. e: ~
67. }
    
68. 
    0 ?- B; }' h2 d9 B4 \: }
69. 
    1 B+ a( Q9 R' t* i  q
70. u8 CAN1_Send_Msg(u8* msg,u8 len)
    $ W0 Z' f4 w+ B9 S
71. {        
    
72.   u8 mbox;
    ; z# w. K5 K  |+ v% q$ W& z
73.   u16 i=0;
      m% q: I5 t) y6 b
74.   CanTxMsg TxMessage;
    
75.   TxMessage.StdId=0x12;        
    % X$ A- k+ O7 \7 b& c1 U8 o
76.   TxMessage.ExtId=0x12;
    0 s& i4 l  s# e& B% n
77.   TxMessage.IDE=0;               
    & P9 B' K% C/ S$ q* [9 y
78.   TxMessage.RTR=0;        
      R$ f  C  N) _. T
79.   TxMessage.DLC=len;                                                
    5 Q" m: t5 P% j2 Z9 n* ^$ q9 ~) m
80.   for(i=0;i<len;i++)
    9 N  V" a/ b+ |
81.   TxMessage.Data<i>=msg<i>;                              
    
82.   mbox= CAN_Transmit(CAN1, &TxMessage);   
    
83.   i=0;
    3 L1 t8 \( H, H' ?
84.   while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))i++;
    
85.   if(i>=0XFFF)return 1;
    
86.   return 0;               
    4 P3 j, D  G3 G* K
87. 
    
88. }
    + b* H6 t" S5 d9 ?9 {, ?: e
89. 
    4 g: }$ Z' }) v8 K/ Q6 r3 ^
90. u8 CAN1_Receive_Msg(u8 *buf)
    
91. {                                      
    / A: N. X7 H0 o# k) l# w! @
92.          u32 i;
    
93.         CanRxMsg RxMessage;
    
94.     if( CAN_MessagePending(CAN1,CAN_FIFO0)==0)return 0;               
    
95.     CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);
    
96.     for(i=0;i<RxMessage.DLC;i++)
    
97.     buf<i>=RxMessage.Data<i>;  
    
98.         return RxMessage.DLC;        
    
99. }
    . X7 L% J5 s, F4 N8 W
100. </i></i></i></i></i>

复制代码

' s1 F% {! ~% H6 C( |+ \3 a