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

　　

! I+ B- v9 S  C% M" ~

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

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

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

/ ]+ Y: L* T4 h* k6 _! a1 a
% W3 h, q( K5 g, R) m  W( m! t

0 t. w' w- p2 V- I: |1 D) I

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

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

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

3.can例程。

; u2 Z0 J" t5 H( G: }, Y/ h* ~

1. #ifndef CAN_H_
   
2. #define CAN_H_
   
3. #include "stm32f10x.h"
     {( _# y. t$ ^: b2 k" q2 E
4. #define RCC_APBxPeriph_CAN_IO RCC_APB2Periph_GPIOA
   3 @$ m9 H! Q& e2 x. O- o
5. #define CAN_RXD GPIO_Pin_11
   3 l- k3 B5 R# l1 W% z
6. #define CAN_TXD GPIO_Pin_12
   
7. #define CAN_IO  GPIOA
   
8. 
   4 Y9 J4 C- {3 _1 W. X* i7 C( k, B5 q
9. enum canrate_e
   , i0 Q7 o8 m* p
10. {
    + F: a: `8 U5 g" N
11.     CANRATE125K=125,
    
12.     CANRATE250K=250,
    
13.     CANRATE500K=500,
    & ]& N9 Z) t) L
14.     CANNOTLINK,
    
15. };
    
16. 
    , w4 N5 T8 f$ i. h
17. enum canStdExt_e
    
18. {
    - @0 l) ~2 B1 J$ O! @
19.     CANSTD=0,
    & q' y4 u* I. N9 P1 b- a% Y* Q
20.     CANEXT=1,
    9 l- C" u& g; l. d6 R
21. };
    
22. struct canrxtx_s
    ; Z# s# A* d* q
23. {
    % v, u; q1 U2 |! T1 Q' Q, G& k
24.     CanRxMsg rxMessage[3];
    
25.     u8 rx_newflag;
    
26.     uint32_t f;
    
27.     CanTxMsg txMessage;
    
28. 
    
29. };
    ( r+ i5 r3 ?4 I; m3 U# {, G5 R
30. 
    0 H+ k3 h0 v: h
31. /*std ID*/
    - ?, ~  ~/ O5 r0 I2 p
32. #define CAN1_TX_STD_ID 0x7DF //11 Bits ID,Functional
    6 n6 [( L  j8 q- B. D8 o' Y# G: S* Z- B
33. 
    
34. #define CAN1_TX_STD_ID_ECM 0x7E0 //11 Bits  ECM ID,physical
    ' ?4 O9 u$ t# I- g8 b
35. #define CAN1_RX_STD_ID_ECM 0x7E8 //11 Bits  ECM ID,physical
    
36. #define CAN1_RX_STD_Filter 0x7FF //11 bits ECM Filter
    9 g9 }, k( V) ]! a" G- D
37. 
    
38. /*extend ID*/
    
39. #define CAN1_TX_EXT_ID 0x18DB33F1 //29 Bits  ID,Functional
    * ?" a8 e( D5 S; L8 Z3 H5 I
40. #define CAN_Id_Extended_HONDA 0x18DBEFF1 //29 Bits  ID,Functional   HONDA
    
41. #endif

复制代码

1. #include "can.h"
   5 J+ P2 ]# E; x# a1 Q- O( m2 ?
2. #include <string.h>
   
3. u8 std_or_ext;
   
4. struct canrxtx_s canrxtx;
   
5. void CAN1_init(enum canrate_e canrate)
   
6. {
     H- o1 G0 V2 W9 ~
7. 
   " y( \: R5 \( E/ ?, H1 @  a$ D
8.     GPIO_InitTypeDef GPIO_InitStructure;
   
9.     CAN_InitTypeDef  CAN_InitStructure;
   
10. 
    
11.     RCC_APB2PeriphClockCmd(RCC_APBxPeriph_CAN_IO | RCC_APB2Periph_AFIO,ENABLE);
    , g1 }. n1 A: S) ^' W
12.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1,ENABLE);
    $ w! w- b6 f- H
13.     GPIO_InitStructure.GPIO_Pin = CAN_RXD;
    
14.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    7 Y1 a7 r0 e9 N  S+ C
15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      D) P+ J# w! \! f; p+ k
16.     GPIO_Init(CAN_IO, &GPIO_InitStructure);
    " ~' |/ Y" u# u) A( a3 Y
17. 
    ( j, p, E+ \/ d8 {/ Q  b
18.     GPIO_InitStructure.GPIO_Pin = CAN_TXD;
    
19.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    
20.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    / x8 D) L% W& I0 U9 ^# l" O
21.     GPIO_Init(CAN_IO, &GPIO_InitStructure);
    0 o9 b; W" d) Q: ~9 t, p, Z8 L
22. 
    - y- i7 T: R+ b) j. n$ m
23.     CAN_DeInit(CAN1);
    
24.     CAN_StructInit(&CAN_InitStructure);
    
25. 
    
26.     CAN_InitStructure.CAN_TTCM = DISABLE;
    0 h: {3 P4 d. \9 E+ v
27.     CAN_InitStructure.CAN_ABOM = DISABLE;
    
28.     CAN_InitStructure.CAN_AWUM = DISABLE;
    : h% C' |/ {; K" U4 G
29.     CAN_InitStructure.CAN_NART = DISABLE;
    
30.     CAN_InitStructure.CAN_RFLM = DISABLE;
    : w# \+ R% ~- @. Q: D
31.     CAN_InitStructure.CAN_TXFP = DISABLE;
    
32.     CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
    
33.     CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;
    1 L3 n+ R! b* z$ j
34.     CAN_InitStructure.CAN_BS1 = CAN_BS1_3tq;
    + _1 c, T, o5 A* J" `
35.     CAN_InitStructure.CAN_BS2 = CAN_BS2_2tq;
    
36.      //CAN BaudRate = 72MHz/(CAN_SJW+CAN_BS1+CAN_BS2)/CAN_Prescaler
    2 ^1 Y5 f; ^: G) o; g+ ~- q
37.      if(canrate==CANRATE125K) /* 125KBps */
    ( r8 g  ]  V5 ~9 y5 Y6 T
38.          CAN_InitStructure.CAN_Prescaler =96;
    
39.      else if(canrate==CANRATE250K) /* 250KBps */
    
40.          CAN_InitStructure.CAN_Prescaler =48;
    " W/ C9 x2 `4 c3 ^! ~# X6 [
41.      else  /* 500KBps */
    8 |; W9 M. ^5 S
42.          CAN_InitStructure.CAN_Prescaler = 24;
    
43. 
    
44.     CAN_Init(CAN1, &CAN_InitStructure);
    # p7 J& N+ p5 X1 Y$ G
45. }
    3 |7 \( p/ Q6 d& ?
46. 
    
47. void CAN1_ConfigFilter(u32 id1, u32 id2, u32 mask1, u32 mask2, u8 std_or_ext)
    
48. {
    % |+ B) e) h; j% ?4 L- `
49.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    
50.     NVIC_InitTypeDef  NVIC_InitStructure;
    
51. 
    4 P0 A4 q0 ^& o
52.     CAN_FilterInitStructure.CAN_FilterNumber=1; //use which filter,0~13
    
53.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
    
54.     if(std_or_ext == CANSTD)
    * A* N$ U; S% p2 }) O
55.     {
    1 n. T) M7 D" E8 e) k
56.         CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_16bit;
    + u, Q/ ^3 z% [( q# w. s
57.         CAN_FilterInitStructure.CAN_FilterIdHigh=id1<<5;
    % P$ z' V0 d0 C. R
58.         CAN_FilterInitStructure.CAN_FilterIdLow=id2<<5;
    
59.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh=mask1<<5;
    
60.         CAN_FilterInitStructure.CAN_FilterMaskIdLow=mask2<<5;
    & o1 A5 H3 c; j" x- n0 d
61. 
    : `% c/ |% M) `! ^; I
62.     }
    ; L7 D9 g8 i. V# z  |/ R+ G, m& m
63.     else
    2 c7 \, b5 u3 b8 I& m
64.     {
    9 I) }% q! {5 F( w" B. ]
65.         CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
    * w' O0 l$ v, V
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);
    
70. 
    8 f; v- y/ M1 R3 n3 W, N
71.     }
    3 L7 U8 C6 J- Y8 @1 I
72. 
    
73.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;
    3 b$ `$ p( z5 @$ `- l$ M
74.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
    
75.     CAN_FilterInit(&CAN_FilterInitStructure);
    
76. 
    ' O( f+ ~: l3 k' A
77.     NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX1_IRQn;
    " A0 ~7 Z/ g$ \+ y. k
78. 
    * u. I6 ]! j  u" y" N; p
79.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    # C# P; _& k7 b# `7 R5 c
80.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    $ ]. r* ?! I. f+ Y  k2 |& N  Z
81.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
82.     NVIC_Init(&NVIC_InitStructure);
    ! D# t7 |! e& _! [+ i
83. 
    
84.     CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
    
85. }
    
86. /************************init******************************/
    ) y: H3 D2 G) r0 o8 m
