CAN基础知识介绍文中介绍了CAN协议的基础知识，以及STM32F4芯片的CAN控制器相关知识，下面将通过实例，利用STM32CubeMX图形化配置工具，来实现CAN通讯的环回测试

3 h9 @$ x; o: l) M1. STM32CubeMX配置
$ E7 }: k/ ^5 k2 {5 `
% }3 w4 S% S- _' q+ F
⏩ CAN是挂载在APB1总线上，设置PCLK1时钟频率到最大45MHz


* p- I8 S! h/ S% S% @  J7 T6 a
  \: `9 K+ S0 j2 y
⏩ 激活CAN1，配置位时序参数，其他基本参数以及工作模式（此处设置为Loopback环回模式）
. p) t! `/ n+ Z( J" S9 f

  d9 J8 f6 f5 n; @
- X1 y( m" Q' t* W' G3 D
7 }0 S$ d  C. s! B, e0 w- {CAN波特率的计算公式：只需要知道BS1和BS2的设置，以及APB1的时钟频率，就可以方便的计算出波特率。比如设置TS1=8、TS2=6和BRP=6，在APB1频率为45Mhz的条件下，即可得到CAN通信的波特率=45000/6/(8+6+1)=500Kbps

# h# ]2 ?( O2 Q
4 L9 E$ I7 N5 ?+ x5 U: R
" M8 L6 \# H- I& V4 P: \  h4 Y
$ ~) Z8 O7 Y- v) ?/ H⏩ 激活USART1作为调试串口，配置相关LED对应的GPIO引脚作为指示灯
! W7 T6 t  d3 C  V1 U* c
- S' K" }0 c4 Q% }
/ [6 L- {/ k6 g6 l3 t) @2. MDK-ARM编程
; O- |2 S3 h2 Y: |# X3 Z$ y
) i! ?: [, `8 b/ R+ F4 m0 U2.1 几个重要的结构体
9 O) u7 o1 F7 G* D& \

+ k9 `0 L0 E4 N6 l6 s8 g, m( a⏩ 主控寄存器 CAN_MCR：负责管理 CAN 的工作模式

1. typedef struct
   
2. {
   9 l+ W) K+ l2 n4 u, P" \
3.   uint32_t Prescaler;       /* 配置 CAN 外设的时钟分频，可设置为 1-1024*/
   # W! Q1 R( |! y; D
4.   uint32_t Mode;            /* 配置 CAN 的工作模式，回环或正常模式 */
   4 X7 k- V3 N' @
5.   uint32_t SyncJumpWidth;   /* 配置 SJW 极限值 */
   4 w: _7 |4 f" ~# G0 w! v) h7 l2 _" R
6.   uint32_t TimeSeg1;        /* 配置 BS1 段长度 */
   
7.   uint32_t TimeSeg2;        /* 配置 BS2 段长度 */
   
8.   FunctionalState TimeTriggeredMode;    /* 是否使能 TTCM 时间触发功能 */
   
9.   FunctionalState AutoBusOff;           /* 是否使能 ABOM 自动离线管理功能 */
   # N5 `" g& [- S( o1 l
10.   FunctionalState AutoWakeUp;           /* 是否使能 AWUM 自动唤醒功能 */
    & K. ?& O8 u8 n6 ]7 U; V7 g
11.   FunctionalState AutoRetransmission;   /* 是否使能 NART 自动重传功能 */
    
12.   FunctionalState ReceiveFifoLocked;    /* 是否使能 RFLM 锁定 FIFO 功能 */
    8 V- m2 T( X+ x0 Q2 b
13.   FunctionalState TransmitFifoPriority; /* 配置 TXFP 报文优先级的判定方法 */
    7 y, E* V, g* I! V
14. } CAN_InitTypeDef;

复制代码

