重构完代码结构了

assets/User_code/bsp/bsp.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define BSP_OK (0)
+#define BSP_ERR (-1)
+#define BSP_ERR_NULL (-2)
+#define BSP_ERR_INITED (-3)
+#define BSP_ERR_NO_DEV (-4)
+
+#ifdef __cplusplus
+}
+#endif

assets/User_code/bsp/buzzer_gpio.c

@@ -0,0 +1,32 @@
+
+
+/* Includes ----------------------------------------------------------------- */
+#include <gpio.h>
+#include "bsp/bsp.h"
+#include "bsp/buzzer_gpio.h"
+/* Private define ----------------------------------------------------------- */
+#define BSP_BUZZER_GPIO GPIOA
+#define BSP_BUZZER_PIN GPIO_PIN_1
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function --------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+int8_t BSP_Buzzer_Set(BSP_Buzzer_Status_t s)
+{
+    switch (s)
+    {
+    case BSP_BUZZER_ON:
+        HAL_GPIO_WritePin(BSP_BUZZER_GPIO, BSP_BUZZER_PIN, GPIO_PIN_SET); // 打开蜂鸣器
+        break;
+    case BSP_BUZZER_OFF:
+        HAL_GPIO_WritePin(BSP_BUZZER_GPIO, BSP_BUZZER_PIN, GPIO_PIN_RESET); // 关闭蜂鸣器
+        break;
+    case BSP_BUZZER_TAGGLE:
+        HAL_GPIO_TogglePin(BSP_BUZZER_GPIO, BSP_BUZZER_PIN); // 切换蜂鸣器状态
+        break;
+    default:
+        return BSP_ERR;
+    }
+    return BSP_OK;
+}

assets/User_code/bsp/buzzer_gpio.h

@@ -0,0 +1,20 @@
+#pragma once
+
+/* Includes ----------------------------------------------------------------- */
+#include <stdint.h>
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+
+/* 设置BUZZER状态 */
+typedef enum
+{
+    BSP_BUZZER_ON,
+    BSP_BUZZER_OFF,
+    BSP_BUZZER_TAGGLE,
+} BSP_Buzzer_Status_t;
+
+/* Exported functions prototypes -------------------------------------------- */
+
+int8_t BSP_Buzzer_Set(BSP_Buzzer_Status_t s);

assets/User_code/bsp/can.c

