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

5 u3 h% f% q" v; k# [# Y        CAN 控制器根据两根线上的电位差来判断总线电平。总线电平分为显性电平和隐性电平，二者必居其一。发送方通过使总线电平发生变化，将消息发送给接收方。具有很高的可靠性，广泛应用于：汽车电子、工业自动化、船舶、医疗设备、工业设备等方面。


4 j" h3 j* q9 x& c3 ]/ |
/ P2 ]$ P% E' q0 ?2、CAN协议的特点
        ①多主控制。
3 ]- `/ b' @$ N4 C$ @
        ②系统柔软性。

. \: K" g) k4 ?6 c        ③ 速度快，距离远。
: O! V( n3 w. E4 V6 N& B7 z) g
7 J# e: t+ w. Y        ④ 具有错误检测、错误通知和错误恢复功能。
& _$ C# d  Z+ C6 I4 t
$ L$ ~- r8 H4 ~; t        ⑤ 故障封闭功能。
, B4 D( O- |& l7 t" q" Z- @& X
        ⑥连接节点多。
# x6 ~- V9 W7 p4 d$ n
# D4 ?7 T( y1 T* N; a3、ISO11898标准下的物理层特征
        CAN 控制器根据CAN_L和CAN_H上的电位差来判断总线电平。总线电平分为显性电平和隐性电平，二者必居其一。发送方通过使总线电平发生变化，将消息发送给接收方。
# W; R. q5 _/ c: A& ^& y$ v
        显性电平对应逻辑：0，CAN_H和CAN_L之差为2.5V左右。

        隐性电平对应逻辑：1，CAN_H和CAN_L之差为0V。
. w8 j4 `+ o; ?7 h4 D
, v( _7 W0 b! U* ~        显性电平具有优先权，只要有一个单元输出显性电平，总线上即为显性电平。而隐形电平则具有包容的意味，只有所有的单元都输出隐性电平，总线上才为隐性电平（显性电平比隐性电平更强）。另外，在CAN总线的起止端都有一个120Ω的终端电阻，来做阻抗匹配，以减少回波反射。

! q0 {; B& y+ n2 v6 M% F

4、CAN 协议的5 种类型帧

$ U. U3 p( u+ C' _+ ]
2 \. x1 v% o: ~  O' k7 p
& H; ?% B# c. l/ a& B其中，数据帧和遥控帧有标准格式和扩展格式两种格式。
+ o, M2 E/ ^* u' U
       标准格式有11 个位的标识符（ID），扩展格式有29 个位的ID 。
- W# ^5 L( V6 J
       其中，最常用，也是最复杂的是数据帧，接着就看看数据帧：

数据帧一般由 7 个段构成
' m, X# Z: F5 E4 ]( B* n
$ t- c: M/ J0 e. J（1） 帧起始。表示数据帧开始的段。
* h4 T# X1 G( f（2） 仲裁段。表示该帧优先级的段。
（3） 控制段。表示数据的字节数及保留位的段。
2 D5 \6 a6 S5 _  M（4） 数据段。数据的内容，一帧可发送 0~8 个字节的数据。
% G6 }4 M) p6 U" o* t（5） CRC 段。检查帧的传输错误的段。
  K* t9 R& e0 X& B, E5 @（6） ACK 段。表示确认正常接收的段。
（7） 帧结束。表示数据帧结束的段。
: e- K+ @4 u2 Q. W8 u
  t# q' A" g$ }+ O$ a

+ x! [" h& M; W# w/ A4.1、总线仲裁介绍
3 U! F( u5 T6 G- d同时多个单元发送数据时，总线仲裁过程：

0 ^! }8 G9 w! K( W
. G+ X/ Y/ d" k& t4 K8 K
        上图中，单元 1 和单元 2 同时开始向总线发送数据，开始部分他们的数据格式是一样的，故无法区分优先级，直到 T 时刻，单元 1 输出隐性电平，而单元 2 输出显性电平，此时单元 1仲裁失利，立刻转入接收状态工作，不再与单元 2 竞争，而单元 2 则顺利获得总线使用权，继续发送自己的数据。这就实现了仲裁，让连续发送显性电平多的单元获得总线使用权.
; g2 T3 u5 H. D# }8 t1 \
7 [' w3 g5 Y' P) E# \/ d- v) @        规律：

              1，总线空闲时，最先发送的单元获得发送优先权，一但发送，其他单元无法抢占。
# w, u0 x; d" M
              2，如果有多个单元同时发送，则连续输出显性电平多的单元，具有较高优先级。
" T1 K$ e. y; K5 ^0 e
! O$ _5 B, y$ {$ t4.2、位时序
/ w/ O( F) T) w6 z, B2 t' Q       位速率：由发送单元在非同步的情况下发送的每秒钟的位数称为位速率。一个位一般可以分为如下四段：
! P- t0 k( Z; G7 ?6 D5 l9 m+ y, h
            同步段（SS）
" q: `0 U: K9 E  R            传播时间段（PTS）
6 @$ h% ]. {$ [            相位缓冲段 1（PBS1）
6 ~  [3 S  t) O9 \( W            相位缓冲段 2（PBS2）

      这些段又由可称为 Time Quantum（以下称为 Tq）的最小时间单位构成，1 位分为 4 个段，每个段又由若干个 Tq 构成，这称为位时序。

       位时间=1/波特率，因此，知道位时间，我们就可以知道波特率1 位由多少个 Tq 构成、每个段又由多少个 Tq 构成等，可以任意设定位时序。通过设定位时序，多个单元可同时采样，也可任意设定采样点。各段的作用和 Tq 数如表所示：



1 个位的构成如图所示：



" w6 _  p% ]/ a; W2 g  h( B上图的采样点，是指读取总线电平，并将读到的电平作为位值的点。位置在 PBS1 结束处。根据这个位时序，我们就可以计算 CAN 通信的波特率了。图中采样时间加大或减少量的最大值就是SJW。
2 ~  d2 S' H4 r# f9 ]9 y' ~$ O
. N5 n# z- }2 \! z6 J5 L5、STM32 CAN控制器简介
       STM32F4 自带的是 bxCAN，即基本扩展 CAN。它支持 CAN 协议 2.0A 和 2.0B。它的设计目标是，以最小的 CPU 负荷来高效处理大量收到的报文。它也支持报文发送的优先级要求(优先级特性可软件配置)。对于安全紧要的应用， bxCAN 提供所有支持时间触发通信模式所需的硬件功能。
2 x. B, N. N  b4 f+ e! r+ D4 VSTM32F4 的 bxCAN 的主要特点有：
          ①支持 CAN 协议 2.0A 和 2.0B 主动模式
          ②波特率最高达 1Mbps
          ③支持时间触发通信
          ④具有 3 个发送邮箱
          ⑤具有 3 级深度的 2 个接收 FIFO
          ⑥可变的过滤器组（28 个， CAN1 和 CAN2 共享）
0 |* q$ u2 l) X2 a
2 a4 ~" G) T+ _% q

5.1、标识符筛选器
! S3 Y- {! W0 U3 U. p* GCAN的标识符不表示目的地址而是表示发送优先级。接收节点根据标识符的值，来决定是否接收对应消息。
STM32 CAN控制器，提供了28个可配置的筛选器组（F1仅互联型才有28个，其他的只有14个），可降低CPU处理CAN通信的开销。
STM32 CAN控制器每个筛选器组由2个32位寄存器组成（CAN_FxR1和CAN_FxR2，x=0~27）。根据位宽不同，每个筛选器组可提供：
# T7 w, ?- w9 J7 c! X                 ● 1个32位筛选器，包括：STDID[10:0]、EXTID[17:0]、IDE和RTR位
  \2 b6 i. _9 q. O9 V
8 k5 f, P8 J) f/ s! Q                 ● 2个16位筛选器，包括：STDID[10:0]、IDE、RTR和EXTID[17:15]位

4 ]. x6 X6 H9 b$ \     4.筛选器可配置为：屏蔽位模式和标识符列表模式。

6 i; U, {( k% `5 a) ~. j在屏蔽位模式下，标识符寄存器和屏蔽寄存器一起，指定报文标识符的任何一位，应该按照“必须匹配”或“不用关心”处理。

# N+ M$ W" B! Q+ u在标识符列表模式下，屏蔽寄存器也被当作标识符寄存器用。因此，不是采用一个标识符加一个屏蔽位的方式，而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟筛选器标识符相同。
8 e) J6 e: @( N! C
9 L) C# s! O* L% m: H; D: b
# A( v" T: t8 M' ~! k7 O( ?
# p( z; J! G. }为了过滤出一组标识符，应该设置筛选器组工作在屏蔽位模式。
为了过滤出一个标识符，应该设置过滤器组工作在标识符列表模式。
* T; `" \1 D% a+ p( L$ E应用程序不用的筛选器组，应该保持在禁用状态(通过CAN_FA1R设置)。
" e2 P. T4 F/ W6 J; w% H8 a" U筛选器组中的每个筛选器，都被编号为(即：筛选器编号)从0开始，到某个最大数值－取决于筛选器组的模式和位宽的设置。
( W: p1 k3 n$ K  s通过CAN_FFA1R的设置，可以将筛选器组关联到FIFO0/FIFO1
5.2、STM32 CAN模式
1）工作模式
( i4 d% \1 @  A5 Q) s
       ①初始化模式（INRQ=1，SLEEP=0）

       ②正常模式（INRQ=0，SLEEP=0）
! b2 D7 R; `3 F3 A
       ③睡眠模式（SLEEP=1）

4 L. T7 {9 V2 S) o4 }* ~% c$ L1 P1 C! \2）测试模式

静默模式（ LBKM=0，SILM=1 ）

( l6 W* w! N  j" c" Y. P' ~
$ F0 v& w7 R( j) t1 w7 p) ]- Y% y8 E
8 `/ j& l9 \0 f# g) B' T环回模式（ LBKM=1，SILM=0 ）

9 q$ y! m$ i6 Q3 o! t7 ?; e

+ b3 Y2 b* f' h) O( D6 d环回静默模式（LBKM=1，SILM=1）

9 u; G9 }. d- M6 X) W! B' x  G

3 O$ G' Z; B2 s! K3）调试模式
) U1 m9 x- x) J0 ?* i# g
; _2 O0 u# w; q2 R& D' s5.3、STM32 CAN发送流程
: U6 a* W; ]1 e8 c      CAN发送流程为：

3 F& T) I0 x& C! ?+ d- l        程序选择1个空置的邮箱（TME=1）--->设置标识符（ID），数据长度和发送数据--->设置CAN_TIxR的TXRQ位为1，请求发送--->邮箱挂号（等待成为最高优先级）--->预定发送（等待总线空闲）--->发送--->邮箱空置。
# F- i& T. E& }0 v
        还包含了很多其他处理，终止发送（ABRQ=1）和发送失败处理等


* k# V0 s  m/ }) j; U' ?
) Z  z4 ~, h8 D* Y' [+ k5.4、STM32 CAN接收流程
CAN接收流程为：
- y! T2 d' a/ g% T* r- {( M
        FIFO空--->收到有效报文--->挂号_1（存入FIFO的一个邮箱，这个由硬件控制，从而节省了 CPU 的处理负荷，简化了软件并保证了数据的一致性）---->收到有效报文---->挂号_2---->收到有效报文---->挂号_3---->收到有效报文à溢出。