⏩ 发送及接收头结构体：主要用于构造发送报文，以及接收报文。收发发文时，需要自定义头结构体变量
4 [& F" @6 H# G
$ I* U! C% ?8 p, k5 b! |: X

1. typedef struct
   + t0 A7 y" g/ m
2. {
   0 d" D2 E- Q7 A! J: J
3.   uint32_t StdId;       /* 存储报文的标准标识符 11 位，0-0x7FF. */
   4 F7 ^5 m. V6 K8 [
4.   uint32_t ExtId;       /* 存储报文的扩展标识符 29 位，0-0x1FFFFFFF. */
   
5.   uint32_t IDE;        /* 存储 IDE 扩展标志 */
   
6.   uint32_t RTR;        /* 存储 RTR 远程帧标志 */
   
7.   uint32_t DLC;        /* 存储报文数据段的长度，0-8 */
   
8.   FunctionalState TransmitGlobalTime;
   
9. } CAN_TxHeaderTypeDef;
   % I- d9 K7 n! _
10. 
    
11. typedef struct
    " d0 T4 A" @! m) Q: G
12. {
    
13.   uint32_t StdId;      /* 存储报文的标准标识符 11 位，0-0x7FF. */
    
14.   uint32_t ExtId;      /* 存储报文的扩展标识符 29 位，0-0x1FFFFFFF. */
    
15.   uint32_t IDE;        /* 存储 IDE 扩展标志 */
    
16.   uint32_t RTR;        /* 存储 RTR 远程帧标志 */
    % O. D) F, B0 t
17.   uint32_t DLC;        /* 存储报文数据段的长度，0-8 */
      k. a: @6 c! @' s& E! U
18.   uint32_t Timestamp;
      M! I! Y- E) y0 R. B/ E
19.   uint32_t FilterMatchIndex;
    9 W6 [( O. N' H! Z1 Q. q/ [
20. } CAN_RxHeaderTypeDef;

复制代码

⏩ 过滤器结构体：STM32CubeMX不会初始化过滤器的相关内容，需要自己添加

# @7 t' {! d# {+ V( ?2 p/ O( c  R

1. typedef struct
   ) j' r0 g! E& j* }) c- Q& J+ p4 c
2. {
     G; P& B  n" I! A
3.   uint32_t FilterIdHigh;         /*CAN_FxR1 寄存器的高 16 位 */
   
4.   uint32_t FilterIdLow;          /*CAN_FxR1 寄存器的低 16 位 */
   9 x- r% E( N1 q
5.   uint32_t FilterMaskIdHigh;     /*CAN_FxR2 寄存器的高 16 位 */
   * Z$ R1 T) Z) d
6.   uint32_t FilterMaskIdLow;      /*CAN_FxR2 寄存器的低 16 位 */
   
7.   uint32_t FilterFIFOAssignment; /* 设置经过筛选后数据存储到哪个接收 FIFO */
   " r# y" X. v# m9 m! @" R# K
8.   uint32_t FilterBank;           /* 筛选器编号，范围0-27，CAN1是0-13，CAN2是14-27 */
   8 Z( W9 U+ A! U
9.   uint32_t FilterMode;           /* 筛选器模式 */
   
10.   uint32_t FilterScale;          /* 设置筛选器的尺度 */
    
11.   uint32_t FilterActivation;     /* 是否使能本筛选器 */
    ! f4 u9 S* ^" u; s
12.   uint32_t SlaveStartFilterBank; /* CAN2起始过滤器组 */
    
13. } CAN_FilterTypeDef;

复制代码

. L* v6 T" R0 G6 c) u6 {. P, ^2.2 程序编写


' B2 }/ D  j8 ]9 D: v⏩ 生成工程后，打开can.c文件，可见STM32CubeMX已经对位时序参数、其他基本参数以及工作模式进行了初始化。但是并没有初始化过滤器的相关内容，因此需要我们自己添加，并在CAN初始化时调用
/ P3 E' {8 c1 Z% R! a) v0 |

# ]& l# H# q  K( ~2 d$ P

1. //下面的设置只使能了FIFO0，并不过滤任何消息
   ; X8 e- f  C: c3 G: G4 M0 s
2. void CAN_Filter_Config(){
   
3.   CAN_FilterTypeDef sFilterConfig;
   * W# [7 M9 A: r8 r5 K
4. 
   
5.   sFilterConfig.FilterBank = 0;      //筛选器编号, CAN1是0-13, CAN2是14-27
   6 p3 w! U5 g2 U2 x) A% D
