CAN总线是汽车电子上不可缺少的技术，虽然现在有些造车新势力开始采用以太网来逐步取代CAN总线的地位，但是CAN总线先天的优势（成本低，安全性好，稳定性好），让其霸占汽车总线的巅峰，也必然有着其过人之处。个人比较看好未来是由CAN总线和以太网两者互相并存的车载网络解决方案。
& R+ J3 B1 o+ x: {
) j* @4 `/ l! j4 A% Y6 ?4 ?  ]
话题扯得有点远，只是想表个态度，即使现在才从零学习CAN总线，它也不是什么快要“没落”的技术，不仅仅在汽车领域上，在工业领域、医疗领域等都有CAN总线的一席之地。

今天分享一个简单的CAN通讯实验，用STM32F103C8T6工控板模拟汽车OBD发送CAN信号，再用另一款STM32F103ZET6开发板模拟汽车电子设备来接收CAN信号，主要实现两个功能：
$ b+ z/ S3 B2 U/ b( _
1）STM32F103C8T6工控板上电后，会自动发送模拟转速信号，具体的：该转速信号的ID号为0x17c，其数据位的第三和第四位为转速数据。STM32F103ZET6开发板上电后，利用CAN中断服务函数不停的接收该转速信号（这一功能模拟汽车电子设备接收汽车OBD发送的CAN广播信号）；
/ I6 s- o7 x) y0 Z2）当按下STM32F103ZET6开发板的按键时，会主动发送一帧CAN信号至STM32F103C8T6工控板，STM32F103C8T6工控板接收到后，会发送一次汽车车速信号（这一功能模拟汽车电子设备接收汽车OBD发送的CAN收发信号）。

硬件部分
& P, V6 U  B( G$ o6 x3 b; a1. CAN的接线
下图是STM32F103C8T6工控板的芯片接线，PB8和PB9对应CAN_RX和CAN_TX；


0 a+ \0 {1 {+ ~2 H
9 j* l# m. V0 E! r5 x, w. u! E% ~8 |下图是STM32F103ZET6开发板的新品接线，PA11和PA12对应CAN_RX和CAN_TX;

# i0 l7 Q  @2 e* B
' e  J$ @8 _+ J
& R/ z; w% B" p8 r7 f将STM32F103C8T6工控板的CAN_H和STM32F103ZET6开发板的CAN_H相连；
$ c2 V( L+ u  R5 }将STM32F103C8T6工控板的CAN_L和STM32F103ZET6开发板的CAN_L相连。
5 H$ w2 w* C- V$ s( q' H  f' t
+ C2 i& P$ d9 p6 z' {& N. i. O软件部分
1. STM32F103C8T6工控板的主要代码
前面也说了，STM32F103C8T6工控板用来模拟汽车OBD发送CAN信号，涉及广播发送CAN信号和收发模式下发送CAN信号。
% }) B1 K0 }$ A$ x1.1 main.c主函数
9 Q& Y& t, l% p/ H- s% U主函数主要包括系统初始化，while循环里主要包含了模拟CAN广播发送的代码，另外还包括转速和车速的变化代码，具体如下：
/ `1 [+ W% m" c4 z

1. /************************************************
   
2. 函数名称：int main()
   ; h+ {, c$ e; {# P4 p
3. 函数功能：主函数入口
   7 Q0 ?7 ?" I+ O) I8 ]0 r
4. 入口参数：无
   
5. 返回参数：int
   4 r6 q6 y' U; b" A0 h1 a, T
6. 开发作者：闲人Ne
   
7. *************************************************/
   
8. #define CAN_500K 4
   
9. u16 can_rpm = 2800;                            // 广播用，模拟的转速, 初始化700rpm，那么700*4=2800
   % U& o% I; R- H9 Z& n
10. u8  can_v   =   10;                            // 收发用，模拟的车速，初始化10kph
    
11. u8  canbuf_broadcast[8] = {0,0,0,0,0,0,0,0};   // 广播用, 模拟接收到转速ID号里的8位数据，转速数据位于[3:4]位
    - G$ d/ c8 ]  [+ {
12. u8  canbuf_rs[8]        = {0,0,0,0,0,0,0,0};   // 收发用，模拟接收到车速ID号里的8位数据，车速数据位于[3] 位
    
13. int main(void)
    # M. \5 U& Y) e& t
14. {
    
15.         u8 t=0;        
    
16.         u8 can_upper_rpm;                    // can_rpm的高8位
    
17.         u8 can_lower_rpm;              // can_rpm的低8位
    
18.         u8 res;                    // 错误号
    3 |  Y9 F4 b3 X+ G; m
19.         delay_init();              // 初始化延时函数   
    
20.         LED_Init();                // 初始化LED函数
    3 J: C' C8 I5 N2 b
21.         CAN_Mode_Init(CAN_500K);   // CAN初始化函数
    % Z- Y* ]' |& S; `3 W3 C6 U: L
22.          while(1)
    
23.         {
    
24.                 can_lower_rpm = can_rpm;                           // can_lower取can_rpm低8位
    ! ?+ M% y9 N6 h: p: ]
25.                 can_upper_rpm = can_rpm >> 8;                      // can_upper取can_rpm高8位
    
26.                 canbuf_broadcast[3] = can_upper_rpm;               // 更新转速ID号里的第[3]位数据；
    $ P# J0 ~' \" x! W- w
27.                 canbuf_broadcast[4] = can_lower_rpm;                           // 更新转速ID号里的第[4]位数据；
    
28.                 res=Can_Send_Msg_broadcast(canbuf_broadcast,8);    // 发送转速数据，模拟汽车CAN广播发送
    
29.                 if(res)D2=0;                                                           // 发送失败时，LED1灯亮
    . t8 ?+ C6 F+ t. |- B. ^
30.                 canbuf_rs[3] = can_v;                                                           // 更新车速ID号里的第[3]位数据；
    
31.                 can_rpm = can_rpm + 40;                           
    - b2 M! h6 n' S
32.                 if(can_rpm > 16000)can_rpm =2800;        
    - |! |0 x+ m1 r7 k5 T
33.                   can_v = can_v + 10;
    
34.                 if(can_v > 160)can_v =10;        
    ' g- k4 H( q! f; o$ [6 t# s
35.                 t++;
    
36.                 if(t==1)
    - O5 ~5 f* X9 F
37.                 {
    ' h1 N1 B* L" ~
38.                         D1=!D1;                                       //提示系统正在运行//        
    ' t6 Z$ z* s  c9 g4 M
39.                         t=0;
      O: a" z4 K$ P3 i
40.                 }        
    $ O2 [/ K4 q" X" v
41.                 delay_ms(1000);               
    / |4 l! i. V9 N$ R& G
42.         }
    3 a  y! \0 f; {8 R* v
43. }
    $ ]2 X+ W- `1 t- y! N+ X6 |6 u
44. /****** Copyright (C)2020 闲人Ne. All Rights Reserved ****** END OF FILE *******/

复制代码

9 m) l9 ^4 z& q4 q7 r/ m0 x1.2 stm32f10x_it.c里的中断服务函数
9 f5 y: ^: V9 E% y; P2 ]8 Q$ SUSB_LP_CAN1_RX0_IRQHandler()函数主要模拟接收到STM32F103ZET6开发板的CAN信号时，发送一帧CAN车速信号（模拟收发模式下发送CAN信号），具体代码如下：

1. /************************************************
   
2. 函数名称：USB_LP_CAN1_RX0_IRQHandler()
   
3. 函数功能：USB_LP_CAN1接收中断服务函数
   1 K! O+ o( s/ e/ p1 _) O
4. 入口参数：无
   
5. 返回参数：无
   
6. 开发作者：闲人Ne
   
7. *************************************************/
   0 M8 D9 X2 I( v/ I- I: ^
8. #define sr_stdid 0x7DF    // 这是从STM32F103ZET6开发板接收到的CAN信号里的ID号
   
9. extern u8 canbuf_rs[8];   // 收发用，模拟接收到车速ID号里的8位数据，车速数据位于[3] 位
   " r& n& C( C4 S) O/ q0 q
10. void USB_LP_CAN1_RX0_IRQHandler(void)
    4 h. K3 q9 u- t
11. {
    
12.         u8 err=0;
    
13.         u8 canbuf_v[8];            
    % |3 G% T. q8 r; O4 C) ^3 Y
14.          CanRxMsg RxMessage;
    1 _  f6 W$ e: Q9 g" E% W
15.         int i=0;
    9 r9 K& c! X. y
16.         CAN_Receive(CAN1, 0, &RxMessage);
    ! |2 ^4 s% T4 x, O$ e* K
17.         if(sr_stdid == RxMessage.StdId)                                         // 判断接收到的CAN信号的ID号是否是0x7DF
    
18.                 for(i=0;i<8;i++)canbuf_v<i>=RxMessage.Data<i>;      
    4 ^( r7 F$ @( O: Q1 }. r1 o% u
19.                  if(canbuf_v[0]==2&canbuf_v[1]==1&canbuf_v[2]==13)  // 判断接收到的CAN信号的数据第0，第1和第2位是否是0x21D
    ; i% Y" M3 Q7 D6 o* S9 R
20.                         err = Can_Send_Msg_rs(canbuf_rs,8);                   // 发送一帧CAN车速信号
    
21.                 if(err)D2=0;                                                                       
    
22. }
    2 \0 c# j. X( q1 z. b0 v+ M7 L
23. /****** Copyright (C)2020 闲人Ne. All Rights Reserved ****** END OF FILE *******/</i></i>

复制代码

1.3 CAN发送一帧信号函数
主要包括两个函数，分别模拟广播模式下发送CAN信号和收发模式下发送CAN信号，具体代码如下：

/ W/ _* u- ^" a. W

1. /********************************************************
   
2. 函数名称：u8 Can_Send_Msg_broadcast(u8* msg,u8 len)
   * ]- W( s+ l$ i$ d3 e# C+ O
3. 函数功能：广播用，CAN发送一组数据        
   * W! X0 `  W. _, H  c) F0 y
