diff --git a/User_Code/bsp/fdcan/bsp_fdcan.c b/User_Code/bsp/fdcan/bsp_fdcan.c
index 134ce8b..66edefe 100644
--- a/User_Code/bsp/fdcan/bsp_fdcan.c
+++ b/User_Code/bsp/fdcan/bsp_fdcan.c
@@ -2,514 +2,394 @@
 #include "main.h"
 #include "memory.h"
 #include "stdlib.h"
-// #include "bsp_dwt.h"
-// #include "bsp_log.h"
+#include "bsp_dwt.h"
+#include "bsp_log.h"
 
-/* FDCAN实例指针存储，用于接收回调 */
-// 在FDCAN产生接收中断会遍历数组,选出hfdcan和rxid与发生中断的实例相同的那个,调用其回调函数
+/* can instance ptrs storage, used for recv callback */
+// 在CAN产生接收中断会遍历数组,选出hcan和rxid与发生中断的实例相同的那个,调用其回调函数
+// @todo: 后续为每个CAN总线单独添加一个can_instance指针数组,提高回调查找的性能
 static FDCANInstance *fdcan_instance[CAN_MX_REGISTER_CNT] = {NULL};
-static uint8_t idx = 0; // 全局FDCAN实例索引,每次有新的模块注册会自增
+static uint8_t idx; // 全局CAN实例索引,每次有新的模块注册会自增
 
-/* ---------------- 静态函数，由FDCANRegister()调用 -------------------- */
+/* ----------------two static function called by CANRegister()-------------------- */
 
 /**
- * @brief 添加过滤器以实现对特定id的报文的接收,会被FDCANRegister()调用
- *        给FDCAN添加过滤器后,FDCAN会根据接收到的报文的id进行消息过滤,符合规则的id会被填入FIFO触发中断
+ * @brief 添加过滤器以实现对特定id的报文的接收,会被CANRegister()调用
+ *        给CAN添加过滤器后,BxCAN会根据接收到的报文的id进行消息过滤,符合规则的id会被填入FIFO触发中断
+ *        对于FDCAN，设置使用特定ID模式过滤。
  *
- * @note H7的FDCAN有多个过滤器,这里为每个FDCAN分配独立的过滤器索引
+ * @note f407的bxCAN有28个过滤器,这里将其配置为前14个过滤器给CAN1使用,后14个被CAN2使用
  *       初始化时,奇数id的模块会被分配到FIFO0,偶数id的模块会被分配到FIFO1
+ *       注册到CAN1的模块使用过滤器0-13,CAN2使用过滤器14-27
+ *       FDCAN的消息RAM是所有FDCAN外设共用的。
+ *       H723系列FDCAN过滤器数量完全在CubeMX中自定义，因此先做一次检查，再添加即可。
  *
- * @attention FDCAN的过滤器配置与标准CAN有所不同,使用掩码模式进行过滤
+ * @attention 你不需要完全理解这个函数的作用,因为它主要是用于初始化,在开发过程中不需要关心底层的实现
+ *            享受开发的乐趣吧!如果你真的想知道这个函数在干什么,请联系作者或自己查阅资料(请直接查阅官方的reference manual)
+ *            FDCAN的教程较少，但是添加FDCAN的人已经发了一篇CSDN讲解了，可以参考一下
  *
- * @param _instance FDCAN实例
+ * @param _instance can instance owned by specific module
  */
-static void FDCANAddFilter(FDCANInstance *_instance)
+static void CANAddFilter(FDCANInstance *_instance)
 {
-    FDCAN_FilterTypeDef can_filter_conf;
-    static uint8_t fdcan1_filter_idx = 0, fdcan2_filter_idx = 0, fdcan3_filter_idx = 0;
 
-    can_filter_conf.IdType = FDCAN_STANDARD_ID; // 标准ID
-    can_filter_conf.FilterType = FDCAN_FILTER_MASK; // 使用掩码模式
+#ifdef FDCAN
+	static uint8_t can1_filter_idx = 0, can2_filter_idx = 0 , can3_filter_idx = 0;
+	//检查是否超出过滤器设定数量上限
+	if(can1_filter_idx > hfdcan1.Init.StdFiltersNbr || can2_filter_idx>hfdcan2.Init.StdFiltersNbr || can3_filter_idx > hfdcan3.Init.StdFiltersNbr)
+	{
+		while(1)
+		{
+			//报错
+		}
+	}
+	uint8_t *filter_idx_p;
 
-    // 根据can_handle判断是哪个FDCAN,然后分配过滤器索引
-    if (_instance->can_handle == &hfdcan1)
-    {
-        can_filter_conf.FilterIndex = fdcan1_filter_idx++;
-    }
-    else if (_instance->can_handle == &hfdcan2)
-    {
-        can_filter_conf.FilterIndex = fdcan2_filter_idx++;
-    }
-    else if (_instance->can_handle == &hfdcan3)
-    {
-        can_filter_conf.FilterIndex = fdcan3_filter_idx++;
-    }
+	if(_instance->can_handle==&hfdcan1)
+	{
+		filter_idx_p=&can1_filter_idx;
+	}
+	else if(_instance->can_handle==&hfdcan2)
+	{
+		filter_idx_p=&can2_filter_idx;
+	}
+	else if(_instance->can_handle==&hfdcan3)
+	{
+		filter_idx_p=&can3_filter_idx;
+	}
+	else
+	{
+		while(1)
+		{
+			//报错
+		}
+	}
 
-    can_filter_conf.FilterConfig = (_instance->rx_id & 1) ? FDCAN_FILTER_TO_RXFIFO0 : FDCAN_FILTER_TO_RXFIFO1;
-    can_filter_conf.FilterID1 = _instance->rx_id << 5; // 标准ID左移5位
-    can_filter_conf.FilterID2 = 0x7FF << 5; // 掩码: 匹配所有标准ID
+	FDCAN_FilterTypeDef fdcan_filter_conf;
+	fdcan_filter_conf.FilterIndex=(*filter_idx_p)++;
+	//使用单个ID模式
+	fdcan_filter_conf.FilterType=FDCAN_FILTER_DUAL;
+	fdcan_filter_conf.FilterConfig=(_instance->tx_id & 1) ? FDCAN_FILTER_TO_RXFIFO0 : FDCAN_FILTER_TO_RXFIFO1;//奇数id的模块会被分配到FIFO0,偶数id的模块会被分配到FIFO1
+	fdcan_filter_conf.FilterID1=_instance->rx_id;
+	fdcan_filter_conf.FilterID2=_instance->rx_id;
+	fdcan_filter_conf.IdType=FDCAN_STANDARD_ID;
+	fdcan_filter_conf.IsCalibrationMsg=0;
+	//fdcan_filter_conf.RxBufferIndex=0;
+
+	HAL_FDCAN_ConfigFilter(_instance->can_handle, &fdcan_filter_conf);
+
+#else
+	CAN_FilterTypeDef can_filter_conf;
+	static uint8_t can1_filter_idx = 0, can2_filter_idx = 14; // 0-13给can1用,14-27给can2用
+
+	can_filter_conf.FilterMode = CAN_FILTERMODE_IDLIST;                                                       // 使用id list模式,即只有将rxid添加到过滤器中才会接收到,其他报文会被过滤
+	can_filter_conf.FilterScale = CAN_FILTERSCALE_16BIT;                                                      // 使用16位id模式,即只有低16位有效
+	can_filter_conf.FilterFIFOAssignment = (_instance->tx_id & 1) ? CAN_RX_FIFO0 : CAN_RX_FIFO1;              // 奇数id的模块会被分配到FIFO0,偶数id的模块会被分配到FIFO1
+	can_filter_conf.SlaveStartFilterBank = 14;                                                                // 从第14个过滤器开始配置从机过滤器(在STM32的BxCAN控制器中CAN2是CAN1的从机)
+	can_filter_conf.FilterIdLow = _instance->rx_id << 5;                                                      // 过滤器寄存器的低16位,因为使用STDID,所以只有低11位有效,高5位要填0
+	can_filter_conf.FilterBank = _instance->can_handle == &hcan1 ? (can1_filter_idx++) : (can2_filter_idx++); // 根据can_handle判断是CAN1还是CAN2,然后自增
+	can_filter_conf.FilterActivation = CAN_FILTER_ENABLE;                                                     // 启用过滤器
+
+	HAL_CAN_ConfigFilter(_instance->can_handle, &can_filter_conf);
+#endif
 
-    if (HAL_FDCAN_ConfigFilter(_instance->can_handle, &can_filter_conf) != HAL_OK)
-    {
-        Error_Handler();
-    }
 }
 
 /**
- * @brief 在第一个FDCAN实例初始化的时候会自动调用此函数,启动FDCAN服务
+ * @brief 在第一个CAN实例初始化的时候会自动调用此函数,启动CAN服务
  *
- * @note 此函数会启动FDCAN1、FDCAN2和FDCAN3,开启相应的FIFO中断通知
+ * @note 此函数会启动CAN1并开启中断
+ *       FDCAN的情况下，我们采用FIFO接收方式（而不是buffer），FIFO和buffer还有queue接收方式请自行查阅H723手册
+ *       FDCAN比bxCAN多了一个全局过滤器，这里配置为全部拒绝，只接受指定ID。
  *
  */