6.   sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; //采用掩码模式
   4 n4 e3 a" Z/ L/ R( R! W* s' X
7.   sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; //设置筛选器的尺度, 采用32位
   ! f" l& D& P" h0 O& ?" A7 P& Q
8.   sFilterConfig.FilterIdHigh = 0X0000;    //过滤器ID高16位,即CAN_FxR1寄存器的高16位
   ' Z5 \4 K( W: ?7 o7 y% Q
9.   sFilterConfig.FilterIdLow = 0X0000;     //过滤器ID低16位,即CAN_FxR1寄存器的低16位
   
10.   sFilterConfig.FilterMaskIdHigh = 0X0000;   //过滤器掩码高16位,即CAN_FxR2寄存器的高16位
    
11.   sFilterConfig.FilterMaskIdLow = 0X0000;    //过滤器掩码低16位,即CAN_FxR2寄存器的低16位
    , S5 V/ L9 n8 C8 T
12.   sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0; //设置经过筛选后数据存储到哪个接收FIFO
    ( Q8 I4 n4 b% ^9 r# u8 E& K4 z* {2 F
13.   sFilterConfig.FilterActivation = ENABLE;   //是否使能本筛选器
    
14.   sFilterConfig.SlaveStartFilterBank = 14;   //指定为CAN1分配多少个滤波器组
    
15. 
    ! {) z6 Q4 P1 N
16.   if(HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig) != HAL_OK)
    
17.   {
    " h; I  m) k; K; j7 g( ^4 I
18.     Error_Handler();
    
19.   }
    
20. }

复制代码

⏩ 编写发送和接收数据函数：此处将格式固定为标准数据帧，ID为12

1. uint8_t CAN1_Send_Msg(uint8_t *msg, uint8_t len){
   7 I% Y1 l  M5 U/ F7 u
2.   uint16_t i = 0;
   
3.   uint32_t txMailBox;
   
4.   uint8_t send_buf[8];
   
5. 
   
6.   txHeader.StdId = 12;
   - G, y3 Q# ^. J" T& n
7.   txHeader.ExtId = 12;
   
8.   txHeader.IDE = CAN_ID_STD;
   " M& n  E# ?8 W& ^2 j/ D% u
9.   txHeader.RTR = CAN_RTR_DATA;
   
10.   txHeader.DLC = len;
    
11. 
    " y* t- m5 m+ |1 H- I& @
12.   for(i = 0; i < len; i++)
    
13.     send_buf[i] = msg[i];
    
14. 
    
15.   if(HAL_CAN_AddTxMessage(&hcan1, &txHeader, send_buf, &txMailBox) != HAL_OK)
    ; I6 ]# f' F  M$ r! ~
16.     return 1;
    
17.   return 0;
    / E4 E3 J- c4 x. A" h" W  L3 s
18. }
    
19. 
    
