jfen/stm32f407ve_black
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

优化实现串口驱动，SPI驱动 W25QXX还需要初始化验证修复

Browse Source
This commit is contained in:
冯佳
2026-01-23 09:59:43 +08:00
parent 51e8d79f78
commit b166bee1a9
69 changed files with 6253 additions and 1178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
HAL/Src/arch/stm32f4/hal_stm32f4.c Normal file
View File

@ -0,0 +1,20 @@
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : hal_stm32f4.c
* @brief : STM32F4 architecture specific HAL initialization
******************************************************************************
*/
/* USER CODE END Header */
#include "hal.h"
/**
* @brief STM32F4 specific initialization
*/
void hal_stm32f4_init(void) {
/* Initialize STM32F4 specific peripherals */
hal_stm32f4_gpio_init();
hal_stm32f4_uart_init();
hal_stm32f4_delay_init();
}

44
HAL/Src/arch/stm32f4/hal_stm32f4_delay.c Normal file
View File

@ -0,0 +1,44 @@
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : hal_stm32f4_delay.c
* @brief : STM32F4 specific Delay HAL implementation
******************************************************************************
*/
/* USER CODE END Header */
#include "hal.h"
#include "hal_delay.h"
#include "stm32f4xx_hal.h"
/**
* @brief STM32F4 specific delay initialization
*/
void hal_stm32f4_delay_init(void) {
/* Delay initialization is handled by HAL_Init() */
}
/**
* @brief STM32F4 specific delay in milliseconds
* @param ms: Delay time in milliseconds
*/
void hal_stm32f4_delay_ms(uint32_t ms) {
HAL_Delay(ms);
}
/**
* @brief STM32F4 specific delay in microseconds
* @param us: Delay time in microseconds
*/
void hal_stm32f4_delay_us(uint32_t us) {
uint32_t ticks = 0;
uint32_t start_tick = 0;
uint32_t tick_freq = HAL_RCC_GetHCLKFreq() / 1000000;
ticks = us * tick_freq;
start_tick = HAL_GetTick() * tick_freq;
while ((HAL_GetTick() * tick_freq - start_tick) < ticks) {
/* Busy wait */
}
}

164
HAL/Src/arch/stm32f4/hal_stm32f4_gpio.c Normal file
View File