4. 入口参数：u8* msg,数据指针,最大为8个字节; u8 len 数据长度
   
5. 返回参数：0,成功;1,失败
   ; |7 T7 y5 k1 K! D
6. 开发作者：闲人Ne
   
7. *********************************************************/
   
8. u8 Can_Send_Msg_broadcast(u8* msg,u8 len)
   
9. {        
   0 \8 T" r: N, O8 B, K. F4 A
10.         u8 mbox;
    $ C7 Z6 _' }+ |- C
11.         u16 i=0;
    ' l1 N, d% S6 L
12.         CanTxMsg TxMessage_b;
    $ k" d1 z" M2 |5 T" l
13.         TxMessage_b.StdId=0x17C;                          // 标准标识符
    % i/ i  J, i  |' `" Y6 [
14.         TxMessage_b.ExtId=0x18DB33F1;              // 扩展标示符
    " l0 ^1 ?/ i! I+ p( z$ k
15.         TxMessage_b.IDE=CAN_Id_Standard;           // 标准帧
    ! c0 t3 C0 C# B5 O: u
16.         TxMessage_b.RTR=CAN_RTR_Data;                  // 数据帧
    " F8 r. m+ O( o4 d3 b6 F* H: j( s
17.         TxMessage_b.DLC=len;                                  // 数据长度
    $ F9 c+ ~% B* {: S( V4 L, r2 O
18.         for(i=0;i<len;i++)
    " z) D: g2 }' r& S5 d5 k: S! q
19.                 TxMessage_b.Data=msg;                                 
    & S5 u' M! l' J) W( t8 p# ]
20.         mbox= CAN_Transmit(CAN1, &TxMessage_b);   
    
21.         i=0;
    
22.         while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))i++;        
    
23.         if(i>=0XFFF)return 1;
    
24.         return 0;         
    
25. }
    