@@ -0,0 +1,141 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\can.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+static void (*CAN_Callback[BSP_CAN_NUM][BSP_CAN_CB_NUM])(void);
+
+/* Private function  -------------------------------------------------------- */
+static BSP_CAN_t CAN_Get(CAN_HandleTypeDef *hcan) {
+  if (hcan->Instance == CAN2)
+    return BSP_CAN_2;
+  else if (hcan->Instance == CAN1)
+    return BSP_CAN_1;
+  else
+    return BSP_CAN_ERR;
+}
+
+void HAL_CAN_TxMailbox0CompleteCallback(CAN_HandleTypeDef *hcan) {
+  BSP_CAN_t bsp_can = CAN_Get(hcan);
+  if (bsp_can != BSP_CAN_ERR) {
+    if (CAN_Callback[bsp_can][HAL_CAN_TX_MAILBOX0_CPLT_CB])
+      CAN_Callback[bsp_can][HAL_CAN_TX_MAILBOX0_CPLT_CB]();
+  }
+}
+
+void HAL_CAN_TxMailbox1CompleteCallback(CAN_HandleTypeDef *hcan) {
+  BSP_CAN_t bsp_can = CAN_Get(hcan);
+  if (bsp_can != BSP_CAN_ERR) {
+    if (CAN_Callback[bsp_can][HAL_CAN_TX_MAILBOX1_CPLT_CB])
+      CAN_Callback[bsp_can][HAL_CAN_TX_MAILBOX1_CPLT_CB]();
+  }
+}
+
+void HAL_CAN_TxMailbox2CompleteCallback(CAN_HandleTypeDef *hcan) {
+  BSP_CAN_t bsp_can = CAN_Get(hcan);
+  if (bsp_can != BSP_CAN_ERR) {
+    if (CAN_Callback[bsp_can][HAL_CAN_TX_MAILBOX2_CPLT_CB])
+      CAN_Callback[bsp_can][HAL_CAN_TX_MAILBOX2_CPLT_CB]();
+  }
+}
+
+void HAL_CAN_TxMailbox0AbortCallback(CAN_HandleTypeDef *hcan) {
+  BSP_CAN_t bsp_can = CAN_Get(hcan);
+  if (bsp_can != BSP_CAN_ERR) {
+    if (CAN_Callback[bsp_can][HAL_CAN_TX_MAILBOX0_ABORT_CB])
+      CAN_Callback[bsp_can][HAL_CAN_TX_MAILBOX0_ABORT_CB]();
+  }
+}
+
+void HAL_CAN_TxMailbox1AbortCallback(CAN_HandleTypeDef *hcan) {
+  BSP_CAN_t bsp_can = CAN_Get(hcan);
+  if (bsp_can != BSP_CAN_ERR) {
+    if (CAN_Callback[bsp_can][HAL_CAN_TX_MAILBOX1_ABORT_CB])
+      CAN_Callback[bsp_can][HAL_CAN_TX_MAILBOX1_ABORT_CB]();
+  }
+}
+
+void HAL_CAN_TxMailbox2AbortCallback(CAN_HandleTypeDef *hcan) {
+  BSP_CAN_t bsp_can = CAN_Get(hcan);
+  if (bsp_can != BSP_CAN_ERR) {
+    if (CAN_Callback[bsp_can][HAL_CAN_TX_MAILBOX2_ABORT_CB])
+      CAN_Callback[bsp_can][HAL_CAN_TX_MAILBOX2_ABORT_CB]();
+  }
+}
+
+void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan) {
+  BSP_CAN_t bsp_can = CAN_Get(hcan);
+  if (bsp_can != BSP_CAN_ERR) {
+    if (CAN_Callback[bsp_can][HAL_CAN_RX_FIFO0_MSG_PENDING_CB])
+      CAN_Callback[bsp_can][HAL_CAN_RX_FIFO0_MSG_PENDING_CB]();
+  }
+}
+
+void HAL_CAN_RxFifo0FullCallback(CAN_HandleTypeDef *hcan) {
+  BSP_CAN_t bsp_can = CAN_Get(hcan);
+  if (bsp_can != BSP_CAN_ERR) {
+    if (CAN_Callback[bsp_can][HAL_CAN_RX_FIFO0_FULL_CB])
+      CAN_Callback[bsp_can][HAL_CAN_RX_FIFO0_FULL_CB]();
+  }
+}
+
+void HAL_CAN_RxFifo1MsgPendingCallback(CAN_HandleTypeDef *hcan) {
+  BSP_CAN_t bsp_can = CAN_Get(hcan);
+  if (bsp_can != BSP_CAN_ERR) {
+    if (CAN_Callback[bsp_can][HAL_CAN_RX_FIFO1_MSG_PENDING_CB])
+      CAN_Callback[bsp_can][HAL_CAN_RX_FIFO1_MSG_PENDING_CB]();
+  }
+}
+
+void HAL_CAN_RxFifo1FullCallback(CAN_HandleTypeDef *hcan) {
+  BSP_CAN_t bsp_can = CAN_Get(hcan);
+  if (bsp_can != BSP_CAN_ERR) {
+    if (CAN_Callback[bsp_can][HAL_CAN_RX_FIFO1_FULL_CB])
+      CAN_Callback[bsp_can][HAL_CAN_RX_FIFO1_FULL_CB]();
+  }
+}
+
+void HAL_CAN_SleepCallback(CAN_HandleTypeDef *hcan) {
+  BSP_CAN_t bsp_can = CAN_Get(hcan);
+  if (bsp_can != BSP_CAN_ERR) {
+    if (CAN_Callback[bsp_can][HAL_CAN_SLEEP_CB])
+      CAN_Callback[bsp_can][HAL_CAN_SLEEP_CB]();
+  }
+}
+
+void HAL_CAN_WakeUpFromRxMsgCallback(CAN_HandleTypeDef *hcan) {
+  BSP_CAN_t bsp_can = CAN_Get(hcan);
+  if (bsp_can != BSP_CAN_ERR) {
+    if (CAN_Callback[bsp_can][HAL_CAN_WAKEUP_FROM_RX_MSG_CB])
+      CAN_Callback[bsp_can][HAL_CAN_WAKEUP_FROM_RX_MSG_CB]();
+  }
+}
+
+void HAL_CAN_ErrorCallback(CAN_HandleTypeDef *hcan) {
+  BSP_CAN_t bsp_can = CAN_Get(hcan);
+  if (bsp_can != BSP_CAN_ERR) {
+    if (CAN_Callback[bsp_can][HAL_CAN_ERROR_CB])
+      CAN_Callback[bsp_can][HAL_CAN_ERROR_CB]();
+  }
+}
+
+/* Exported functions ------------------------------------------------------- */
+CAN_HandleTypeDef *BSP_CAN_GetHandle(BSP_CAN_t can) {
+  switch (can) {
+    case BSP_CAN_2:
+      return &hcan2;
+    case BSP_CAN_1:
+      return &hcan1;
+    default:
+      return NULL;
+  }
+}
+
+int8_t BSP_CAN_RegisterCallback(BSP_CAN_t can, BSP_CAN_Callback_t type,
+                                void (*callback)(void)) {
+  if (callback == NULL) return BSP_ERR_NULL;
+  CAN_Callback[can][type] = callback;
+  return BSP_OK;
+}

assets/User_code/bsp/can.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <can.h>
+
+#include "bsp/bsp.h"
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+typedef enum {
+  BSP_CAN_1,
+  BSP_CAN_2,
+  BSP_CAN_NUM,
+  BSP_CAN_ERR,
+} BSP_CAN_t;
+
+typedef enum {
+  HAL_CAN_TX_MAILBOX0_CPLT_CB,
+  HAL_CAN_TX_MAILBOX1_CPLT_CB,
+  HAL_CAN_TX_MAILBOX2_CPLT_CB,
+  HAL_CAN_TX_MAILBOX0_ABORT_CB,
+  HAL_CAN_TX_MAILBOX1_ABORT_CB,
+  HAL_CAN_TX_MAILBOX2_ABORT_CB,
+  HAL_CAN_RX_FIFO0_MSG_PENDING_CB,
+  HAL_CAN_RX_FIFO0_FULL_CB,
+  HAL_CAN_RX_FIFO1_MSG_PENDING_CB,
+  HAL_CAN_RX_FIFO1_FULL_CB,
+  HAL_CAN_SLEEP_CB,
+  HAL_CAN_WAKEUP_FROM_RX_MSG_CB,
+  HAL_CAN_ERROR_CB,
+  BSP_CAN_CB_NUM
+} BSP_CAN_Callback_t;
+
+/* Exported functions prototypes -------------------------------------------- */
+CAN_HandleTypeDef *BSP_CAN_GetHandle(BSP_CAN_t can);
+int8_t BSP_CAN_RegisterCallback(BSP_CAN_t can, BSP_CAN_Callback_t type,
+                                void (*callback)(void));
+
+#ifdef __cplusplus
+}
+#endif