# g: t, y. q" w2 h( D
        CAN收到的有效报文，存储在3级邮箱深度的FIFO中。FIFO接收到的报文数，我们可以通过查询CAN_RFxR的FMP寄存器来得到，只要FMP不为0，我们就可以从FIFO读出收到的报文。

7 U" u3 K& c" U( G; b# F6 }9 [         报文FIFO具有锁定功能(由CAN_MCR，RFLM位控制)，锁定后，新数据将丢弃，不锁定则新数据将替代老数据
. A4 p& Y% Y4 I; K  a& ^+ b


5.5、STM32 CAN位时序
      STM32F4 把传播时间段和相位缓冲段 1（STM32F4 称之为时间段1）合并了，所以 STM32F4 的 CAN 一个位只有 3 段：同步段（SYNC_SEG）、时间段 1（BS1）和时间段 2（BS2）。 STM32F4 的 BS1 段可以设置为 1~16 个时间单元，刚好等于CAN的传播时间段和相位缓冲段 1 之和。
! x( o: k7 {5 m1 @5 y5 D


         图中还给出了 CAN 波特率的计算公式，我们只需要知道 BS1 和 BS2 的设置，以及 APB1的时钟频率（一般为 42Mhz），就可以方便的计算出波特率。
! |; {  T5 ^$ I
4 G9 _. Z2 E! o) F2 Y         比如：
; e% J% y. q8 Z. k2 a8 v
0 O, E; Z7 Z0 D' e1 ?* i                  STM32F103，设TS1=8、TS2=7、BRP=3，波特率=36000/[(9+8+1)*4]=500Kbps。
) D( t* p$ e9 n4 `
                  STM32F407，设TS1=6、TS2=5、BRP=5，波特率=42000/[(7+6+1)*6]=500Kbps。

) F8 O- V+ P, X/ w; U5 k2 ?( P6、参考代码

1. #include "can.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   6 t5 h. D# u* G4 U" U5 w
4. 
   
5. u8 CAN1_Mode_Init(u8 tsjw,u8 tbs2,u8 tbs1,u16 brp,u8 mode)
   ' W( F: e- t! }8 U: j4 B8 r" U
6. {
   
7.           GPIO_InitTypeDef GPIO_InitStructure;
   
8.         CAN_InitTypeDef        CAN_InitStructure;
   
9.           CAN_FilterInitTypeDef  CAN_FilterInitStructure;
   , Z& Z( Q1 r7 u+ ?* e  c
10. 
    ) w# k/ h; x3 n* A5 t2 m( e
11.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE)；
    
12.           RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    0 ]. \3 [- @3 m. ?8 q
13. 
    3 _  V3 {% u( ^# z  Z. y: u6 d9 t
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;
    # ?6 V& W) M( h8 G  M% E: Y' l  R
19.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    % B8 R. B5 ^, \/ I6 k, X% @
20. 
    
21.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource11,GPIO_AF_CAN1);
    6 u* x8 `' d# G: }+ b& T6 D5 _
22.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource12,GPIO_AF_CAN1);
    * _5 h0 M2 c3 e
23.          
    
24.            CAN_InitStructure.CAN_TTCM=DISABLE;
    . z5 {6 O0 x4 S7 P/ g4 C
25.           CAN_InitStructure.CAN_ABOM=DISABLE;
    % K( x  h9 F8 f$ `2 p3 N
26.           CAN_InitStructure.CAN_AWUM=DISABLE;
    
27.           CAN_InitStructure.CAN_NART=ENABLE;
    7 @; I5 C1 m6 x) l
28.           CAN_InitStructure.CAN_RFLM=DISABLE;
    / y- Q2 @% W" X" G) q' S$ E
29.           CAN_InitStructure.CAN_TXFP=DISABLE;
    
30.           CAN_InitStructure.CAN_Mode= mode;
    6 o, p9 q5 o# m, I' g8 b4 [: m' L
31.           CAN_InitStructure.CAN_SJW=tsjw;
    
32.           CAN_InitStructure.CAN_BS1=tbs1;
    
33.           CAN_InitStructure.CAN_BS2=tbs2;
    
34.           CAN_InitStructure.CAN_Prescaler=brp;
    . O+ s* j2 u$ m- ~9 X
35.           CAN_Init(CAN1, &CAN_InitStructure);
    0 @# M8 n% ]; n6 {! X
36. 
    ) N* W% Y$ q4 q
37.          CAN_FilterInitStructure.CAN_FilterNumber=0;
    
38.           CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
    $ r. J' Q2 s) i  n3 V# U
39.           CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
    ) ~1 }0 d/ K5 c7 X
40.           CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;
    
41.           CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
    
42.           CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
    
43.           CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
    
44.            CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0;
    
45.           CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
    
46.           CAN_FilterInit(&CAN_FilterInitStructure);
    
47.                
    
48.         CAN_ITConfig(CAN1,CAN_IT_FMP0,ENABLE);            
    
49. 
    
50.           NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX0_IRQn;
    - C$ u/ b: n1 \0 ]) _- `+ h7 ~4 L& T
51.           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;   
    ! {" F- f1 T- Y+ u3 O: O% m* D! v  n
52.           NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;           
    
53.           NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    0 u9 o3 w( @7 S' V, W' K: w$ r% _8 z: c
54.           NVIC_Init(&NVIC_InitStructure);
    4 W" H) Z2 x) K: v( a1 P: Q' y- `
55. 
    9 z4 y6 Q; m7 u6 p9 y% F# `
56.         return 0;
    
57. }   
    
58. 
    . C1 A* O2 X! v# K: B6 _
59.                     
    
60. void CAN1_RX0_IRQHandler(void)
    " B9 J5 P! W& N3 A$ b- V
61. {
    
62.           CanRxMsg RxMessage;
    
63.         int i=0;
    ) M1 ~2 i9 s" Q0 i/ X. I
64.     CAN_Receive(CAN1, 0, &RxMessage);
    
65.         for(i=0;i<8;i++)
    % U: e( }& h+ n! o8 {: l# p  {0 V
66.         printf("rxbuf[%d]:%d\r\n",i,RxMessage.Data<i>);
    , m# U7 Z' D* Z6 v; |
67. }
    # w) {1 ?  i' S7 l' {2 o$ I
68. 
    ) O$ Z2 ?+ B+ W1 R
69. 
    1 O) Y) `7 Y! Y/ ?1 c
70. u8 CAN1_Send_Msg(u8* msg,u8 len)
    
71. {        
    
72.   u8 mbox;
    
73.   u16 i=0;
    
74.   CanTxMsg TxMessage;
    
75.   TxMessage.StdId=0x12;        
    
76.   TxMessage.ExtId=0x12;
    
77.   TxMessage.IDE=0;               
    
78.   TxMessage.RTR=0;        
    
79.   TxMessage.DLC=len;                                                
    
80.   for(i=0;i<len;i++)
    , Y* y  u+ b9 N5 Y. M
81.   TxMessage.Data<i>=msg<i>;                              
      [1 I" \- e% Q5 L, J0 x7 Z
82.   mbox= CAN_Transmit(CAN1, &TxMessage);   
    7 L" J: D5 |3 f4 ^
83.   i=0;
    8 a1 b0 x" Y7 O, |% O1 k2 R, O
84.   while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))i++;
    
85.   if(i>=0XFFF)return 1;
    
86.   return 0;               
    8 W" h1 f  U9 T7 }* A
87. 
    
88. }
    
89. 
    + ~( q* T# z5 {1 z9 f
90. u8 CAN1_Receive_Msg(u8 *buf)
    * [+ g4 p; V* O- W, M2 k% W0 H3 {
91. {                                      
    
92.          u32 i;
    
93.         CanRxMsg RxMessage;
    
94.     if( CAN_MessagePending(CAN1,CAN_FIFO0)==0)return 0;               
    
95.     CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);
    ( ?& a, }: Z& e8 q( X
96.     for(i=0;i<RxMessage.DLC;i++)
    6 U. k$ d* |4 N7 D, ~( o4 A
97.     buf<i>=RxMessage.Data<i>;  
    , g$ c% ?$ c3 a
98.         return RxMessage.DLC;        
    
99. }
    # }4 W* A7 a! I& Z
100. </i></i></i></i></i>

复制代码

  s3 t% ]+ s0 B: F# }9 B  f