26. /********************************************************
    1 F7 B! c9 F; `# D
27. 函数名称：u8 Can_Send_Msg_rs(u8* msg,u8 len)
    
28. 函数功能：收发用，CAN发送一组数据        
    9 h, e+ R1 U4 C' V  ]9 Q
29. 入口参数：u8* msg,数据指针,最大为8个字节; u8 len 数据长度
    % [1 e5 g$ Y  s- G4 e) b
30. 返回参数：0,成功;1,失败
    ' _- u8 q% l$ P  d& U- |$ r. V
31. 开发作者：闲人Ne
    , C* }. T2 O6 X5 I' v
32. *********************************************************/
    + K- m0 T/ G0 `7 R1 w9 h2 s
33. u8 Can_Send_Msg_rs(u8* msg,u8 len)
    3 [/ S! j3 }/ R" n" ^  v7 e! y0 s
34. {        
    # v; S; X# C6 w' V) N! M7 |
35.         u8 mbox;
    
36.         u16 i=0;
    ! [2 }- X! r' z# {/ J7 ^
37.         CanTxMsg TxMessage_r;
    
38.         TxMessage_r.StdId=0x7E8;                          // 标准标识符
    
39.         TxMessage_r.ExtId=0x18DB33F1;                  // 扩展标示符
    
40.         TxMessage_r.IDE=CAN_Id_Standard;           // 标准帧
    ' U0 b7 p0 f$ ]( Y' h4 J; ]
41.         TxMessage_r.RTR=CAN_RTR_Data;                  // 数据帧
    
42.         TxMessage_r.DLC=len;                                  // 数据长度
    
43.         for(i=0;i<len;i++)
    
44.                 TxMessage_r.Data=msg;                                 
    
45.         mbox= CAN_Transmit(CAN1, &TxMessage_r);   
    4 h4 k! r: J- l( w# c
46.         i=0;
    7 }. m2 T& A5 ]+ b' k
47.         while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))i++;        
    
48.         if(i>=0XFFF)return 1;
    
49.         return 0;         
    
50. }

复制代码

3 z; Q9 |) @# r$ U* Q4 b( `; r2. STM32F103ZET6开发板的主要代码
前面也说了，STM32F103ZET6开发板用来模拟汽车电子设备接收汽车OBD发送的CAN信号。
2.1 main.c主函数
' V7 S5 B3 L+ G) q8 c9 U; m主函数主要包括系统初始化，while循环里主要包含了按键按下时，发送CAN请求信号，具体如下：

  J7 h& _. ^( K- ?6 B- p

1. /************************************************
   ; l8 N& g1 o/ s- R
2. 函数名称：int main()
   
3. 函数功能：主函数
   8 V" _$ l3 c6 F& J3 @1 g! r
4. 入口参数：无
   # A, v* v/ c! ]# g+ F1 S6 L
5. 返回参数：int
   ( a+ R' B+ w6 l9 T
6. 开发作者：闲人Ne
     s$ {4 D2 g& M, b  R
7. *************************************************/
     g  N/ y8 D1 a0 A- ~( i. _3 ]& z
8. int main(void)
   
9. {         
   
10.         u8 canbuf_v[8]={2,1,13,0,0,0,0,0};                 // 0x 21D0 0000
    4 |. C# T- R$ w& ?8 ?
11.         u8 key;
    
12.         u8 i=0,t=0;
    
13.         u8 res;
      o5 ?7 k2 _5 G- h7 ?
14.         u8 mode=CAN_Mode_Normal;                           //CAN工作模式;CAN_Mode_Normal(0)：普通模式，CAN_Mode_LoopBack(1)：环回模式
    
15.         delay_init();                                               //延时函数初始化  
    
16.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);    //设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
    0 I% y' K* m* k& M4 @: }+ p: g
17.         uart_init(115200);                                            //串口初始化为115200
      F4 B( B3 G% z4 b. d. x5 S/ Z3 k
18.         LED_Init();                                                             //初始化与LED连接的硬件接口
    5 w8 k( C  e- f) m  h. q% D% e
19.         KEY_Init();                                                           //按键初始化                 
    8 K) k: x7 M& c& H4 c" ^5 t0 V
20.         CAN_Mode_Init(CAN_SJW_1tq,CAN_BS2_8tq,CAN_BS1_9tq,4,CAN_Mode_Normal);  //CAN初始化环回模式,波特率500Kbps           
    ; e+ Q8 M6 I2 L* s- L
21.          while(1)
    . [4 {/ P/ j0 K* ^0 w1 Q6 |
22.         {
    9 u" N, D1 [* b3 N9 ]& S
23.                 key=KEY_Scan(0);
    
24.                 if(key==KEY0_PRES)                          
    ) Z- ~/ d: u9 t! F( g1 ?# J
25.                 {
    6 ?) J. y2 j" Z; v' }
26.                         printf("\n发送CAN数据为：");
    9 z4 b# L8 v" h" K5 q* U" m
27.                         for(i=0;i<8;i++)
    
28.                                 printf("\n[%x]",canbuf_v);
    
29.                         printf("\r\n");
    
30.                         res=Can_Send_Msg(canbuf_v,8);              // 发送CAN请求信号                          
    $ J7 J7 d" c1 [, ~4 X  k0 z
31.                         if(res)printf("\n发送失败！\r\n");               
    , S- R$ d5 @/ u0 e
32.                 }
    
33.                 t++;
    
34.                 delay_ms(10);
    
35.                 if(t==20)
    
36.                 {
    
37.                         LED0=!LED0;                                                         
    
38.                         t=0;
    % r' H( E# O' Z6 U2 s
39.                 }                  
    - y0 z' `. \+ u; p
40.         }
    
41. }
    9 H1 a+ h# z1 x" h' |: h
42. /****** Copyright (C)2020 闲人Ne. All Rights Reserved ****** END OF FILE *******/

复制代码

2.2 stm32f10x_it.c里的中断服务函数
USB_LP_CAN1_RX0_IRQHandler()函数主要模拟接收到STM32F103C8T6开发板的CAN信号，并根据ID号判断是接收了广播模式下的转速信号还是收发模式下的车速信号，具体代码如下：
! l$ M  Q/ ]: J2 \3 S
' y$ T4 d! R, U- J+ z/ E