-static void FDCANServiceInit()
+void CANServiceInit()
 {
-    // 配置全局过滤器 - 拒绝所有不匹配的帧
-    HAL_FDCAN_ConfigGlobalFilter(&hfdcan1, FDCAN_REJECT, FDCAN_REJECT, FDCAN_FILTER_REMOTE, FDCAN_FILTER_REMOTE);
-    HAL_FDCAN_ConfigGlobalFilter(&hfdcan2, FDCAN_REJECT, FDCAN_REJECT, FDCAN_FILTER_REMOTE, FDCAN_FILTER_REMOTE);
-    HAL_FDCAN_ConfigGlobalFilter(&hfdcan3, FDCAN_REJECT, FDCAN_REJECT, FDCAN_FILTER_REMOTE, FDCAN_FILTER_REMOTE);
+#ifdef FDCAN
+	//可能不需要这么多中断
+	uint32_t FDCAN_RXActiveITs = FDCAN_IT_RX_FIFO0_NEW_MESSAGE|FDCAN_IT_RX_FIFO0_FULL\
+			|FDCAN_IT_RX_FIFO0_WATERMARK|FDCAN_IT_RX_FIFO0_MESSAGE_LOST \
+			|FDCAN_IT_RX_FIFO1_NEW_MESSAGE| FDCAN_IT_RX_FIFO1_FULL\
+			|FDCAN_IT_RX_FIFO1_WATERMARK|FDCAN_IT_RX_FIFO1_MESSAGE_LOST;
 
-    // 启动FDCAN
-    HAL_FDCAN_Start(&hfdcan1);
-    HAL_FDCAN_Start(&hfdcan2);
-    HAL_FDCAN_Start(&hfdcan3);
 
-    // 激活接收中断 - FDCAN1使用FIFO0, FDCAN2和FDCAN3使用FIFO1
-    HAL_FDCAN_ActivateNotification(&hfdcan1, FDCAN_IT_RX_FIFO0_NEW_MESSAGE, 0);
-    HAL_FDCAN_ActivateNotification(&hfdcan2, FDCAN_IT_RX_FIFO1_NEW_MESSAGE, 0);
-    HAL_FDCAN_ActivateNotification(&hfdcan3, FDCAN_IT_RX_FIFO1_NEW_MESSAGE, 0);
+	//HAL_FDCAN_ConfigClockCalibration()
+	HAL_FDCAN_ConfigRxFifoOverwrite(&hfdcan1,FDCAN_RX_FIFO0,FDCAN_RX_FIFO_OVERWRITE);
+	HAL_FDCAN_ConfigRxFifoOverwrite(&hfdcan1,FDCAN_RX_FIFO1,FDCAN_RX_FIFO_OVERWRITE);
+	HAL_FDCAN_ConfigGlobalFilter(&hfdcan1, FDCAN_REJECT, FDCAN_REJECT, FDCAN_REJECT_REMOTE, FDCAN_REJECT_REMOTE);//全局过滤器设置
+	HAL_FDCAN_Start(&hfdcan1);
+	HAL_FDCAN_ActivateNotification(&hfdcan1,FDCAN_RXActiveITs, 0);
 
-    // 激活错误中断
-    HAL_FDCAN_ActivateNotification(&hfdcan1, FDCAN_IT_BUS_OFF, 0);
-    HAL_FDCAN_ActivateNotification(&hfdcan2, FDCAN_IT_BUS_OFF, 0);
-    HAL_FDCAN_ActivateNotification(&hfdcan3, FDCAN_IT_BUS_OFF, 0);
+	HAL_FDCAN_ConfigRxFifoOverwrite(&hfdcan2,FDCAN_RX_FIFO0,FDCAN_RX_FIFO_OVERWRITE);
+	HAL_FDCAN_ConfigRxFifoOverwrite(&hfdcan2,FDCAN_RX_FIFO1,FDCAN_RX_FIFO_OVERWRITE);
+	HAL_FDCAN_ConfigGlobalFilter(&hfdcan2, FDCAN_REJECT, FDCAN_REJECT, FDCAN_REJECT_REMOTE, FDCAN_REJECT_REMOTE);
+	HAL_FDCAN_Start(&hfdcan2);
+	HAL_FDCAN_ActivateNotification(&hfdcan2,FDCAN_RXActiveITs, 0);
+
+
+	HAL_FDCAN_ConfigRxFifoOverwrite(&hfdcan3,FDCAN_RX_FIFO0,FDCAN_RX_FIFO_OVERWRITE);
+	HAL_FDCAN_ConfigRxFifoOverwrite(&hfdcan3,FDCAN_RX_FIFO1,FDCAN_RX_FIFO_OVERWRITE);
+	HAL_FDCAN_ConfigGlobalFilter(&hfdcan3, FDCAN_REJECT, FDCAN_REJECT, FDCAN_REJECT_REMOTE, FDCAN_REJECT_REMOTE);
+	HAL_FDCAN_Start(&hfdcan3);
+	HAL_FDCAN_ActivateNotification(&hfdcan3,FDCAN_RXActiveITs, 0);
+
+
+#else
+	HAL_CAN_Start(&hcan1);
+	HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING);
+	HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO1_MSG_PENDING);
+	HAL_CAN_Start(&hcan2);
+	HAL_CAN_ActivateNotification(&hcan2, CAN_IT_RX_FIFO0_MSG_PENDING);
+	HAL_CAN_ActivateNotification(&hcan2, CAN_IT_RX_FIFO1_MSG_PENDING);
+#endif
 
