STM32 STMF4系列HAL库使用双CAN配置及注意事项

喜欢ヅ旅行 2023-07-03 07:21 13阅读 0赞

# STMF4系列HAL库使用双CAN配置及注意事项 #

--------------------

**主控芯片：STM32F406ZGT6**  
**软件版本：STM32CUBEMX 5.4**  
**HAL库版本：STM32Cube FW\_F4 V1.24.2**

~~~~~~~~         对于本实验芯片，该单片机具有两个CAN接口，CAN1为主机CAN，CAN2为从机CAN；`CAN2是和CAN1有关联的，要想使用CAN2必须先使能CAN1的时钟！`

--------------------

**扫描以下二维码，关注公众号`雍正不秃头`获取更多STM32资源及干货！**  
![在这里插入图片描述][20210126155428872.png]

--------------------

**先了解几个关键词简称：**

*  最小时间单位（Tq，Time Quantum）
 *  同步段（SS，Synchronization Segment）1tq
 *  传播时间段（PTS，Propagation Time Segment）1~8tq
 *  相位缓冲段1（PBS1，Phase Buffer Segment1）1~8tq
 *  相位缓冲段2（PBS2，Phase Buffer Segment2）2~8tq
 *  再同步补偿宽度（SJW，reSynchronization Jump Width）1~4tq
 *  波特率分频器（BRP，Baud Rate Prescaler）

STM32把传播时间段(PTS)和相位缓冲段1(PBS1)合并了，形成了时间段1（TS1）。

CAN位时序寄存器（CAN\_BTR）用于设置TS1、TS2、BRP、SJW等参数，这些参数直接决定CAN的波特率。  
![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeS16aGVuZw_size_20_color_FFFFFF_t_70_g_se_x_16][]

*  SJW\[1:0\]再同步补偿宽度
 *  TS1\[3:0\]时间段1
 *  TS2\[2:0\]时间段2
 *  BRP\[9:0\]波特率分频器

**可以看到没有同步段(SS段)，这是因为STM32已经将SS段固化为1。**

下面这张图是波特率计算公式：  
![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeS16aGVuZw_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

整合一下波特率计算公式就是这样的：

`波特率 = APB1 / [(1 + (TS1+1) + (TS2+1)) * (BRP+1)]`

在简化就是：`波特率 = 时钟主频 / 分频 / （tq1 + tq2 + ss）`

其中SS就是同步段，已经恒为1，所以：`波特率 = 时钟主频 / 分频 / （tq1 + tq2 + 1）`

下面我们开始实际设置波特率，这里要注意，CAN的波特率最大为1Mbps。

另外还有一个参数是：**再同步补偿宽度(reSynchronization Jump Width)** 这个参数，其实就是一个由数个Tq组成的一个段，用来对同步误差进行补偿，可以简单理解为为了提高精准度的，例如两个CAN进行通讯时由于两个板子的晶振可能存在误差从而导致CAN的波特率没有那么精准，所以就需要设置一个补偿参数去修正，这个参数就需要根据你实际的板子情况去调整了。

--------------------

# 时钟配置 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70]

--------------------

# CAN配置 #

~~~~~~~~         CAN外设是挂载在APB1\_PCLK1时钟上的，APB1\_PCLK1是42M。CAN的最大速率是1MHZ，本实验配置为500KHZ。波特率配置计算方法：

*  `CAN波特率 = APB1_PCLK1/分频/(tq1 + tq2 + ss)`，其中SS是SS段，在STM32中已经固定为1个tq
 *  `本实验波特率 = 42MHZ/4分频/(14 + 6 + 1) = 0.5MHZ = 500KHZ`  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 1]  
    **使能CAN接收中断**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 2]  
    **配置CAN的IO，此步骤必须！！要不然HAL库函数MX\_CAN\_Init初始化会失败！！**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 3]

**CAN2和CAN1是同样的配置，这里不再贴CAN2的配置图了。**

--------------------

# STM32外设CAN过滤器说明 #

**STM32CUBEMX生成的代码默认是没有设置ID筛选器的，所以需要手动添加过滤器代码。下面一张图，STM32的过滤器组：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 4]

**STM32F407ZG有28组筛选器，一组筛选器有两个32位的寄存器，筛选器组可配置为四种模式：**

