一、什么是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接口在哪？

　　

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

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

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

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

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

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

3.can例程。

1. #ifndef CAN_H_
   : F  y% O; D4 z: F
2. #define CAN_H_
   
3. #include "stm32f10x.h"
   * n3 B# i9 J) s- F" L9 I$ |
4. #define RCC_APBxPeriph_CAN_IO RCC_APB2Periph_GPIOA
   
5. #define CAN_RXD GPIO_Pin_11
   ; x6 Z  k1 k# ?
6. #define CAN_TXD GPIO_Pin_12
   
7. #define CAN_IO  GPIOA
   
8. 
   
9. enum canrate_e
   
10. {
    
11.     CANRATE125K=125,
    1 c* i) X8 U6 R$ ~7 W4 \
12.     CANRATE250K=250,
    / y7 ]- X6 p' u3 t( i+ S
13.     CANRATE500K=500,
    
14.     CANNOTLINK,
    
15. };
    ! i4 o7 M6 T0 a" v
16. 
    
17. enum canStdExt_e
    
18. {
    
19.     CANSTD=0,
    
20.     CANEXT=1,
    : y, c( q2 ]. V- ?5 k6 v( l2 I
21. };
    
22. struct canrxtx_s
    * f7 _% Y/ U4 c6 F
23. {
    & ?2 O# P) T* n. Y) H! n; V
24.     CanRxMsg rxMessage[3];
    
25.     u8 rx_newflag;
    + u: V$ O& E$ }2 n0 _/ `& {. Y
26.     uint32_t f;
    . v, e0 C7 h. ~9 s% S- D) f8 M
27.     CanTxMsg txMessage;
    
28. 
    / ~5 K1 c* p7 {3 q
29. };
    
30. 
    
31. /*std ID*/
    1 w2 V/ i, o* X! I# y6 D+ P
32. #define CAN1_TX_STD_ID 0x7DF //11 Bits ID,Functional
    7 }- z7 v' z0 n
33. 
    * {: @) d) P) k6 L( K+ s( g
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
    3 G+ ?* Z# }* y9 V1 N  U/ B9 A3 F) p& I
37. 
    
38. /*extend ID*/
    
39. #define CAN1_TX_EXT_ID 0x18DB33F1 //29 Bits  ID,Functional
    : U- H2 x& V" o) H; C& j) W
40. #define CAN_Id_Extended_HONDA 0x18DBEFF1 //29 Bits  ID,Functional   HONDA
    
41. #endif

复制代码

1. #include "can.h"
   
2. #include <string.h>
   
3. u8 std_or_ext;
   
4. struct canrxtx_s canrxtx;
   ; U# H' |9 Z/ r0 q
5. void CAN1_init(enum canrate_e canrate)
   * f: e' L; y& b" l- w0 p* b
6. {
   " \6 Q# v) t$ f. X+ G2 l
7. 
   ! d7 Q7 C( Q0 P8 s
8.     GPIO_InitTypeDef GPIO_InitStructure;
   
9.     CAN_InitTypeDef  CAN_InitStructure;
   ! O4 u' U7 [1 M+ `2 X! _" }; }4 `% j
10. 
    . t  l9 S" c5 H2 V3 M/ V
11.     RCC_APB2PeriphClockCmd(RCC_APBxPeriph_CAN_IO | RCC_APB2Periph_AFIO,ENABLE);
    / |1 U3 J0 w' u2 U
12.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1,ENABLE);
    
