一、什么是can总线？

can总线因为使用电压差表示逻辑1和0，所以抗干扰性强，传播距离远（500kbps 时130M），比特率越小越远

1.can有几根线？

　　2根，can_H ,can_L

2.can怎么表示1,0?

　　can_H - can_L > 0.9V ,为逻辑 0，也称为显性电平。

　　can_H - can_L < 0.5v ,为逻辑1，也称为隐性电平。

一般can_H为3.5V ， 2.5V

一般can_L为2.5V ,1.5V

二、stm32 怎么使用can总线

1.can接口在哪？

　　

% T! T! I3 Q! z

" W3 p; `/ @9 X+ Q* k

　　stm32有can总线控制器，以及有库函数stm32f10x_can.c可以驱动该控制器

　　但stm32只是有can总线控制器，要真正连接can总线，她还要外接can总线收发器，才能分出来can_H ,can_L,例如如下芯片：

　　这个芯片的主要作用是发送时根据TXD的电平来决定can_H 和can_L的电平，以及接收时根据can_H 和 can_L的电平差来决定RXD的电平。

* v) {& E" G* T( x& x
7 h! G' `0 b5 T; s) S4 m8 R5 [# L
; U. @! W) R, C3 K8 I1 Z* K

2.can概念入门比较好的文档

https://wenku.baidu.com/view/7701528a6529647d2728520f.html

这个文档比较详细的介绍了can帧的类型，以及各个帧每个字节，每个bit的含义，以及优先级仲裁机制。下面的例程是数据帧。

3.can例程。