1. u8 canbuf[8];            
   ; N# b0 f4 c/ x0 u, t/ Z
2. #define stdid_broad 0x17C
   ! G8 r; u2 D6 Q1 m
3. #define stdid_rs          0x7E8
   
4. void USB_LP_CAN1_RX0_IRQHandler(void)
   
5. {
   
6.         u16 rpm;
   
7.         u8 v;
   
8.           CanRxMsg RxMessage;
   
9.         int i=0;
   6 l+ r9 q( V' S( `; `
10.           CAN_Receive(CAN1, 0, &RxMessage);
    - X6 C% |3 o2 n4 ~4 O$ t
11.         if(RxMessage.StdId == stdid_broad)                // 判断接收到的CAN信号的ID号是否为 0x17C
    . @& \1 m# ?3 I9 q$ m
12.         {
    
13.                 for(i=0;i<8;i++)canbuf=RxMessage.Data;
    
14.                 rpm = (canbuf[3]<<8|canbuf[4])/4;
    
15.                 printf("\n接收到的汽车转速为：%d rpm \r\n",rpm);
    / ^# ]  Q" s, f% t: Y( B# j* m/ c
16.         }
    5 n0 C' s% V' D/ @) A7 I- S7 H+ S% X9 F
17.         else
    % a/ u" q  H* g6 @2 M* c1 S' C
18.                 if(RxMessage.StdId == stdid_rs)              // 判断接收到的CAN信号的ID号是否为 0x7E8
    
19.                 {
    
20.                         for(i=0;i<8;i++)canbuf=RxMessage.Data;
    
21.                         v = canbuf[3];
    $ D- U6 a: U* T- D
22.                         printf("\n接收到的汽车车速为：%d kph \r\n",v);        
    2 p( J! m3 S4 U, D
23.                 }                        
    
24. }

复制代码

2.3 STM32F103ZET6开发板还包含了串口通讯函数，主要用来与电脑通讯，显示运行结果。这些知识可以参考我以前写的文章。

; l+ r3 i0 @! j/ G- K实验结果
实验结果如下图所示，系统运行后，将STM32F103ZET6开发板的串口接到电脑上，可实时看到从STM32F103C8T6工控板传来的转速信号，当按下STM32F103ZET6开发板的按键时，可从STM32F103C8T6工控板接收到一次车速信号。


& t3 f0 e# {% q/ b1 s+ _  X备注：
  Y4 i) _# p+ B% n" }( q1）对于CAN的基础知识可以参考之前我写的文章；
  d2 @7 @& W4 P0 e) {: n6 |2）汽车CAN总线知识参考ISO 15765-4，ISO 15031-5，SAE J1939这些标准。
, n+ }1 z0 o4 Y6 S# y0 N————————————————
) Z0 h% K$ _0 J( ~* z) V9 c' g: ?版权声明：天亮继续睡
. w# ^: `/ w5 M

% e# \+ C# o2 r- Z% `
  ~( s$ ^0 r: w& }