@ -0,0 +1,164 @@
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : hal_stm32f4_gpio.c
* @brief : STM32F4 specific GPIO HAL implementation
******************************************************************************
*/
/* USER CODE END Header */
#include "hal.h"
#include "hal_gpio.h"
#include "stm32f4xx_hal.h"
/**
* @brief Convert HAL GPIO port to STM32 GPIO port
* @param port: HAL GPIO port
* @retval STM32 GPIO port
*/
static GPIO_TypeDef* hal_gpio_port_to_stm32(hal_gpio_port_t port) {
switch (port) {
case HAL_GPIO_PORT_A: return GPIOA;
case HAL_GPIO_PORT_B: return GPIOB;
case HAL_GPIO_PORT_C: return GPIOC;
case HAL_GPIO_PORT_D: return GPIOD;
case HAL_GPIO_PORT_E: return GPIOE;
case HAL_GPIO_PORT_F: return GPIOF;
case HAL_GPIO_PORT_G: return GPIOG;
case HAL_GPIO_PORT_H: return GPIOH;
case HAL_GPIO_PORT_I: return GPIOI;
// case HAL_GPIO_PORT_J: return GPIOJ;
// case HAL_GPIO_PORT_K: return GPIOK;
default: return NULL;
}
}
/**
* @brief Convert HAL GPIO pin to STM32 GPIO pin
* @param pin: HAL GPIO pin
* @retval STM32 GPIO pin
*/
static uint16_t hal_gpio_pin_to_stm32(hal_gpio_pin_t pin) {
return (1U << pin);
}
/**
* @brief Convert HAL GPIO state to STM32 GPIO state
* @param state: HAL GPIO state
* @retval STM32 GPIO state
*/
static GPIO_PinState hal_gpio_state_to_stm32(hal_gpio_pin_state_t state) {
return (state == HAL_GPIO_PIN_SET) ? GPIO_PIN_SET : GPIO_PIN_RESET;
}
/**
* @brief STM32F4 specific GPIO initialization
*/
void hal_stm32f4_gpio_init(void) {
/* GPIO initialization is handled by BSP layer */
}
/**
* @brief STM32F4 specific GPIO write pin implementation
*/
void hal_stm32f4_gpio_write_pin(hal_gpio_port_t port, hal_gpio_pin_t pin, hal_gpio_pin_state_t state) {
GPIO_TypeDef* stm32_port = hal_gpio_port_to_stm32(port);
if (stm32_port == NULL) {
return;
}
uint16_t stm32_pin = hal_gpio_pin_to_stm32(pin);
GPIO_PinState stm32_state = hal_gpio_state_to_stm32(state);
HAL_GPIO_WritePin(stm32_port, stm32_pin, stm32_state);
}
/**
* @brief STM32F4 specific GPIO toggle pin implementation
*/
void hal_stm32f4_gpio_toggle_pin(hal_gpio_port_t port, hal_gpio_pin_t pin) {
GPIO_TypeDef* stm32_port = hal_gpio_port_to_stm32(port);
if (stm32_port == NULL) {
return;
}
uint16_t stm32_pin = hal_gpio_pin_to_stm32(pin);
HAL_GPIO_TogglePin(stm32_port, stm32_pin);
}
/**
* @brief STM32F4 specific GPIO read pin implementation
*/
hal_gpio_pin_state_t hal_stm32f4_gpio_read_pin(hal_gpio_port_t port, hal_gpio_pin_t pin) {
GPIO_TypeDef* stm32_port = hal_gpio_port_to_stm32(port);
if (stm32_port == NULL) {
return HAL_GPIO_PIN_RESET;
}
uint16_t stm32_pin = hal_gpio_pin_to_stm32(pin);
GPIO_PinState stm32_state = HAL_GPIO_ReadPin(stm32_port, stm32_pin);
return (stm32_state == GPIO_PIN_SET) ? HAL_GPIO_PIN_SET : HAL_GPIO_PIN_RESET;
}
/**
* @brief STM32F4 specific GPIO configure pin implementation
*/
void hal_stm32f4_gpio_configure_pin(const hal_gpio_config_t *config) {
if (config == NULL) {
return;
}
GPIO_TypeDef* stm32_port = hal_gpio_port_to_stm32(config->port);
if (stm32_port == NULL) {
return;
}
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* Enable GPIO clock */
switch (config->port) {
case HAL_GPIO_PORT_A: __HAL_RCC_GPIOA_CLK_ENABLE(); break;
case HAL_GPIO_PORT_B: __HAL_RCC_GPIOB_CLK_ENABLE(); break;
case HAL_GPIO_PORT_C: __HAL_RCC_GPIOC_CLK_ENABLE(); break;
case HAL_GPIO_PORT_D: __HAL_RCC_GPIOD_CLK_ENABLE(); break;
case HAL_GPIO_PORT_E: __HAL_RCC_GPIOE_CLK_ENABLE(); break;
case HAL_GPIO_PORT_F: __HAL_RCC_GPIOF_CLK_ENABLE(); break;
case HAL_GPIO_PORT_G: __HAL_RCC_GPIOG_CLK_ENABLE(); break;
case HAL_GPIO_PORT_H: __HAL_RCC_GPIOH_CLK_ENABLE(); break;
case HAL_GPIO_PORT_I: __HAL_RCC_GPIOI_CLK_ENABLE(); break;
default: break;
}
/* Configure GPIO parameters */
GPIO_InitStruct.Pin = hal_gpio_pin_to_stm32(config->pin);
/* Convert HAL GPIO mode to STM32 GPIO mode */
switch (config->mode) {
case HAL_GPIO_MODE_INPUT: GPIO_InitStruct.Mode = GPIO_MODE_INPUT; break;
case HAL_GPIO_MODE_OUTPUT_PP: GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; break;
case HAL_GPIO_MODE_OUTPUT_OD: GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD; break;
case HAL_GPIO_MODE_AF_PP: GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; break;
case HAL_GPIO_MODE_AF_OD: GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; break;
case HAL_GPIO_MODE_ANALOG: GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; break;
case HAL_GPIO_MODE_IT_RISING: GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING; break;
case HAL_GPIO_MODE_IT_FALLING: GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING; break;
case HAL_GPIO_MODE_IT_RISING_FALLING: GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING; break;
default: GPIO_InitStruct.Mode = GPIO_MODE_INPUT; break;
}
/* Convert HAL GPIO pull to STM32 GPIO pull */
switch (config->pull) {
case HAL_GPIO_PULL_NO: GPIO_InitStruct.Pull = GPIO_NOPULL; break;
case HAL_GPIO_PULL_UP: GPIO_InitStruct.Pull = GPIO_PULLUP; break;
case HAL_GPIO_PULL_DOWN: GPIO_InitStruct.Pull = GPIO_PULLDOWN; break;
default: GPIO_InitStruct.Pull = GPIO_NOPULL; break;
}
/* Convert HAL GPIO speed to STM32 GPIO speed */
switch (config->speed) {
case HAL_GPIO_SPEED_LOW: GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; break;
case HAL_GPIO_SPEED_MEDIUM: GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM; break;
case HAL_GPIO_SPEED_HIGH: GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; break;
case HAL_GPIO_SPEED_VERY_HIGH: GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; break;
default: GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; break;
}
/* Initialize GPIO */
HAL_GPIO_Init(stm32_port, &GPIO_InitStruct);
}