assets/User_code/bsp/delay.c

@@ -0,0 +1,118 @@
+#include "bsp_delay.h"
+
+#include "cmsis_os.h"
+#include "main.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+static uint8_t fac_us = 0;
+static uint32_t fac_ms = 0;
+/* Private function  -------------------------------------------------------- */
+static void delay_ticks(uint32_t ticks)
+{
+    uint32_t told = SysTick->VAL;
+    uint32_t tnow = 0;
+    uint32_t tcnt = 0;
+    uint32_t reload = SysTick->LOAD;
+    while (1)
+    {
+        tnow = SysTick->VAL;
+        if (tnow != told)
+        {
+            if (tnow < told)
+            {
+                tcnt += told - tnow;
+            }
+            else
+            {
+                tcnt += reload - tnow + told;
+            }
+            told = tnow;
+            if (tcnt >= ticks)
+            {
+                break;
+            }
+        }
+    }
+}
+/* Exported functions ------------------------------------------------------- */
+
+/**
+ * @brief 毫秒延时函数
+ * @param ms
+ * @return
+ */
+int8_t BSP_Delay(uint32_t ms)
+{
+    uint32_t tick_period = 1000u / osKernelGetTickFreq();
+    uint32_t ticks = ms / tick_period;
+
+    switch (osKernelGetState())
+    {
+    case osKernelError:
+    case osKernelReserved:
+    case osKernelLocked:
+    case osKernelSuspended:
+        return BSP_ERR;
+
+    case osKernelRunning:
+        osDelay(ticks ? ticks : 1);
+        break;
+
+    case osKernelInactive:
+    case osKernelReady:
+        HAL_Delay(ms);
+        break;
+    }
+    return BSP_OK;
+}
+
+/**
+ * @brief 延时初始化
+ * @param  
+ * @return 
+ */
+int8_t BSP_Delay_Init(void)
+{
+    if (SystemCoreClock == 0)
+    {
+        return BSP_ERR;
+    }
+    fac_us = SystemCoreClock / 1000000;
+    fac_ms = SystemCoreClock / 1000;
+    return BSP_OK;
+}
+
+/**
+ * @brief 微秒延时，注意：此函数会阻塞当前线程，直到延时结束，并且会被中断打断
+ * @param us 
+ * @return 
+ */
+int8_t BSP_Delay_us(uint32_t us)
+{
+    if (fac_us == 0)
+    {
+        return BSP_ERR;
+    }
+    uint32_t ticks = us * fac_us;
+    delay_ticks(ticks);
+    return BSP_OK;
+}
+
+/**
+ * @brief 毫秒延时，注意：此函数会阻塞当前线程，直到延时结束，并且会被中断打断
+ * @param ms 
+ * @return 
+ */
+int8_t BSP_Delay_ms(uint32_t ms)
+{
+    if (fac_ms == 0)
+    {
+        return BSP_ERR;
+    }
+    uint32_t ticks = ms * fac_ms;
+    delay_ticks(ticks);
+    return BSP_OK;
+}

assets/User_code/bsp/delay.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <stdint.h>
+
+#include "bsp/bsp.h"
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+/* Exported functions prototypes -------------------------------------------- */
+int8_t BSP_Delay(uint32_t ms);
+
+int8_t BSP_Delay_Init(void);
+int8_t BSP_Delay_us(uint32_t us);
+int8_t BSP_Delay_ms(uint32_t ms);
+
+#ifdef __cplusplus
+}
+#endif

assets/User_code/bsp/dependencies.csv

@@ -0,0 +1,2 @@
+i2c,I2C
+uart,USART,UART

assets/User_code/bsp/describe.csv

@@ -0,0 +1,2 @@
+uart,要求开启dma和中断
+can,要求开启can的中断

assets/User_code/bsp/gpio_exti.c

@@ -0,0 +1,72 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\gpio.h"
+
+#include <gpio.h>
+#include <main.h>
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+static void (*GPIO_Callback[BSP_GPIO_NUM][BSP_GPIO_CB_NUM])(void);
+
+/* Private function  -------------------------------------------------------- */
+static BSP_GPIO_t GPIO_Get(uint16_t pin) {
+  switch (pin) {
+    case USER_KEY_Pin:
+      return BSP_GPIO_USER_KEY;
+    /* case XXX_Pin:
+      return BSP_GPIO_XXX; */
+    default:
+      return BSP_GPIO_ERR;
+  }
+}
+
+void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
+  BSP_GPIO_t gpio = GPIO_Get(GPIO_Pin);
+  if (gpio != BSP_GPIO_ERR) {
+    if (GPIO_Callback[gpio][BSP_GPIO_EXTI_CB]) {
+      GPIO_Callback[gpio][BSP_GPIO_EXTI_CB]();
+    }
+  }
+}
+
+/* Exported functions ------------------------------------------------------- */
+int8_t BSP_GPIO_RegisterCallback(BSP_GPIO_t gpio, BSP_GPIO_Callback_t type, void (*callback)(void)) {
+  if (callback == NULL || gpio >= BSP_GPIO_NUM || type >= BSP_GPIO_CB_NUM) return BSP_ERR_NULL;
+
+  GPIO_Callback[gpio][type] = callback;
+  return BSP_OK;
+}
+
+int8_t BSP_GPIO_EnableIRQ(BSP_GPIO_t gpio) {
+  switch (gpio) {
+    case BSP_GPIO_USER_KEY:
+      HAL_NVIC_EnableIRQ(USER_KEY_EXTI_IRQn);
+      break;
+
+    /* case BSP_GPIO_XXX:
+      HAL_NVIC_EnableIRQ(XXX_IRQn);
+      break; */
+
+    default:
+      return BSP_ERR;
+  }
+  return BSP_OK;
+}
+
+int8_t BSP_GPIO_DisableIRQ(BSP_GPIO_t gpio) {
+  switch (gpio) {
+    case BSP_GPIO_USER_KEY:
+      HAL_NVIC_DisableIRQ(USER_KEY_EXTI_IRQn);
+      break;
+
+    /* case BSP_GPIO_XXX:
+      HAL_NVIC_DisableIRQ(XXX_IRQn);
+      break; */
+
+    default:
+      return BSP_ERR;
+  }
+  return BSP_OK;
+}

