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/a/bsp_adc.c
+++ b/User/bsp/a/bsp_adc.c
@@ -0,0 +1,14 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_adc.h"
+
+#include "adc.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+float BSP_GetTemprater(void) { return 0.0f; }
+float BSP_GetBatteryVolt(void) { return 0.0f; }
+uint8_t BSP_GetHardwareVersion(void) { return 1u; }
--- a/User/bsp/a/bsp_buzzer.c
+++ b/User/bsp/a/bsp_buzzer.c
@@ -0,0 +1,23 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_buzzer.h"
+
+#include "main.h"
+#include "tim.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+uint8_t BSP_Buzzer_Start(void) { return HAL_TIM_PWM_Start(&htim12, TIM_CHANNEL_4); }
+
+uint8_t BSP_Buzzer_Set(float freq, float duty_cycle) {
+  uint16_t pulse = freq * PWM_RESOLUTION;
+  __HAL_TIM_SET_COMPARE(&htim12, TIM_CHANNEL_4, pulse);
+
+  pulse = duty_cycle * PWM_RESOLUTION;
+  __HAL_TIM_PRESCALER(&htim12, pulse);
+  return 0;
+}
+uint8_t BSP_Buzzer_Stop(void) { return HAL_TIM_PWM_Stop(&htim12, TIM_CHANNEL_4); }
--- a/User/bsp/a/bsp_crc32.c
+++ b/User/bsp/a/bsp_crc32.c
@@ -0,0 +1,10 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_crc.h"
+#include "crc.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
--- a/User/bsp/a/bsp_delay.c
+++ b/User/bsp/a/bsp_delay.c
@@ -0,0 +1,20 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_delay.h"
+
+#include "cmsis_os.h"
+#include "main.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+uint8_t BSP_Delay(uint32_t ms) {
+  if (osKernelRunning()) {
+    osDelay(ms);
+  } else {
+    HAL_Delay(ms);
+  }
+  return 0;
+}
--- a/User/bsp/a/bsp_flash.c
+++ b/User/bsp/a/bsp_flash.c
@@ -0,0 +1,11 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_flash.h"
+
+#include "main.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
--- a/User/bsp/a/bsp_fric.c
+++ b/User/bsp/a/bsp_fric.c
@@ -0,0 +1,27 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_fric.h"
+
+#include "bsp_delay.h"
+#include "tim.h"
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+uint8_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 0;
+}
+uint8_t BSP_Fric_Set(float duty_cycle) {
+  uint16_t pulse = duty_cycle * PWM_RESOLUTION;
+  __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, pulse);
+  __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_4, pulse);
+}
+
+uint8_t BSP_Fric_Stop(void) {
+  HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
+  HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_4);
+}
--- a/User/bsp/a/bsp_laser.c
+++ b/User/bsp/a/bsp_laser.c
@@ -0,0 +1,20 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_laser.h"
+
+#include "gpio.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+uint8_t Laser_On(void) {
+  HAL_GPIO_WritePin(LASER_GPIO_Port, LASER_Pin, GPIO_PIN_SET);
+  return 0;
+}
+
+uint8_t Laser_Off(void) {
+  HAL_GPIO_WritePin(LASER_GPIO_Port, LASER_Pin, GPIO_PIN_RESET);
+  return 0;
+}
--- a/User/bsp/a/bsp_led.c
+++ b/User/bsp/a/bsp_led.c
@@ -0,0 +1,84 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_led.h"
+
+#include "gpio.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+
+uint8_t BSP_LED_Set(BSP_LED_Channel_t ch, BSP_LED_Status_t s, int16_t duty_cycle) {
+  GPIO_TypeDef *gpiox;
+  uint16_t gpio_pin;
+
+  switch (ch) {
+    case BSP_LED1:
+      gpio_pin = LED1_Pin;
+      gpiox = LED1_GPIO_Port;
+      break;
+
+    case BSP_LED2:
+      gpio_pin = LED2_Pin;
+      gpiox = LED2_GPIO_Port;
+      break;
+
+    case BSP_LED3:
+      gpio_pin = LED3_Pin;
+      gpiox = LED3_GPIO_Port;
+      break;
+
+    case BSP_LED4:
+      gpio_pin = LED4_Pin;
+      gpiox = LED4_GPIO_Port;
+      break;
+
+    case BSP_LED5:
+      gpio_pin = LED5_Pin;
+      gpiox = LED5_GPIO_Port;
+      break;
+
+    case BSP_LED6:
+      gpio_pin = LED6_Pin;
+      gpiox = LED6_GPIO_Port;
+      break;
+
+    case BSP_LED7:
+      gpio_pin = LED7_Pin;
+      gpiox = LED7_GPIO_Port;
+      break;
+
+    case BSP_LED8:
+      gpio_pin = LED8_Pin;
+      gpiox = LED8_GPIO_Port;
+      break;
+
+    case BSP_LED_RED:
+      gpiox = LED_R_GPIO_Port;
+      gpio_pin = LED_R_Pin;
+      break;
+
+    case BSP_LED_GRN:
+      gpiox = LED_G_GPIO_Port;
+      gpio_pin = LED_G_Pin;
+      break;
+  }
+
+  switch (s) {
+    case BSP_LED_ON:
+      HAL_GPIO_WritePin(gpiox, gpio_pin, GPIO_PIN_RESET);
+      break;
+
+    case BSP_LED_OFF:
+      HAL_GPIO_WritePin(gpiox, gpio_pin, GPIO_PIN_SET);
+      break;
+
+    case BSP_LED_TAGGLE:
+      HAL_GPIO_TogglePin(gpiox, gpio_pin);
+      break;
+  }
+
+  return 0;
+}
--- a/User/bsp/a/bsp_power.c
+++ b/User/bsp/a/bsp_power.c
@@ -0,0 +1,52 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_power.h"
+
+#include "gpio.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+uint8_t Power_On(BSP_Power_Port_t port) {
+  switch (port) {
+    case POWER_PORT1:
+      HAL_GPIO_WritePin(POWER1_CTRL_GPIO_Port, POWER1_CTRL_Pin, GPIO_PIN_RESET);
+      break;
+
+    case POWER_PORT2:
+      HAL_GPIO_WritePin(POWER2_CTRL_GPIO_Port, POWER2_CTRL_Pin, GPIO_PIN_RESET);
+      break;
+
+    case POWER_PORT3:
+      HAL_GPIO_WritePin(POWER3_CTRL_GPIO_Port, POWER3_CTRL_Pin, GPIO_PIN_RESET);
+      break;
+
+    case POWER_PORT4:
+      HAL_GPIO_WritePin(POWER4_CTRL_GPIO_Port, POWER4_CTRL_Pin, GPIO_PIN_RESET);
+      break;
+  }
+  return 0;
+}
+
+uint8_t Power_Off(BSP_Power_Port_t port) {
+  switch (port) {
+    case POWER_PORT1:
+      HAL_GPIO_WritePin(POWER1_CTRL_GPIO_Port, POWER1_CTRL_Pin, GPIO_PIN_SET);
+      break;
+
+    case POWER_PORT2:
+      HAL_GPIO_WritePin(POWER2_CTRL_GPIO_Port, POWER2_CTRL_Pin, GPIO_PIN_SET);
+      break;
+
+    case POWER_PORT3:
+      HAL_GPIO_WritePin(POWER3_CTRL_GPIO_Port, POWER3_CTRL_Pin, GPIO_PIN_SET);
+      break;
+
+    case POWER_PORT4:
+      HAL_GPIO_WritePin(POWER4_CTRL_GPIO_Port, POWER4_CTRL_Pin, GPIO_PIN_SET);
+      break;
+  }
+  return 0;
+}
--- a/User/bsp/a/bsp_pwm.c
+++ b/User/bsp/a/bsp_pwm.c
@@ -0,0 +1,37 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_pwm.h"
+
+#include "main.h"
+#include "tim.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+uint8_t BSP_PWM_Start(BSP_PWM_Channel_t ch) {
+  switch (ch) {
+    case BSP_PWM_IMU_HEAT:
+      HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_2);
+      break;
+  }
+  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 * PWM_RESOLUTION;
+
+  switch (ch) {
+    case BSP_PWM_IMU_HEAT:
+      __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_2, pulse);
+      break;
+    default:
+      return -1;
+  }
+  return 0;
+}
+
+uint8_t BSP_PWM_Stop(BSP_PWM_Channel_t ch);
--- a/User/bsp/a/bsp_rand.c
+++ b/User/bsp/a/bsp_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/a/bsp_servo.c
+++ b/User/bsp/a/bsp_servo.c
@@ -0,0 +1,11 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_servo.h"
+
+#include "tim.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
--- a/User/bsp/a/bsp_spi.c
+++ b/User/bsp/a/bsp_spi.c
@@ -0,0 +1,295 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_spi.h"
+
+#include "main.h"
+#include "spi.h"
+
+/* Private define ----------------------------------------------------------- */
+#define OLED_SPI SPI1
+#define IMU_SPI SPI5
+/* #define XXX_SPI SPIX */
+
+/* Private macro ------------------------------------------------------------ */
+#define IMU_SPI_NSS_Reset() \
+  HAL_GPIO_WritePin(SPI5_NSS_GPIO_Port, SPI5_NSS_Pin, GPIO_PIN_RESET)
+#define IMU_SPI_NSS_Set() \
+  HAL_GPIO_WritePin(SPI5_NSS_GPIO_Port, SPI5_NSS_Pin, GPIO_PIN_SET)
+
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+static struct {
+  struct {
+    void (*TxCpltCallback)(void);       /* SPI Tx Completed callback */
+    void (*RxCpltCallback)(void);       /* SPI Rx Completed callback */
+    void (*TxRxCpltCallback)(void);     /* SPI TxRx Completed callback */
+    void (*TxHalfCpltCallback)(void);   /* SPI Tx Half Completed callback */
+    void (*RxHalfCpltCallback)(void);   /* SPI Rx Half Completed callback */
+    void (*TxRxHalfCpltCallback)(void); /* SPI TxRx Half Completed callback */
+    void (*ErrorCallback)(void);        /* SPI Error callback */
+    void (*AbortCpltCallback)(void);    /* SPI Abort callback */
+  } oled;
+
+  struct {
+    void (*TxCpltCallback)(void);       /* SPI Tx Completed callback */
+    void (*RxCpltCallback)(void);       /* SPI Rx Completed callback */
+    void (*TxRxCpltCallback)(void);     /* SPI TxRx Completed callback */
+    void (*TxHalfCpltCallback)(void);   /* SPI Tx Half Completed callback */
+    void (*RxHalfCpltCallback)(void);   /* SPI Rx Half Completed callback */
+    void (*TxRxHalfCpltCallback)(void); /* SPI TxRx Half Completed callback */
+    void (*ErrorCallback)(void);        /* SPI Error callback */
+    void (*AbortCpltCallback)(void);    /* SPI Abort callback */
+  } imu;
+} bsp_spi_callback;
+
+/* Private function  -------------------------------------------------------- */
+void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) {
+  if (hspi->Instance == OLED_SPI) {
+    if (bsp_spi_callback.oled.TxCpltCallback != NULL) {
+      bsp_spi_callback.oled.TxCpltCallback();
+    }
+  } else if (hspi->Instance == IMU_SPI) {
+    IMU_SPI_NSS_Set();
+    if (bsp_spi_callback.imu.TxCpltCallback != NULL) {
+      bsp_spi_callback.imu.TxCpltCallback();
+    }
+  }
+}
+
+void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi) {
+  if (hspi->Instance == OLED_SPI) {
+    if (bsp_spi_callback.oled.RxCpltCallback != NULL) {
+      bsp_spi_callback.oled.RxCpltCallback();
+    }
+  } else if (hspi->Instance == IMU_SPI) {
+    IMU_SPI_NSS_Set();
+    if (bsp_spi_callback.imu.RxCpltCallback != NULL) {
+      bsp_spi_callback.imu.RxCpltCallback();
+    }
+  }
+}
+
+void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) {
+  if (hspi->Instance == OLED_SPI) {
+    if (bsp_spi_callback.oled.TxRxCpltCallback != NULL) {
+      bsp_spi_callback.oled.TxRxCpltCallback();
+    }
+  } else if (hspi->Instance == IMU_SPI) {
+    if (bsp_spi_callback.imu.TxRxCpltCallback != NULL) {
+      bsp_spi_callback.imu.TxRxCpltCallback();
+    }
+  }
+}
+
+void HAL_SPI_TxHalfCpltCallback(SPI_HandleTypeDef *hspi) {
+  if (hspi->Instance == OLED_SPI) {
+    if (bsp_spi_callback.oled.TxHalfCpltCallback != NULL) {
+      bsp_spi_callback.oled.TxHalfCpltCallback();
+    }
+  } else if (hspi->Instance == IMU_SPI) {
+    if (bsp_spi_callback.imu.TxHalfCpltCallback != NULL) {
+      bsp_spi_callback.imu.TxHalfCpltCallback();
+    }
+  }
+}
+
+void HAL_SPI_RxHalfCpltCallback(SPI_HandleTypeDef *hspi) {
+  if (hspi->Instance == OLED_SPI) {
+    if (bsp_spi_callback.oled.RxHalfCpltCallback != NULL) {
+      bsp_spi_callback.oled.RxHalfCpltCallback();
+    }
+  } else if (hspi->Instance == IMU_SPI) {
+    if (bsp_spi_callback.imu.RxHalfCpltCallback != NULL) {
+      bsp_spi_callback.imu.RxHalfCpltCallback();
+    }
+  }
+}
+
+void HAL_SPI_TxRxHalfCpltCallback(SPI_HandleTypeDef *hspi) {
+  if (hspi->Instance == OLED_SPI) {
+    if (bsp_spi_callback.oled.TxRxHalfCpltCallback != NULL) {
+      bsp_spi_callback.oled.TxRxHalfCpltCallback();
+    }
+  } else if (hspi->Instance == IMU_SPI) {
+    if (bsp_spi_callback.imu.TxRxHalfCpltCallback != NULL) {
+      bsp_spi_callback.imu.TxRxHalfCpltCallback();
+    }
+  }
+}
+
+void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi) {
+  if (hspi->Instance == OLED_SPI) {
+    if (bsp_spi_callback.oled.ErrorCallback != NULL) {
+      bsp_spi_callback.oled.ErrorCallback();
+    }
+  } else if (hspi->Instance == IMU_SPI) {
+    if (bsp_spi_callback.imu.ErrorCallback != NULL) {
+      bsp_spi_callback.imu.ErrorCallback();
+    }
+  }
+}
+
+void HAL_SPI_AbortCpltCallback(SPI_HandleTypeDef *hspi) {
+  if (hspi->Instance == OLED_SPI) {
+    if (bsp_spi_callback.oled.AbortCpltCallback != NULL) {
+      bsp_spi_callback.oled.AbortCpltCallback();
+    }
+  } else if (hspi->Instance == IMU_SPI) {
+    if (bsp_spi_callback.imu.AbortCpltCallback != NULL) {
+      bsp_spi_callback.imu.AbortCpltCallback();
+    }
+  }
+  /*
+  else if (hspi->Instance == XXX_SPI) {
+          if (bsp_spi_callback.xxx.AbortCpltCallback != NULL) {
+                  bsp_spi_callback.xxx.AbortCpltCallback();
+          }
+  }
+  */
+}
+
+/* Exported functions ------------------------------------------------------- */
+int8_t BSP_SPI_RegisterCallback(BSP_SPI_t spi, BSP_SPI_Callback_t type,
+                             void (*callback)(void)) {
+  if (callback == NULL) return -1;
+
+  switch (spi) {
+    case BSP_SPI_IMU:
+      switch (type) {
+        case BSP_SPI_TX_COMPLETE_CB:
+          bsp_spi_callback.imu.TxCpltCallback = callback;
+          break;
+        case BSP_SPI_RX_COMPLETE_CB:
+          bsp_spi_callback.imu.RxCpltCallback = callback;
+          break;
+        case BSP_SPI_TX_RX_COMPLETE_CB:
+          bsp_spi_callback.imu.TxRxCpltCallback = callback;
+          break;
+        case BSP_SPI_TX_HALF_COMPLETE_CB:
+          bsp_spi_callback.imu.TxHalfCpltCallback = callback;
+          break;
+        case BSP_SPI_RX_HALF_COMPLETE_CB:
+          bsp_spi_callback.imu.RxHalfCpltCallback = callback;
+          break;
+        case BSP_SPI_TX_RX_HALF_COMPLETE_CB:
+          bsp_spi_callback.imu.TxRxHalfCpltCallback = callback;
+          break;
+        case BSP_SPI_ERROR_CB:
+          bsp_spi_callback.imu.ErrorCallback = callback;
+          break;
+        case BSP_SPI_ABORT_CB:
+          bsp_spi_callback.imu.AbortCpltCallback = callback;
+          break;
+        default:
+          return -1;
+      }
+      break;
+
+    case BSP_SPI_OLED:
+      switch (type) {
+        case BSP_SPI_TX_COMPLETE_CB:
+          bsp_spi_callback.oled.TxCpltCallback = callback;
+          break;
+        case BSP_SPI_RX_COMPLETE_CB:
+          bsp_spi_callback.oled.RxCpltCallback = callback;
+          break;
+        case BSP_SPI_TX_RX_COMPLETE_CB:
+          bsp_spi_callback.oled.TxRxCpltCallback = callback;
+          break;
+        case BSP_SPI_TX_HALF_COMPLETE_CB:
+          bsp_spi_callback.oled.TxHalfCpltCallback = callback;
+          break;
+        case BSP_SPI_RX_HALF_COMPLETE_CB:
+          bsp_spi_callback.oled.RxHalfCpltCallback = callback;
+          break;
+        case BSP_SPI_TX_RX_HALF_COMPLETE_CB:
+          bsp_spi_callback.oled.TxRxHalfCpltCallback = callback;
+          break;
+        case BSP_SPI_ERROR_CB:
+          bsp_spi_callback.oled.ErrorCallback = callback;
+          break;
+        case BSP_SPI_ABORT_CB:
+          bsp_spi_callback.oled.AbortCpltCallback = callback;
+          break;
+        default:
+          return -1;
+      }
+      break;
+      /*
+      case BSP_SPI_XXX:
+              switch (type) {
+                      case BSP_SPI_TX_COMPLETE_CB:
+                              bsp_spi_callback.xxx.TxCpltCallback = callback;
+                              break;
+                      case BSP_SPI_RX_COMPLETE_CB:
+                              bsp_spi_callback.xxx.RxCpltCallback = callback;
+                              break;
+                      case BSP_SPI_TX_RX_COMPLETE_CB:
+                              bsp_spi_callback.xxx.TxRxCpltCallback = callback;
+                              break;
+                      case BSP_SPI_TX_HALF_COMPLETE_CB:
+                              bsp_spi_callback.xxx.TxHalfCpltCallback =
+      callback; break; case BSP_SPI_RX_HALF_COMPLETE_CB:
+                              bsp_spi_callback.xxx.RxHalfCpltCallback =
+      callback; break; case BSP_SPI_TX_RX_HALF_COMPLETE_CB:
+                              bsp_spi_callback.xxx.TxRxHalfCpltCallback =
+      callback; break; case BSP_SPI_ERROR_CB: bsp_spi_callback.xxx.ErrorCallback
+      = callback; break; case BSP_SPI_ABORT_CB:
+                              bsp_spi_callback.xxx.AbortCpltCallback = callback;
+                              break;
+                      default:
+                              return -1;
+              }
+              break;
+              */
+  }
+  return 0;
+}
+
+int8_t BSP_SPI_Transmit(BSP_SPI_t spi, uint8_t *data, uint16_t len) {
+  if (data == NULL) return -1;
+
+  switch (spi) {
+    case BSP_SPI_IMU:
+      /* Do NOT use hardware NSS. It doesn't implement the same logic. */
+      IMU_SPI_NSS_Reset();
+      HAL_SPI_Transmit(&hspi5, data, len, 55);
+      break;
+
+    case BSP_SPI_OLED:
+      HAL_SPI_Transmit(&hspi1, data, len, 55);
+      // HAL_SPI_Transmit_DMA(&hspi1, data, len);
+      break;
+
+      /*
+      case BSP_SPI_XXX:
+              HAL_SPI_Transmit_DMA(&hspix, data, len);
+              break;
+      */
+  }
+  return 0;
+}
+
+int8_t BSP_SPI_Receive(BSP_SPI_t spi, uint8_t *data, uint16_t len) {
+  if (data == NULL) return -1;
+
+  switch (spi) {
+    case BSP_SPI_IMU:
+      IMU_SPI_NSS_Reset();
+      if (len > 1u) {
+        HAL_SPI_Receive_DMA(&hspi5, data, len);
+      } else {
+        HAL_SPI_Receive(&hspi5, data, len, 55);
+      }
+      break;
+
+    case BSP_SPI_OLED:
+      return -1;
+
+      /*
+      case BSP_SPI_XXX:
+              HAL_SPI_Receive(&hspix, data, len);
+              break;
+      */
+  }
+  return 0;
+}
--- a/User/bsp/a/bsp_uart.c
+++ b/User/bsp/a/bsp_uart.c
@@ -0,0 +1,198 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_uart.h"
+
+#include "usart.h"
+
+/* Private define ----------------------------------------------------------- */
+#define DR16_UART USART1
+/* #define XXX_UART USARTX */
+
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+static struct {
+  struct {
+    void (*TxHalfCpltCallback)(void); /* UART Tx Half Complete Callback */
+    void (*TxCpltCallback)(void);     /* UART Tx Complete Callback */
+    void (*RxHalfCpltCallback)(void); /* UART Rx Half Complete Callback */
+    void (*RxCpltCallback)(void);     /* UART Rx Complete Callback */
+    void (*ErrorCallback)(void);      /* UART Error Callback */
+    void (*AbortCpltCallback)(void);  /* UART Abort Complete Callback */
+    void (*AbortTransmitCpltCallback)(
+        void); /* UART Abort Transmit Complete Callback */
+    void (*AbortReceiveCpltCallback)(
+        void); /* UART Abort Receive Complete Callback  */
+  } dr16;
+  /* Add other uart device here. */
+} bsp_uart_callback;
+
+/* Private function  -------------------------------------------------------- */
+void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
+  if (huart->Instance == DR16_UART) {
+    if (bsp_uart_callback.dr16.TxCpltCallback != NULL) {
+      bsp_uart_callback.dr16.TxCpltCallback();
+    }
+  }
+}
+
+void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart) {
+  if (huart->Instance == DR16_UART) {
+    if (bsp_uart_callback.dr16.TxHalfCpltCallback != NULL) {
+      bsp_uart_callback.dr16.TxHalfCpltCallback();
+    }
+  }
+}
+
+void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
+  if (huart->Instance == DR16_UART) {
+    if (bsp_uart_callback.dr16.RxCpltCallback != NULL) {
+      bsp_uart_callback.dr16.RxCpltCallback();
+    }
+  }
+}
+
+void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart) {
+  if (huart->Instance == DR16_UART) {
+    if (bsp_uart_callback.dr16.RxHalfCpltCallback != NULL) {
+      bsp_uart_callback.dr16.RxHalfCpltCallback();
+    }
+  }
+}
+
+void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) {
+  if (huart->Instance == DR16_UART) {
+    if (bsp_uart_callback.dr16.ErrorCallback != NULL) {
+      bsp_uart_callback.dr16.ErrorCallback();
+    }
+  }
+}
+
+void HAL_UART_AbortCpltCallback(UART_HandleTypeDef *huart) {
+  if (huart->Instance == DR16_UART) {
+    if (bsp_uart_callback.dr16.AbortCpltCallback != NULL) {
+      bsp_uart_callback.dr16.AbortCpltCallback();
+    }
+  }
+}
+
+void HAL_UART_AbortTransmitCpltCallback(UART_HandleTypeDef *huart) {
+  if (huart->Instance == DR16_UART) {
+    if (bsp_uart_callback.dr16.AbortTransmitCpltCallback != NULL) {
+      bsp_uart_callback.dr16.AbortTransmitCpltCallback();
+    }
+  }
+}
+
+void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart) {
+  if (huart->Instance == DR16_UART) {
+    if (bsp_uart_callback.dr16.AbortReceiveCpltCallback != NULL) {
+      bsp_uart_callback.dr16.AbortReceiveCpltCallback();
+    }
+  }
+  /*
+  else if (hspi->Instance == XXX_UART) {
+          if (bsp_uart_callback.xxx.AbortReceiveCpltCallback != NULL) {
+                  bsp_uart_callback.xxx.AbortReceiveCpltCallback();
+          }
+  }
+  */
+}
+
+/* Exported functions ------------------------------------------------------- */
+int8_t BSP_UART_RegisterCallback(BSP_UART_t uart, BSP_UART_Callback_t type,
+                              void (*callback)(void)) {
+  if (callback == NULL) return -1;
+
+  switch (uart) {
+    case BSP_UART_DR16:
+      switch (type) {
+        case BSP_UART_TX_HALFCOMPLETE_CB:
+          bsp_uart_callback.dr16.TxHalfCpltCallback = callback;
+          break;
+        case BSP_UART_TX_COMPLETE_CB:
+          bsp_uart_callback.dr16.TxCpltCallback = callback;
+          break;
+        case BSP_UART_RX_HALFCOMPLETE_CB:
+          bsp_uart_callback.dr16.RxHalfCpltCallback = callback;
+          break;
+        case BSP_UART_RX_COMPLETE_CB:
+          bsp_uart_callback.dr16.RxCpltCallback = callback;
+          break;
+        case BSP_UART_ERROR_CB:
+          bsp_uart_callback.dr16.ErrorCallback = callback;
+          break;
+        case BSP_UART_ABORT_COMPLETE_CB:
+          bsp_uart_callback.dr16.AbortCpltCallback = callback;
+          break;
+        case BSP_UART_ABORT_TRANSMIT_COMPLETE_CB:
+          bsp_uart_callback.dr16.AbortTransmitCpltCallback = callback;
+          break;
+        case BSP_UART_ABORT_RECEIVE_COMPLETE_CB:
+          bsp_uart_callback.dr16.AbortReceiveCpltCallback = callback;
+          break;
+        default:
+          return -1;
+      }
+      break;
+    /*
+    case BSP_UART_XXX:
+            switch (type) {
+                    case BSP_UART_TX_HALFCOMPLETE_CB:
+                            bsp_uart_callback.xxx.TxHalfCpltCallback = callback;
+                            break;
+                    case BSP_UART_TX_COMPLETE_CB:
+                            bsp_uart_callback.xxx.TxCpltCallback = callback;
+                            break;
+                    case BSP_UART_RX_HALFCOMPLETE_CB:
+                            bsp_uart_callback.xxx.RxHalfCpltCallback = callback;
+                            break;
+                    case BSP_UART_RX_COMPLETE_CB:
+                            bsp_uart_callback.xxx.RxCpltCallback = callback;
+                            break;
+                    case BSP_UART_ERROR_CB:
+                            bsp_uart_callback.xxx.ErrorCallback = callback;
+                            break;
+                    case BSP_UART_ABORT_COMPLETE_CB:
+                            bsp_uart_callback.xxx.AbortCpltCallback = callback;
+                            break;
+                    case BSP_UART_ABORT_TRANSMIT_COMPLETE_CB:
+                            bsp_uart_callback.xxx.AbortTransmitCpltCallback =
+    callback; break; case BSP_UART_ABORT_RECEIVE_COMPLETE_CB:
+                            bsp_uart_callback.xxx.AbortReceiveCpltCallback =
+    callback; break; default: return -1;
+            }
+            break;
+    */
+    default:
+      return -1;
+  }
+  return 0;
+}
+
+int8_t BSP_UART_Transmit(BSP_UART_t uart, uint8_t *data, uint16_t len) {
+  if (data == NULL) return -1;
+
+  switch (uart) {
+    case BSP_UART_DR16:
+      return -1;
+      /*
+      case BSP_UART_XXX:
+              return -1;
+      */
+  }
+  return 0;
+}
+int8_t BSP_UART_Receive(BSP_UART_t uart, uint8_t *data, uint16_t len) {
+  if (data == NULL) return -1;
+
+  switch (uart) {
+    case BSP_UART_DR16:
+      HAL_UART_Receive_DMA(&huart1, data, len);
+      break;
+      /*
+      case BSP_UART_XXX:
+              return -1;
+      */
+  }
+  return 0;
+}
--- a/User/bsp/a/bsp_usb.c
+++ b/User/bsp/a/bsp_usb.c
@@ -0,0 +1,30 @@
+/* Includes ----------------------------------------------------------------- */
+#include "bsp_usb.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "usbd_cdc_if.h"
+
+/* Private define ----------------------------------------------------------- */
+/* Private macro ------------------------------------------------------------ */
+/* Private typedef ---------------------------------------------------------- */
+/* Private variables -------------------------------------------------------- */
+uint8_t usb_tx_buf[512];
+uint8_t usb_rx_buf[512];
+
+/* Private function  -------------------------------------------------------- */
+/* Exported functions ------------------------------------------------------- */
+uint8_t BSP_USB_Printf(const char *fmt, ...) {
+  static va_list ap;
+  uint16_t len = 0;
+
+  va_start(ap, fmt);
+  len = vsprintf((char *)usb_tx_buf, fmt, ap);
+  va_end(ap);
+
+  CDC_Transmit_FS(usb_tx_buf, len);
+
+  return 0;
+}
--- a/User/bsp/adc.h
+++ b/User/bsp/adc.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <stdint.h>
+
+#include "bsp/bsp.h"
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+/* Exported functions prototypes -------------------------------------------- */
+float BSP_GetTemperature(void);
+float BSP_GetBatteryVolt(void);
+uint8_t BSP_GetHardwareVersion(void);
+
+#ifdef __cplusplus
+}
+#endif
--- a/User/bsp/bsp.h
+++ b/User/bsp/bsp.h
@@ -0,0 +1,17 @@
+#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)
+
+#define SIGNAL_BSP_USB_BUF_RECV (1u << 0)
+
+#ifdef __cplusplus
+}
+#endif
--- a/User/bsp/buzzer.h
+++ b/User/bsp/buzzer.h
@@ -0,0 +1,22 @@
+#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_Buzzer_Start(void);
+int8_t BSP_Buzzer_Set(float freq, float duty_cycle);
+int8_t BSP_Buzzer_Stop(void);
+
+#ifdef __cplusplus
+}
+#endif
--- 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;
+  }
+}
--- a/User/bsp/can.h
+++ b/User/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
--- a/User/bsp/crc32.h
+++ b/User/bsp/crc32.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "bsp/bsp.h"
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+/* Exported functions prototypes -------------------------------------------- */
+uint32_t BSP_CRC32_Calc(uint8_t *buf, size_t len);
+bool BSP_CRC32_Verify(uint8_t *buf, size_t len);
+bool BSP_CRC32_Append(uint8_t *buf, size_t len);
+
+#ifdef __cplusplus
+}
+#endif
--- a/User/bsp/delay.h
+++ b/User/bsp/delay.h
@@ -0,0 +1,20 @@
+#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);
+
+#ifdef __cplusplus
+}
+#endif
--- a/User/bsp/flash.h
+++ b/User/bsp/flash.h
@@ -0,0 +1,78 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ------------------------------------------------------------------ */
+#include <main.h>
+
+#include "bsp/bsp.h"
+
+/* Exported constants -------------------------------------------------------- */
+/* Base address of the Flash sectors */
+#define ADDR_FLASH_SECTOR_0 ((uint32_t)0x08000000)
+/* Base address of Sector 0, 16 Kbytes   */
+#define ADDR_FLASH_SECTOR_1 ((uint32_t)0x08004000)
+/* Base address of Sector 1, 16 Kbytes   */
+#define ADDR_FLASH_SECTOR_2 ((uint32_t)0x08008000)
+/* Base address of Sector 2, 16 Kbytes   */
+#define ADDR_FLASH_SECTOR_3 ((uint32_t)0x0800C000)
+/* Base address of Sector 3, 16 Kbytes   */
+#define ADDR_FLASH_SECTOR_4 ((uint32_t)0x08010000)
+/* Base address of Sector 4, 64 Kbytes   */
+#define ADDR_FLASH_SECTOR_5 ((uint32_t)0x08020000)
+/* Base address of Sector 5, 128 Kbytes  */
+#define ADDR_FLASH_SECTOR_6 ((uint32_t)0x08040000)
+/* Base address of Sector 6, 128 Kbytes  */
+#define ADDR_FLASH_SECTOR_7 ((uint32_t)0x08060000)
+/* Base address of Sector 7, 128 Kbytes  */
+#define ADDR_FLASH_SECTOR_8 ((uint32_t)0x08080000)
+/* Base address of Sector 8, 128 Kbytes  */
+#define ADDR_FLASH_SECTOR_9 ((uint32_t)0x080A0000)
+/* Base address of Sector 9, 128 Kbytes  */
+#define ADDR_FLASH_SECTOR_10 ((uint32_t)0x080C0000)
+/* Base address of Sector 10, 128 Kbytes */
+#define ADDR_FLASH_SECTOR_11 ((uint32_t)0x080E0000)
+/* Base address of Sector 11, 128 Kbytes */
+
+#ifdef DEV_BOARD_C
+#define ADDR_FLASH_END ((uint32_t)0x08100000) /* End address for flash */
+#else
+#define ADDR_FLASH_SECTOR_12 ((uint32_t)0x08100000)
+/* Base address of Sector 12, 16 Kbytes  */
+#define ADDR_FLASH_SECTOR_13 ((uint32_t)0x08104000)
+/* Base address of Sector 13, 16 Kbytes  */
+#define ADDR_FLASH_SECTOR_14 ((uint32_t)0x08108000)
+/* Base address of Sector 14, 16 Kbytes  */
+#define ADDR_FLASH_SECTOR_15 ((uint32_t)0x0810C000)
+/* Base address of Sector 15, 16 Kbytes  */
+#define ADDR_FLASH_SECTOR_16 ((uint32_t)0x08110000)
+/* Base address of Sector 16, 64 Kbytes  */
+#define ADDR_FLASH_SECTOR_17 ((uint32_t)0x08120000)
+/* Base address of Sector 17, 128 Kbytes */
+#define ADDR_FLASH_SECTOR_18 ((uint32_t)0x08140000)
+/* Base address of Sector 18, 128 Kbytes */
+#define ADDR_FLASH_SECTOR_19 ((uint32_t)0x08160000)
+/* Base address of Sector 19, 128 Kbytes */
+#define ADDR_FLASH_SECTOR_20 ((uint32_t)0x08180000)
+/* Base address of Sector 20, 128 Kbytes */
+#define ADDR_FLASH_SECTOR_21 ((uint32_t)0x081A0000)
+/* Base address of Sector 21, 128 Kbytes */
+#define ADDR_FLASH_SECTOR_22 ((uint32_t)0x081C0000)
+/* Base address of Sector 22, 128 Kbytes */
+#define ADDR_FLASH_SECTOR_23 ((uint32_t)0x081E0000)
+/* Base address of Sector 23, 128 Kbytes */
+#define ADDR_FLASH_END ((uint32_t)0x08200000) /* End address for flash */
+#endif
+
+/* Exported macro ------------------------------------------------------------ */
+/* Exported types ------------------------------------------------------------ */
+/* Exported functions prototypes --------------------------------------------- */
+void BSP_Flash_EraseSector(uint32_t sector);
+void BSP_Flash_WriteBytes(uint32_t address, const uint8_t *buf, size_t len);
+void BSP_Flash_ReadBytes(uint32_t address, void *buf, size_t len);
+
+#ifdef __cplusplus
+}
+#endif
--- a/User/bsp/fric.h
+++ b/User/bsp/fric.h
@@ -0,0 +1,22 @@
+#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_Fric_Start(void);
+int8_t BSP_Fric_Set(float duty_cycle);
+int8_t BSP_Fric_Stop(void);
+
+#ifdef __cplusplus
+}
+#endif
--- a/User/bsp/gpio.h
+++ b/User/bsp/gpio.h
@@ -0,0 +1,23 @@
+#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_GPIO_RegisterCallback(uint16_t pin, void (*callback)(void));
+
+int8_t BSP_GPIO_EnableIRQ(uint16_t pin);
+int8_t BSP_GPIO_DisableIRQ(uint16_t pin);
+
+#ifdef __cplusplus
+}
+#endif
--- a/User/bsp/i2c.h
+++ b/User/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_COMP,
+  /* BSP_I2C_XXX,*/
+  BSP_I2C_NUM,
+  BSP_I2C_ERR,
+} BSP_I2C_t;
+
+/* I2C支持的中断回调函数类型，具体参考HAL中定义 */
+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
--- a/User/bsp/laser.h
+++ b/User/bsp/laser.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 -------------------------------------------- */
+
+/* duty_cycle大于零时，A板为全开，C板为pwm调光*/
+int8_t BSP_Laser_Start(void);
+int8_t BSP_Laser_Set(float duty_cycle);
+int8_t BSP_Laser_Stop(void);
+
+#ifdef __cplusplus
+}
+#endif
--- a/User/bsp/led.h
+++ b/User/bsp/led.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <stdint.h>
+
+#include "bsp/bsp.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 {
+#ifdef DEV_BOARD_A
+  BSP_LED1,
+  BSP_LED2,
+  BSP_LED3,
+  BSP_LED4,
+  BSP_LED5,
+  BSP_LED6,
+  BSP_LED7,
+  BSP_LED8,
+#elif defined DEV_BOARD_C
+  BSP_LED_BLU,
+#endif
+  BSP_LED_RED,
+  BSP_LED_GRN,
+} BSP_LED_Channel_t;
+
+/* Exported functions prototypes -------------------------------------------- */
+
+/* 用于A板时，会无视duty_cycle的值。使用B板时，duty_cycle才有效*/
+int8_t BSP_LED_Set(BSP_LED_Channel_t ch, BSP_LED_Status_t s, float duty_cycle);
+
+#ifdef __cplusplus
+}
+#endif
--- a/User/bsp/mm.h
+++ b/User/bsp/mm.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <stddef.h>
+#include <stdint.h>
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+/* Exported functions prototypes -------------------------------------------- */
+void *BSP_Malloc(size_t size);
+void BSP_Free(void *pv);
+
+#ifdef __cplusplus
+}
+#endif
--- a/User/bsp/power.h
+++ b/User/bsp/power.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <stdbool.h>
+#include <stdint.h>
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+
+/* 电源输出接口 */
+typedef enum {
+  POWER_PORT1,
+  POWER_PORT2,
+  POWER_PORT3,
+  POWER_PORT4,
+} BSP_Power_Port_t;
+
+/* Exported functions prototypes -------------------------------------------- */
+int8_t BSP_Power_Set(BSP_Power_Port_t port, bool s);
+
+#ifdef __cplusplus
+}
+#endif
--- a/User/bsp/pwm.h
+++ b/User/bsp/pwm.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <stdint.h>
+
+#include "bsp/bsp.h"
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+
+/* PWM通道 */
+typedef enum {
+  BSP_PWM_IMU_HEAT,
+  BSP_PWM_SHOOT_SERVO,
+} BSP_PWM_Channel_t;
+
+/* 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
--- a/User/bsp/rand.h
+++ b/User/bsp/rand.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <stdint.h>
+
+#include "bsp/bsp.h"
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+/* Exported functions prototypes -------------------------------------------- */
+uint32_t BSP_GetRandomNum(void);
+int32_t BSP_GetRandomRangle(int32_t min, int32_t max);
+
+#ifdef __cplusplus
+}
+#endif
--- a/User/bsp/servo.h
+++ b/User/bsp/servo.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <stdint.h>
+
+#include "bsp/bsp.h"
+
+/* Exported constants ------------------------------------------------------- */
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+
+/* 舵机通道 */
+typedef enum {
+  BSP_SERVO_A = 0,
+  BSP_SERVO_B,
+  BSP_SERVO_C,
+  BSP_SERVO_D,
+  BSP_SERVO_E,
+  BSP_SERVO_F,
+  BSP_SERVO_G,
+#ifdef DEV_BOARD_A
+  BSP_SERVO_H,
+  BSP_SERVO_S,
+  BSP_SERVO_T,
+  BSP_SERVO_U,
+  BSP_SERVO_V,
+  BSP_SERVO_W,
+  BSP_SERVO_X,
+  BSP_SERVO_Y,
+  BSP_SERVO_Z,
+#endif
+  BSP_SERVO_NUM,
+} BSP_Servo_Channel_t;
+
+/* Exported functions prototypes -------------------------------------------- */
+int8_t BSP_Servo_Init(BSP_Servo_Channel_t ch, float max_angle);
+int8_t BSP_Servo_Start(BSP_Servo_Channel_t ch);
+int8_t BSP_Servo_Set(BSP_Servo_Channel_t ch, uint8_t angle);
+int8_t BSP_Servo_Stop(BSP_Servo_Channel_t ch);
+
+#ifdef __cplusplus
+}
+#endif
--- a/User/bsp/spi.h
+++ b/User/bsp/spi.h
@@ -0,0 +1,47 @@
+#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_OLED,
+  BSP_SPI_IMU,
+  /* 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
--- a/User/bsp/uart.h
+++ b/User/bsp/uart.h
@@ -0,0 +1,50 @@
+#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_DR16,
+  BSP_UART_REF,
+  BSP_UART_AI,
+  /* 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
--- a/User/bsp/usb.h
+++ b/User/bsp/usb.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ----------------------------------------------------------------- */
+#include <cmsis_os2.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "bsp/bsp.h"
+
+/* Exported constants ------------------------------------------------------- */
+#define BSP_USB_MAX_RX_LEN 128 /* USB接收数据缓冲区长度 */
+#define BSP_USB_MAX_TX_LEN 1024 /* USB发送数据缓冲区长度 */
+
+/* Exported macro ----------------------------------------------------------- */
+/* Exported types ----------------------------------------------------------- */
+
+extern osThreadId_t gbsp_usb_alert; /* 暴露给USB库用以提示任务收到新内容 */
+extern uint8_t usb_rx_buf[BSP_USB_MAX_RX_LEN]; /* 暴露给USB库用以存储接收数据 */
+extern uint8_t usb_tx_buf[BSP_USB_MAX_TX_LEN]; /* 暴露给USB库用以存储发送数据 */
+/* Exported functions prototypes -------------------------------------------- */
+int8_t BSP_USB_ReadyReceive(osThreadId_t alert);  /* 指示USB库准备好接收数据 */
+char BSP_USB_ReadChar(void); /* 读取缓存第一个字符 */
+
+int8_t BSP_USB_Printf(const char *fmt, ...); /* 打印至虚拟串口 */
+
+#ifdef __cplusplus
+}
+#endif