一、什么是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! C+ T4 |. D6 i& i; v* w  m* l

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

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

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

' v' k' M7 j7 f' a: m0 N! ~5 u# f( e0 |2 G0 W


& T( O/ `( K: a) {$ f

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

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

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

3.can例程。

1. #ifndef CAN_H_
   
2. #define CAN_H_
   1 k+ I+ V  Z# g& A: d
3. #include "stm32f10x.h"
   
4. #define RCC_APBxPeriph_CAN_IO RCC_APB2Periph_GPIOA
   . N- R: o# L& D0 R
5. #define CAN_RXD GPIO_Pin_11
   
6. #define CAN_TXD GPIO_Pin_12
   $ p, N: Q" J) U  C2 `
7. #define CAN_IO  GPIOA
   9 k/ u) ^$ C1 W7 a# g0 h' G
8. 
   . z* y; y0 F7 T3 X$ R/ |
9. enum canrate_e
   ; U$ h3 W! `3 {1 A% V- d* y# S
10. {
    2 T! n. u* ~) O& k; m
11.     CANRATE125K=125,
    + i: q! H/ w2 @) d
12.     CANRATE250K=250,
    
13.     CANRATE500K=500,
    
14.     CANNOTLINK,
    
15. };
    0 G) `( |" }1 W8 P
16. 
    
17. enum canStdExt_e
    
18. {
    : ]- T9 ], y$ l% ^6 C9 p
19.     CANSTD=0,
    ' {7 T9 Z4 p# @; F0 M* C. {
20.     CANEXT=1,
    
21. };
    # S/ b  n+ s& s  r* R( @; a) d* \8 G
22. struct canrxtx_s
    2 I+ h9 E7 `5 Z" z! @
23. {
    " h7 S0 o( `* Y' |* @$ B' ?0 l
24.     CanRxMsg rxMessage[3];
    
25.     u8 rx_newflag;
    4 D+ {3 b. b8 b3 |. _( [
26.     uint32_t f;
    5 H1 f  q; B% l/ Y3 W6 w5 V: A% J/ |
27.     CanTxMsg txMessage;
    
28. 
    
29. };
    1 O8 D+ Y6 L/ f5 w
30. 
    8 L1 ~) C& d# `# E7 M: Z
31. /*std ID*/
    1 c0 b: W' I  h2 s# o
32. #define CAN1_TX_STD_ID 0x7DF //11 Bits ID,Functional
    
33. 
    ! V9 M3 _8 k, M) [$ T, u3 U
34. #define CAN1_TX_STD_ID_ECM 0x7E0 //11 Bits  ECM ID,physical
    & I3 @& e4 @4 D, x
35. #define CAN1_RX_STD_ID_ECM 0x7E8 //11 Bits  ECM ID,physical
    
36. #define CAN1_RX_STD_Filter 0x7FF //11 bits ECM Filter
    1 T7 @3 h) j% u0 O* E' V
37. 
    
38. /*extend ID*/
    # X+ @4 F0 d7 y: P( W& L4 a
39. #define CAN1_TX_EXT_ID 0x18DB33F1 //29 Bits  ID,Functional
    
40. #define CAN_Id_Extended_HONDA 0x18DBEFF1 //29 Bits  ID,Functional   HONDA
    3 ~  E1 H( ?  i% v! Y- q) J; b
41. #endif

复制代码

1. #include "can.h"
   5 v( Z% f- W* T# E1 ]) W
2. #include <string.h>
   5 c2 s) Z# l/ v9 H4 ^# F4 F
3. u8 std_or_ext;
   
4. struct canrxtx_s canrxtx;
   
5. void CAN1_init(enum canrate_e canrate)
   
6. {
   
7. 
   7 E$ J5 S" \+ k8 N) t  L
8.     GPIO_InitTypeDef GPIO_InitStructure;
   % x6 g; X% z: o1 i+ [. o
9.     CAN_InitTypeDef  CAN_InitStructure;
   2 }( V  S8 a/ I( d* {+ s4 l) ?
10. 
    
11.     RCC_APB2PeriphClockCmd(RCC_APBxPeriph_CAN_IO | RCC_APB2Periph_AFIO,ENABLE);
    " u5 a% [$ P! }8 |
12.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1,ENABLE);
    
13.     GPIO_InitStructure.GPIO_Pin = CAN_RXD;
    + U: o  h5 W- u: j+ E
14.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    4 y3 x/ y, G3 f- @, L0 B
15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    7 Q0 y8 P+ w2 c
16.     GPIO_Init(CAN_IO, &GPIO_InitStructure);
    3 x6 d) n: }! v, L6 U
17. 
    6 t  H5 T, M( Q, @+ b) x5 i2 M