-    // LOGINFO("[bsp_fdcan] FDCAN Service Init");
 }
 
-/**
- * @brief 从FDCAN数据长度码转换为实际数据长度
- * @param dlc 数据长度码
- * @return uint8_t 实际数据长度
- */
-static uint8_t FDCANDlcToLen(uint32_t dlc)
-{
-    if (dlc <= FDCAN_DLC_BYTES_8)
-        return dlc;
-    else if (dlc == FDCAN_DLC_BYTES_12)
-        return 12;
-    else if (dlc == FDCAN_DLC_BYTES_16)
-        return 16;
-    else if (dlc == FDCAN_DLC_BYTES_20)
-        return 20;
-    else if (dlc == FDCAN_DLC_BYTES_24)
-        return 24;
-    else if (dlc == FDCAN_DLC_BYTES_32)
-        return 32;
-    else if (dlc == FDCAN_DLC_BYTES_48)
-        return 48;
-    else if (dlc == FDCAN_DLC_BYTES_64)
-        return 64;
-    return 0;
-}
+/* ----------------------- two extern callable function -----------------------*/
 
-/**
- * @brief 从实际数据长度转换为FDCAN数据长度码
- * @param len 实际数据长度
- * @return uint32_t 数据长度码
- */
-static uint32_t FDCANLenToDlc(uint8_t len)
-{
-    if (len <= 8)
-        return len;
-    else if (len == 12)
-        return FDCAN_DLC_BYTES_12;
-    else if (len == 16)
-        return FDCAN_DLC_BYTES_16;
-    else if (len == 20)
-        return FDCAN_DLC_BYTES_20;
-    else if (len == 24)
-        return FDCAN_DLC_BYTES_24;
-    else if (len == 32)
-        return FDCAN_DLC_BYTES_32;
-    else if (len == 48)
-        return FDCAN_DLC_BYTES_48;
-    else if (len == 64)
-        return FDCAN_DLC_BYTES_64;
-    return FDCAN_DLC_BYTES_8;
-}
-
-/* ----------------------- 外部可调用函数 -----------------------*/
-
-FDCANInstance *FDCANRegister(FDCAN_Init_Config_s *config)
+FDCANInstance *CANRegister(FDCAN_Init_Config_s *config)
 {
     if (!idx)
     {
-        FDCANServiceInit(); // 第一次注册,先进行硬件初始化
+        CANServiceInit(); // 第一次注册,先进行硬件初始化
+        LOGINFO("[bsp_can] CAN Service Init");
     }
     if (idx >= CAN_MX_REGISTER_CNT) // 超过最大实例数
     {
         while (1)
         {
-            // Todo:LOGERROR("[bsp_fdcan] FDCAN instance exceeded MAX num, consider balance the load of FDCAN bus");
+        	LOGERROR("[bsp_can] CAN instance exceeded MAX num, consider balance the load of CAN bus");
         }
+
     }
     for (size_t i = 0; i < idx; i++)
-    {
-        // 重复注册 | id重复
+    { // 重复注册 | id重复
         if (fdcan_instance[i]->rx_id == config->rx_id && fdcan_instance[i]->can_handle == config->can_handle)
         {
             while (1)
             {
-                // Todo:LOGERROR("[bsp_fdcan] FDCAN id crash ,tx [%d] or rx [%d] already registered", config->tx_id, config->rx_id);
+            	LOGERROR("[}bsp_can] CAN id crash ,tx [%d] or rx [%d] already registered", &config->tx_id, &config->rx_id);
             }
+
         }
     }
 
-    auto instance = (FDCANInstance *) malloc(sizeof(FDCANInstance)); // 分配空间
-    memset(instance, 0, sizeof(FDCANInstance)); // 分配的空间未必是0,所以要先清空
-
+    FDCANInstance *instance = (FDCANInstance *)malloc(sizeof(FDCANInstance)); // 分配空间
+    memset(instance, 0, sizeof(FDCANInstance));                           // 分配的空间未必是0,所以要先清空
     // 进行发送报文的配置
-    instance->txconf.Identifier = config->tx_id; // 发送id
-    instance->txconf.IdType = FDCAN_STANDARD_ID; // 使用标准id
-    instance->txconf.TxFrameType = FDCAN_DATA_FRAME; // 发送数据帧
-    instance->txconf.DataLength = FDCAN_DLC_BYTES_8; // 默认发送长度为8
-    instance->txconf.ErrorStateIndicator = FDCAN_ESI_ACTIVE;
-    instance->txconf.BitRateSwitch = FDCAN_BRS_OFF; // 默认关闭比特率切换
-    instance->txconf.FDFormat = FDCAN_CLASSIC_CAN; // 默认经典CAN模式
-    instance->txconf.TxEventFifoControl = FDCAN_NO_TX_EVENTS;
-    instance->txconf.MessageMarker = 0;
-
+#ifdef FDCAN
+    instance->txconf.Identifier = config->tx_id; 				// 发送id
+    instance->txconf.IdType = FDCAN_STANDARD_ID;  				// 使用标准id,扩展id则使用CAN_ID_EXT(目前没有需求)
+    instance->txconf.TxFrameType = FDCAN_DATA_FRAME,    		// 发送数据帧
+    instance->txconf.DataLength = FDCAN_DLC_BYTES_8,    		// 数据长度为8字节
+	instance->txconf.ErrorStateIndicator = FDCAN_ESI_ACTIVE,	// 兼容CAN2.0,错误状态指示器设为主动
+	instance->txconf.BitRateSwitch = FDCAN_BRS_OFF,         	// 兼容CAN2.0禁用位速率切换
+	instance->txconf.FDFormat = FDCAN_CLASSIC_CAN,          	// 使用经典CAN格式
+	instance->txconf.TxEventFifoControl = FDCAN_NO_TX_EVENTS,	// 不需要，禁用事件FIFO
+	instance->txconf.MessageMarker = 0;                     	// 不使用消息标记
+#else
+    instance->txconf.StdId = config->tx_id; // 发送id
+    instance->txconf.IDE = CAN_ID_STD;      // 使用标准id,扩展id则使用CAN_ID_EXT(目前没有需求)
+    instance->txconf.RTR = CAN_RTR_DATA;    // 发送数据帧
+    instance->txconf.DLC = 0x08;            // 默认发送长度为8
+#endif
     // 设置回调函数和接收发送id
     instance->can_handle = config->can_handle;
-    instance->tx_id = config->tx_id;
+    instance->tx_id = config->tx_id; // 好像没用,可以删掉
     instance->rx_id = config->rx_id;
     instance->can_module_callback = config->can_module_callback;
     instance->id = config->id;
 
-    FDCANAddFilter(instance); // 添加FDCAN过滤器规则
-    fdcan_instance[idx++] = instance; // 将实例保存到fdcan_instance中
+    CANAddFilter(instance);         // 添加CAN过滤器规则
+    fdcan_instance[idx++] = instance; // 将实例保存到can_instance中
 
-    return instance; // 返回FDCAN实例指针
+    return instance; // 返回can实例指针
 }
 
-/**
- * @brief 通过FDCAN实例发送消息
- *        发送前需要向FDCAN实例的tx_buff写入发送数据
- *
- * @attention 超时时间不应该超过调用此函数的任务的周期,否则会导致任务阻塞
- *
- * @param _instance FDCAN实例
- * @param timeout 超时时间,单位为ms
- * @return uint8_t 发送成功返回1,失败返回0
- */
-uint8_t FDCANTransmit(FDCANInstance *_instance, float timeout)
+/* @todo 目前似乎封装过度,应该添加一个指向tx_buff的指针,tx_buff不应该由CAN instance保存 */
+/* 如果让CANinstance保存txbuff,会增加一次复制的开销 */
+uint8_t CANTransmit(FDCANInstance *_instance, float timeout)
 {
-    // static uint32_t busy_count;
+    static uint32_t busy_count;
     static volatile float wait_time __attribute__((unused)); // for cancel warning
-    // float dwt_start = DWT_GetTimeline_ms();
-
-    // 等待发送FIFO有空闲位置
-    while (HAL_FDCAN_GetTxFifoFreeLevel(_instance->can_handle) == 0)
+    float dwt_start = DWT_GetTimeline_ms();
+#ifdef FDCAN
+    while(HAL_FDCAN_GetTxFifoFreeLevel(_instance->can_handle)==0)
+#else
+    while (HAL_CAN_GetTxMailboxesFreeLevel(_instance->can_handle) == 0) // 等待邮箱空闲
+#endif
     {
-        // if (DWT_GetTimeline_ms() - dwt_start > timeout) // 超时
-        // {
-        //     LOGWARNING("[bsp_fdcan] FDCAN TX FIFO full! failed to add msg to FIFO. Cnt [%d]", busy_count);
-        //     busy_count++;
-        //     return 0;
-        // }
+        if (DWT_GetTimeline_ms() - dwt_start > timeout) // 超时
+        {
+            LOGWARNING("[bsp_can] CAN MAILbox full! failed to add msg to mailbox. Cnt [%d]", busy_count);
+            busy_count++;
+            return 0;
+        }
     }
-    // wait_time = DWT_GetTimeline_ms() - dwt_start;
+    wait_time = DWT_GetTimeline_ms() - dwt_start;
 
-    // 发送消息
-    if (HAL_FDCAN_AddMessageToTxFifoQ(_instance->can_handle, &_instance->txconf, _instance->tx_buff) != HAL_OK)
+#ifdef FDCAN
+    if (HAL_FDCAN_AddMessageToTxFifoQ(_instance->can_handle, &_instance->txconf, _instance->tx_buff))
+#else
+    // tx_mailbox会保存实际填入了这一帧消息的邮箱,但是知道是哪个邮箱发的似乎也没啥用
+    if (HAL_CAN_AddTxMessage(_instance->can_handle, &_instance->txconf, _instance->tx_buff, &_instance->tx_mailbox))
+#endif
     {
-        // LOGWARNING("[bsp_fdcan] FDCAN bus BUS! cnt:%d", busy_count);
-        // busy_count++;
+        LOGWARNING("[bsp_can] CAN bus BUSY! cnt:%d", busy_count);
+        busy_count++;
         return 0;
     }
     return 1; // 发送成功
 }
 
-/**
- * @brief 修改FDCAN发送报文的数据帧长度
- *        注意FDCAN最大支持64字节,在没有进行修改的时候,默认长度为8
- *
- * @param _instance 要修改长度的FDCAN实例
- * @param length    设定长度
- */
-void FDCANSetDLC(FDCANInstance *_instance, uint8_t length)
+void CANSetDLC(FDCANInstance *_instance, uint8_t length)
 {
     // 发送长度错误!检查调用参数是否出错,或出现野指针/越界访问
-    if (length > 64 || length == 0) // 安全检查
+    if (length > 8 || length == 0) // 安全检查
         while (1)
         {
-            //Todo:LOGERROR("[bsp_fdcan] FDCAN DLC error! check your code or wild pointer");
+        	LOGERROR("[bsp_can] CAN DLC error! check your code or wild pointer");
         }
-    _instance->txconf.DataLength = FDCANLenToDlc(length);
+
+    _instance->txconf.DataLength = length;
 }
 
+/* -----------------------belows are callback definitions--------------------------*/
+
+//对于FDCAN，回调函数和处理方式完全不同，因此直接用两套逻辑处理
+#ifdef FDCAN
 /**
- * @brief 设置FDCAN波特率
- * @param hfdcan FDCAN句柄
- * @param mode CAN模式：CAN_CLASS或CAN_FD_BRS
- * @param baud 波特率选择
- */
-void bsp_fdcan_set_baud(FDCAN_HandleTypeDef *hfdcan, uint8_t mode, uint8_t baud)
-{
-    uint32_t nom_brp = 0, nom_seg1 = 0, nom_seg2 = 0, nom_sjw = 0;
-    uint32_t dat_brp = 0, dat_seg1 = 0, dat_seg2 = 0, dat_sjw = 0;
-
-    if (mode == CAN_CLASS)
-    {
-        switch (baud)
-        {
-            case CAN_BR_125K:
-                nom_brp = 4;
-                nom_seg1 = 139;
-                nom_seg2 = 20;
-                nom_sjw = 20;
-                break;
-            case CAN_BR_200K:
-                nom_brp = 2;
-                nom_seg1 = 174;
-                nom_seg2 = 25;
-                nom_sjw = 25;
-                break;
-            case CAN_BR_250K:
-                nom_brp = 2;
-                nom_seg1 = 139;
-                nom_seg2 = 20;
-                nom_sjw = 20;
-                break;
-            case CAN_BR_500K:
-                nom_brp = 1;
-                nom_seg1 = 139;
-                nom_seg2 = 20;
-                nom_sjw = 20;
-                break;
-            case CAN_BR_1M:
-                nom_brp = 1;
-                nom_seg1 = 59;
-                nom_seg2 = 20;
-                nom_sjw = 20;
-                break;
-            default:
-                break;
-        }
-        dat_brp = 1;
-        dat_seg1 = 29;
-        dat_seg2 = 10;
-        dat_sjw = 10; // 仲裁域默认1M
-        hfdcan->Init.FrameFormat = FDCAN_FRAME_CLASSIC;
-    }
-    else if (mode == CAN_FD_BRS)
-    {
-        switch (baud)
-        {
-            case CAN_BR_2M:
-                dat_brp = 1;
-                dat_seg1 = 29;
-                dat_seg2 = 10;
-                dat_sjw = 10;
-                break;
-            case CAN_BR_2M5:
-                dat_brp = 1;
-                dat_seg1 = 25;
-                dat_seg2 = 6;
-                dat_sjw = 6;
-                break;
-            case CAN_BR_3M2:
-                dat_brp = 1;
-                dat_seg1 = 19;
-                dat_seg2 = 5;
-                dat_sjw = 5;
-                break;
-            case CAN_BR_4M:
-                dat_brp = 1;
-                dat_seg1 = 14;
-                dat_seg2 = 5;
-                dat_sjw = 5;
-                break;
-            case CAN_BR_5M:
-                dat_brp = 1;
-                dat_seg1 = 13;
-                dat_seg2 = 2;
-                dat_sjw = 2;
-                break;
-            default:
-                break;
-        }
-        nom_brp = 1;
-        nom_seg1 = 59;
-        nom_seg2 = 20;
-        nom_sjw = 20; // 数据域默认1M
-        hfdcan->Init.FrameFormat = FDCAN_FRAME_FD_BRS;
-    }
-
-    HAL_FDCAN_Stop(hfdcan);
-
-    hfdcan->Init.NominalPrescaler = nom_brp;
-    hfdcan->Init.NominalTimeSeg1 = nom_seg1;
-    hfdcan->Init.NominalTimeSeg2 = nom_seg2;
-    hfdcan->Init.NominalSyncJumpWidth = nom_sjw;
-
-    hfdcan->Init.DataPrescaler = dat_brp;
-    hfdcan->Init.DataTimeSeg1 = dat_seg1;
-    hfdcan->Init.DataTimeSeg2 = dat_seg2;
-    hfdcan->Init.DataSyncJumpWidth = dat_sjw;
-
-    if (HAL_FDCAN_Init(hfdcan) != HAL_OK)
-    {
-        Error_Handler();
-    }
-
-    // 重新启动FDCAN并配置过滤器
-    HAL_FDCAN_Start(hfdcan);
-    HAL_FDCAN_ConfigGlobalFilter(hfdcan, FDCAN_REJECT, FDCAN_REJECT, FDCAN_FILTER_REMOTE, FDCAN_FILTER_REMOTE);
-
-    // 重新激活通知
-    if (hfdcan == &hfdcan1)
-    {
-        HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_RX_FIFO0_NEW_MESSAGE, 0);
-    }
-    else
-    {
-        HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_RX_FIFO1_NEW_MESSAGE, 0);
-    }
-    HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_BUS_OFF, 0);
-}
-
-/* ----------------------- 回调函数定义 --------------------------*/
-
-/**
- * @brief 此函数会被下面两个函数调用,用于处理FIFO0和FIFO1接收中断(说明收到了新的数据)
+ * @brief 此函数会被下面两个函数调用,用于处理FIFO0和FIFO1溢出中断(说明收到了新的数据)
  *        所有的实例都会被遍历,找到can_handle和rx_id相等的实例时,调用该实例的回调函数
  *
- * @param _hcan FDCAN句柄
- * @param fifox 传递给HAL_FDCAN_GetRxMessage()以从特定FIFO获取消息
+ * @param _fdhcan
+ * @param fifox passed to HAL_CAN_GetRxMessage() to get mesg from a specific fifo
  */
