CAN基础知识介绍文中介绍了CAN协议的基础知识，以及STM32F4芯片的CAN控制器相关知识，下面将通过实例，利用STM32CubeMX图形化配置工具，来实现CAN通讯的环回测试
2 O6 i, @: f' `$ @$ Y/ U
1. STM32CubeMX配置

! k% C" \( ]" J3 s$ ]
⏩ CAN是挂载在APB1总线上，设置PCLK1时钟频率到最大45MHz

; F: Q4 H3 l6 L# b6 _$ R) M
! J( g6 g( k7 |' b; t7 a
" O1 [0 V" y- r- ?4 {
0 ]) T$ c! i8 S: E# e⏩ 激活CAN1，配置位时序参数，其他基本参数以及工作模式（此处设置为Loopback环回模式）
- {+ h2 H1 ~. \2 h; j
3 s2 G5 {# x- N$ p4 I4 S, I


: b+ P/ s4 l8 x2 k" sCAN波特率的计算公式：只需要知道BS1和BS2的设置，以及APB1的时钟频率，就可以方便的计算出波特率。比如设置TS1=8、TS2=6和BRP=6，在APB1频率为45Mhz的条件下，即可得到CAN通信的波特率=45000/6/(8+6+1)=500Kbps
; h% r4 l# [+ a


5 J7 @( f  b- z& U  w- r8 g
⏩ 激活USART1作为调试串口，配置相关LED对应的GPIO引脚作为指示灯
5 _. ~( e' G0 |) B% P

5 ~: J" K4 R; \4 W- a2. MDK-ARM编程

2.1 几个重要的结构体


5 A. C& J3 k: O9 `; K7 V- x⏩ 主控寄存器 CAN_MCR：负责管理 CAN 的工作模式

1. typedef struct
   
2. {
   
3.   uint32_t Prescaler;       /* 配置 CAN 外设的时钟分频，可设置为 1-1024*/
   
4.   uint32_t Mode;            /* 配置 CAN 的工作模式，回环或正常模式 */
   ! t( b9 M- k/ y8 ~
5.   uint32_t SyncJumpWidth;   /* 配置 SJW 极限值 */
   4 g4 n1 E" d% |+ |  j% Z4 O' b1 N. t6 p
6.   uint32_t TimeSeg1;        /* 配置 BS1 段长度 */
   : |  ]  k# h, a: l* Z! ?- F
7.   uint32_t TimeSeg2;        /* 配置 BS2 段长度 */
   
8.   FunctionalState TimeTriggeredMode;    /* 是否使能 TTCM 时间触发功能 */
   + g) a8 m7 a2 d8 B. `7 J, S% i
9.   FunctionalState AutoBusOff;           /* 是否使能 ABOM 自动离线管理功能 */
   
10.   FunctionalState AutoWakeUp;           /* 是否使能 AWUM 自动唤醒功能 */
    + p" w1 u; L' a: H$ \
11.   FunctionalState AutoRetransmission;   /* 是否使能 NART 自动重传功能 */
    , C5 q3 x0 q3 f  N3 J8 @3 o  k0 |
12.   FunctionalState ReceiveFifoLocked;    /* 是否使能 RFLM 锁定 FIFO 功能 */
    - o! q& V. i4 v* [$ ]; I
13.   FunctionalState TransmitFifoPriority; /* 配置 TXFP 报文优先级的判定方法 */
    1 V. l/ ~5 A, P& l# s. M- W
14. } CAN_InitTypeDef;

复制代码

⏩ 发送及接收头结构体：主要用于构造发送报文，以及接收报文。收发发文时，需要自定义头结构体变量


$ ]( `' t: W5 v# a

1. typedef struct
   % T5 b9 t+ N, |  P. b9 K6 @: n
2. {
   
3.   uint32_t StdId;       /* 存储报文的标准标识符 11 位，0-0x7FF. */
   & p4 Y/ ^. M, r) `9 g
4.   uint32_t ExtId;       /* 存储报文的扩展标识符 29 位，0-0x1FFFFFFF. */
   
5.   uint32_t IDE;        /* 存储 IDE 扩展标志 */
   7 U- t. D: i* o8 }3 T0 V0 u
6.   uint32_t RTR;        /* 存储 RTR 远程帧标志 */
   
7.   uint32_t DLC;        /* 存储报文数据段的长度，0-8 */
   , _! _$ @: R  S# v" J
8.   FunctionalState TransmitGlobalTime;
   
9. } CAN_TxHeaderTypeDef;
   ) H) ]. `! ^* [3 R" v
10. 
    : k, P& W9 S0 t6 V$ p) U0 x" F0 Q
11. typedef struct
    
12. {
    ' I: X+ i" _1 y) y
13.   uint32_t StdId;      /* 存储报文的标准标识符 11 位，0-0x7FF. */
    5 J, `  [1 K. M' A) r4 S
14.   uint32_t ExtId;      /* 存储报文的扩展标识符 29 位，0-0x1FFFFFFF. */
    : Y* l1 g& g- V
15.   uint32_t IDE;        /* 存储 IDE 扩展标志 */
    5 d! I9 m) {1 V3 x' t: H2 q
16.   uint32_t RTR;        /* 存储 RTR 远程帧标志 */
    
17.   uint32_t DLC;        /* 存储报文数据段的长度，0-8 */
    
18.   uint32_t Timestamp;
    ; X; k/ w% f' j8 |
19.   uint32_t FilterMatchIndex;
    
20. } CAN_RxHeaderTypeDef;