13.     GPIO_InitStructure.GPIO_Pin = CAN_RXD;
    * e7 Y& G' X5 [6 s( H' ]; `3 |
14.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    4 j9 ^5 P1 C3 u/ A. z2 h9 O$ g
15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
16.     GPIO_Init(CAN_IO, &GPIO_InitStructure);
    6 B# ?  l) f4 _9 b; f& ]5 g1 b
17. 
    , {' H& _4 \) T" H) U5 R9 K0 I; T
18.     GPIO_InitStructure.GPIO_Pin = CAN_TXD;
    
19.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    
20.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
21.     GPIO_Init(CAN_IO, &GPIO_InitStructure);
    
22. 
    
23.     CAN_DeInit(CAN1);
    
24.     CAN_StructInit(&CAN_InitStructure);
    , D5 b8 R$ o% {+ A) O
25. 
    
26.     CAN_InitStructure.CAN_TTCM = DISABLE;
    
27.     CAN_InitStructure.CAN_ABOM = DISABLE;
    
28.     CAN_InitStructure.CAN_AWUM = DISABLE;
    
29.     CAN_InitStructure.CAN_NART = DISABLE;
    ( ]) f* C' \( \3 M6 [! d% b  u9 k
30.     CAN_InitStructure.CAN_RFLM = DISABLE;
    
31.     CAN_InitStructure.CAN_TXFP = DISABLE;
    7 W: [% x# B$ w
32.     CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
    
33.     CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;
    1 }3 @/ i. q; M& a7 E6 m/ _, ^0 H
34.     CAN_InitStructure.CAN_BS1 = CAN_BS1_3tq;
    . C' @0 ?2 s: m2 v  M9 n9 I! s& D
35.     CAN_InitStructure.CAN_BS2 = CAN_BS2_2tq;
    
36.      //CAN BaudRate = 72MHz/(CAN_SJW+CAN_BS1+CAN_BS2)/CAN_Prescaler
    - ~- p6 C9 J! N3 [# P4 _4 x) ^
37.      if(canrate==CANRATE125K) /* 125KBps */
    0 e2 ]8 b0 x! z$ y8 ^+ w
38.          CAN_InitStructure.CAN_Prescaler =96;
    3 A) q  V3 H, X/ S; O* w2 [
39.      else if(canrate==CANRATE250K) /* 250KBps */
    
40.          CAN_InitStructure.CAN_Prescaler =48;
    ) C! r, x* A- n* V
41.      else  /* 500KBps */
    
42.          CAN_InitStructure.CAN_Prescaler = 24;
    / d, G0 |! U- Q+ h0 Z8 L6 l
43. 
    ) j' W+ W) V% G9 z* l% C+ K
44.     CAN_Init(CAN1, &CAN_InitStructure);
    
45. }
    1 S& E+ g" O$ O( c1 \0 C
46. 
    
47. void CAN1_ConfigFilter(u32 id1, u32 id2, u32 mask1, u32 mask2, u8 std_or_ext)
    , k) ]. X/ F" v  O; Y. E- W  i
48. {
    
49.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    9 `4 c/ V/ A, ]' a+ u
50.     NVIC_InitTypeDef  NVIC_InitStructure;
    
51. 
    
52.     CAN_FilterInitStructure.CAN_FilterNumber=1; //use which filter,0~13
    9 u6 G0 d$ A! i5 d/ J$ _
53.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
    - N- ]; F3 ]( r
54.     if(std_or_ext == CANSTD)
    , Z0 w2 k: ^% h- w, S$ ]5 [
55.     {
    2 p4 ~* p. P, Y6 Y. g- E, o
56.         CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_16bit;
    
57.         CAN_FilterInitStructure.CAN_FilterIdHigh=id1<<5;
    
58.         CAN_FilterInitStructure.CAN_FilterIdLow=id2<<5;
    3 W2 }, X1 k. _* s1 C; F/ M( P2 B
59.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh=mask1<<5;
    
60.         CAN_FilterInitStructure.CAN_FilterMaskIdLow=mask2<<5;
    6 }7 ^/ ?# Q+ \& Y, V
61. 
    
62.     }
    
63.     else
    
64.     {
    
65.         CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
    ! z7 F- k* W3 x6 s# w
66.         CAN_FilterInitStructure.CAN_FilterIdHigh=(u16) (id1>>13);
    
67.         CAN_FilterInitStructure.CAN_FilterIdLow=(u16) (((id1&0x00001FFF)<<3)|CAN_Id_Extended|CAN_RTR_DATA);
    
68.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh=(u16) (mask1>>13);
    
69.         CAN_FilterInitStructure.CAN_FilterMaskIdLow=(u16) ((mask1&0x00001FFF)<<3);
    $ W; S/ m$ Q. G- E1 G& z; T
70. 
    ' i6 v- P& d& d. A: e0 B# b! y. I& |
71.     }
    
72. 
    
73.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;
    
74.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
    5 L. y/ n- ]6 \2 n
75.     CAN_FilterInit(&CAN_FilterInitStructure);
    ( ~8 L0 ^4 A. o$ a
76. 
    
77.     NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX1_IRQn;
    * t4 W& T& }8 N
78. 
    . E! c+ |& ~1 O1 l
79.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    
80.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    
81.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    3 n; e- t0 ^9 r- Y
82.     NVIC_Init(&NVIC_InitStructure);
    $ b5 O4 L* n; ^1 Z' J/ I( a
83. 
    ) }* L+ T# Z# D6 p( }. n" y
84.     CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
    - u2 I* M+ n' c% k  }) N  F
85. }
    , c. |1 S$ }! i" x
86. /************************init******************************/
    
87. void init_demo()
    $ F( B: k( P2 Y) a) h/ F