assets/User_code/bsp/gpio_exti.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <stdint.h>
+
+#include "bsp/bsp.h"
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+
+/* GPIO设备枚举，与设备对应 */
+typedef enum {
+  BSP_GPIO_USER_KEY,
+  /* BSP_GPIO_XXX, */
+  BSP_GPIO_NUM,
+  BSP_GPIO_ERR,
+} BSP_GPIO_t;
+
+/* GPIO支持的中断回调函数类型 */
+typedef enum {
+  BSP_GPIO_EXTI_CB,
+  BSP_GPIO_CB_NUM,
+} BSP_GPIO_Callback_t;
+
+/* Exported functions prototypes -------------------------------------------- */
+int8_t BSP_GPIO_RegisterCallback(BSP_GPIO_t gpio, BSP_GPIO_Callback_t type, void (*callback)(void));
+int8_t BSP_GPIO_EnableIRQ(BSP_GPIO_t gpio);
+int8_t BSP_GPIO_DisableIRQ(BSP_GPIO_t gpio);
+
+#ifdef __cplusplus
+}
+#endif

assets/User_code/bsp/i2c.c

@@ -0,0 +1,109 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\i2c.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+static void (*I2C_Callback[BSP_I2C_NUM][BSP_I2C_CB_NUM])(void);
+
+/* Private function  -------------------------------------------------------- */
+static BSP_I2C_t I2C_Get(I2C_HandleTypeDef *hi2c) {
+  if (hi2c->Instance == I2C1) 
+    return BSP_I2C_EXAMPLE;
+  // else if (hi2c->Instance == I2CX)
+  //   return BSP_I2C_XXX;
+  else
+    return BSP_I2C_ERR;
+}
+
+void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c) {
+  BSP_I2C_t bsp_i2c = I2C_Get(hi2c);
+  if (bsp_i2c != BSP_I2C_ERR) {
+    if (I2C_Callback[bsp_i2c][HAL_I2C_MASTER_TX_CPLT_CB])
+      I2C_Callback[bsp_i2c][HAL_I2C_MASTER_TX_CPLT_CB]();
+  }
+}
+
+void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c) {
+  BSP_I2C_t bsp_i2c = I2C_Get(hi2c);
+  if (bsp_i2c != BSP_I2C_ERR) {
+    if (I2C_Callback[bsp_i2c][HAL_I2C_MASTER_RX_CPLT_CB])
+      I2C_Callback[bsp_i2c][HAL_I2C_MASTER_RX_CPLT_CB]();
+  }
+}
+
+void HAL_I2C_SlaveTxCpltCallback(I2C_HandleTypeDef *hi2c) {
+  BSP_I2C_t bsp_i2c = I2C_Get(hi2c);
+  if (bsp_i2c != BSP_I2C_ERR) {
+    if (I2C_Callback[bsp_i2c][HAL_I2C_SLAVE_TX_CPLT_CB])
+      I2C_Callback[bsp_i2c][HAL_I2C_SLAVE_TX_CPLT_CB]();
+  }
+}
+
+void HAL_I2C_SlaveRxCpltCallback(I2C_HandleTypeDef *hi2c) {
+  BSP_I2C_t bsp_i2c = I2C_Get(hi2c);
+  if (bsp_i2c != BSP_I2C_ERR) {
+    if (I2C_Callback[bsp_i2c][HAL_I2C_SLAVE_RX_CPLT_CB])
+      I2C_Callback[bsp_i2c][HAL_I2C_SLAVE_RX_CPLT_CB]();
+  }
+}
+
+void HAL_I2C_ListenCpltCallback(I2C_HandleTypeDef *hi2c) {
+  BSP_I2C_t bsp_i2c = I2C_Get(hi2c);
+  if (bsp_i2c != BSP_I2C_ERR) {
+    if (I2C_Callback[bsp_i2c][HAL_I2C_LISTEN_CPLT_CB])
+      I2C_Callback[bsp_i2c][HAL_I2C_LISTEN_CPLT_CB]();
+  }
+}
+
+void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef *hi2c) {
+  BSP_I2C_t bsp_i2c = I2C_Get(hi2c);
+  if (bsp_i2c != BSP_I2C_ERR) {
+    if (I2C_Callback[bsp_i2c][HAL_I2C_MEM_TX_CPLT_CB])
+      I2C_Callback[bsp_i2c][HAL_I2C_MEM_TX_CPLT_CB]();
+  }
+}
+
+void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c) {
+  BSP_I2C_t bsp_i2c = I2C_Get(hi2c);
+  if (bsp_i2c != BSP_I2C_ERR) {
+    if (I2C_Callback[bsp_i2c][HAL_I2C_MEM_RX_CPLT_CB])
+      I2C_Callback[bsp_i2c][HAL_I2C_MEM_RX_CPLT_CB]();
+  }
+}
+
+void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c) {
+  BSP_I2C_t bsp_i2c = I2C_Get(hi2c);
+  if (bsp_i2c != BSP_I2C_ERR) {
+    if (I2C_Callback[bsp_i2c][HAL_I2C_ERROR_CB])
+      I2C_Callback[bsp_i2c][HAL_I2C_ERROR_CB]();
+  }
+}
+
+void HAL_I2C_AbortCpltCallback(I2C_HandleTypeDef *hi2c) {
+  BSP_I2C_t bsp_i2c = I2C_Get(hi2c);
+  if (bsp_i2c != BSP_I2C_ERR) {
+    if (I2C_Callback[bsp_i2c][HAL_I2C_ABORT_CPLT_CB])
+      I2C_Callback[bsp_i2c][HAL_I2C_ABORT_CPLT_CB]();
+  }
+}
+
+/* Exported functions ------------------------------------------------------- */
+I2C_HandleTypeDef *BSP_I2C_GetHandle(BSP_I2C_t i2c) {
+  switch (i2c) {
+    case BSP_I2C_EXAMPLE:
+      return &hi2c1;
+    // case BSP_I2C_XXX:
+    //         return &hi2cX;
+    default:
+      return NULL;
+  }
+}
+
+int8_t BSP_I2C_RegisterCallback(BSP_I2C_t i2c, BSP_I2C_Callback_t type,
+                                void (*callback)(void)) {
+  if (callback == NULL) return BSP_ERR_NULL;
+  I2C_Callback[i2c][type] = callback;
+  return BSP_OK;
+}