-static void FDCANFIFOxCallback(FDCAN_HandleTypeDef *_hcan, uint32_t fifox)
+static void FDCANFIFOxCallback(FDCAN_HandleTypeDef *_hfdcan, uint32_t fifox)
 {
-    FDCAN_RxHeaderTypeDef rxconf;
-    uint8_t can_rx_buff[64];
-
-    while (HAL_FDCAN_GetRxFifoFillLevel(_hcan, fifox)) // FIFO不为空,有可能在其他中断时有多帧数据进入
+    static FDCAN_RxHeaderTypeDef rxconf; // 同上
+	static uint16_t DataLength = 0;
+    static uint8_t fdcan_rx_buff[8];
+    while (HAL_FDCAN_GetRxFifoFillLevel(_hfdcan, fifox)) // FIFO不为空,有可能在其他中断时有多帧数据进入
     {
-        HAL_FDCAN_GetRxMessage(_hcan, fifox, &rxconf, can_rx_buff); // 从FIFO中获取数据
-
-        for (size_t i = 0; i < idx; ++i)
+        HAL_FDCAN_GetRxMessage(_hfdcan, fifox, &rxconf, fdcan_rx_buff); // 从FIFO中获取数据
+		//解析数据长度，@Todo 此处在用新版本重新生成后可能得修改，DataLength可能不需要右移，具体情况具体看	！
+		if(((rxconf.DataLength >> 16) & 0xF)>=0 && ((rxconf.DataLength >> 16) & 0xF)<=8)
+		{
+			DataLength=(rxconf.DataLength >> 16) & 0xF; // 保存接收到的数据长度
+		}
+		else
+		{
+			DataLength=0;
+		}
+        if(rxconf.RxFrameType==FDCAN_DATA_FRAME && rxconf.IdType==FDCAN_STANDARD_ID)
         {
-            // 两者相等说明这是要找的实例
-            if (_hcan == fdcan_instance[i]->can_handle && rxconf.Identifier == fdcan_instance[i]->rx_id)
-            {
-                if (fdcan_instance[i]->can_module_callback != NULL) // 回调函数不为空就调用
-                {
-                    fdcan_instance[i]->rx_len = FDCANDlcToLen(rxconf.DataLength); // 保存接收到的数据长度
-                    memcpy(fdcan_instance[i]->rx_buff, can_rx_buff, fdcan_instance[i]->rx_len); // 消息拷贝到对应实例
-                    fdcan_instance[i]->can_module_callback(fdcan_instance[i]); // 触发回调进行数据解析和处理
-                }
-                return;
-            }
+        	for (size_t i = 0; i < idx; ++i)
+			{
+        		// 两者相等说明这是要找的实例
+				if (_hfdcan == fdcan_instance[i]->can_handle && rxconf.Identifier == fdcan_instance[i]->rx_id)
+				{
+					if (fdcan_instance[i]->can_module_callback != NULL) // 回调函数不为空就调用
+					{
+						fdcan_instance[i]->rx_len = DataLength;               // 保存接收到的数据长度
+						memcpy(fdcan_instance[i]->rx_buff, fdcan_rx_buff, fdcan_instance[i]->rx_len); // 消息拷贝到对应实例
+						fdcan_instance[i]->can_module_callback(fdcan_instance[i]);     // 触发回调进行数据解析和处理
+					}
+					return;
+				}
+			}
         }
     }
 }
 