88. {
    
89.     std_or_ext = CANEXT;
    
90.     CAN1_init(CANRATE500K);
    * I/ o. ^2 Z5 h# `! t1 \
91.     CAN1_ConfigFilter(0x18DAF110,0x18DAF110,0x1FFFF100,0x1FFFF100,std_or_ext);//extend ID
    
92. }
    - m- W3 j$ n( Y& I$ m) O
93. /************************tx******************************/
    
94. /*datalen<=8*/
    & m( @! ?7 O# L3 R% \/ b
95. int CAN1_TransASerialData(u8* pdata,u8 datalen)
    
96. {
    & f& M' h2 K( B( ?
97.     u8 i=0;
    
98. 
    & g1 Q, [: r6 A; \. L7 D6 @/ m
99.     Delay_ms(20);
    : K! B* B% o( y( S, E) L
100. 
     
101.     if(std_or_ext == CANEXT)
     
102.     {
     
103.         canrxtx.txMessage.StdId=0x00;
     
104.         canrxtx.txMessage.ExtId=CAN_Id_Extended_HONDA;//bentian
     
105.         canrxtx.txMessage.RTR=CAN_RTR_DATA;
     # {) W, i1 R) O- T2 `
106.         canrxtx.txMessage.IDE=CAN_Id_Extended;// 29 bits
     1 [: a. |" h  N3 m
107. 
     
108.     }
     
109.     if(std_or_ext== CANSTD)
     
110.     {
     
111.         canrxtx.txMessage.StdId=CAN1_TX_STD_ID;
     ; P' N9 W$ k( ]3 B4 V, e
112.         canrxtx.txMessage.ExtId=0x00;
     
113.         canrxtx.txMessage.RTR=CAN_RTR_DATA;
     5 x* I7 _% @% r% T
114.         canrxtx.txMessage.IDE=CAN_Id_Standard;//11 bits
     - K; ?: b3 n1 N. A6 C
115.     }
     
116. 
     
117.     canrxtx.txMessage.DLC=0x08;
     
118.     canrxtx.txMessage.Data[0]=datalen;
     + ?* c, r, {- S# _2 L1 \3 \% J
119.     memcpy(&(canrxtx.txMessage.Data[1]),pdata,datalen);
     
120. 
     8 l% V9 X: n) [* S
121. 
     $ h+ V9 C& z; \' ^; F
122.     while(((i++)<3)&&(CAN_TxStatus_NoMailBox==CAN_Transmit( CAN1,&canrxtx.txMessage)))
     
123. 
     . y" h2 L+ Z7 k! v
124.     if(i>=3)    //timeout
     6 A! ?! Z8 \+ b6 e. x3 C$ V
125.     {
     / i; }2 g3 c+ \; u( z+ f/ N% l
126.         return (-1);
       x  T/ G3 J! b& r% f
127.     }
     ) g2 E$ p+ Z- G! |* I
128. 
     0 [; B+ l& m1 b4 r- X% ~7 s
129.     canrxtx.rx_newflag=0;
     3 T6 E$ K$ t7 K  {& q7 `3 |$ W
130.     return (0);
     $ p8 ]& i; q# G- j' f
131. 
     5 P, e, l7 o$ @+ ^) g  [
132. }
     + H, e1 l; b( L. S( K: S
133. /************************rx******************************/
     
134. void CAN1_RX1_IRQHandler(void)
     9 @9 J2 k, }; Q! Q7 q5 s: T5 R
135. {
     ) g# N+ `1 W1 E) h8 h; D
136.     memset(&canrxtx.rxMessage,0,sizeof(CanRxMsg));
     5 \0 E0 o0 C! j. m7 R$ V
137.     if(CAN_MessagePending(CAN1,CAN_FIFO0))
     9 ~( v5 D( U& n
138.         {
     3 A+ H- e$ a; |  Z0 R
139.             CAN_Receive(CAN1,CAN_FIFO0,&canrxtx.rxMessage[0]);
     9 `& K4 u1 {  u* N" F2 n. `6 o
140.         }
     ) H" f) X1 g* q5 m; F
141.     canrxtx.rx_newflag=1;
     3 G4 _9 J% X6 L; c6 e  k/ @; m
142. }

复制代码

三、标识符过滤器的解释

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

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>

复制代码

+ T4 L+ C7 D8 i. Q5 N" J* jstm32有0~13个过滤器组，每个过滤器组有两个32位的寄存器，通过设置下面两个结构体成员的值可以有四种组合：CAN_FilterMode 和 CAN_FilterScale

四、关于邮箱

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

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

: X' t4 L* @+ ^' [. Q: A, w0 y9 N

五、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位的隐性电平。不管。

3.位填充的概念

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

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

8 T8 d. R/ U8 X+ R
: O+ Y  f5 X" j" W, T" H4 }1 X  Z