18.     GPIO_InitStructure.GPIO_Pin = CAN_TXD;
    7 p5 _9 m( a8 ?; ?$ }0 k& @$ [% I
19.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    % A+ B1 b% D; Q( v- q$ J
20.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
21.     GPIO_Init(CAN_IO, &GPIO_InitStructure);
    : |; j; ^1 i7 V9 x# [) r0 O0 u
22. 
    * A' ?/ [) k4 s! ?3 B1 D4 Y2 R: l) K
23.     CAN_DeInit(CAN1);
      d. p8 t4 R  ~+ S6 [
24.     CAN_StructInit(&CAN_InitStructure);
    
25. 
    
26.     CAN_InitStructure.CAN_TTCM = DISABLE;
    
27.     CAN_InitStructure.CAN_ABOM = DISABLE;
    1 A: C# Q2 N6 Q4 O
28.     CAN_InitStructure.CAN_AWUM = DISABLE;
    
29.     CAN_InitStructure.CAN_NART = DISABLE;
    
30.     CAN_InitStructure.CAN_RFLM = DISABLE;
    
31.     CAN_InitStructure.CAN_TXFP = DISABLE;
    ( i5 l/ v( Y! ^6 }! [) x0 Z
32.     CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
    
33.     CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;
    
34.     CAN_InitStructure.CAN_BS1 = CAN_BS1_3tq;
    & ?1 ^, i- B+ Y/ [% h3 O
35.     CAN_InitStructure.CAN_BS2 = CAN_BS2_2tq;
    1 n" X7 @0 M, [
36.      //CAN BaudRate = 72MHz/(CAN_SJW+CAN_BS1+CAN_BS2)/CAN_Prescaler
    
37.      if(canrate==CANRATE125K) /* 125KBps */
    
38.          CAN_InitStructure.CAN_Prescaler =96;
    $ f8 H2 ?0 d" C$ J/ ]( W* `4 ~  J% ~7 D
39.      else if(canrate==CANRATE250K) /* 250KBps */
    8 f$ ]+ v  i% [$ A8 I% q4 e$ Y( v
40.          CAN_InitStructure.CAN_Prescaler =48;
    
41.      else  /* 500KBps */
    # R$ a" A8 r8 ]6 M/ y4 D* O
42.          CAN_InitStructure.CAN_Prescaler = 24;
    * I" ~* Z- f6 G1 I$ m- X. ]
43. 
    
44.     CAN_Init(CAN1, &CAN_InitStructure);
    
45. }
    ' h/ C9 N- N! H& x( e5 O7 @: {' \/ o
46. 
    
47. void CAN1_ConfigFilter(u32 id1, u32 id2, u32 mask1, u32 mask2, u8 std_or_ext)
    
48. {
    
49.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    
50.     NVIC_InitTypeDef  NVIC_InitStructure;
    
51. 
    
52.     CAN_FilterInitStructure.CAN_FilterNumber=1; //use which filter,0~13
    " G0 V8 `: C6 m1 J. X2 H! [
53.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
    
54.     if(std_or_ext == CANSTD)
    
55.     {
    
56.         CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_16bit;
    
57.         CAN_FilterInitStructure.CAN_FilterIdHigh=id1<<5;
    
58.         CAN_FilterInitStructure.CAN_FilterIdLow=id2<<5;
    
59.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh=mask1<<5;
    
60.         CAN_FilterInitStructure.CAN_FilterMaskIdLow=mask2<<5;
    2 C9 z  l1 r( V0 u& K& y- I! x% h
61. 
    ) E- v: I  W2 M7 h# q6 `2 n: F
62.     }
    
63.     else
    
64.     {
    - ~; d( X1 a: K
65.         CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
    
66.         CAN_FilterInitStructure.CAN_FilterIdHigh=(u16) (id1>>13);
    , V8 Y) L+ x# x. F
67.         CAN_FilterInitStructure.CAN_FilterIdLow=(u16) (((id1&0x00001FFF)<<3)|CAN_Id_Extended|CAN_RTR_DATA);
    
68.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh=(u16) (mask1>>13);
    ; w/ q( Q7 `5 {) V6 k0 I
69.         CAN_FilterInitStructure.CAN_FilterMaskIdLow=(u16) ((mask1&0x00001FFF)<<3);
    
70. 
    
71.     }
    
72. 
    
73.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;
      r& ^/ B7 d! S1 X4 p5 y3 z
74.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
    
75.     CAN_FilterInit(&CAN_FilterInitStructure);
    
76. 
    
77.     NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX1_IRQn;
    
78. 
    . J3 h2 O; ]& k: ~& H
79.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    
80.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    * R! O9 {6 C. _5 ^$ S5 N" C5 K
81.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    5 ~9 i, h4 ?) R& y& E, [" h
82.     NVIC_Init(&NVIC_InitStructure);
    
83. 
    
84.     CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
    
85. }
    5 m5 l9 ~# m2 f6 ^5 c+ h* k, j
86. /************************init******************************/
    
87. void init_demo()
    ) a3 b, O! [2 w" m
88. {
    1 E1 }: N) ^5 w" N
89.     std_or_ext = CANEXT;
    
90.     CAN1_init(CANRATE500K);
    
91.     CAN1_ConfigFilter(0x18DAF110,0x18DAF110,0x1FFFF100,0x1FFFF100,std_or_ext);//extend ID
    
92. }
    & F1 ], H% ~$ z
93. /************************tx******************************/
    3 u: H& K& U6 x, x+ |
94. /*datalen<=8*/
    8 @* M+ L# s+ h2 w5 v2 j
95. int CAN1_TransASerialData(u8* pdata,u8 datalen)
    
96. {
    
97.     u8 i=0;
    
98. 
    % Y5 y5 l6 u$ q
99.     Delay_ms(20);
    
100. 
     : S1 V/ f1 X& p+ z5 ?  n
101.     if(std_or_ext == CANEXT)
     
102.     {
     
103.         canrxtx.txMessage.StdId=0x00;
     0 G  t3 K4 K1 D8 i2 f9 ~
104.         canrxtx.txMessage.ExtId=CAN_Id_Extended_HONDA;//bentian
     
105.         canrxtx.txMessage.RTR=CAN_RTR_DATA;
     + U$ q8 o% H: w6 l
106.         canrxtx.txMessage.IDE=CAN_Id_Extended;// 29 bits
     
107. 
     0 K3 C4 r& V3 J
108.     }
     
109.     if(std_or_ext== CANSTD)
     
110.     {
     
111.         canrxtx.txMessage.StdId=CAN1_TX_STD_ID;
     " v- N0 D# z7 Q0 x, V( b# t
112.         canrxtx.txMessage.ExtId=0x00;
     
113.         canrxtx.txMessage.RTR=CAN_RTR_DATA;
     
114.         canrxtx.txMessage.IDE=CAN_Id_Standard;//11 bits
     $ L- ?" u- e1 S) g
115.     }
     " e* e8 M8 O- a; k7 i
116. 
     
117.     canrxtx.txMessage.DLC=0x08;
     # y5 a( ^  j& |+ g0 j4 F+ ^
118.     canrxtx.txMessage.Data[0]=datalen;
     
119.     memcpy(&(canrxtx.txMessage.Data[1]),pdata,datalen);
     
120. 
     
121. 
     5 g( P4 {4 S2 ~1 P% o% c3 O7 v
122.     while(((i++)<3)&&(CAN_TxStatus_NoMailBox==CAN_Transmit( CAN1,&canrxtx.txMessage)))
     8 v0 q% D: m' |0 t: y4 _
123. 
     , c9 @0 p# W( b5 {# y
124.     if(i>=3)    //timeout
     
125.     {
     " n6 y9 B, q% g3 |0 p1 E
126.         return (-1);
     
127.     }
     % z6 J9 G" x& m/ R& Z% x" e& y
128. 
     
129.     canrxtx.rx_newflag=0;
     2 |. e- ]) ?! z; |) B
130.     return (0);
     2 q  T& s4 I/ e0 v
131. 
     & w# O* n2 b+ {' m
132. }
     # F. Z. Q% f5 q8 P; ]
133. /************************rx******************************/
     + D, n8 w1 i! {' S- s. X8 |4 ?9 z
134. void CAN1_RX1_IRQHandler(void)
     
135. {
     
136.     memset(&canrxtx.rxMessage,0,sizeof(CanRxMsg));
     
137.     if(CAN_MessagePending(CAN1,CAN_FIFO0))
     0 p, Y- l' j! n  c
138.         {
     
139.             CAN_Receive(CAN1,CAN_FIFO0,&canrxtx.rxMessage[0]);
     
140.         }
     & N, d. F7 y$ u0 R1 n4 L" m
141.     canrxtx.rx_newflag=1;
     
142. }

复制代码

5 {7 A7 N& k  u2 N$ W9 }1 y

三、标识符过滤器的解释

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

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>

复制代码

stm32有0~13个过滤器组，每个过滤器组有两个32位的寄存器，通过设置下面两个结构体成员的值可以有四种组合：CAN_FilterMode 和 CAN_FilterScale


- H# f8 O. e  |: Q' O% L! j. H

四、关于邮箱

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

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

9 Y( A- q0 c% W( B: }7 S0 R. B0 m

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

8 n1 _1 u% U+ ?. a: j( ^0 z

3.位填充的概念

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

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

; @# p) z6 Z. d3 S7 E