-/**
- * @brief 注意,STM32的FDCAN设备有独立的FIFO
- * 下面两个函数是HAL库中的回调函数,他们被HAL声明为__weak,这里对他们进行重载(重写)
- * 当FIFO0或FIFO1有新消息时会调用这两个函数
- */
 
-/**
- * @brief rx fifo callback. Once FIFO_0 has new message, this func would be called
- *
- * @param hfdcan FDCAN handle indicate which device the message in FIFO_0 comes from
- * @param RxFifo0ITs FIFO0中断标志
- */
 void HAL_FDCAN_RxFifo0Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo0ITs)
 {
-    if ((RxFifo0ITs & FDCAN_IT_RX_FIFO0_NEW_MESSAGE) != RESET)
-    {
-        FDCANFIFOxCallback(hfdcan, FDCAN_RX_FIFO0); // 调用我们自己写的函数来处理消息
-    }
+	/* 检查Rx FIFO 0中是否有消息丢失 */
+	if ((RxFifo0ITs & FDCAN_IT_RX_FIFO0_MESSAGE_LOST) != 0)
+	{
+		//报错
+	}
+	/* 检查是否有新消息写入Rx FIFO 0或到达一定阈值 */
+	if ((RxFifo0ITs & FDCAN_IT_RX_FIFO0_NEW_MESSAGE)||(RxFifo0ITs & FDCAN_IT_RX_FIFO0_FULL)||(RxFifo0ITs & FDCAN_IT_RX_FIFO0_WATERMARK))
+	{
+		FDCANFIFOxCallback(hfdcan, FDCAN_RX_FIFO0); // 调用我们自己写的函数来处理消息
+	}
 }
