infantry

2025-03-11 21:32:41 +08:00
parent 1480a30aa1
commit 740dc38e96
327 changed files with 252743 additions and 0 deletions
--- a/User/bsp/c/adc.c
+++ b/User/bsp/c/adc.c
@@ -0,0 +1,50 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\adc.h"
+
+#include <adc.h>
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+static volatile float volt_vrefint_proportion =
+    8.0586080586080586080586080586081e-4f;
+
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+float BSP_GetTemperature(void) {
+  ADC_ChannelConfTypeDef sConfig;
+
+  sConfig.Channel = ADC_CHANNEL_TEMPSENSOR;
+  sConfig.Rank = 1;
+  sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
+  sConfig.Offset = 0;
+
+  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) Error_Handler();
+
+  HAL_ADC_Start(&hadc1);
+  HAL_ADC_PollForConversion(&hadc1, 5u);
+  uint32_t raw = HAL_ADC_GetValue(&hadc1);
+  float temp = (float)raw * volt_vrefint_proportion;
+  return (temp - 0.76f) * 400.0f + 25.0f;
+}
+
+float BSP_GetBatteryVolt(void) {
+  ADC_ChannelConfTypeDef sConfig;
+
+  sConfig.Channel = ADC_CHANNEL_8;
+  sConfig.Rank = 1;
+  sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
+  sConfig.Offset = 0;
+
+  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK) Error_Handler();
+
+  HAL_ADC_Start(&hadc3);
+  HAL_ADC_PollForConversion(&hadc3, 5u);
+  uint32_t raw = HAL_ADC_GetValue(&hadc3);
+  float volt =
+      (float)raw * volt_vrefint_proportion * 10.090909090909090909090909090909f;
+
+  return volt;
+}
+uint8_t BSP_GetHardwareVersion(void) { return 1u; }
--- a/User/bsp/c/buzzer.c
+++ b/User/bsp/c/buzzer.c
@@ -0,0 +1,30 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\buzzer.h"
+
+#include <main.h>
+#include <tim.h>
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+int8_t BSP_Buzzer_Start(void) {
+  if (HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_3) == HAL_OK) return BSP_OK;
+  return BSP_ERR;
+}
+
+int8_t BSP_Buzzer_Set(float freq, float duty_cycle) {
+  uint16_t pulse = (uint16_t)(duty_cycle * (float)UINT16_MAX);
+  __HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_3, pulse);
+
+  pulse = (uint16_t)freq;
+  __HAL_TIM_PRESCALER(&htim4, pulse);
+  return BSP_OK;
+}
+
+int8_t BSP_Buzzer_Stop(void) {
+  if (HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_3) == HAL_OK) return BSP_OK;
+  return BSP_ERR;
+}
--- a/User/bsp/c/can.c
+++ b/User/bsp/c/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;
+}
--- a/User/bsp/c/crc32.c
+++ b/User/bsp/c/crc32.c
@@ -0,0 +1,26 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\crc32.h"
+
+#include <crc.h>
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+uint32_t BSP_CRC32_Calc(uint8_t *buf, size_t len) {
+  return HAL_CRC_Calculate(&hcrc, (uint32_t *)buf, len / sizeof(uint32_t));
+}
+
+bool BSP_CRC32_Verify(uint8_t *buf, size_t len) {
+  if (len < 2) return false;
+
+  uint32_t expected = BSP_CRC32_Calc(buf, len / sizeof(uint32_t) - 1);
+
+  return expected == ((uint32_t *)buf)[len / sizeof(uint32_t) - 1];
+}
+
+bool BSP_CRC32_Append(uint8_t *buf, size_t len) {
+  return HAL_CRC_Accumulate(&hcrc, (uint32_t *)buf, len / sizeof(uint32_t));
+}
--- a/User/bsp/c/delay.c
+++ b/User/bsp/c/delay.c
@@ -0,0 +1,34 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\delay.h"
+
+#include <cmsis_os2.h>
+#include <main.h>
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+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;
+}
--- a/User/bsp/c/flash.c
+++ b/User/bsp/c/flash.c
@@ -0,0 +1,51 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\flash.h"
+
+#include <main.h>
+#include <string.h>
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+
+void BSP_Flash_EraseSector(uint32_t sector) {
+  FLASH_EraseInitTypeDef flash_erase;
+  uint32_t sector_error;
+
+#ifdef DEV_BOARD_C
+  if (sector > 0 && sector < 12) {
+#elif
+  if (sector > 0 && sector < 24) {
+#endif
+    flash_erase.Sector = sector;
+    flash_erase.TypeErase = FLASH_TYPEERASE_SECTORS;
+    flash_erase.VoltageRange = FLASH_VOLTAGE_RANGE_3;
+    flash_erase.NbSectors = 1;
+
+    HAL_FLASH_Unlock();
+    while (FLASH_WaitForLastOperation(50) != HAL_OK)
+      ;
+    HAL_FLASHEx_Erase(&flash_erase, &sector_error);
+    HAL_FLASH_Lock();
+  }
+}
+
+void BSP_Flash_WriteBytes(uint32_t address, const uint8_t *buf, size_t len) {
+  HAL_FLASH_Unlock();
+  while (len > 0) {
+    while (FLASH_WaitForLastOperation(50) != HAL_OK)
+      ;
+    HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, address, *buf);
+    address++;
+    buf++;
+    len--;
+  }
+  HAL_FLASH_Lock();
+}
+
+void BSP_Flash_ReadBytes(uint32_t address, void *buf, size_t len) {
+  memcpy(buf, (void *)address, len);
+}
--- a/User/bsp/c/fric.c
+++ b/User/bsp/c/fric.c
@@ -0,0 +1,31 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\fric.h"
+
+#include <tim.h>
+
+#include "bsp\delay.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+int8_t BSP_Fric_Start(void) {
+  HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
+  BSP_Delay(500);
+  HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
+  return BSP_OK;
+}
+int8_t BSP_Fric_Set(float duty_cycle) {
+  uint16_t pulse = (uint16_t)(duty_cycle * (float)UINT16_MAX);
+  __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, pulse);
+  __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_4, pulse);
+  return BSP_OK;
+}
+
+int8_t BSP_Fric_Stop(void) {
+  HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
+  HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_4);
+  return BSP_OK;
+}
--- a/User/bsp/c/gpio.c
+++ b/User/bsp/c/gpio.c
@@ -0,0 +1,93 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\gpio.h"
+
+#include <gpio.h>
+#include <main.h>
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+static void (*GPIO_Callback[16])(void);
+
+/* Private function  -------------------------------------------------------- */
+void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
+  for (uint8_t i = 0; i < 16; i++) {
+    if (GPIO_Pin & (1 << i)) {
+      if (GPIO_Callback[i]) {
+        GPIO_Callback[i]();
+      }
+    }
+  }
+}
+
+/* Exported functions ------------------------------------------------------- */
+int8_t BSP_GPIO_RegisterCallback(uint16_t pin, void (*callback)(void)) {
+  if (callback == NULL) return BSP_ERR_NULL;
+
+  for (uint8_t i = 0; i < 16; i++) {
+    if (pin & (1 << i)) {
+      GPIO_Callback[i] = callback;
+      break;
+    }
+  }
+  return BSP_OK;
+}
+
+int8_t BSP_GPIO_EnableIRQ(uint16_t pin) {
+  switch (pin) {
+    case ACCL_INT_Pin:
+      HAL_NVIC_EnableIRQ(ACCL_INT_EXTI_IRQn);
+      break;
+
+    case GYRO_INT_Pin:
+      HAL_NVIC_EnableIRQ(GYRO_INT_EXTI_IRQn);
+      break;
+
+    case USER_KEY_Pin:
+      HAL_NVIC_EnableIRQ(USER_KEY_EXTI_IRQn);
+      break;
+
+    case CMPS_INT_Pin:
+      HAL_NVIC_EnableIRQ(CMPS_INT_EXTI_IRQn);
+      break;
+      /*
+      case XXX_Pin:
+              HAL_NVIC_EnableIRQ(XXX_IRQn);
+              break;
+      */
+
+    default:
+      return BSP_ERR;
+  }
+  return BSP_OK;
+}
+
+int8_t BSP_GPIO_DisableIRQ(uint16_t pin) {
+  switch (pin) {
+    case ACCL_INT_Pin:
+      HAL_NVIC_DisableIRQ(ACCL_INT_EXTI_IRQn);
+      break;
+
+    case GYRO_INT_Pin:
+      HAL_NVIC_DisableIRQ(GYRO_INT_EXTI_IRQn);
+      break;
+
+    case USER_KEY_Pin:
+      HAL_NVIC_DisableIRQ(USER_KEY_EXTI_IRQn);
+      break;
+
+    case CMPS_INT_Pin:
+      HAL_NVIC_DisableIRQ(CMPS_INT_EXTI_IRQn);
+      break;
+      /*
+      case XXX_Pin:
+              HAL_NVIC_EnableIRQ(XXX_IRQn);
+              break;
+      */
+
+    default:
+      return BSP_ERR;
+  }
+  return BSP_OK;
+}
--- a/User/bsp/c/i2c.c
+++ b/User/bsp/c/i2c.c
@@ -0,0 +1,112 @@
+/* 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 == I2C3) return BSP_I2C_COMP;
+  /*
+  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_COMP:
+      return &hi2c3;
+    /*
+    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;
+}
--- a/User/bsp/c/laser.c
+++ b/User/bsp/c/laser.c
@@ -0,0 +1,30 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\laser.h"
+
+#include <tim.h>
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+int8_t BSP_Laser_Start(void) {
+  HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_3);
+  return BSP_OK;
+}
+
+int8_t BSP_Laser_Set(float duty_cycle) {
+  if (duty_cycle > 1.0f) return BSP_ERR;
+
+  uint16_t pulse = (uint16_t)(duty_cycle * (float)UINT16_MAX);
+
+  __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_3, pulse);
+
+  return BSP_OK;
+}
+
+int8_t BSP_Laser_Stop(void) {
+  HAL_TIM_PWM_Stop(&htim3, TIM_CHANNEL_3);
+  return BSP_OK;
+}
--- a/User/bsp/c/led.c
+++ b/User/bsp/c/led.c
@@ -0,0 +1,61 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\led.h"
+
+#include <tim.h>
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+static uint32_t led_stats;
+
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+
+int8_t BSP_LED_Set(BSP_LED_Channel_t ch, BSP_LED_Status_t s, float duty_cycle) {
+  if (duty_cycle > 1.0f) return BSP_ERR;
+
+  uint32_t tim_ch;
+  uint16_t pulse = (uint16_t)(duty_cycle * (float)UINT16_MAX);
+
+  switch (ch) {
+    case BSP_LED_RED:
+      __HAL_TIM_SET_COMPARE(&htim5, TIM_CHANNEL_3, pulse);
+      tim_ch = TIM_CHANNEL_3;
+      break;
+
+    case BSP_LED_GRN:
+      __HAL_TIM_SET_COMPARE(&htim5, TIM_CHANNEL_2, pulse);
+      tim_ch = TIM_CHANNEL_2;
+      break;
+
+    case BSP_LED_BLU:
+      __HAL_TIM_SET_COMPARE(&htim5, TIM_CHANNEL_1, pulse);
+      tim_ch = TIM_CHANNEL_1;
+      break;
+  }
+
+  switch (s) {
+    case BSP_LED_ON:
+      HAL_TIM_PWM_Start(&htim5, tim_ch);
+      led_stats |= tim_ch;
+      break;
+
+    case BSP_LED_OFF:
+      HAL_TIM_PWM_Stop(&htim5, tim_ch);
+      led_stats &= ~tim_ch;
+      break;
+
+    case BSP_LED_TAGGLE:
+      if (led_stats & tim_ch) {
+        HAL_TIM_PWM_Stop(&htim5, tim_ch);
+        led_stats &= ~tim_ch;
+      } else {
+        HAL_TIM_PWM_Start(&htim5, tim_ch);
+        led_stats |= tim_ch;
+      }
+      break;
+  }
+
+  return BSP_OK;
+}
--- a/User/bsp/c/mm.c
+++ b/User/bsp/c/mm.c
@@ -0,0 +1,14 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\mm.h"
+
+#include "FreeRTOS.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+inline void *BSP_Malloc(size_t size) { return pvPortMalloc(size); }
+
+inline void BSP_Free(void *pv) { vPortFree(pv); }
--- a/User/bsp/c/pwm.c
+++ b/User/bsp/c/pwm.c
@@ -0,0 +1,67 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\pwm.h"
+
+#include <main.h>
+#include <tim.h>
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+int8_t BSP_PWM_Start(BSP_PWM_Channel_t ch) {
+  switch (ch) {
+    case BSP_PWM_IMU_HEAT:
+      HAL_TIM_PWM_Start(&htim10, TIM_CHANNEL_1);
+      break;
+    case BSP_PWM_SHOOT_SERVO:
+      HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
+      break;
+  }
+  return BSP_OK;
+}
+
+int8_t BSP_PWM_Set(BSP_PWM_Channel_t ch, float duty_cycle) {
+  if (duty_cycle > 1.0f) return BSP_ERR;
+  if (duty_cycle < 0.0f) duty_cycle = 0.f;
+
+  uint16_t pulse;
+
+  /* 通过PWM通道对应定时器重载值和给定占空比，计算PWM周期值 */
+  switch (ch) {
+    case BSP_PWM_IMU_HEAT:
+      pulse = (uint16_t)(duty_cycle * (float)__HAL_TIM_GET_AUTORELOAD(&htim10));
+      break;
+    case BSP_PWM_SHOOT_SERVO:
+      pulse = (uint16_t)(duty_cycle * (float)__HAL_TIM_GET_AUTORELOAD(&htim1));
+      break;
+  }
+
+  if (pulse > 0) {
+    switch (ch) {
+      case BSP_PWM_IMU_HEAT:
+        __HAL_TIM_SET_COMPARE(&htim10, TIM_CHANNEL_1, pulse);
+        break;
+      case BSP_PWM_SHOOT_SERVO:
+        __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, pulse);
+        break;
+    }
+  } else {
+    BSP_PWM_Stop(ch);
+  }
+  return BSP_OK;
+}
+
+int8_t BSP_PWM_Stop(BSP_PWM_Channel_t ch) {
+  switch (ch) {
+    case BSP_PWM_IMU_HEAT:
+      HAL_TIM_PWM_Stop(&htim10, TIM_CHANNEL_1);
+      break;
+    case BSP_PWM_SHOOT_SERVO:
+      HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
+      break;
+  }
+  HAL_GPIO_WritePin(IMU_HEAT_PWM_GPIO_Port, IMU_HEAT_PWM_Pin, GPIO_PIN_RESET);
+  return BSP_OK;
+}
--- a/User/bsp/c/rand.c
+++ b/User/bsp/c/rand.c
@@ -0,0 +1,11 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\rand.h"
+
+#include "rng.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
--- a/User/bsp/c/servo.c
+++ b/User/bsp/c/servo.c
@@ -0,0 +1,128 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\servo.h"
+
+#include <main.h>
+#include <tim.h>
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+static float range[BSP_SERVO_NUM];
+
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+int8_t BSP_Servo_Init(BSP_Servo_Channel_t ch, float max_angle) {
+  range[ch] = max_angle;
+
+  return BSP_OK;
+}
+
+int8_t BSP_Servo_Start(BSP_Servo_Channel_t ch) {
+  switch (ch) {
+    case BSP_SERVO_A:
+      HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
+      break;
+
+    case BSP_SERVO_B:
+      HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_2);
+      break;
+
+    case BSP_SERVO_C:
+      HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_3);
+      break;
+
+    case BSP_SERVO_D:
+      HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_4);
+      break;
+
+    case BSP_SERVO_E:
+      HAL_TIM_PWM_Start(&htim8, TIM_CHANNEL_1);
+      break;
+
+    case BSP_SERVO_F:
+      HAL_TIM_PWM_Start(&htim8, TIM_CHANNEL_2);
+      break;
+
+    case BSP_SERVO_G:
+      HAL_TIM_PWM_Start(&htim8, TIM_CHANNEL_3);
+
+    case BSP_SERVO_NUM:
+      break;
+  }
+  return BSP_OK;
+}
+
+int8_t BSP_Servo_Set(BSP_Servo_Channel_t ch, uint8_t angle) {
+  if (angle > 1.0f) return BSP_ERR;
+
+  uint16_t pulse = angle * UINT16_MAX;
+
+  switch (ch) {
+    case BSP_SERVO_A:
+      __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, pulse);
+      break;
+
+    case BSP_SERVO_B:
+      __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_2, pulse);
+      break;
+
+    case BSP_SERVO_C:
+      __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_3, pulse);
+      break;
+
+    case BSP_SERVO_D:
+      __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_4, pulse);
+      break;
+
+    case BSP_SERVO_E:
+      __HAL_TIM_SET_COMPARE(&htim8, TIM_CHANNEL_1, pulse);
+      break;
+
+    case BSP_SERVO_F:
+      __HAL_TIM_SET_COMPARE(&htim8, TIM_CHANNEL_2, pulse);
+      break;
+
+    case BSP_SERVO_G:
+      __HAL_TIM_SET_COMPARE(&htim8, TIM_CHANNEL_3, pulse);
+
+    case BSP_SERVO_NUM:
+      break;
+  }
+  return BSP_OK;
+}
+
+int8_t BSP_Servo_Stop(BSP_Servo_Channel_t ch) {
+  switch (ch) {
+    case BSP_SERVO_A:
+      HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
+      break;
+
+    case BSP_SERVO_B:
+      HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_2);
+      break;
+
+    case BSP_SERVO_C:
+      HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_3);
+      break;
+
+    case BSP_SERVO_D:
+      HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_4);
+      break;
+
+    case BSP_SERVO_E:
+      HAL_TIM_PWM_Stop(&htim8, TIM_CHANNEL_1);
+      break;
+
+    case BSP_SERVO_F:
+      HAL_TIM_PWM_Stop(&htim8, TIM_CHANNEL_2);
+      break;
+
+    case BSP_SERVO_G:
+      HAL_TIM_PWM_Stop(&htim8, TIM_CHANNEL_3);
+
+    case BSP_SERVO_NUM:
+      break;
+  }
+  return BSP_OK;
+}
--- a/User/bsp/c/spi.c
+++ b/User/bsp/c/spi.c
@@ -0,0 +1,110 @@
+/* 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_IMU;
+  else if (hspi->Instance == SPI2)
+    return BSP_SPI_OLED;
+  /*
+  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_OLED:
+      return &hspi2;
+    case BSP_SPI_IMU:
+      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;
+}
--- a/User/bsp/c/uart.c
+++ b/User/bsp/c/uart.c
@@ -0,0 +1,130 @@
+/* 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 == USART3)
+    return BSP_UART_DR16;
+  else if (huart->Instance == USART1)
+    return BSP_UART_REF;
+  else if (huart->Instance == USART6)
+    return BSP_UART_AI;
+  /*
+  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_DR16:
+      return &huart3;
+    case BSP_UART_REF:
+      return &huart1;
+    case BSP_UART_AI:
+      return &huart6;
+    /*
+    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;
+}
--- a/User/bsp/c/usb.c
+++ b/User/bsp/c/usb.c
@@ -0,0 +1,61 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp\usb.h"
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "bsp\delay.h"
+#include "usbd_cdc_if.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Must set to NULL explicitly. */
+osThreadId_t gbsp_usb_alert = NULL;
+uint8_t usb_rx_buf[BSP_USB_MAX_RX_LEN];
+uint8_t usb_tx_buf[BSP_USB_MAX_TX_LEN];
+
+/* Private function  -------------------------------------------------------- */
+static int8_t BSP_USB_Transmit(uint8_t *buffer, uint16_t len) {
+  uint8_t retry = 0;
+  do {
+    if (CDC_Transmit_FS(buffer, len) != USBD_OK) {
+      retry++;
+      BSP_Delay(10);
+    } else {
+      break;
+    }
+  } while (retry < 3);
+  return BSP_OK;
+}
+
+/* Exported functions ------------------------------------------------------- */
+int8_t BSP_USB_ReadyReceive(osThreadId_t alert) {
+  if (alert == NULL) return BSP_ERR_NULL;
+
+  gbsp_usb_alert = alert;
+  CDC_ReadyReceive();
+  return BSP_OK;
+}
+
+char BSP_USB_ReadChar(void) { return usb_rx_buf[0]; }
+
+int8_t BSP_USB_Printf(const char *fmt, ...) {
+  va_list ap;
+  uint16_t len = 0;
+
+  va_start(ap, fmt);
+  len =
+      (uint16_t)vsnprintf((char *)usb_tx_buf, BSP_USB_MAX_TX_LEN - 1, fmt, ap);
+  va_end(ap);
+
+  if (len > 0) {
+    BSP_USB_Transmit(usb_tx_buf, len);
+    return BSP_OK;
+  } else {
+    return BSP_ERR_NULL;
+  }
+}