配置CAN
先了解几个关键词简称：

最小时间单位（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的波特率。



SJW[1:0]再同步补偿宽度

TS1[3:0]时间段1

TS2[2:0]时间段2

BRP[9:0]波特率分频器

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

除去这几个参数，还需要设置分频，STM32F1系列一般是跑到72M主频，CAN是挂在36M的APB1时钟上，设置CAN的分频就是分的这个36M。

下面这张图是波特率计算公式：



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

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

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

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

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

stm32f103的CAN的时钟主频是36M，分9频就是4M，设置tq1=5，tq2=2，ss恒等于1，那么：波特率 = 36MHz / 9分频 /(5 + 2 + 1) = 500KHz

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

注意：stm32cubemx生成的CAN代码是不带过滤器的，需要自己手动添加。





代码修改
STM32CUBEMX生成的CAN配置代码是没有过滤器设置的，需要手动添加。

1. typedef struct
   
2. {
   
3.         uint32_t mailbox;
   
4.         CAN_TxHeaderTypeDef hdr;
   
5.         uint8_t payload[8];
   
6. }CAN_TxPacketTypeDef;
   
7. 
   
8. typedef struct
   
9. {
   
10.         CAN_RxHeaderTypeDef hdr;
    
11.         uint8_t payload[8];
    
12. }CAN_RxPacketTypeDef;

复制代码

1. /// CAN过滤器寄存器位宽类型定义
   
2. typedef union
   
3. {
   
4.     __IO uint32_t value;
   
5.     struct
   
6.     {
   
7.         uint8_t REV : 1;                        ///< [0]    ：未使用
   
8.         uint8_t RTR : 1;                        ///< [1]    : RTR（数据帧或远程帧标志位）
   
9.         uint8_t IDE : 1;                        ///< [2]    : IDE（标准帧或扩展帧标志位）
   
10.         uint32_t EXID : 18;                        ///< [21:3] : 存放扩展帧ID
    
11.         uint16_t STID : 11;                        ///< [31:22]: 存放标准帧ID
    
12.     } Sub;
    
13. } CAN_FilterRegTypeDef;
    
14. 
    
15. 
    
16. #define CAN_BASE_ID 0                                                ///< CAN标准ID，最大11位，也就是0x7FF
    
17. 
    
18. #define CAN_FILTER_MODE_MASK_ENABLE 1                ///< CAN过滤器模式选择：=0：列表模式  =1：屏蔽模式
    
19. 
    
20. #define CAN_ID_TYPE_STD_ENABLE      1       ///< CAN过滤ID类型选择：=1：标准ID，=0：扩展ID
    
21. 
    
22. void CAN_Filter_Config(void)
    
23. {
    
24.     CAN_FilterTypeDef sFilterConfig;
    
25.     CAN_FilterRegTypeDef IDH = {0};
    
26.     CAN_FilterRegTypeDef IDL = {0};
    
27. 
    
28. #if CAN_ID_TYPE_STD_ENABLE
    
29.     IDH.Sub.STID = (CAN_BASE_ID >> 16) & 0xFFFF;                // 标准ID高16位
    
30.     IDL.Sub.STID = (CAN_BASE_ID & 0xFFFF);                                // 标准ID低16位
    
31. #else
    
32.     IDH.Sub.EXID = (CAN_BASE_ID >> 16) & 0xFFFF;                // 扩展ID高16位
    
33.     IDL.Sub.EXID = (CAN_BASE_ID & 0xFFFF);                                // 扩展ID低16位
    
34.     IDL.Sub.IDE  = 1;                                                                        // 扩展帧标志位置位
    
35. #endif
    
36.     sFilterConfig.FilterBank           = 0;                                                                                                // 设置过滤器组编号
    
37. #if CAN_FILTER_MODE_MASK_ENABLE
    
38.     sFilterConfig.FilterMode           = CAN_FILTERMODE_IDMASK;                                                        // 屏蔽位模式
    
39. #else
    
40.     sFilterConfig.FilterMode           = CAN_FILTERMODE_IDLIST;                                                        // 列表模式
    
41. #endif
    
42.     sFilterConfig.FilterScale          = CAN_FILTERSCALE_32BIT;                                                        // 32位宽
    
43.     sFilterConfig.FilterIdHigh         = IDH.value;                                                                                // 标识符寄存器一ID高十六位，放入扩展帧位
    
44.     sFilterConfig.FilterIdLow          = IDL.value;                                                                                // 标识符寄存器一ID低十六位，放入扩展帧位
    
45.     sFilterConfig.FilterMaskIdHigh     = IDH.value;                                                                                // 标识符寄存器二ID高十六位，放入扩展帧位
    
46.     sFilterConfig.FilterMaskIdLow      = IDL.value;                                                                                // 标识符寄存器二ID低十六位，放入扩展帧位
    
47.     sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;                                                                        // 过滤器组关联到FIFO0
    
48.     sFilterConfig.FilterActivation     = ENABLE;                                                                                // 激活过滤器
    
49.     sFilterConfig.SlaveStartFilterBank = 14;                                                                                        // 设置从CAN的起始过滤器编号，本单片机只有一个CAN，顾此参数无效
    
50.     if (HAL_CAN_ConfigFilter(&hcan, &sFilterConfig) != HAL_OK)
    
51.     {
    
52.         Error_Handler();
    
53.     }
    
54. }
    