-
-/**
- * @brief rx fifo callback. Once FIFO_1 has new message, this func would be called
- *
- * @param hfdcan FDCAN handle indicate which device the message in FIFO_1 comes from
- * @param RxFifo1ITs FIFO1中断标志
- */
 void HAL_FDCAN_RxFifo1Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo1ITs)
 {
-    if ((RxFifo1ITs & FDCAN_IT_RX_FIFO1_NEW_MESSAGE) != RESET)
-    {
-        FDCANFIFOxCallback(hfdcan, FDCAN_RX_FIFO1); // 调用我们自己写的函数来处理消息
-    }
+	/* 检查Rx FIFO 1中是否有消息丢失 */
+	if ((RxFifo1ITs & FDCAN_IT_RX_FIFO1_MESSAGE_LOST) != 0)
+	{
+		//报错
+	}
+	/* 检查是否有新消息写入Rx FIFO 1或到达一定阈值 */
+	if ((RxFifo1ITs & FDCAN_IT_RX_FIFO1_NEW_MESSAGE)||(RxFifo1ITs & FDCAN_IT_RX_FIFO1_FULL)||(RxFifo1ITs & FDCAN_IT_RX_FIFO1_WATERMARK))
+	{
+		FDCANFIFOxCallback(hfdcan, FDCAN_RX_FIFO1); // 调用我们自己写的函数来处理消息
+	}
+}
+
+
+#else
+
+
+/**
+* @brief 此函数会被下面两个函数调用,用于处理FIFO0和FIFO1溢出中断(说明收到了新的数据)
+*        所有的实例都会被遍历,找到can_handle和rx_id相等的实例时,调用该实例的回调函数
+*
+* @param _hcan
+* @param fifox passed to HAL_CAN_GetRxMessage() to get mesg from a specific fifo
+*/
+static void CANFIFOxCallback(CAN_HandleTypeDef *_hcan, uint32_t fifox)
+{
+   static CAN_RxHeaderTypeDef rxconf; // 同上
+   uint8_t can_rx_buff[8];
+   while (HAL_CAN_GetRxFifoFillLevel(_hcan, fifox)) // FIFO不为空,有可能在其他中断时有多帧数据进入
+   {
+       HAL_CAN_GetRxMessage(_hcan, fifox, &rxconf, can_rx_buff); // 从FIFO中获取数据
+       for (size_t i = 0; i < idx; ++i)
+       { // 两者相等说明这是要找的实例
+           if (_hcan == fdcan_instance[i]->can_handle && rxconf.StdId == fdcan_instance[i]->rx_id)
+           {
+               if (fdcan_instance[i]->can_module_callback != NULL) // 回调函数不为空就调用
+               {
+                   fdcan_instance[i]->rx_len = rxconf.DLC;                      // 保存接收到的数据长度
+                   memcpy(fdcan_instance[i]->rx_buff, can_rx_buff, rxconf.DLC); // 消息拷贝到对应实例
+                   fdcan_instance[i]->can_module_callback(fdcan_instance[i]);     // 触发回调进行数据解析和处理
+               }
+               return;
+           }
+       }
+   }
 }
 
 /**
- * @brief 错误状态回调函数
- * @param hfdcan FDCAN句柄
- * @param ErrorStatusITs 错误状态中断标志
- */
-void HAL_FDCAN_ErrorStatusCallback(FDCAN_HandleTypeDef *hfdcan, uint32_t ErrorStatusITs)
+* @brief 注意,STM32的两个CAN设备共享两个FIFO
+* 下面两个函数是HAL库中的回调函数,他们被HAL声明为__weak,这里对他们进行重载(重写)
+* 当FIFO0或FIFO1溢出时会调用这两个函数
+*/
+// 下面的函数会调用CANFIFOxCallback()来进一步处理来自特定CAN设备的消息
+
+/**
+* @brief rx fifo callback. Once FIFO_0 is full,this func would be called
+*
+* @param hcan CAN handle indicate which device the oddest mesg in FIFO_0 comes from
+*/
+void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
 {
-    if (ErrorStatusITs & FDCAN_IR_BO)
-    {
-        // 总线关闭恢复
-        CLEAR_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_INIT);
-        hfdcan->ErrorCode = 0;
-        // LOGWARNING("[bsp_fdcan] FDCAN Bus Off recovered");
-    }
-    if (ErrorStatusITs & FDCAN_IR_EP)
-    {
-        // 错误被动状态处理，重新初始化FDCAN
-        // LOGWARNING("[bsp_fdcan] FDCAN Error Passive, reinitializing...");
-
-        if (hfdcan->Instance == FDCAN1)
-        {
-            MX_FDCAN1_Init();
-        }
-        else if (hfdcan->Instance == FDCAN2)
-        {
-            MX_FDCAN2_Init();
-        }
-        else if (hfdcan->Instance == FDCAN3)
-        {
-            MX_FDCAN3_Init();
-        }
-
-        // 重新配置并启动
-        HAL_FDCAN_Start(hfdcan);
-        HAL_FDCAN_ConfigGlobalFilter(hfdcan, FDCAN_REJECT, FDCAN_REJECT, FDCAN_FILTER_REMOTE, FDCAN_FILTER_REMOTE);
-
-        if (hfdcan == &hfdcan1)
-        {
-            HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_RX_FIFO0_NEW_MESSAGE, 0);
-        }
-        else
-        {
-            HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_RX_FIFO1_NEW_MESSAGE, 0);
-        }
-        HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_BUS_OFF, 0);
-
-        hfdcan->ErrorCode = 0;
-    }
+   CANFIFOxCallback(hcan, CAN_RX_FIFO0); // 调用我们自己写的函数来处理消息
 }
 
