| /** |
| ****************************************************************************** |
| * @file hw_uart.c |
| * @author MCD Application Team |
| * @brief hardware access |
| ****************************************************************************** |
| * @attention |
| * |
| * Copyright (c) 2018(-2021) STMicroelectronics. |
| * All rights reserved. |
| * |
| * This software is licensed under terms that can be found in the LICENSE file |
| * in the root directory of this software component. |
| * If no LICENSE file comes with this software, it is provided AS-IS. |
| * |
| ****************************************************************************** |
| */ |
| |
| /* Includes ------------------------------------------------------------------*/ |
| #include "app_common.h" |
| #include "hw_conf.h" |
| |
| /* Macros --------------------------------------------------------------------*/ |
| #define HW_UART_INIT(__HANDLE__, __USART_BASE__) \ |
| do \ |
| { \ |
| (__HANDLE__).Instance = (__USART_BASE__); \ |
| (__HANDLE__).Init.BaudRate = CFG_HW_##__USART_BASE__##_BAUDRATE; \ |
| (__HANDLE__).Init.WordLength = CFG_HW_##__USART_BASE__##_WORDLENGTH; \ |
| (__HANDLE__).Init.StopBits = CFG_HW_##__USART_BASE__##_STOPBITS; \ |
| (__HANDLE__).Init.Parity = CFG_HW_##__USART_BASE__##_PARITY; \ |
| (__HANDLE__).Init.HwFlowCtl = CFG_HW_##__USART_BASE__##_HWFLOWCTL; \ |
| (__HANDLE__).Init.Mode = CFG_HW_##__USART_BASE__##_MODE; \ |
| (__HANDLE__).Init.OverSampling = CFG_HW_##__USART_BASE__##_OVERSAMPLING; \ |
| (__HANDLE__).AdvancedInit.AdvFeatureInit = CFG_HW_##__USART_BASE__##_ADVFEATUREINIT; \ |
| HAL_UART_Init(&(__HANDLE__)); \ |
| } while (0) |
| |
| #define HW_UART_RX_IT(__HANDLE__, __USART_BASE__) \ |
| do \ |
| { \ |
| HW_##__HANDLE__##RxCb = cb; \ |
| (__HANDLE__).Instance = (__USART_BASE__); \ |
| HAL_UART_Receive_IT(&(__HANDLE__), p_data, size); \ |
| } while (0) |
| |
| #define HW_UART_TX_IT(__HANDLE__, __USART_BASE__) \ |
| do \ |
| { \ |
| HW_##__HANDLE__##TxCb = cb; \ |
| (__HANDLE__).Instance = (__USART_BASE__); \ |
| HAL_UART_Transmit_IT(&(__HANDLE__), p_data, size); \ |
| } while (0) |
| |
| #define HW_UART_TX(__HANDLE__, __USART_BASE__) \ |
| do \ |
| { \ |
| (__HANDLE__).Instance = (__USART_BASE__); \ |
| hal_status = HAL_UART_Transmit(&(__HANDLE__), p_data, size, timeout); \ |
| } while (0) |
| |
| #define HW_UART_MSP_UART_INIT(__HANDLE__, __USART_BASE__) \ |
| do \ |
| { \ |
| /* Enable GPIO clock */ \ |
| CFG_HW_##__USART_BASE__##_TX_PORT_CLK_ENABLE(); \ |
| \ |
| /* Enable USART clock */ \ |
| __HAL_RCC_##__USART_BASE__##_CLK_ENABLE(); \ |
| \ |
| GPIO_InitStruct.Pin = CFG_HW_##__USART_BASE__##_TX_PIN; \ |
| GPIO_InitStruct.Mode = CFG_HW_##__USART_BASE__##_TX_MODE; \ |
| GPIO_InitStruct.Pull = CFG_HW_##__USART_BASE__##_TX_PULL; \ |
| GPIO_InitStruct.Speed = CFG_HW_##__USART_BASE__##_TX_SPEED; \ |
| GPIO_InitStruct.Alternate = CFG_HW_##__USART_BASE__##_TX_ALTERNATE; \ |
| \ |
| HAL_GPIO_Init(CFG_HW_##__USART_BASE__##_TX_PORT, &GPIO_InitStruct); \ |
| \ |
| CFG_HW_##__USART_BASE__##_RX_PORT_CLK_ENABLE(); \ |
| \ |
| GPIO_InitStruct.Pin = CFG_HW_##__USART_BASE__##_RX_PIN; \ |
| GPIO_InitStruct.Mode = CFG_HW_##__USART_BASE__##_RX_MODE; \ |
| GPIO_InitStruct.Pull = CFG_HW_##__USART_BASE__##_RX_PULL; \ |
| GPIO_InitStruct.Speed = CFG_HW_##__USART_BASE__##_RX_SPEED; \ |
| GPIO_InitStruct.Alternate = CFG_HW_##__USART_BASE__##_RX_ALTERNATE; \ |
| \ |
| HAL_GPIO_Init(CFG_HW_##__USART_BASE__##_RX_PORT, &GPIO_InitStruct); \ |
| \ |
| CFG_HW_##__USART_BASE__##_CTS_PORT_CLK_ENABLE(); \ |
| \ |
| GPIO_InitStruct.Pin = CFG_HW_##__USART_BASE__##_CTS_PIN; \ |
| GPIO_InitStruct.Mode = CFG_HW_##__USART_BASE__##_CTS_MODE; \ |
| GPIO_InitStruct.Pull = CFG_HW_##__USART_BASE__##_CTS_PULL; \ |
| GPIO_InitStruct.Speed = CFG_HW_##__USART_BASE__##_CTS_SPEED; \ |
| GPIO_InitStruct.Alternate = CFG_HW_##__USART_BASE__##_CTS_ALTERNATE; \ |
| \ |
| HAL_GPIO_Init(CFG_HW_##__USART_BASE__##_CTS_PORT, &GPIO_InitStruct); \ |
| \ |
| HAL_NVIC_SetPriority(__USART_BASE__##_IRQn, CFG_HW_##__USART_BASE__##_PREEMPTPRIORITY, \ |
| CFG_HW_##__USART_BASE__##_SUBPRIORITY); \ |
| HAL_NVIC_EnableIRQ(__USART_BASE__##_IRQn); \ |
| } while (0) |
| |
| #define HW_UART_MSP_TX_DMA_INIT(__HANDLE__, __USART_BASE__) \ |
| do \ |
| { \ |
| /* Configure the DMA handler for Transmission process */ \ |
| /* Enable DMA clock */ \ |
| CFG_HW_##__USART_BASE__##_DMA_CLK_ENABLE(); \ |
| /* Enable DMA MUX clock */ \ |
| CFG_HW_##__USART_BASE__##_DMAMUX_CLK_ENABLE(); \ |
| \ |
| HW_hdma_##__HANDLE__##_tx.Instance = CFG_HW_##__USART_BASE__##_TX_DMA_CHANNEL; \ |
| HW_hdma_##__HANDLE__##_tx.Init.Request = CFG_HW_##__USART_BASE__##_TX_DMA_REQ; \ |
| HW_hdma_##__HANDLE__##_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; \ |
| HW_hdma_##__HANDLE__##_tx.Init.PeriphInc = DMA_PINC_DISABLE; \ |
| HW_hdma_##__HANDLE__##_tx.Init.MemInc = DMA_MINC_ENABLE; \ |
| HW_hdma_##__HANDLE__##_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; \ |
| HW_hdma_##__HANDLE__##_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; \ |
| HW_hdma_##__HANDLE__##_tx.Init.Mode = DMA_NORMAL; \ |
| HW_hdma_##__HANDLE__##_tx.Init.Priority = DMA_PRIORITY_LOW; \ |
| \ |
| HAL_DMA_Init(&HW_hdma_##__HANDLE__##_tx); \ |
| \ |
| /* Associate the initialized DMA handle to the UART handle */ \ |
| __HAL_LINKDMA(huart, hdmatx, HW_hdma_##__HANDLE__##_tx); \ |
| \ |
| /* NVIC configuration for DMA transfer complete interrupt */ \ |
| HAL_NVIC_SetPriority(CFG_HW_##__USART_BASE__##_TX_DMA_IRQn, CFG_HW_##__USART_BASE__##_DMA_TX_PREEMPTPRIORITY, \ |
| CFG_HW_##__USART_BASE__##_DMA_TX_SUBPRIORITY); \ |
| HAL_NVIC_EnableIRQ(CFG_HW_##__USART_BASE__##_TX_DMA_IRQn); \ |
| } while (0) |
| |
| /* Variables ------------------------------------------------------------------*/ |
| #if (CFG_HW_USART1_ENABLED == 1) |
| UART_HandleTypeDef huart1 = { 0 }; |
| #if (CFG_HW_USART1_DMA_TX_SUPPORTED == 1) |
| DMA_HandleTypeDef HW_hdma_huart1_tx = { 0 }; |
| #endif |
| void (*HW_huart1RxCb)(void); |
| void (*HW_huart1TxCb)(void); |
| #endif |
| |
| #if (CFG_HW_LPUART1_ENABLED == 1) |
| UART_HandleTypeDef lpuart1 = { 0 }; |
| #if (CFG_HW_LPUART1_DMA_TX_SUPPORTED == 1) |
| DMA_HandleTypeDef HW_hdma_lpuart1_tx = { 0 }; |
| #endif |
| void (*HW_lpuart1RxCb)(void); |
| void (*HW_lpuart1TxCb)(void); |
| #endif |
| |
| void HW_UART_Init(hw_uart_id_t hw_uart_id) |
| { |
| switch (hw_uart_id) |
| { |
| #if (CFG_HW_USART1_ENABLED == 1) |
| case hw_uart1: |
| HW_UART_INIT(huart1, USART1); |
| break; |
| #endif |
| |
| #if (CFG_HW_LPUART1_ENABLED == 1) |
| case hw_lpuart1: |
| HW_UART_INIT(lpuart1, LPUART1); |
| break; |
| #endif |
| |
| default: |
| break; |
| } |
| |
| return; |
| } |
| |
| void HW_UART_Receive_IT(hw_uart_id_t hw_uart_id, uint8_t * p_data, uint16_t size, void (*cb)(void)) |
| { |
| switch (hw_uart_id) |
| { |
| #if (CFG_HW_USART1_ENABLED == 1) |
| case hw_uart1: |
| HW_UART_RX_IT(huart1, USART1); |
| break; |
| #endif |
| |
| #if (CFG_HW_LPUART1_ENABLED == 1) |
| case hw_lpuart1: |
| HW_UART_RX_IT(lpuart1, LPUART1); |
| break; |
| #endif |
| |
| default: |
| break; |
| } |
| |
| return; |
| } |
| |
| void HW_UART_Transmit_IT(hw_uart_id_t hw_uart_id, uint8_t * p_data, uint16_t size, void (*cb)(void)) |
| { |
| switch (hw_uart_id) |
| { |
| #if (CFG_HW_USART1_ENABLED == 1) |
| case hw_uart1: |
| HW_UART_TX_IT(huart1, USART1); |
| break; |
| #endif |
| |
| #if (CFG_HW_LPUART1_ENABLED == 1) |
| case hw_lpuart1: |
| HW_UART_TX_IT(lpuart1, LPUART1); |
| break; |
| #endif |
| |
| default: |
| break; |
| } |
| |
| return; |
| } |
| |
| hw_status_t HW_UART_Transmit(hw_uart_id_t hw_uart_id, uint8_t * p_data, uint16_t size, uint32_t timeout) |
| { |
| HAL_StatusTypeDef hal_status = HAL_OK; |
| hw_status_t hw_status = hw_uart_ok; |
| |
| switch (hw_uart_id) |
| { |
| #if (CFG_HW_USART1_ENABLED == 1) |
| case hw_uart1: |
| HW_UART_TX(huart1, USART1); |
| break; |
| #endif |
| |
| #if (CFG_HW_LPUART1_ENABLED == 1) |
| case hw_lpuart1: |
| HW_UART_TX(lpuart1, LPUART1); |
| break; |
| #endif |
| |
| default: |
| break; |
| } |
| |
| switch (hal_status) |
| { |
| case HAL_OK: |
| hw_status = hw_uart_ok; |
| break; |
| |
| case HAL_ERROR: |
| hw_status = hw_uart_error; |
| break; |
| |
| case HAL_BUSY: |
| hw_status = hw_uart_busy; |
| break; |
| |
| case HAL_TIMEOUT: |
| hw_status = hw_uart_to; |
| break; |
| |
| default: |
| break; |
| } |
| |
| return hw_status; |
| } |
| |
| hw_status_t HW_UART_Transmit_DMA(hw_uart_id_t hw_uart_id, uint8_t * p_data, uint16_t size, void (*cb)(void)) |
| { |
| HAL_StatusTypeDef hal_status = HAL_OK; |
| hw_status_t hw_status = hw_uart_ok; |
| |
| switch (hw_uart_id) |
| { |
| #if (CFG_HW_USART1_ENABLED == 1) |
| case hw_uart1: |
| HW_huart1TxCb = cb; |
| huart1.Instance = USART1; |
| hal_status = HAL_UART_Transmit_DMA(&huart1, p_data, size); |
| break; |
| #endif |
| |
| #if (CFG_HW_USART2_ENABLED == 1) |
| case hw_uart2: |
| HW_huart2TxCb = cb; |
| huart2.Instance = USART2; |
| hal_status = HAL_UART_Transmit_DMA(&huart2, p_data, size); |
| break; |
| #endif |
| |
| #if (CFG_HW_LPUART1_ENABLED == 1) |
| case hw_lpuart1: |
| HW_lpuart1TxCb = cb; |
| lpuart1.Instance = LPUART1; |
| hal_status = HAL_UART_Transmit_DMA(&lpuart1, p_data, size); |
| break; |
| #endif |
| |
| default: |
| break; |
| } |
| |
| switch (hal_status) |
| { |
| case HAL_OK: |
| hw_status = hw_uart_ok; |
| break; |
| |
| case HAL_ERROR: |
| hw_status = hw_uart_error; |
| break; |
| |
| case HAL_BUSY: |
| hw_status = hw_uart_busy; |
| break; |
| |
| case HAL_TIMEOUT: |
| hw_status = hw_uart_to; |
| break; |
| |
| default: |
| break; |
| } |
| |
| return hw_status; |
| } |
| |
| void HW_UART_Interrupt_Handler(hw_uart_id_t hw_uart_id) |
| { |
| switch (hw_uart_id) |
| { |
| #if (CFG_HW_USART1_ENABLED == 1) |
| case hw_uart1: |
| HAL_UART_IRQHandler(&huart1); |
| break; |
| #endif |
| |
| #if (CFG_HW_LPUART1_ENABLED == 1) |
| case hw_lpuart1: |
| HAL_UART_IRQHandler(&lpuart1); |
| break; |
| #endif |
| |
| default: |
| break; |
| } |
| |
| return; |
| } |
| |
| void HW_UART_DMA_Interrupt_Handler(hw_uart_id_t hw_uart_id) |
| { |
| switch (hw_uart_id) |
| { |
| #if (CFG_HW_USART1_DMA_TX_SUPPORTED == 1) |
| case hw_uart1: |
| HAL_DMA_IRQHandler(huart1.hdmatx); |
| break; |
| #endif |
| |
| #if (CFG_HW_USART2_DMA_TX_SUPPORTED == 1) |
| case hw_uart2: |
| HAL_DMA_IRQHandler(huart2.hdmatx); |
| break; |
| #endif |
| |
| #if (CFG_HW_LPUART1_DMA_TX_SUPPORTED == 1) |
| case hw_lpuart1: |
| HAL_DMA_IRQHandler(lpuart1.hdmatx); |
| break; |
| #endif |
| |
| default: |
| break; |
| } |
| |
| return; |
| } |
| |
| void HAL_UART_MspInit(UART_HandleTypeDef * huart) |
| { |
| GPIO_InitTypeDef GPIO_InitStruct = { 0 }; |
| |
| switch ((uint32_t) huart->Instance) |
| { |
| #if (CFG_HW_USART1_ENABLED == 1) |
| case (uint32_t) USART1: |
| HW_UART_MSP_UART_INIT(huart1, USART1); |
| #if (CFG_HW_USART1_DMA_TX_SUPPORTED == 1) |
| HW_UART_MSP_TX_DMA_INIT(huart1, USART1); |
| #endif |
| break; |
| #endif |
| |
| #if (CFG_HW_LPUART1_ENABLED == 1) |
| case (uint32_t) LPUART1: |
| HW_UART_MSP_UART_INIT(lpuart1, LPUART1); |
| #if (CFG_HW_LPUART1_DMA_TX_SUPPORTED == 1) |
| HW_UART_MSP_TX_DMA_INIT(lpuart1, LPUART1); |
| #endif |
| break; |
| #endif |
| |
| default: |
| break; |
| } |
| |
| return; |
| } |
| |
| void HAL_UART_RxCpltCallback(UART_HandleTypeDef * huart) |
| { |
| switch ((uint32_t) huart->Instance) |
| { |
| #if (CFG_HW_USART1_ENABLED == 1) |
| case (uint32_t) USART1: |
| if (HW_huart1RxCb) |
| { |
| HW_huart1RxCb(); |
| } |
| break; |
| #endif |
| |
| #if (CFG_HW_LPUART1_ENABLED == 1) |
| case (uint32_t) LPUART1: |
| if (HW_lpuart1RxCb) |
| { |
| HW_lpuart1RxCb(); |
| } |
| break; |
| #endif |
| |
| default: |
| break; |
| } |
| |
| return; |
| } |
| |
| void HAL_UART_TxCpltCallback(UART_HandleTypeDef * huart) |
| { |
| switch ((uint32_t) huart->Instance) |
| { |
| #if (CFG_HW_USART1_ENABLED == 1) |
| case (uint32_t) USART1: |
| if (HW_huart1TxCb) |
| { |
| HW_huart1TxCb(); |
| } |
| break; |
| #endif |
| |
| #if (CFG_HW_LPUART1_ENABLED == 1) |
| case (uint32_t) LPUART1: |
| if (HW_lpuart1TxCb) |
| { |
| HW_lpuart1TxCb(); |
| } |
| break; |
| #endif |
| |
| default: |
| break; |
| } |
| |
| return; |
| } |