assets/User_code/bsp/i2c.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <i2c.h>
+
+#include "bsp/bsp.h"
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+
+/* 要添加使用I2C的新设备，需要先在此添加对应的枚举值 */
+
+/* I2C实体枚举，与设备对应 */
+typedef enum {
+  BSP_I2C_EXAMPLE,
+  /* BSP_I2C_XXX,*/
+  BSP_I2C_NUM,
+  BSP_I2C_ERR,
+} BSP_I2C_t;
+
+/* I2C支持的中断回调函数类型*/
+typedef enum {
+  HAL_I2C_MASTER_TX_CPLT_CB,
+  HAL_I2C_MASTER_RX_CPLT_CB,
+  HAL_I2C_SLAVE_TX_CPLT_CB,
+  HAL_I2C_SLAVE_RX_CPLT_CB,
+  HAL_I2C_LISTEN_CPLT_CB,
+  HAL_I2C_MEM_TX_CPLT_CB,
+  HAL_I2C_MEM_RX_CPLT_CB,
+  HAL_I2C_ERROR_CB,
+  HAL_I2C_ABORT_CPLT_CB,
+  BSP_I2C_CB_NUM,
+} BSP_I2C_Callback_t;
+
+/* Exported functions prototypes -------------------------------------------- */
+I2C_HandleTypeDef *BSP_I2C_GetHandle(BSP_I2C_t i2c);
+int8_t BSP_I2C_RegisterCallback(BSP_I2C_t i2c, BSP_I2C_Callback_t type,
+                                void (*callback)(void));
+
+#ifdef __cplusplus
+}
+#endif

assets/User_code/bsp/led_gpio.c

@@ -0,0 +1,50 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp/led_gpio.h"
+#include "bsp/bsp.h"
+#include <gpio.h>
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+
+/* Private variables -------------------------------------------------------- */
+static uint32_t led_stats; // 使用位掩码记录每个通道的状态，最多支持32LED
+
+// 定义 LED 引脚和端口映射表：需要根据自己的修改，添加，或删减。
+static const BSP_LED_Config_t LED_CONFIGS[] = {
+    {GPIOA, GPIO_PIN_2}, // BSP_LED_1
+    {GPIOA, GPIO_PIN_3}, // BSP_LED_2
+    {GPIOA, GPIO_PIN_4}, // BSP_LED_3
+};
+
+#define LED_CHANNEL_COUNT (sizeof(LED_CONFIGS) / sizeof(LED_CONFIGS[0])) // 通道数量
+
+/* Private function --------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+int8_t BSP_LED_Set(BSP_LED_Channel_t ch, BSP_LED_Status_t s)
+{
+    if (ch < LED_CHANNEL_COUNT)
+    {
+        GPIO_TypeDef *port = LED_CONFIGS[ch].port;
+        uint16_t pin = LED_CONFIGS[ch].pin;
+        switch (s)
+        {
+        case BSP_LED_ON:
+            led_stats |= (1 << ch);
+            HAL_GPIO_WritePin(port, pin, GPIO_PIN_SET); // 点亮LED
+            break;
+        case BSP_LED_OFF:
+            led_stats &= ~(1 << ch);
+            HAL_GPIO_WritePin(port, pin, GPIO_PIN_RESET); // 熄灭LED
+            break;
+        case BSP_LED_TAGGLE:
+            led_stats ^= (1 << ch);
+            HAL_GPIO_TogglePin(port, pin); // 切换LED状态
+            break;
+        default:
+            return BSP_ERR;
+        }
+        return BSP_OK;
+    }
+    return BSP_ERR;
+}

assets/User_code/bsp/led_gpio.h

@@ -0,0 +1,36 @@
+#pragma once
+
+/* Includes ----------------------------------------------------------------- */
+#include <stdint.h>
+#include "gpio.h"
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+
+/* LED灯状态，设置用 */
+typedef enum
+{
+    BSP_LED_ON,
+    BSP_LED_OFF,
+    BSP_LED_TAGGLE,
+} BSP_LED_Status_t;
+
+/* LED通道 */
+typedef enum
+{
+    BSP_LED_1,
+    BSP_LED_2,
+    BSP_LED_3,
+    /*BSP_LED_XXX*/
+} BSP_LED_Channel_t;
+
+/* LED GPIO 配置 */
+typedef struct
+{
+    GPIO_TypeDef *port; // GPIO 端口 (如 GPIOA, GPIOB)
+    uint16_t pin;       // GPIO 引脚
+} BSP_LED_Config_t;
+
+/* Exported functions prototypes -------------------------------------------- */
+
+int8_t BSP_LED_Set(BSP_LED_Channel_t ch, BSP_LED_Status_t s);