复制代码

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

. ]: O  @/ ]+ c/ }

1. typedef struct
   
2. {
   0 n( b/ c% ], }1 m7 }
3.   uint32_t FilterIdHigh;         /*CAN_FxR1 寄存器的高 16 位 */
   
4.   uint32_t FilterIdLow;          /*CAN_FxR1 寄存器的低 16 位 */
   4 M3 B* N! @$ g" E& I2 K2 t& N: g
5.   uint32_t FilterMaskIdHigh;     /*CAN_FxR2 寄存器的高 16 位 */
   # R$ ^9 U' _7 L" K
6.   uint32_t FilterMaskIdLow;      /*CAN_FxR2 寄存器的低 16 位 */
   
7.   uint32_t FilterFIFOAssignment; /* 设置经过筛选后数据存储到哪个接收 FIFO */
   
8.   uint32_t FilterBank;           /* 筛选器编号，范围0-27，CAN1是0-13，CAN2是14-27 */
   % i( }) S0 E# K! w0 {" l
9.   uint32_t FilterMode;           /* 筛选器模式 */
   
10.   uint32_t FilterScale;          /* 设置筛选器的尺度 */
    
11.   uint32_t FilterActivation;     /* 是否使能本筛选器 */
    ! e6 ]' G1 k& y  L3 p
12.   uint32_t SlaveStartFilterBank; /* CAN2起始过滤器组 */
    ' a; K; B5 I% A& Y+ t/ r+ }
13. } CAN_FilterTypeDef;