55. 
    
56. uint8_t CAN_Transmit(CAN_TxPacketTypeDef* packet)
    
57. {
    
58.         if(HAL_CAN_AddTxMessage(&hcan, &packet->hdr, packet->payload, &packet->mailbox) != HAL_OK)
    
59.                 return 1;
    
60.         return 0;
    
61. }
    
62. 
    
63. void CAN_Init(void)
    
64. {
    
65.     MX_CAN_Init();
    
66.     CAN_Filter_Config();
    
67.     HAL_CAN_Start(&hcan);
    
68.     HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);                                        // 使能CAN接收中断
    
69. }
    
70. 
    
71. void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *canHandle)
    
72. {
    
73.         static CAN_RxPacketTypeDef packet;
    
74.         
    
75.     // CAN数据接收
    
76.     if (canHandle->Instance == hcan.Instance)
    
77.     {
    
78.         if (HAL_CAN_GetRxMessage(canHandle, CAN_RX_FIFO0, &packet.hdr, packet.payload) == HAL_OK)                // 获得接收到的数据头和数据
    
79.         {
    
80.                         printf("\r\n\r\n\r\n################### CAN RECV ###################\r\n");
    
81.                         printf("STID:0x%X\r\n",packet.hdr.StdId);
    
82.                         printf("EXID:0x%X\r\n",packet.hdr.ExtId);
    
83.                         printf("DLC :%d\r\n", packet.hdr.DLC);
    
84.                         printf("DATA:");
    
85.                         for(int i = 0; i < packet.hdr.DLC; i++)
    
86.                         {
    
87.                                 printf("0x%02X ", packet.payload<i>);
    
88.                         }
    
89.            HAL_CAN_ActivateNotification(canHandle, CAN_IT_RX_FIFO0_MSG_PENDING);                                                // 再次使能FIFO0接收中断
    
90.         }
    
91.     }
    
92. }</i>

复制代码

1. 
   
2. CAN_TxPacketTypeDef g_CanTxPacket;
   
3. 
   
4. void CAN_SetTxPacket(void)
   
5. {
   
6.         g_CanTxPacket.hdr.StdId = 0x321;                        // 标准ID
   
7. //        g_CanTxPacket.hdr.ExtId = 0x10F01234;                // 扩展ID
   
8.         g_CanTxPacket.hdr.IDE = CAN_ID_STD;                        // 标准ID类型
   
9. //        g_CanTxPacket.hdr.IDE = CAN_ID_EXT;                        // 扩展ID类型
   
10.         g_CanTxPacket.hdr.DLC = 8;                                        // 数据长度
    
11.         g_CanTxPacket.hdr.RTR = CAN_RTR_DATA;                // 数据帧
    
12. //        g_CanTxPacket.hdr.RTR = CAN_RTR_REMOTE;                // 远程帧
    
13.         g_CanTxPacket.hdr.TransmitGlobalTime = DISABLE;
    
14.         
    
15.         for(int i = 0; i < 8; i++)
    
16.         {
    
17.                 g_CanTxPacket.payload<i> = i;
    
18.         }
    
19. }
    
20. 
    
21. int main()
    
22. {
    
23.     HAL_Init();
    
24.     SystemClock_Config();
    
25.     MX_GPIO_Init();
    
26.     MX_USART1_UART_Init();
    
27.     CAN_Init();
    
28.         printf("----------------------------------------\r\n");
    
29. 
    
30.         CAN_SetTxPacket();
    
31.         
    
32.     while(1)
    
33.     {
    
34.                 if(CAN_Transmit(&g_CanTxPacket) != 0)
    
35.                         printf("failed\r\n");
    
36.                 HAL_Delay(1000);
    
37.     }
    
38. }
    
39. 
    

复制代码