assets/User_code/bsp/servo_pwm.c

@@ -0,0 +1,48 @@
+/* Includes ----------------------------------------------------------------- */
+#include "servo_pwm.h"
+
+#include "main.h"
+
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+
+int8_t BSP_PWM_Start(BSP_PWM_Channel_t ch) {
+  
+  TIM_HandleTypeDef* htim = pwm_channel_config[ch].htim;
+  uint32_t channel = pwm_channel_config[ch].channel;
+
+  if(HAL_TIM_PWM_Start(htim, channel)!=HAL_OK){
+	return -1;
+  }else return 0;
+}
+
+int8_t BSP_PWM_Set(BSP_PWM_Channel_t ch, float duty_cycle) {
+  if (duty_cycle > 1.0f) return -1;
+
+  uint16_t pulse = duty_cycle/CYCLE * PWM_RESOLUTION;
+
+  if(__HAL_TIM_SET_COMPARE(pwm_channel_config[ch].htim, pwm_channel_config[ch].channel, pulse)!=HAL_OK){
+	return -1;
+  }else return 0;
+}
+
+int8_t BSP_PWM_Stop(BSP_PWM_Channel_t ch){
+
+  TIM_HandleTypeDef* htim = pwm_channel_config[ch].htim;
+  uint32_t channel = pwm_channel_config[ch].channel;
+
+  if(HAL_TIM_PWM_Stop(htim, channel)!=HAL_OK){
+	return -1;
+  }else return 0;
+
+
+};
+
+
+
+

assets/User_code/bsp/servo_pwm.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <stdint.h>
+#include "tim.h"
+#include "bsp/bsp.h"
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+typedef struct {
+  TIM_HandleTypeDef* htim; // 定时器句柄
+  uint32_t channel;        // 定时器通道
+} PWM_Channel_Config_t;
+
+#define PWM_RESOLUTION 1000 // ARR                                      change begin
+#define CYCLE 20 //ms
+
+typedef enum {				
+  BSP_PWM_SERVO = 0,      
+  BSP_PWM_IMU_HEAT = 1,   
+} BSP_PWM_Channel_t;
+
+const PWM_Channel_Config_t pwm_channel_config[] = {		
+  [BSP_PWM_SERVO] = { &htim1, TIM_CHANNEL_1 },  // xxx 对应 TIMx 通道x
+  [BSP_PWM_IMU_HEAT] = { &htim1, TIM_CHANNEL_2 } 
+};																	  //change end
+
+/* Exported functions prototypes -------------------------------------------- */
+int8_t BSP_PWM_Start(BSP_PWM_Channel_t ch);
+int8_t BSP_PWM_Set(BSP_PWM_Channel_t ch, float duty_cycle);
+int8_t BSP_PWM_Stop(BSP_PWM_Channel_t ch);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+
+

assets/User_code/bsp/spi.c