复制代码

  i, g( b7 `+ W1 W  E* A
' R; J3 E/ H, M" m2.2 程序编写


⏩ 生成工程后，打开can.c文件，可见STM32CubeMX已经对位时序参数、其他基本参数以及工作模式进行了初始化。但是并没有初始化过滤器的相关内容，因此需要我们自己添加，并在CAN初始化时调用
( W* k6 V5 c2 G8 M- x/ {0 O

1. //下面的设置只使能了FIFO0，并不过滤任何消息
   
2. void CAN_Filter_Config(){
   
3.   CAN_FilterTypeDef sFilterConfig;
   % H+ W% ^4 Y2 ]# \" }( d$ A
4. 
   
5.   sFilterConfig.FilterBank = 0;      //筛选器编号, CAN1是0-13, CAN2是14-27
   ; }, z- y+ T1 y# t+ r: {
6.   sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; //采用掩码模式
   . s* x$ p; i8 ~( ~7 U: O
7.   sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; //设置筛选器的尺度, 采用32位
   
8.   sFilterConfig.FilterIdHigh = 0X0000;    //过滤器ID高16位,即CAN_FxR1寄存器的高16位
   
9.   sFilterConfig.FilterIdLow = 0X0000;     //过滤器ID低16位,即CAN_FxR1寄存器的低16位
   6 V& Y( R7 [1 R! C3 q2 {
10.   sFilterConfig.FilterMaskIdHigh = 0X0000;   //过滤器掩码高16位,即CAN_FxR2寄存器的高16位
    
11.   sFilterConfig.FilterMaskIdLow = 0X0000;    //过滤器掩码低16位,即CAN_FxR2寄存器的低16位
    4 w# O& N+ B. \. q1 I
12.   sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0; //设置经过筛选后数据存储到哪个接收FIFO
    
13.   sFilterConfig.FilterActivation = ENABLE;   //是否使能本筛选器
    ' M5 K7 Y9 C' c+ x9 h
14.   sFilterConfig.SlaveStartFilterBank = 14;   //指定为CAN1分配多少个滤波器组
    
15. 
    ! W: j. \2 [; }2 w) D2 z3 F
16.   if(HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig) != HAL_OK)
    
17.   {
    ; b1 b4 ~0 ~5 Y) j+ j/ a9 D+ s
18.     Error_Handler();
    
19.   }
    
20. }

复制代码

( T. P. T" H3 u, t8 H9 i⏩ 编写发送和接收数据函数：此处将格式固定为标准数据帧，ID为12
* W9 y3 T8 `$ D/ e, s! j- r, [

1. uint8_t CAN1_Send_Msg(uint8_t *msg, uint8_t len){
     D& I" R1 v* s) B, F4 L3 W% J
2.   uint16_t i = 0;
   8 Y5 s5 `9 L/ Z* ?$ ^
3.   uint32_t txMailBox;
   $ s/ e) B8 C. {8 l4 D* r  v) u, n
4.   uint8_t send_buf[8];
   * L4 H. u' x+ s5 S' b; x7 Z/ W
5. 
   
6.   txHeader.StdId = 12;
   
7.   txHeader.ExtId = 12;
   % \5 t9 i3 _- f8 t
8.   txHeader.IDE = CAN_ID_STD;
   
9.   txHeader.RTR = CAN_RTR_DATA;
   1 Q0 `7 ?. J+ e1 U) G
10.   txHeader.DLC = len;
    
11. 
    8 c" t, ^! f0 Z+ G) l3 M% C5 ?
12.   for(i = 0; i < len; i++)
    4 ?! Z% N1 l4 ?: T
13.     send_buf[i] = msg[i];
    
14. 
    8 M  Z1 q$ W) N' h
15.   if(HAL_CAN_AddTxMessage(&hcan1, &txHeader, send_buf, &txMailBox) != HAL_OK)
    
16.     return 1;
    
17.   return 0;
    
18. }
    ' q  _( X# M, y# A/ v! u
19. 
    # p. j6 R3 ]3 s: `9 F2 x
20. uint8_t CAN1_Recv_Msg(uint8_t *buf){
    
21.   uint16_t i = 0;
    2 f8 ]9 ]  A" S0 y  }! g4 a
22.   HAL_CAN_GetRxMessage(&hcan1, CAN_RX_FIFO0, &rxHeader, buf);
    ) Q+ ], E3 p% K- R/ y: e$ H  @9 [% i
23. 
    
24.   if(rxHeader.IDE == CAN_ID_STD)
    
25.     printf("StdId ID: %d\r\n", rxHeader.StdId);
    . M& E: U' |$ i2 E5 i! C( X8 d$ V
26.   else
    
27.     printf("ExtId ID: %d\r\n", rxHeader.ExtId);
    / k+ z0 a+ ~* _! H2 E( L
28. 
    
29.   printf("CAN IDE: %d\r\n", rxHeader.IDE);
    , v# g, L  r3 T. J6 ^9 X6 l
30.   printf("CAN RTR: %d\r\n", rxHeader.RTR);
    $ G2 }7 z  o. u# `0 P0 @
31.   printf("CAN DLC: %d\r\n", rxHeader.DLC);
    6 g, f4 o6 t- _' |
32.   printf("Recv Data: ");
    
33. 
    
34.   for(i = 0; i < rxHeader.DLC; i++)
    
35.     printf("%c",buf[i]);
    
36. 
    
37.   printf("\n");
    
38.   return rxHeader.DLC;
    
39. }