-// 弱定义的接收回调函数，用户可重写
-__weak void fdcan1_rx_callback(void)
+/**
+* @brief rx fifo callback. Once FIFO_1 is full,this func would be called
+*
+* @param hcan CAN handle indicate which device the oddest mesg in FIFO_1 comes from
+*/
+void HAL_CAN_RxFifo1MsgPendingCallback(CAN_HandleTypeDef *hcan)
 {
-    // 用户可重写
+   CANFIFOxCallback(hcan, CAN_RX_FIFO1); // 调用我们自己写的函数来处理消息
 }
 
-__weak void fdcan2_rx_callback(void)
-{
-    // 用户可重写
-}
 
-__weak void fdcan3_rx_callback(void)
-{
-    // 用户可重写
-}
+#endif
diff --git a/User_Code/bsp/fdcan/bsp_fdcan.h b/User_Code/bsp/fdcan/bsp_fdcan.h
index 00bc9ce..7ee5a74 100644
--- a/User_Code/bsp/fdcan/bsp_fdcan.h
+++ b/User_Code/bsp/fdcan/bsp_fdcan.h
@@ -1,93 +1,103 @@
-#ifndef __BSP_FDCAN_H__
-#define __BSP_FDCAN_H__
+#ifndef BSP_CAN_H
+#define BSP_CAN_H
+
+//在此选择CAN类型，两者只能选择一个！！！
+#define FDCAN //G系列和H7系列使用FDCAN
+//#define BXCAN //F系列使用BxCAN
+
+//CAN类型宏定义检查，有错误停止编译
+#if !defined(FDCAN) && !defined(BXCAN)
+    #error "Neither FDCAN nor BXCAN is defined. Please define one of them."
+#elif defined(FDCAN) && defined(BXCAN)
+    #error "Both FDCAN and BXCAN are defined. Please define only one."
+#endif
+
 
-#include "main.h"
-#include "fdcan.h"
 #include <stdint.h>
+#ifdef FDCAN
+#include "fdcan.h"
+#define hcan1  hfdcan1
+#define hcan2  hfdcan2
+#define hcan3  hfdcan3
 
-#define CAN_MX_REGISTER_CNT 16     // 最大FDCAN设备注册数量
-#define MX_CAN_FILTER_CNT (3 * 14) // 最多可以使用的CAN过滤器数量，支持3个CAN
-#define DEVICE_CAN_CNT 3           // FDCAN1, FDCAN2, FDCAN3
+#define CAN_MX_REGISTER_CNT 16     // 这个数量取决于CAN总线的负载
+#define MX_CAN_FILTER_CNT (3 * 14) // 最多可以使用的CAN过滤器数量,目前远不会用到这么多
+#define DEVICE_CAN_CNT 3           //H723VG有3个FDCAN
 
-#define CAN_CLASS   0
-#define CAN_FD_BRS  1
+#endif
+#ifdef BXCAN
+#include "can.h"
+// 最多能够支持的CAN设备数
+#define CAN_MX_REGISTER_CNT 16     // 这个数量取决于CAN总线的负载
+#define MX_CAN_FILTER_CNT (2 * 14) // 最多可以使用的CAN过滤器数量,目前远不会用到这么多
+#define DEVICE_CAN_CNT 2           // 根据板子设定,F407IG有CAN1,CAN2,因此为2;F334只有一个,则设为1
+// 如果只有1个CAN,还需要把bsp_can.c中所有的hcan2变量改为hcan1(别担心,主要是总线和FIFO的负载均衡,不影响功能)
+#endif
 
-#define CAN_BR_125K 0
-#define CAN_BR_200K 1
-#define CAN_BR_250K 2
-#define CAN_BR_500K 3
-#define CAN_BR_1M   4
-#define CAN_BR_2M   5
-#define CAN_BR_2M5  6
-#define CAN_BR_3M2  7
-#define CAN_BR_4M   8
-#define CAN_BR_5M   9
 