*  **`1个32位筛选器-标识符掩码模式`，这时候筛选器组的两个32位寄存器一个用来存放ID，另一个用来存放ID的掩码**
 *  **`两个32位筛选器-标识符列表模式`，这时候筛选器组的两个32位寄存器都用来存放ID**
 *  **`两个16位筛选器-标识符掩码模式`，这时候筛选器组被分成了4个16位的寄存器，分别存放ID高16位+掩码高16位，ID低16位+掩码低16位**
 *  **`四个16位筛选-标识符列表模式`，这时候筛选器组被分成了4个16位的寄存器，都存放ID的高16位和低16位**

**贴上我的配置代码，：**

#define CAN1_FILTER_MODE_MASK_ENABLE 1 ///< CAN1过滤器模式选择：=1：屏蔽位模式 =0：屏蔽列表模式
    #define CAN2_FILTER_MODE_MASK_ENABLE 1 ///< CAN2过滤器模式选择：=1：屏蔽位模式 =0：屏蔽列表模式
    
    #define CAN1_BASE_ID 0x10F00266 ///< 主CAN过滤ID
    #define CAN2_BASE_ID 0x10F0F126 ///< 从CAN过滤ID
    
    #define CAN1_FILTER_BANK 0 ///< 主CAN过滤器组编号
    #define CAN2_FILTER_BANK 14 ///< 从CAN过滤器组编号
    
    /// CAN过滤器寄存器位宽类型定义
    typedef union
    { 
        __IO uint32_t value;
        struct
        { 
            uint8_t REV : 1;			///< [0] ：未使用
            uint8_t RTR : 1;			///< [1] : RTR（数据帧或远程帧标志位）
            uint8_t IDE : 1;			///< [2] : IDE（标准帧或扩展帧标志位）
            uint32_t EXID : 18;			///< [21:3] : 存放扩展帧ID
            uint16_t STID : 11;			///< [31:22]: 存放标准帧ID
        } Sub;
    } CAN_FilterRegTypeDef;
    
    // CAN_FMR寄存器位宽类型定义
    typedef union 
    { 
    	__IO uint32_t value;
    	struct
    	{ 
    		uint8_t FINIT : 1;
    		uint8_t RESERVER_0 : 7;
    		uint8_t CAN2SB : 6;
    		uint32_t RESERVER_1 : 18;
    	}Sub;
    }FMR_TypeDef;
    
    /// 设置CAN1的过滤器（主CAN）
    static void CAN1_Filter_Config(void)
    { 
    	CAN_FilterTypeDef sFilterConfig;
        CAN_FilterRegTypeDef IDH = { 0};
        CAN_FilterRegTypeDef IDL = { 0};
    
    	IDH.Sub.IDE  = 0;								// 标准帧
    	IDH.Sub.STID = 0;								// 标准帧ID值
        IDH.Sub.EXID = (CAN1_BASE_ID >> 16) & 0xFFFF;	// 扩展帧高16位ID值
    	
    	IDL.Sub.IDE  = 1;								// 扩展帧
    	IDL.Sub.STID = 0;								// 标准帧ID值
        IDL.Sub.EXID = (CAN1_BASE_ID & 0xFFFF);			// 扩展帧低16位ID值
    
    	sFilterConfig.FilterBank           = CAN1_FILTER_BANK;								// 设置过滤器组编号
    #if CAN1_FILTER_MODE_MASK_ENABLE
        sFilterConfig.FilterMode           = CAN_FILTERMODE_IDMASK;							// 屏蔽位模式
    #else
    	sFilterConfig.FilterMode           = CAN_FILTERMODE_IDLIST;							// 列表模式
    #endif
        sFilterConfig.FilterScale          = CAN_FILTERSCALE_32BIT;							// 32位宽
        sFilterConfig.FilterIdHigh         = IDH.value;										// 标识符寄存器一ID高十六位，放入扩展帧位
        sFilterConfig.FilterIdLow          = IDL.value;										// 标识符寄存器一ID低十六位，放入扩展帧位
        sFilterConfig.FilterMaskIdHigh     = IDH.value;										// 标识符寄存器二ID高十六位，放入扩展帧位
        sFilterConfig.FilterMaskIdLow      = IDL.value;										// 标识符寄存器二ID低十六位，放入扩展帧位
        sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;									// 过滤器组关联到FIFO0
        sFilterConfig.FilterActivation     = ENABLE;										// 激活过滤器
        sFilterConfig.SlaveStartFilterBank = CAN2_FILTER_BANK;								// 设置CAN2的起始过滤器组（对于单CAN的CPU或从CAN此参数无效；对于双CAN的CPU此参数为从CAN的起始过滤器组编号）
        if (HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig) != HAL_OK)
        { 
            Error_Handler();
        }
    	{ 
    		FMR_TypeDef regval = { 0};
    		regval.value = hcan1.Instance->FMR;
    		printf("------ CAN1:> FMR:0x%0X CAN2SB:0x%X \r\n", regval.value, regval.Sub.CAN2SB);
    	}
    }
    
    /// 设置CAN2的过滤器（从CAN）
    static void CAN2_Filter_Config(void)
    { 
    	CAN_FilterTypeDef sFilterConfig;
        CAN_FilterRegTypeDef IDH = { 0};
        CAN_FilterRegTypeDef IDL = { 0};
    
    	IDH.Sub.IDE  = 0;
    	IDH.Sub.STID = 0;
        IDH.Sub.EXID = (CAN2_BASE_ID >> 16) & 0xFFFF;
    	
    	IDL.Sub.IDE  = 1;
    	IDL.Sub.STID = 0;
        IDL.Sub.EXID = (CAN2_BASE_ID & 0xFFFF);
    
        sFilterConfig.FilterBank           = CAN2_FILTER_BANK;								// 设置过滤器组编号
    #if CAN2_FILTER_MODE_MASK_ENABLE
        sFilterConfig.FilterMode           = CAN_FILTERMODE_IDMASK;							// 屏蔽位模式
    #else
    	sFilterConfig.FilterMode           = CAN_FILTERMODE_IDLIST;							// 列表模式
    #endif
        sFilterConfig.FilterScale          = CAN_FILTERSCALE_32BIT;							// 32位宽
        sFilterConfig.FilterIdHigh         = IDH.value;										// 标识符寄存器一ID高十六位，放入扩展帧位
        sFilterConfig.FilterIdLow          = IDL.value;										// 标识符寄存器一ID低十六位，放入扩展帧位
        sFilterConfig.FilterMaskIdHigh     = IDH.value;										// 标识符寄存器二ID高十六位，放入扩展帧位
        sFilterConfig.FilterMaskIdLow      = IDL.value;										// 标识符寄存器二ID低十六位，放入扩展帧位
        sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;									// 过滤器组关联到FIFO0
        sFilterConfig.FilterActivation     = ENABLE;										// 激活过滤器
        sFilterConfig.SlaveStartFilterBank = 28;											// 无效
        if (HAL_CAN_ConfigFilter(&hcan2, &sFilterConfig) != HAL_OK)
        { 
            Error_Handler();
        }
    	{ 
    		FMR_TypeDef regval = { 0};
    		regval.value = hcan2.Instance->FMR;
    		printf("------ CAN2:> FMR:0x%0X CAN2SB:0x%X \r\n", regval.value, regval.Sub.CAN2SB);
    	}
    }
    
    /// CAN初始化
    void CAN_Init(void)
    { 
        MX_CAN1_Init();																		// 初始化CNA1
        CAN1_Filter_Config();																// 初始化CNA1过滤器
        HAL_CAN_Start(&hcan1);																// 启动CAN1
        HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING);					// 激活CAN1 FIFO0
    
        MX_CAN2_Init();
        CAN2_Filter_Config();
        HAL_CAN_Start(&hcan2);
        HAL_CAN_ActivateNotification(&hcan2, CAN_IT_RX_FIFO0_MSG_PENDING);
    }
    
    /** * CAN数据传输 * @param buf 待发送的数据 * @param len 数据长度 * @param number CAN编号，=0：CAN1，=1：CAN2 * @return 0：成功 other：失败 */
    uint8_t CAN_Transmit(const void* buf, uint32_t len, uint8_t number)
    { 
        uint32_t txmailbox = 0;
        uint32_t offset = 0;
        CAN_TxHeaderTypeDef hdr;
    
        hdr.IDE = CAN_ID_EXT;													// ID类型：扩展帧
        hdr.RTR = CAN_RTR_DATA;													// 帧类型：数据帧
        hdr.StdId = 0;															// 标准帧ID,最大11位，也就是0x7FF
        hdr.ExtId = number == 0 ? CAN1_BASE_ID : CAN2_BASE_ID;					// 扩展帧ID,最大29位，也就是0x1FFFFFFF
        hdr.TransmitGlobalTime = DISABLE;
    
        while (len != 0)
        { 
            hdr.DLC = len > 8 ? 8 : len;			// 数据长度
            if (HAL_CAN_AddTxMessage(number == 0 ? &hcan1 : &hcan2, &hdr, ((uint8_t *)buf) + offset, &txmailbox) != HAL_OK)
                return 1;
            offset += hdr.DLC;
            len -= hdr.DLC;
        }
        return 0;
    }
    
    uint8_t CAN1_RX_STA = 0;		///< CAN1数据接收标志：[7]:数据 [6:0]:未使用
    uint8_t CAN2_RX_STA = 0;		///< CAN2数据接收标志：[7]:数据 [6:0]:未使用
    
    uint8_t CAN1_RX_BUF[8];			///< CAN1数据接收缓存
    uint8_t CAN2_RX_BUF[8];			///< CAN2数据接收缓存
    
    uint8_t CAN1_TX_BUF[8];			///< CAN1数据发送缓存
    uint8_t CAN2_TX_BUF[8];			///< CAN2数据发送缓存
    
    /** * CAN FIFO0 数据接收中断回调函数 * @param hcan CAN句柄 */
    void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
    { 
        static CAN_RxHeaderTypeDef CAN_RX_HDR;
    
        // CAN1数据接收
        if (hcan->Instance == hcan1.Instance)
        { 
            // 数据已经处理
            if ((CAN1_RX_STA & 0x80) == 0)
            { 
                // 清空缓存
                memset(CAN1_RX_BUF, 0, 8);
    
                // 接收数据
                if (HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &CAN_RX_HDR, CAN1_RX_BUF) == HAL_OK)		// 获得接收到的数据头和数据
                { 
                    CAN1_RX_STA |= 0x80;																// 标记接收到数据
                    HAL_CAN_ActivateNotification(hcan, CAN_IT_RX_FIFO0_MSG_PENDING);					// 再次使能FIFO0接收中断
                }
            }
        }
    
        // CAN2数据接收
        else if (hcan->Instance == hcan2.Instance)
        { 
            // 数据已经处理
            if ((CAN2_RX_STA & 0x80) == 0)
            { 
                // 清空缓存
                memset(CAN2_RX_BUF, 0, 8);
    
                // 接收数据
                if (HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &CAN_RX_HDR, CAN2_RX_BUF) == HAL_OK)		// 获得接收到的数据头和数据
                { 
                    CAN2_RX_STA |= 0x80;																// 标记接收到数据
                    HAL_CAN_ActivateNotification(hcan, CAN_IT_RX_FIFO0_MSG_PENDING);					// 再次使能FIFO0接收中断
                }
            }
        }
    }
    
    ///< CAN数据处理函数
    inline void CAN_RecvHandler(void)
    { 
        // CAN1有数据收到
        if (CAN1_RX_STA & 0x80)
        { 
    		int i = 0;
    		memcpy(CAN1_TX_BUF, CAN1_RX_BUF, sizeof(CAN1_RX_BUF));		// 拷贝出数据
    		CAN1_RX_STA = 0;											// 重置CAN1接收状态
    		for(i = 0; i != 8; i++)
    		{ 
    			printf("CAN1_TX_BUF[%d]:0x%X\r\n", i, CAN1_TX_BUF[i]);
    		}
    		printf("\r\n\r\n");
        }
    
        // CAN2有数据收到
        if (CAN2_RX_STA & 0x80)
        { 
    		int i = 0;
    		memcpy(CAN2_TX_BUF, CAN2_RX_BUF, sizeof(CAN2_RX_BUF));		// 拷贝出数据
    		CAN2_RX_STA = 0;											// 重置CAN1接收状态
    		for(i = 0; i != 8; i++)
    		{ 
    			printf("CAN2_TX_BUF[%d]:0x%X\r\n", i, CAN2_TX_BUF[i]);
    		}
    		printf("\r\n\r\n");
        }
    }

[20210126155428872.png]: https://img-blog.csdnimg.cn/20210126155428872.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeS16aGVuZw_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/4783866cd97d41f1b35a80ca4aae9ae3.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAeS16aGVuZw==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeS16aGVuZw_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/4f9a0ef7766841fc8671353d8cb869fe.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAeS16aGVuZw==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200204122327976.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200204122550852.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200204123043335.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200204123207163.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/2020020413350172.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz,size_16,color_FFFFFF,t_70