@@ -0,0 +1,106 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\spi.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+static void (*SPI_Callback[BSP_SPI_NUM][BSP_SPI_CB_NUM])(void);
+
+/* Private function  -------------------------------------------------------- */
+static BSP_SPI_t SPI_Get(SPI_HandleTypeDef *hspi) {
+  if (hspi->Instance == SPI1)
+    return BSP_SPI_EXAMPLE;
+  /*
+  else if (hspi->Instance == SPIX)
+                  return BSP_SPI_XXX;
+  */
+  else
+    return BSP_SPI_ERR;
+}
+
+void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) {
+  BSP_SPI_t bsp_spi = SPI_Get(hspi);
+  if (bsp_spi != BSP_SPI_ERR) {
+    if (SPI_Callback[bsp_spi][BSP_SPI_TX_CPLT_CB]) {
+      SPI_Callback[bsp_spi][BSP_SPI_TX_CPLT_CB]();
+    }
+  }
+}
+
+void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi) {
+  BSP_SPI_t bsp_spi = SPI_Get(hspi);
+  if (bsp_spi != BSP_SPI_ERR) {
+    if (SPI_Callback[SPI_Get(hspi)][BSP_SPI_RX_CPLT_CB])
+      SPI_Callback[SPI_Get(hspi)][BSP_SPI_RX_CPLT_CB]();
+  }
+}
+
+void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) {
+  BSP_SPI_t bsp_spi = SPI_Get(hspi);
+  if (bsp_spi != BSP_SPI_ERR) {
+    if (SPI_Callback[SPI_Get(hspi)][BSP_SPI_TX_RX_CPLT_CB])
+      SPI_Callback[SPI_Get(hspi)][BSP_SPI_TX_RX_CPLT_CB]();
+  }
+}
+
+void HAL_SPI_TxHalfCpltCallback(SPI_HandleTypeDef *hspi) {
+  BSP_SPI_t bsp_spi = SPI_Get(hspi);
+  if (bsp_spi != BSP_SPI_ERR) {
+    if (SPI_Callback[SPI_Get(hspi)][BSP_SPI_TX_HALF_CPLT_CB])
+      SPI_Callback[SPI_Get(hspi)][BSP_SPI_TX_HALF_CPLT_CB]();
+  }
+}
+
+void HAL_SPI_RxHalfCpltCallback(SPI_HandleTypeDef *hspi) {
+  BSP_SPI_t bsp_spi = SPI_Get(hspi);
+  if (bsp_spi != BSP_SPI_ERR) {
+    if (SPI_Callback[SPI_Get(hspi)][BSP_SPI_RX_HALF_CPLT_CB])
+      SPI_Callback[SPI_Get(hspi)][BSP_SPI_RX_HALF_CPLT_CB]();
+  }
+}
+
+void HAL_SPI_TxRxHalfCpltCallback(SPI_HandleTypeDef *hspi) {
+  BSP_SPI_t bsp_spi = SPI_Get(hspi);
+  if (bsp_spi != BSP_SPI_ERR) {
+    if (SPI_Callback[SPI_Get(hspi)][BSP_SPI_TX_RX_HALF_CPLT_CB])
+      SPI_Callback[SPI_Get(hspi)][BSP_SPI_TX_RX_HALF_CPLT_CB]();
+  }
+}
+
+void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi) {
+  BSP_SPI_t bsp_spi = SPI_Get(hspi);
+  if (bsp_spi != BSP_SPI_ERR) {
+    if (SPI_Callback[SPI_Get(hspi)][BSP_SPI_ERROR_CB])
+      SPI_Callback[SPI_Get(hspi)][BSP_SPI_ERROR_CB]();
+  }
+}
+
+void HAL_SPI_AbortCpltCallback(SPI_HandleTypeDef *hspi) {
+  BSP_SPI_t bsp_spi = SPI_Get(hspi);
+  if (bsp_spi != BSP_SPI_ERR) {
+    if (SPI_Callback[SPI_Get(hspi)][BSP_SPI_ABORT_CPLT_CB])
+      SPI_Callback[SPI_Get(hspi)][BSP_SPI_ABORT_CPLT_CB]();
+  }
+}
+
+/* Exported functions ------------------------------------------------------- */
+SPI_HandleTypeDef *BSP_SPI_GetHandle(BSP_SPI_t spi) {
+  switch (spi) {
+    case BSP_SPI_EXAMPLE:
+      return &hspi1;
+    /*
+    case BSP_SPI_XXX:
+            return &hspiX;
+    */
+    default:
+      return NULL;
+  }
+}
+
+int8_t BSP_SPI_RegisterCallback(BSP_SPI_t spi, BSP_SPI_Callback_t type,
+                                void (*callback)(void)) {
+  if (callback == NULL) return BSP_ERR_NULL;
+  SPI_Callback[spi][type] = callback;
+  return BSP_OK;
+}

assets/User_code/bsp/spi.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <spi.h>
+
+#include "bsp/bsp.h"
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+
+/* 要添加使用SPI的新设备，需要先在此添加对应的枚举值 */
+
+/* SPI实体枚举，与设备对应 */
+typedef enum {
+  BSP_SPI_EXAMPLE,
+  /* BSP_SPI_XXX,*/
+  BSP_SPI_NUM,
+  BSP_SPI_ERR,
+} BSP_SPI_t;
+
+/* SPI支持的中断回调函数类型，具体参考HAL中定义 */
+typedef enum {
+  BSP_SPI_TX_CPLT_CB,
+  BSP_SPI_RX_CPLT_CB,
+  BSP_SPI_TX_RX_CPLT_CB,
+  BSP_SPI_TX_HALF_CPLT_CB,
+  BSP_SPI_RX_HALF_CPLT_CB,
+  BSP_SPI_TX_RX_HALF_CPLT_CB,
+  BSP_SPI_ERROR_CB,
+  BSP_SPI_ABORT_CPLT_CB,
+  BSP_SPI_CB_NUM,
+} BSP_SPI_Callback_t;
+
+/* Exported functions prototypes -------------------------------------------- */
+SPI_HandleTypeDef *BSP_SPI_GetHandle(BSP_SPI_t spi);
+int8_t BSP_SPI_RegisterCallback(BSP_SPI_t spi, BSP_SPI_Callback_t type,
+                                void (*callback)(void));
+
+#ifdef __cplusplus
+}
+#endif

assets/User_code/bsp/uart.c