254
HAL/Src/arch/stm32f4/hal_stm32f4_spi.c Normal file
View File

@ -0,0 +1,254 @@
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : hal_stm32f4_spi.c
* @brief : STM32F4 specific SPI HAL implementation
******************************************************************************
*/
/* USER CODE END Header */
#include "hal.h"
#include "hal_spi.h"
#include "hal_stm32f4_spi.h"
#include "stm32f4xx_hal.h"
#include "stm32f4xx_hal_spi.h"
#include <stdbool.h>
/* SPI handles */
static SPI_HandleTypeDef hspi1;
static SPI_HandleTypeDef hspi2;
static SPI_HandleTypeDef hspi3;
static SPI_HandleTypeDef hspi4;
static SPI_HandleTypeDef hspi5;
static SPI_HandleTypeDef hspi6;
/**
* @brief Get SPI handle based on instance
* @param instance SPI instance identifier
* @return Pointer to SPI handle
*/
static SPI_HandleTypeDef* get_spi_handle(hal_spi_instance_t instance) {
switch (instance) {
case HAL_SPI_INSTANCE_1:
return &hspi1;
case HAL_SPI_INSTANCE_2:
return &hspi2;
case HAL_SPI_INSTANCE_3:
return &hspi3;
case HAL_SPI_INSTANCE_4:
return &hspi4;
case HAL_SPI_INSTANCE_5:
return &hspi5;
case HAL_SPI_INSTANCE_6:
return &hspi6;
default:
return NULL;
}
}
/**
* @brief STM32F4 specific SPI initialization
* @param instance SPI instance identifier
* @param config SPI configuration structure
* @return true if initialization is successful, false otherwise
*/
bool hal_stm32f4_spi_init(hal_spi_instance_t instance, const hal_spi_config_t *config) {
if (config == NULL) {
return false;
}
SPI_HandleTypeDef* hspi = get_spi_handle(instance);
if (hspi == NULL) {
return false;
}
/* Configure SPI parameters */
hspi->Instance = NULL;
hspi->Init.Mode = (config->mode == HAL_SPI_MODE_MASTER) ? SPI_MODE_MASTER : SPI_MODE_SLAVE;
hspi->Init.DataSize = (config->databits == HAL_SPI_DATABITS_8) ? SPI_DATASIZE_8BIT : SPI_DATASIZE_16BIT;
hspi->Init.CLKPolarity = (config->polarity == HAL_SPI_POLARITY_LOW) ? SPI_POLARITY_LOW : SPI_POLARITY_HIGH;
hspi->Init.CLKPhase = (config->phase == HAL_SPI_PHASE_1EDGE) ? SPI_PHASE_1EDGE : SPI_PHASE_2EDGE;
hspi->Init.NSS = SPI_NSS_SOFT; /* Use software NSS */
/* Calculate baud rate prescaler based on desired baud rate */
uint32_t apb_clock = HAL_RCC_GetPCLK2Freq(); /* Assume SPI1 is on APB2 */
uint32_t prescaler = 0;
uint32_t temp_prescaler = 2;
while (apb_clock / temp_prescaler > config->baudrate) {
temp_prescaler <<= 1;
prescaler++;
}
hspi->Init.BaudRatePrescaler = (uint32_t)temp_prescaler;
hspi->Init.FirstBit = SPI_FIRSTBIT_MSB; /* Default to MSB first */
hspi->Init.TIMode = SPI_TIMODE_DISABLE;
hspi->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
hspi->Init.CRCPolynomial = 10;
/* Configure GPIO and enable clocks based on instance */
GPIO_InitTypeDef GPIO_InitStruct = {0};
switch (instance) {
case HAL_SPI_INSTANCE_1:
/* Enable SPI1 clock */
__HAL_RCC_SPI1_CLK_ENABLE();
/* Enable GPIOB clock */
__HAL_RCC_GPIOB_CLK_ENABLE();
/* Configure SPI1 GPIO pins: SCK(PB3), MISO(PB4), MOSI(PB5) */
GPIO_InitStruct.Pin = GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF5_SPI1;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
hspi->Instance = SPI1;
break;
case HAL_SPI_INSTANCE_2:
/* Enable SPI2 clock */
__HAL_RCC_SPI2_CLK_ENABLE();
/* Enable GPIOB clock */
__HAL_RCC_GPIOB_CLK_ENABLE();
/* Configure SPI2 GPIO pins: SCK(PB13), MISO(PB14), MOSI(PB15) */
GPIO_InitStruct.Pin = GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
hspi->Instance = SPI2;
break;
case HAL_SPI_INSTANCE_3:
/* Enable SPI3 clock */
__HAL_RCC_SPI3_CLK_ENABLE();
/* Enable GPIOC clock */
__HAL_RCC_GPIOC_CLK_ENABLE();
/* Configure SPI3 GPIO pins: SCK(PC10), MISO(PC11), MOSI(PC12) */
GPIO_InitStruct.Pin = GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF6_SPI3;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
hspi->Instance = SPI3;
break;
default:
return false;
}
/* Initialize SPI */
if (HAL_SPI_Init(hspi) != HAL_OK) {
return false;
}
return true;
}
/**
* @brief STM32F4 specific SPI deinitialization
* @param instance SPI instance identifier
* @return true if deinitialization is successful, false otherwise
*/
bool hal_stm32f4_spi_deinit(hal_spi_instance_t instance) {
SPI_HandleTypeDef* hspi = get_spi_handle(instance);
if (hspi == NULL || hspi->Instance == NULL) {
return false;
}
if (HAL_SPI_DeInit(hspi) != HAL_OK) {
return false;
}
/* Disable SPI clock */
switch (instance) {
case HAL_SPI_INSTANCE_1:
__HAL_RCC_SPI1_CLK_DISABLE();
break;
case HAL_SPI_INSTANCE_2:
__HAL_RCC_SPI2_CLK_DISABLE();
break;
case HAL_SPI_INSTANCE_3:
__HAL_RCC_SPI3_CLK_DISABLE();
break;
default:
return false;
}
return true;
}
/**
* @brief STM32F4 specific SPI transmit implementation
* @param instance SPI instance identifier
* @param p_data Pointer to data buffer to transmit
* @param size Size of data to transmit
* @return true if transmission is successful, false otherwise
*/
bool hal_stm32f4_spi_transmit(hal_spi_instance_t instance, const uint8_t *p_data, uint16_t size) {
if (p_data == NULL || size == 0) {
return false;
}
SPI_HandleTypeDef* hspi = get_spi_handle(instance);
if (hspi == NULL || hspi->Instance == NULL) {
return false;
}
HAL_StatusTypeDef status = HAL_SPI_Transmit(hspi, (uint8_t*)p_data, size, HAL_MAX_DELAY);
return (status == HAL_OK);
}
/**
* @brief STM32F4 specific SPI receive implementation
* @param instance SPI instance identifier
* @param p_data Pointer to data buffer to receive
* @param size Size of data to receive
* @return true if reception is successful, false otherwise
*/
bool hal_stm32f4_spi_receive(hal_spi_instance_t instance, uint8_t *p_data, uint16_t size) {
if (p_data == NULL || size == 0) {
return false;
}
SPI_HandleTypeDef* hspi = get_spi_handle(instance);
if (hspi == NULL || hspi->Instance == NULL) {
return false;
}
HAL_StatusTypeDef status = HAL_SPI_Receive(hspi, p_data, size, HAL_MAX_DELAY);
return (status == HAL_OK);
}
/**
* @brief STM32F4 specific SPI transmit and receive implementation
* @param instance SPI instance identifier
* @param p_tx_data Pointer to data buffer to transmit
* @param p_rx_data Pointer to data buffer to receive
* @param size Size of data to transmit/receive
* @return true if transmission and reception are successful, false otherwise
*/
bool hal_stm32f4_spi_transmit_receive(hal_spi_instance_t instance, const uint8_t *p_tx_data, uint8_t *p_rx_data, uint16_t size) {
if (p_tx_data == NULL || p_rx_data == NULL || size == 0) {
return false;
}
SPI_HandleTypeDef* hspi = get_spi_handle(instance);
if (hspi == NULL || hspi->Instance == NULL) {
return false;
}
HAL_StatusTypeDef status = HAL_SPI_TransmitReceive(hspi, (uint8_t*)p_tx_data, p_rx_data, size, HAL_MAX_DELAY);
return (status == HAL_OK);
}