复制代码

⏩ 默认Cubemx生成的代码并没有can start，没有调用HAL_CAN_Start(&hcan1) 来使能CAN，因此需要在CAN初始化代码中添加
% N* d5 b/ W$ [! D+ j" T
' \9 U: R" F! w! S) T8 _5 Y" g. Y2 j

1. void MX_CAN1_Init(void){
   " g! j" S, W  i9 E2 _7 f1 L
2.   ......
   , k( p* q' S1 d* U" S
3.   /* USER CODE BEGIN CAN1_Init 2 */
   / d. C9 P3 t  [$ p
4.   CAN_Filter_Config();
   " w/ }- h' ]: v# G, T6 R  }
5.   HAL_CAN_Start(&hcan1);
   ) K( F& T* a+ E  e$ O
6.   /* USER CODE END CAN1_Init 2 */
   / ?, Q" o0 O6 `) f' O$ b3 Q
7. }

复制代码

⏩ 主函数main.c中，代码如下

1. int main(void){
   ' Z! M; V9 l: o1 D: I/ O
2.   HAL_Init();
     `) L/ F6 L* G" Z7 h& }
3.   SystemClock_Config();
   
4.   MX_GPIO_Init();
   
5.   MX_CAN1_Init();
   
6.   MX_USART1_UART_Init();
   4 r9 q" @2 L: _/ e
7.   /* USER CODE BEGIN 2 */
     J4 L" q: r. k+ V$ o* _
8.   uint8_t ret,i;
   
9.   printf("CAN Testing....!\r\n");
   ; }+ G+ ?9 b: f$ q
10.   uint8_t txdata[8] = {76, 79, 79, 80, 66, 65, 67, 75};
    7 a2 G. {4 h: H3 `0 W6 k0 C# J; z- I
11.   uint8_t rxdata[8];
    
12.    /* USER CODE END 2 */
    3 H6 W+ e  R! b& Q' i
13.    /* Infinite loop */
    ! C7 L0 T5 B; t! R0 Z
14.    /* USER CODE BEGIN WHILE */
    
15.   while (1)
    
16.   {
    ! ?1 D4 T3 m# g0 b/ G/ G
17.     HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
    
18.     HAL_Delay(1000);
    / |& x! ~. f8 u8 ^
19.     printf("Start Send data...\r\n");
    
20.   
    / {- E/ ?5 l4 e+ E" v2 x
21.     ret = CAN1_Send_Msg(txdata, 8);
    
22.     if(ret == 0)
      t  h" P: w  |9 l& f. n8 ~
23.       printf("CAN Send success!\r\n");
    
24.     else
    $ P& q& Q, ?# b4 _) z
25.       printf("CAN Send failed!\r\n");
    
26.   
    
27.     CAN1_Recv_Msg(rxdata);
    2 w' o+ e8 n5 T" b3 i. M
28.     printf("+++++++++++++++++++++++++++++++\r\n");
    
29.     /* USER CODE END WHILE */
    8 L4 t5 ~" `- C& \
30.     /* USER CODE BEGIN 3 */
    $ A9 @/ G5 q- ]5 X! s  i
31.   }
    5 w& x$ X' R& R8 v. h/ S
32.   /* USER CODE END 3 */
    
33. }

复制代码

3. 下载测试


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

+ A4 s& W- Q! ^, I" e& n



转载自： 嵌入式攻城狮
" [: A# ~' T1 G- _: \* D如有侵权请联系删除
' I' R7 B+ p9 ~& F( `1 {' L


, [/ ~& g/ ^6 ]