@@ -0,0 +1,118 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\uart.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+static void (*UART_Callback[BSP_UART_NUM][BSP_UART_CB_NUM])(void);
+
+/* Private function  -------------------------------------------------------- */
+static BSP_UART_t UART_Get(UART_HandleTypeDef *huart) {
+  if (huart->Instance == USART1)
+    return BSP_UART_EXAMPLE;
+  // else if (huart->Instance == USARTX)
+  //   return BSP_UART_XXX;
+  else
+    return BSP_UART_ERR;
+}
+
+void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
+  BSP_UART_t bsp_uart = UART_Get(huart);
+  if (bsp_uart != BSP_UART_ERR) {
+    if (UART_Callback[bsp_uart][BSP_UART_TX_CPLT_CB]) {
+      UART_Callback[bsp_uart][BSP_UART_TX_CPLT_CB]();
+    }
+  }
+}
+
+void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart) {
+  BSP_UART_t bsp_uart = UART_Get(huart);
+  if (bsp_uart != BSP_UART_ERR) {
+    if (UART_Callback[bsp_uart][BSP_UART_TX_HALF_CPLT_CB]) {
+      UART_Callback[bsp_uart][BSP_UART_TX_HALF_CPLT_CB]();
+    }
+  }
+}
+
+void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
+  BSP_UART_t bsp_uart = UART_Get(huart);
+  if (bsp_uart != BSP_UART_ERR) {
+    if (UART_Callback[bsp_uart][BSP_UART_RX_CPLT_CB]) {
+      UART_Callback[bsp_uart][BSP_UART_RX_CPLT_CB]();
+    }
+  }
+}
+
+void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart) {
+  BSP_UART_t bsp_uart = UART_Get(huart);
+  if (bsp_uart != BSP_UART_ERR) {
+    if (UART_Callback[bsp_uart][BSP_UART_RX_HALF_CPLT_CB]) {
+      UART_Callback[bsp_uart][BSP_UART_RX_HALF_CPLT_CB]();
+    }
+  }
+}
+
+void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) {
+  BSP_UART_t bsp_uart = UART_Get(huart);
+  if (bsp_uart != BSP_UART_ERR) {
+    if (UART_Callback[bsp_uart][BSP_UART_ERROR_CB]) {
+      UART_Callback[bsp_uart][BSP_UART_ERROR_CB]();
+    }
+  }
+}
+
+void HAL_UART_AbortCpltCallback(UART_HandleTypeDef *huart) {
+  BSP_UART_t bsp_uart = UART_Get(huart);
+  if (bsp_uart != BSP_UART_ERR) {
+    if (UART_Callback[bsp_uart][BSP_UART_ABORT_CPLT_CB]) {
+      UART_Callback[bsp_uart][BSP_UART_ABORT_CPLT_CB]();
+    }
+  }
+}
+
+void HAL_UART_AbortTransmitCpltCallback(UART_HandleTypeDef *huart) {
+  BSP_UART_t bsp_uart = UART_Get(huart);
+  if (bsp_uart != BSP_UART_ERR) {
+    if (UART_Callback[bsp_uart][BSP_UART_ABORT_TX_CPLT_CB]) {
+      UART_Callback[bsp_uart][BSP_UART_ABORT_TX_CPLT_CB]();
+    }
+  }
+}
+
+void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart) {
+  BSP_UART_t bsp_uart = UART_Get(huart);
+  if (bsp_uart != BSP_UART_ERR) {
+    if (UART_Callback[bsp_uart][BSP_UART_ABORT_RX_CPLT_CB]) {
+      UART_Callback[bsp_uart][BSP_UART_ABORT_RX_CPLT_CB]();
+    }
+  }
+}
+
+/* Exported functions ------------------------------------------------------- */
+void BSP_UART_IRQHandler(UART_HandleTypeDef *huart) {
+  if (__HAL_UART_GET_FLAG(huart, UART_FLAG_IDLE)) {
+    __HAL_UART_CLEAR_IDLEFLAG(huart);
+    if (UART_Callback[UART_Get(huart)][BSP_UART_IDLE_LINE_CB]) {
+      UART_Callback[UART_Get(huart)][BSP_UART_IDLE_LINE_CB]();
+    }
+  }
+}
+
+UART_HandleTypeDef *BSP_UART_GetHandle(BSP_UART_t uart) {
+  switch (uart) {
+    case BSP_UART_EXAMPLE:
+      return &huart1;
+    // case BSP_UART_XXX:
+    //   return &huartX;
+    default:
+      return NULL;
+  }
+}
+
+int8_t BSP_UART_RegisterCallback(BSP_UART_t uart, BSP_UART_Callback_t type,
+                                 void (*callback)(void)) {
+  if (callback == NULL) return BSP_ERR_NULL;
+  UART_Callback[uart][type] = callback;
+  return BSP_OK;
+}

assets/User_code/bsp/uart.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <usart.h>
+
+#include "bsp/bsp.h"
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+
+/* 要添加使用UART的新设备，需要先在此添加对应的枚举值 */
+
+/* UART实体枚举，与设备对应 */
+typedef enum {
+  BSP_UART_EXAMPLE,
+  /*BSP_UART_XXX*/
+  BSP_UART_NUM,
+  BSP_UART_ERR,
+} BSP_UART_t;
+
+/* UART支持的中断回调函数类型，具体参考HAL中定义 */
+typedef enum {
+  BSP_UART_TX_HALF_CPLT_CB,
+  BSP_UART_TX_CPLT_CB,
+  BSP_UART_RX_HALF_CPLT_CB,
+  BSP_UART_RX_CPLT_CB,
+  BSP_UART_ERROR_CB,
+  BSP_UART_ABORT_CPLT_CB,
+  BSP_UART_ABORT_TX_CPLT_CB,
+  BSP_UART_ABORT_RX_CPLT_CB,
+
+  BSP_UART_IDLE_LINE_CB,
+  BSP_UART_CB_NUM,
+} BSP_UART_Callback_t;
+
+/* Exported functions prototypes -------------------------------------------- */
+UART_HandleTypeDef *BSP_UART_GetHandle(BSP_UART_t uart);
+int8_t BSP_UART_RegisterCallback(BSP_UART_t uart, BSP_UART_Callback_t type,
+                                 void (*callback)(void));
+
+#ifdef __cplusplus
+}
+#endif