161
HAL/Src/arch/stm32f4/hal_stm32f4_uart.c Normal file
View File

@ -0,0 +1,161 @@
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : hal_stm32f4_uart.c
* @brief : STM32F4 specific UART HAL implementation
******************************************************************************
*/
/* USER CODE END Header */
#include "hal.h"
#include "hal_uart.h"
#include "stm32f4xx_hal.h"
#include "stm32f4xx_hal_uart.h"
/* UART handle */
static UART_HandleTypeDef huart1;
/**
* @brief STM32F4 specific UART initialization
*/
void hal_stm32f4_uart_init(void) {
/* UART initialization is handled by HAL_Init() */
/* Configure UART GPIO pins */
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* Enable UART clock */
__HAL_RCC_USART1_CLK_ENABLE();
/* Enable GPIO clocks */
__HAL_RCC_GPIOA_CLK_ENABLE();
/* Configure USART1 Tx (PA9) as alternate function push-pull */
GPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* Configure USART1 Rx (PA10) as alternate function push-pull */
GPIO_InitStruct.Pin = GPIO_PIN_10;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* Initialize UART */
huart1.Instance = USART1;
huart1.Init.BaudRate = 115200;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart1) != HAL_OK) {
/* Initialization Error */
while (1);
}
}
/**
* @brief STM32F4 specific UART configuration
*/
void hal_stm32f4_uart_config(const hal_uart_config_t *config) {
if (config == NULL) {
return;
}
/* Update UART configuration */
huart1.Init.BaudRate = config->baudrate;
/* Convert parity */
switch (config->parity) {
case HAL_UART_PARITY_NONE:
huart1.Init.Parity = UART_PARITY_NONE;
break;
case HAL_UART_PARITY_ODD:
huart1.Init.Parity = UART_PARITY_ODD;
break;
case HAL_UART_PARITY_EVEN:
huart1.Init.Parity = UART_PARITY_EVEN;
break;
default:
huart1.Init.Parity = UART_PARITY_NONE;
break;
}
/* Convert stop bits */
huart1.Init.StopBits = (config->stopbits == HAL_UART_STOPBITS_1) ?
UART_STOPBITS_1 : UART_STOPBITS_2;
/* Convert data bits */
huart1.Init.WordLength = (config->databits == HAL_UART_DATABITS_8) ?
UART_WORDLENGTH_8B : UART_WORDLENGTH_9B;
/* Re-initialize UART */
if (HAL_UART_Init(&huart1) != HAL_OK) {
/* Initialization Error */
while (1);
}
}
/**
* @brief STM32F4 specific UART send implementation
*/
void hal_stm32f4_uart_send(hal_uart_instance_t instance, const uint8_t *data, size_t length) {
if (data == NULL || length == 0) {
return;
}
/* Currently only supports USART1 */
if (instance == HAL_UART_INSTANCE_1) {
HAL_UART_Transmit(&huart1, (uint8_t *)data, length, HAL_MAX_DELAY);
}
}
/**
* @brief STM32F4 specific UART receive implementation
*/
size_t hal_stm32f4_uart_receive(hal_uart_instance_t instance, uint8_t *data, size_t length) {
if (data == NULL || length == 0) {
return 0;
}
/* Currently only supports USART1 */
if (instance == HAL_UART_INSTANCE_1) {
HAL_StatusTypeDef status = HAL_UART_Receive(&huart1, data, length, HAL_MAX_DELAY);
if (status == HAL_OK) {
return length;
}
}
return 0;
}
/**
* @brief STM32F4 specific UART TX ready check
*/
uint8_t hal_stm32f4_uart_is_tx_ready(hal_uart_instance_t instance) {
/* Currently only supports USART1 */
if (instance == HAL_UART_INSTANCE_1) {
return (HAL_UART_GetState(&huart1) == HAL_UART_STATE_READY) ? 1 : 0;
}
return 0;
}
/**
* @brief STM32F4 specific UART RX ready check
*/
uint8_t hal_stm32f4_uart_is_rx_ready(hal_uart_instance_t instance) {
/* Currently only supports USART1 */
if (instance == HAL_UART_INSTANCE_1) {
return (HAL_UART_GetState(&huart1) == HAL_UART_STATE_READY) ? 1 : 0;
}
return 0;
}