robofish/RMUC2026
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

infantry

Browse Source
This commit is contained in:
RB
2025-03-11 21:32:41 +08:00
parent 1480a30aa1
commit 740dc38e96
327 changed files with 252743 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
User/bsp/a/bsp_adc.c Normal file
View File

@@ -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; }

23
User/bsp/a/bsp_buzzer.c Normal file
View File

@@ -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); }

10
User/bsp/a/bsp_crc32.c Normal file
View File

@@ -0,0 +1,10 @@
/* Includes ----------------------------------------------------------------- */
#include "bsp_crc.h"
#include "crc.h"
/* Private define ----------------------------------------------------------- */
/* Private macro ------------------------------------------------------------ */
/* Private typedef ---------------------------------------------------------- */
/* Private variables -------------------------------------------------------- */
/* Private function -------------------------------------------------------- */
/* Exported functions ------------------------------------------------------- */

20
User/bsp/a/bsp_delay.c Normal file
View File

@@ -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;
}

11
User/bsp/a/bsp_flash.c Normal file
View File

@@ -0,0 +1,11 @@
/* Includes ----------------------------------------------------------------- */
#include "bsp_flash.h"
#include "main.h"
/* Private define ----------------------------------------------------------- */
/* Private macro ------------------------------------------------------------ */
/* Private typedef ---------------------------------------------------------- */
/* Private variables -------------------------------------------------------- */
/* Private function -------------------------------------------------------- */
/* Exported functions ------------------------------------------------------- */

27
User/bsp/a/bsp_fric.c Normal file
View File

@@ -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);
}

20
User/bsp/a/bsp_laser.c Normal file
View File

@@ -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;
}

84
User/bsp/a/bsp_led.c Normal file
View File

@@ -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;
}

52
User/bsp/a/bsp_power.c Normal file
View File

@@ -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;
}

37
User/bsp/a/bsp_pwm.c Normal file
View File

@@ -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);

11
User/bsp/a/bsp_rand.c Normal file
View File

@@ -0,0 +1,11 @@
/* Includes ----------------------------------------------------------------- */
#include "bsp_rand.h"
#include "rng.h"
/* Private define ----------------------------------------------------------- */
/* Private macro ------------------------------------------------------------ */
/* Private typedef ---------------------------------------------------------- */
/* Private variables -------------------------------------------------------- */
/* Private function -------------------------------------------------------- */
/* Exported functions ------------------------------------------------------- */

11
User/bsp/a/bsp_servo.c Normal file
View File

@@ -0,0 +1,11 @@
/* Includes ----------------------------------------------------------------- */
#include "bsp_servo.h"
#include "tim.h"
/* Private define ----------------------------------------------------------- */
/* Private macro ------------------------------------------------------------ */
/* Private typedef ---------------------------------------------------------- */
/* Private variables -------------------------------------------------------- */
/* Private function -------------------------------------------------------- */
/* Exported functions ------------------------------------------------------- */

295
User/bsp/a/bsp_spi.c Normal file
View File

@@ -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;
}

198
User/bsp/a/bsp_uart.c Normal file
View File

@@ -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;
}

30
User/bsp/a/bsp_usb.c Normal file
View File

@@ -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;
}