8 F$ O1 {/ i1 l% @6 z

1. #ifndef CAN_H_
   3 L3 d  z0 y* [: {; c6 |
2. #define CAN_H_
   
3. #include "stm32f10x.h"
   
4. #define RCC_APBxPeriph_CAN_IO RCC_APB2Periph_GPIOA
   
5. #define CAN_RXD GPIO_Pin_11
   ; |4 B4 V+ w& @# f
6. #define CAN_TXD GPIO_Pin_12
   " f4 z! {/ d6 V; H# G# _
7. #define CAN_IO  GPIOA
   
8. 
   
9. enum canrate_e
   ( U" ~% J% N9 D# U$ M1 `( S- s- _
10. {
    
11.     CANRATE125K=125,
    
12.     CANRATE250K=250,
    
13.     CANRATE500K=500,
    
14.     CANNOTLINK,
    - \$ f! r& G4 N6 K6 L
15. };
    5 o8 \0 _8 s! q  R1 R+ `1 z
16. 
    
17. enum canStdExt_e
    
18. {
    ! K& H5 W7 p( _$ K$ L: a
19.     CANSTD=0,
    - d4 h& F/ J7 z% e8 p- y
20.     CANEXT=1,
    
21. };
    
22. struct canrxtx_s
    
23. {
    
24.     CanRxMsg rxMessage[3];
    ) _$ `2 E2 \% k3 n  a* H( x, m1 j
25.     u8 rx_newflag;
    + Q+ D1 d4 {: g' a/ {! K& j" T
26.     uint32_t f;
    
27.     CanTxMsg txMessage;
    * k6 _" n1 C/ k" w# ~( I/ w
28. 
    
29. };
    : L! L2 `- A2 U
30. 
    7 ^% G( p, F* N2 C7 \* b$ |
31. /*std ID*/
    ( W! f2 J5 F7 S0 _* y7 E
32. #define CAN1_TX_STD_ID 0x7DF //11 Bits ID,Functional
    
33. 
    
34. #define CAN1_TX_STD_ID_ECM 0x7E0 //11 Bits  ECM ID,physical
    
35. #define CAN1_RX_STD_ID_ECM 0x7E8 //11 Bits  ECM ID,physical
    
36. #define CAN1_RX_STD_Filter 0x7FF //11 bits ECM Filter
    ! Z7 F7 I) g$ \& a2 B* s+ Q2 I
37. 
    8 s: l6 e, b: E( E# ^
38. /*extend ID*/
    
39. #define CAN1_TX_EXT_ID 0x18DB33F1 //29 Bits  ID,Functional
    4 Q1 V9 m; x0 W" X; F2 e3 ~) f# W
40. #define CAN_Id_Extended_HONDA 0x18DBEFF1 //29 Bits  ID,Functional   HONDA
    ( M# [" K  x8 m( J
41. #endif

复制代码

1. #include "can.h"
   8 w  p9 y3 y2 C7 f4 X3 ^
2. #include <string.h>
   2 N/ {& j7 @& H
3. u8 std_or_ext;
   * r+ ~! H. M1 T$ V$ q- |
4. struct canrxtx_s canrxtx;
   
5. void CAN1_init(enum canrate_e canrate)
   
6. {
   
7. 
   
8.     GPIO_InitTypeDef GPIO_InitStructure;
   
9.     CAN_InitTypeDef  CAN_InitStructure;
   + n- U! U' n5 U" ^. v# i/ n
10. 
    
11.     RCC_APB2PeriphClockCmd(RCC_APBxPeriph_CAN_IO | RCC_APB2Periph_AFIO,ENABLE);
      f7 n) {) e2 g
12.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1,ENABLE);
    
13.     GPIO_InitStructure.GPIO_Pin = CAN_RXD;
    $ r' P9 u" ]$ |4 o1 N% b' H
14.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
16.     GPIO_Init(CAN_IO, &GPIO_InitStructure);
    ( |7 t5 p8 S2 R! ?! Y
17. 
    
18.     GPIO_InitStructure.GPIO_Pin = CAN_TXD;
    
19.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    
20.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    ) m1 j9 X) ^" Q- c' H* [+ t
21.     GPIO_Init(CAN_IO, &GPIO_InitStructure);
    " N* o! F9 i9 G+ E- J- `
22. 
    
23.     CAN_DeInit(CAN1);
    . K/ \+ S; D& Y  [3 u
24.     CAN_StructInit(&CAN_InitStructure);
    
25. 
    
26.     CAN_InitStructure.CAN_TTCM = DISABLE;
    . j6 g  N0 T6 I8 l7 v# @
27.     CAN_InitStructure.CAN_ABOM = DISABLE;
    - K$ H: L1 W4 \+ L- o
28.     CAN_InitStructure.CAN_AWUM = DISABLE;
    ) _5 }4 f" I7 I; [" j. `
29.     CAN_InitStructure.CAN_NART = DISABLE;
    3 c& `, r9 X, R2 n4 J" y
30.     CAN_InitStructure.CAN_RFLM = DISABLE;
    
31.     CAN_InitStructure.CAN_TXFP = DISABLE;
    
32.     CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
    
33.     CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;
    ; I1 q$ v# |( d# G/ h
34.     CAN_InitStructure.CAN_BS1 = CAN_BS1_3tq;
    
35.     CAN_InitStructure.CAN_BS2 = CAN_BS2_2tq;
    + l: G6 J1 F5 x5 o  H
36.      //CAN BaudRate = 72MHz/(CAN_SJW+CAN_BS1+CAN_BS2)/CAN_Prescaler
    4 e3 o: G/ g4 @5 \4 O1 L
37.      if(canrate==CANRATE125K) /* 125KBps */
    
38.          CAN_InitStructure.CAN_Prescaler =96;
    
39.      else if(canrate==CANRATE250K) /* 250KBps */
    ( P% j/ N" C; o1 g3 J0 d) O
40.          CAN_InitStructure.CAN_Prescaler =48;
    7 d! \7 R  A% p7 a" w6 z1 g) M0 i
41.      else  /* 500KBps */
    
42.          CAN_InitStructure.CAN_Prescaler = 24;
    % f6 v2 {5 y- a7 J3 t1 j. `2 J7 i/ R4 j
43. 
    
44.     CAN_Init(CAN1, &CAN_InitStructure);
    
45. }
    . x+ }! i$ s. _
46. 
    3 c8 v- \% @9 M2 J  B# {1 h
47. void CAN1_ConfigFilter(u32 id1, u32 id2, u32 mask1, u32 mask2, u8 std_or_ext)
    6 [) N- c6 B5 i. n1 P& M
48. {
    
49.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    + {  c2 R2 s) Z/ c% h2 ~" C
50.     NVIC_InitTypeDef  NVIC_InitStructure;
    
51. 
    
52.     CAN_FilterInitStructure.CAN_FilterNumber=1; //use which filter,0~13
    + Q9 p9 j9 G# X! M5 ?: A
53.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
    0 w( n+ o# R1 z1 ]: @$ g) t
54.     if(std_or_ext == CANSTD)
    / ^! d8 M) ?+ f, Q4 b$ I
55.     {
    , ?, C" ~- Z6 q  [
56.         CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_16bit;
    
57.         CAN_FilterInitStructure.CAN_FilterIdHigh=id1<<5;
    5 {; v# @+ o8 Q
58.         CAN_FilterInitStructure.CAN_FilterIdLow=id2<<5;
    
59.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh=mask1<<5;
    
60.         CAN_FilterInitStructure.CAN_FilterMaskIdLow=mask2<<5;
    
61. 
    $ V3 [- a, {( `$ ~: _& a% `* L5 g
62.     }
    
63.     else
    " J& M; y) A% g
64.     {
    
65.         CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
    4 m& M# r! e. j2 V4 |# M
66.         CAN_FilterInitStructure.CAN_FilterIdHigh=(u16) (id1>>13);
    8 L3 _8 t  Q6 U2 P7 `( I: m
67.         CAN_FilterInitStructure.CAN_FilterIdLow=(u16) (((id1&0x00001FFF)<<3)|CAN_Id_Extended|CAN_RTR_DATA);
    ! X/ Z* F) Y6 o9 w  `' W! ]+ R# e
68.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh=(u16) (mask1>>13);
    8 k+ b0 S- K- U& T
69.         CAN_FilterInitStructure.CAN_FilterMaskIdLow=(u16) ((mask1&0x00001FFF)<<3);
    
70. 
    
71.     }
    
72. 
    
73.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;
    
74.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
    
75.     CAN_FilterInit(&CAN_FilterInitStructure);
    
76. 
    
77.     NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX1_IRQn;
    
78. 
    . k$ F, O+ m# e4 _
79.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    . `$ s/ D2 {3 k5 O  V5 E
80.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    ' t9 q1 y/ o  M- A! z) b1 Y+ q- R
81.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    6 h3 K4 V3 P  G( ]: R/ `+ F
82.     NVIC_Init(&NVIC_InitStructure);
    ) j, p+ F( z$ u/ w# O0 v
83. 
    
84.     CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
    ) _$ K, d; O4 H6 |5 K
85. }
    
86. /************************init******************************/
    # _- C# r( `0 u7 u; }+ B9 F
87. void init_demo()
    7 l% \7 A. y8 R" ~
88. {
    . l& P8 r$ ]5 g8 p9 v: a) G
89.     std_or_ext = CANEXT;
    
90.     CAN1_init(CANRATE500K);
    
91.     CAN1_ConfigFilter(0x18DAF110,0x18DAF110,0x1FFFF100,0x1FFFF100,std_or_ext);//extend ID
    
92. }
    
93. /************************tx******************************/
    
94. /*datalen<=8*/
    
95. int CAN1_TransASerialData(u8* pdata,u8 datalen)
    ; S7 ?- f/ m) S
96. {
    
97.     u8 i=0;
    
98. 
    " [& X2 S& s9 E- c. Y! S
99.     Delay_ms(20);
    
100. 
     3 h+ ~8 V: I$ e8 Z0 M
101.     if(std_or_ext == CANEXT)
     
102.     {
     
103.         canrxtx.txMessage.StdId=0x00;
     
104.         canrxtx.txMessage.ExtId=CAN_Id_Extended_HONDA;//bentian
     / N: ]( b# c8 |$ v& C) d( U
105.         canrxtx.txMessage.RTR=CAN_RTR_DATA;
     7 `6 v+ n* z2 t
106.         canrxtx.txMessage.IDE=CAN_Id_Extended;// 29 bits
     
107. 
     
108.     }
     
109.     if(std_or_ext== CANSTD)
     + t, P1 R" \1 X  _7 o% o! }
110.     {
     ! X/ Y+ O$ o3 a" Q! a
111.         canrxtx.txMessage.StdId=CAN1_TX_STD_ID;
     
112.         canrxtx.txMessage.ExtId=0x00;
       F/ |, d" d! o8 t$ c
113.         canrxtx.txMessage.RTR=CAN_RTR_DATA;
     9 S, k) |% G( t9 u
114.         canrxtx.txMessage.IDE=CAN_Id_Standard;//11 bits
     
115.     }
     - c( w8 O& L" k1 V
116. 
     : ?: l; p% Z; k% q8 m
117.     canrxtx.txMessage.DLC=0x08;
     $ f  t% T! r# Q/ I: N: t
118.     canrxtx.txMessage.Data[0]=datalen;
       s+ F7 D) G! X' m. C
119.     memcpy(&(canrxtx.txMessage.Data[1]),pdata,datalen);
     - w9 L& b6 W. s
120. 
     
121. 
     2 d- N3 H" D8 K' k; o9 q
122.     while(((i++)<3)&&(CAN_TxStatus_NoMailBox==CAN_Transmit( CAN1,&canrxtx.txMessage)))
     
123. 
     & M9 b/ |+ _8 K$ p4 s' g
124.     if(i>=3)    //timeout
     
125.     {
     
126.         return (-1);
     
127.     }
     # d1 c3 ~2 h/ x/ j
128. 
     
129.     canrxtx.rx_newflag=0;
     : _9 o7 ?/ f# p' E0 t6 ~6 Z3 t# `) w2 U
130.     return (0);
     
131. 
     8 U% T5 q! f# ]3 R
132. }
     0 W( y7 P( D, ~$ m8 f2 g, M/ V
133. /************************rx******************************/
     # R1 \! Y$ D) t! T
134. void CAN1_RX1_IRQHandler(void)
     
135. {
     - f0 \0 q1 u0 s; L8 K
136.     memset(&canrxtx.rxMessage,0,sizeof(CanRxMsg));
     
137.     if(CAN_MessagePending(CAN1,CAN_FIFO0))
     
138.         {
     8 z6 s3 e) I) k$ O/ m
139.             CAN_Receive(CAN1,CAN_FIFO0,&canrxtx.rxMessage[0]);
     : r' H4 q6 g! A. k7 T; t
140.         }
     4 J" h9 A5 D( {9 d" }3 s. K
141.     canrxtx.rx_newflag=1;
     . F3 g4 A$ O' v4 v# i
142. }

复制代码

. c6 V- F$ ^+ f. a. ^

三、标识符过滤器的解释

过滤器只是用于接收，判断某个报文是否能通过过滤器，过滤器初始化如下：   

1. CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;      

复制代码

1. <font face="Tahoma" color="#000000">CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_16bit;          </font><div><font face="Tahoma" color="#000000">CAN_FilterInitStructure.CAN_FilterIdHigh=id1<<5;                                                                        CAN_FilterInitStructure.CAN_FilterIdLow=id2<<5;                                                                            CAN_FilterInitStructure.CAN_FilterMaskIdHigh=mask1<<5;                                                                  CAN_FilterInitStructure.CAN_FilterMaskIdLow=mask2<<5;  </font></div>

复制代码

5 I6 E6 j2 E. w  vstm32有0~13个过滤器组，每个过滤器组有两个32位的寄存器，通过设置下面两个结构体成员的值可以有四种组合：CAN_FilterMode 和 CAN_FilterScale
) E+ F& ~/ T3 S3 p5 G) S
+ {; R8 V* Z! V3 `

四、关于邮箱

如下图，发送3个邮箱，接收每个FIFO 3个邮箱，这是硬件自动管理的，软件不用管，只要判断发送成不成功，中断接收哪个FIFO就行了（要接收过滤器初始化时绑定的那个FIFO）。

每个邮箱都可以存储一个独立的报文，发送调度器（下图红圈）会根据标识符(ID)的优先级来决定先发送哪个报文（比如发送时3个邮箱都有报文，标识符不一样），PS：标识符数值越小，优先级越高，这是由CAN总线仲裁机制决定的（线与，0可以与掉1）。

# c! E- l5 l- T5 W' m. Q

" |1 y9 p; W% |; V" w; y: n$ a( z

五、can中容易理解错的概念

1.CAN总线中是没有地址这个概念的，每个报文都是群发。

所有节点都可以发送和接收，先发送的有优先权，此时其它节点处于监听模式，看是否有能通过自己过滤器的报文。

当同时有多个节点需要同时发送时，can总线将实行仲裁，标识符小的优先发送，被仲裁下去想要发送的节点立即转入监听状态，等待下次机会。

标识符是报文的一部分，如下图所示：

2.不管是标准帧或者扩展帧，最多只能携带8字节数据，用户可以根据这8个字节私立协议。

SOF：帧起始信号，显性电平，即can_H和can_L相差很小，小于0.5V，库函数做了赋值，不管。

标识符：11bit或者29bits，代表着本条报文的优先级

RTR：帧类型，是远程帧还是数据帧

IDE：标准帧还是扩展帧

R0：保留位，库函数做了，不管

DLC：数据域长度

数据域：具体携带的数据，最长8字节

CRC：对CRC前所有字节进行校验，得到的结果，库函数进行了这一步，不需要我们自己计算，不管。

CRC分隔符：1个隐性电平，库函数做了，不管

ACK Field:库函数做了，

EOF：帧结束标志，至少连续7位的隐性电平。不管。

9 Z# b7 z) @( h( j% P, W8 l0 L

9 a7 |! m$ y" z3 h

3.位填充的概念

在CAN消息帧中，帧起始，仲裁场。控制场，数据场和CRC段，均以位填充方法进行编码。当发送器在发送流中检测到5个极性相同的连续位时，自动插入一个部补位码。

我觉得这个只要了解就行了，实际编程中库函数已经帮我们做了。