-/* FDCAN实例结构体，每个注册到FDCAN的模块都应该有这个变量 */
+
+/* can instance typedef, every module registered to CAN should have this variable */
 #pragma pack(1)
-typedef struct _FDCANInstance {
-    FDCAN_HandleTypeDef *can_handle; // FDCAN句柄
-    FDCAN_TxHeaderTypeDef txconf; // FDCAN报文发送配置
-    uint32_t tx_id; // 发送id
-    uint32_t tx_mailbox; // FDCAN消息填入的邮箱号
-    uint8_t tx_buff[64]; // 发送缓存，FDCAN最大支持64字节
-    uint8_t rx_buff[64]; // 接收缓存，FDCAN最大支持64字节
-    uint32_t rx_id; // 接收id
-    uint8_t rx_len; // 接收长度
-    // 接收的回调函数，用于解析接收到的数据
-    void (*can_module_callback)(struct _FDCANInstance *); // 回调函数需要实例来区分注册的设备
-    void *id; // 使用FDCAN外设的模块指针
+typedef struct _
+{
+#ifdef FDCAN
+    FDCAN_HandleTypeDef  *can_handle; // can句柄
+    FDCAN_TxHeaderTypeDef txconf;    // CAN报文发送配置
+#else
+    CAN_HandleTypeDef *can_handle; // can句柄
+    CAN_TxHeaderTypeDef txconf;    // CAN报文发送配置
+#endif
+    uint32_t tx_id;                // 发送id
+    uint32_t tx_mailbox;           // CAN消息填入的邮箱号
+    uint8_t tx_buff[8];            // 发送缓存,发送消息长度可以通过CANSetDLC()设定,最大为8
+    uint8_t rx_buff[8];            // 接收缓存,最大消息长度为8
+    uint32_t rx_id;                // 接收id
+    uint8_t rx_len;                // 接收长度,可能为0-8
+    // 接收的回调函数,用于解析接收到的数据
+    void (*can_module_callback)(struct _ *); // callback needs an instance to tell among registered ones
+    void *id;                                // 使用can外设的模块指针(即id指向的模块拥有此can实例,是父子关系)
 } FDCANInstance;
 #pragma pack()
 
-/* FDCAN实例初始化结构体，将此结构体指针传入注册函数 */
-typedef struct {
-    FDCAN_HandleTypeDef *can_handle; // FDCAN句柄
-    uint32_t tx_id; // 发送id
-    uint32_t rx_id; // 接收id
+/* CAN实例初始化结构体,将此结构体指针传入注册函数 */
+typedef struct
+{
+#ifdef FDCAN
+    FDCAN_HandleTypeDef  *can_handle;           // can句柄
+#else
+    CAN_HandleTypeDef *can_handle;              // can句柄
+#endif
+    uint32_t tx_id;                             // 发送id
+    uint32_t rx_id;                             // 接收id
     void (*can_module_callback)(FDCANInstance *); // 处理接收数据的回调函数
-    void *id; // 拥有FDCAN实例的模块地址
+    void *id;                                   // 拥有can实例的模块地址,用于区分不同的模块(如果有需要的话),如果不需要可以不传入
 } FDCAN_Init_Config_s;
 
 /**
- * @brief 注册一个模块到FDCAN服务，在使用FDCAN设备前调用
- * @param config 初始化配置
- * @return FDCANInstance* 模块拥有的FDCAN实例
+ * @brief Register a module to CAN service,remember to call this before using a CAN device
+ *        注册(初始化)一个can实例,需要传入初始化配置的指针.
+ * @param config init config
+ * @return CANInstance* can instance owned by module
  */
-FDCANInstance *FDCANRegister(FDCAN_Init_Config_s *config);
+FDCANInstance *CANRegister(FDCAN_Init_Config_s *config);
 
 /**
- * @brief 修改FDCAN发送报文的数据帧长度
- * @param _instance 要修改长度的FDCAN实例
- * @param length 设定长度，FDCAN最大支持64字节
+ * @brief 修改CAN发送报文的数据帧长度;注意最大长度为8,在没有进行修改的时候,默认长度为8
+ *
+ * @param _instance 要修改长度的can实例
+ * @param length    设定长度
  */
-void FDCANSetDLC(FDCANInstance *_instance, uint8_t length);
+void CANSetDLC(FDCANInstance *_instance, uint8_t length);
 
 /**
- * @brief 通过FDCAN实例发送消息
- *        发送前需要向FDCAN实例的tx_buff写入发送数据
+ * @brief transmit mesg through CAN device,通过can实例发送消息
+ *        发送前需要向CAN实例的tx_buff写入发送数据
  *
  * @attention 超时时间不应该超过调用此函数的任务的周期,否则会导致任务阻塞
  *
- * @param _instance 模块拥有的FDCAN实例
- * @param timeout 超时时间,单位为ms
- * @return uint8_t 发送成功返回1,失败返回0
+ * @param timeout 超时时间,单位为ms;后续改为us,获得更精确的控制
+ * @param _instance* can instance owned by module
  */
-uint8_t FDCANTransmit(FDCANInstance *_instance, float timeout);
+uint8_t CANTransmit(FDCANInstance *_instance,float timeout);
 
-/**
- * @brief 设置FDCAN波特率
- * @param hfdcan FDCAN句柄
- * @param mode CAN模式：CAN_CLASS或CAN_FD_BRS
- * @param baud 波特率选择
- */
-void bsp_fdcan_set_baud(FDCAN_HandleTypeDef *hfdcan, uint8_t mode, uint8_t baud);
-
-// 弱定义的接收回调函数，用户可重写
-__weak void fdcan1_rx_callback(void);
-
-__weak void fdcan2_rx_callback(void);
-
-__weak void fdcan3_rx_callback(void);
-
-#endif /* __BSP_FDCAN_H_ */
+#endif
diff --git a/User_Code/module/periph/servo/mg996/mg996.h b/User_Code/module/periph/servo/mg996/mg996.h
index 4ec536b..c83cf7a 100644
--- a/User_Code/module/periph/servo/mg996/mg996.h
+++ b/User_Code/module/periph/servo/mg996/mg996.h
@@ -18,9 +18,7 @@ extern "C"
 #endif
 
 #include <stdint.h>
-
-// 前向声明PWM实例结构体，与bsp_pwm.h中的类型保持一致
-typedef struct PWMInstance PWMInstance;
+#include "bsp_pwm.h"
 
 /**
  * @brief MG996舵机初始化配置结构体