20. uint8_t CAN1_Recv_Msg(uint8_t *buf){
    
21.   uint16_t i = 0;
    
22.   HAL_CAN_GetRxMessage(&hcan1, CAN_RX_FIFO0, &rxHeader, buf);
    
23. 
    
24.   if(rxHeader.IDE == CAN_ID_STD)
    . ^9 C3 w; A; l- m+ H
25.     printf("StdId ID: %d\r\n", rxHeader.StdId);
    + f4 X/ P4 U1 ~# C, N6 R0 f4 o. t
26.   else
    
27.     printf("ExtId ID: %d\r\n", rxHeader.ExtId);
    
28. 
    
29.   printf("CAN IDE: %d\r\n", rxHeader.IDE);
    0 [! |' h  }, s( y: Y7 H
30.   printf("CAN RTR: %d\r\n", rxHeader.RTR);
    
31.   printf("CAN DLC: %d\r\n", rxHeader.DLC);
    
32.   printf("Recv Data: ");
    ( \4 v! c: R( c4 G  _% @1 ^- X: I
33. 
      @, b2 G  P- W  ?
34.   for(i = 0; i < rxHeader.DLC; i++)
    
35.     printf("%c",buf[i]);
    
36. 
    : g8 r( S  O" p) x% Q
37.   printf("\n");
    
38.   return rxHeader.DLC;
    
39. }

复制代码

⏩ 默认Cubemx生成的代码并没有can start，没有调用HAL_CAN_Start(&hcan1) 来使能CAN，因此需要在CAN初始化代码中添加

+ ?* x  X3 c& S9 t: x1 H

1. void MX_CAN1_Init(void){
   ; X, h/ H* Z8 ~7 F  e
2.   ......
   
3.   /* USER CODE BEGIN CAN1_Init 2 */
   
4.   CAN_Filter_Config();
   
5.   HAL_CAN_Start(&hcan1);
   / V! ?8 A/ ?/ y
6.   /* USER CODE END CAN1_Init 2 */
     b* \( n; g9 B6 D  g* w. J: w
7. }

复制代码

  X2 k; P& g* C! |! O⏩ 主函数main.c中，代码如下
1 @* k$ q$ m% H0 f# b* i6 z0 T
$ V0 O; i' b. s: j, ^* A7 L2 o  e
! a& S: J0 ]8 B& c

1. int main(void){
   
2.   HAL_Init();
   
3.   SystemClock_Config();
   
4.   MX_GPIO_Init();
   ; z% T& P' y# E3 N2 ?, i, s2 f
5.   MX_CAN1_Init();
   1 r) z4 x: l9 I' K
6.   MX_USART1_UART_Init();
   1 H- J  E! e: S7 L- b2 I% y, i. W
7.   /* USER CODE BEGIN 2 */
   " E% Q7 r3 J& S7 L3 f; U8 V; G9 N% d6 |
8.   uint8_t ret,i;
   
9.   printf("CAN Testing....!\r\n");
   * |) C0 ~6 g% _& }3 V6 `. a
10.   uint8_t txdata[8] = {76, 79, 79, 80, 66, 65, 67, 75};
    / a( u4 C6 L% y6 O8 Q+ |3 ^
11.   uint8_t rxdata[8];
    
12.    /* USER CODE END 2 */
      s# ]2 E7 N% }$ X3 k2 O5 ^
13.    /* Infinite loop */
    
14.    /* USER CODE BEGIN WHILE */
    
15.   while (1)
    
16.   {
    
17.     HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
    - m- G* c; r9 N* a+ F4 p
18.     HAL_Delay(1000);
    ; J7 y8 G3 H& u; m
19.     printf("Start Send data...\r\n");
    / ~# e& k' ^4 j$ h
20.   
    
21.     ret = CAN1_Send_Msg(txdata, 8);
    , V3 Z- y$ K' H4 z
22.     if(ret == 0)
    + |$ m/ ?" i; _
23.       printf("CAN Send success!\r\n");
    
24.     else
    
25.       printf("CAN Send failed!\r\n");
    
26.   
    ' P! f# {( m3 {6 T8 J6 C
27.     CAN1_Recv_Msg(rxdata);
    - |* B( m/ l# ~& E" w7 s
28.     printf("+++++++++++++++++++++++++++++++\r\n");
    
29.     /* USER CODE END WHILE */
    
30.     /* USER CODE BEGIN 3 */
    / a2 F, q# W5 i( S; ~- g* f9 W) q+ z
31.   }
    6 h# y& j) P) G& C+ g! ?1 H# P
32.   /* USER CODE END 3 */
    
33. }

复制代码

/ m% Z% q0 a! Q* l/ p3. 下载测试


编译无误后下载到开发板，可以看到系统运行时D1指示灯不断闪烁，串口不断的打印CAN环回测试的数据

: m; X3 W5 ?7 D3 q/ s# Z9 C* L
% b" F: R" q- \5 F


6 ]: ]1 h9 C; C' W9 _2 z转载自： 嵌入式攻城狮
) P; P8 K# L- L如有侵权请联系删除
0 L) X1 n9 ~8 B, a5 |
. e1 h1 t+ `4 f) D/ h

( @$ o  o3 B* j0 u. D: o
! l0 U1 L* ~* w8 K# e7 v" g; l