87. void init_demo()
    
88. {
    
89.     std_or_ext = CANEXT;
    
90.     CAN1_init(CANRATE500K);
    
91.     CAN1_ConfigFilter(0x18DAF110,0x18DAF110,0x1FFFF100,0x1FFFF100,std_or_ext);//extend ID
    
92. }
    
93. /************************tx******************************/
    # ^7 I% o- l/ ^. \- F* e# o$ m! {
94. /*datalen<=8*/
    6 t2 \2 f5 i/ a- ^; }  ~1 v
95. int CAN1_TransASerialData(u8* pdata,u8 datalen)
      Q# P. z! M9 @. [5 n8 L
96. {
    
97.     u8 i=0;
    
98. 
    ) z& N# _6 v- E8 A/ C
99.     Delay_ms(20);
    
100. 
     $ c5 k4 X  T1 J0 {: {9 q
101.     if(std_or_ext == CANEXT)
     - ]' V; e4 f" `* A* {6 Z, w
102.     {
     
103.         canrxtx.txMessage.StdId=0x00;
     
104.         canrxtx.txMessage.ExtId=CAN_Id_Extended_HONDA;//bentian
     . ]/ w. f3 b# f9 G
105.         canrxtx.txMessage.RTR=CAN_RTR_DATA;
     / `4 A6 g" n" Q" W3 x
106.         canrxtx.txMessage.IDE=CAN_Id_Extended;// 29 bits
     
107. 
     . @# u% i7 w4 R/ J
108.     }
     
109.     if(std_or_ext== CANSTD)
     
110.     {
     
111.         canrxtx.txMessage.StdId=CAN1_TX_STD_ID;
     
112.         canrxtx.txMessage.ExtId=0x00;
     
113.         canrxtx.txMessage.RTR=CAN_RTR_DATA;
     , {# o& Y0 e: D% I3 Y) C; X
114.         canrxtx.txMessage.IDE=CAN_Id_Standard;//11 bits
     
115.     }
     1 e9 z* U, s- o
116. 
     
117.     canrxtx.txMessage.DLC=0x08;
     . s6 x5 u6 F* r# r* @* T
118.     canrxtx.txMessage.Data[0]=datalen;
     - `& l1 \* {# @/ u& T! s# M" u6 `% x
119.     memcpy(&(canrxtx.txMessage.Data[1]),pdata,datalen);
     
120. 
     ' w4 z! }: Y6 i3 \0 s9 a
121. 
     ! O- A7 x' e- J# l" K6 k7 ^2 R
122.     while(((i++)<3)&&(CAN_TxStatus_NoMailBox==CAN_Transmit( CAN1,&canrxtx.txMessage)))
     
123. 
     ! i8 l( w2 {7 ^" d
124.     if(i>=3)    //timeout
     $ x2 ]% C! X3 D" e6 s$ s' h
125.     {
     . t6 M  [* d8 k( H% j+ U
126.         return (-1);
     
127.     }
     0 Y, z. C) @: G
128. 
     1 W/ I8 J/ k& d: H: K- N
129.     canrxtx.rx_newflag=0;
     
130.     return (0);
     . X$ r2 W9 N6 x  |) P; C
131. 
     
132. }
     % v1 f' W$ M' O9 z6 _: G% E7 O
133. /************************rx******************************/
     ) z/ S1 m6 v; U( u6 e. C
134. void CAN1_RX1_IRQHandler(void)
     / C6 E( @- D; n% F
135. {
     5 _( T8 g& k1 D! }! j; j
136.     memset(&canrxtx.rxMessage,0,sizeof(CanRxMsg));
     
137.     if(CAN_MessagePending(CAN1,CAN_FIFO0))
     ' ~! G% ~* w( U/ @$ c  F* _, o: [
138.         {
     3 K3 o4 s; b# H& ?* q+ E
139.             CAN_Receive(CAN1,CAN_FIFO0,&canrxtx.rxMessage[0]);
     
140.         }
     
141.     canrxtx.rx_newflag=1;
     5 _9 S! J& O9 A6 o* i& A- m/ I0 c
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>

复制代码

stm32有0~13个过滤器组，每个过滤器组有两个32位的寄存器，通过设置下面两个结构体成员的值可以有四种组合：CAN_FilterMode 和 CAN_FilterScale
! ^, J% j9 m4 q. J9 G3 h0 [. w
: l5 ^5 W% n; S- A! k. K2 ?7 |1 i# x: D$ m
# ~* L4 s1 {& q  x- |& e

四、关于邮箱

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

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

8 T( O4 ^- Y( D$ {: G9 E, `/ j/ u

' C& _+ b6 m+ o9 n6 X/ T% J

五、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个极性相同的连续位时，自动插入一个部补位码。

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

  E7 n( H3 Y6 Y- N: W7 X$ y# D' t