prj to mdks

This commit is contained in:
hwq
2025-09-17 09:11:22 +08:00
parent ea8dcada90
commit 31a048e428
44 changed files with 268 additions and 2966 deletions
+693
View File
@@ -0,0 +1,693 @@
/**
* Change Logs:
* 憓𧼮 __HAL_UART_FLUSH_DRREGISTER
*/
/* Includes ------------------------------------------------------------------*/
#include "bsp_uart.h"
/* Private variables ---------------------------------------------------------*/
#if (BSP_USING_UART2_RE || BSP_USING_UART3_RE)
static volatile uint8_t _uart2_alter;
static volatile uint8_t _uart3_alter;
#endif
static UART_Callback_t _UART_RxCallback;
static UART_Callback_t _UART_RxIdleCallback;
static UART_Callback_t _UART_DMA_RxCallback;
static UART_Callback_t _UART_DMA_TxCallback;
#if (BSP_USING_UART1)
UART_CREATE(1);
#endif
#if (BSP_USING_UART2)
UART_CREATE(2);
#endif
#if (BSP_USING_UART2_RE)
UART_CREATE(2_RE);
#endif
#if (BSP_USING_UART3)
UART_CREATE(3);
#endif
#if (BSP_USING_UART3_RE)
UART_CREATE(3_RE);
#endif
#if (BSP_USING_UART4)
UART_CREATE(4);
#endif
#if (BSP_USING_UART5)
UART_CREATE(5);
#endif
#if (BSP_USING_UART6)
UART_CREATE(6);
#endif
struct UART_STRUCT *_uart_group[] =
{
#if (BSP_USING_UART1)
&UART(1),
#endif
#if (BSP_USING_UART2)
&UART(2),
#endif
#if (BSP_USING_UART2_RE)
&UART(2_RE),
#endif
#if (BSP_USING_UART3)
&UART(3),
#endif
#if (BSP_USING_UART3_RE)
&UART(3_RE),
#endif
#if (BSP_USING_UART4)
&UART(4),
#endif
#if (BSP_USING_UART5)
&UART(5),
#endif
#if (BSP_USING_UART6)
&UART(6),
#endif
};
static const uint8_t _uart_qty = sizeof(_uart_group) / sizeof(struct UART_STRUCT *);
/* Private function prototypes -----------------------------------------------*/
static inline void _UART_IntHandler (struct UART_STRUCT *uart);
static inline void _UART_Alternate (struct UART_STRUCT *uart);
/* Exported functions ---------------------------------------------------------*/
/**
* @brief UART 亙藁? * @note ?UART 憭𤥁挽𡝗𧋦賣㺭憭銵?UART 憭𤥁挽滚虾靚
* @param[in] uart: UART 撖寡情
* @param[in] rx_callback: 交𤣰桐葉賣㺭
* @param[in] rx_idle_callback: 蝛粹𤦭銝剜鱏? * @param[in] dma_rx_callback: DMA 交𤣰銝剜鱏? * @param[in] dma_tx_callback: DMA 賣㺭
* @retval None
*/
void BSP_UART_Port_Init( struct UART_STRUCT *uart,
UART_Callback_t rx_callback,
UART_Callback_t rx_idle_callback,
UART_Callback_t dma_rx_callback,
UART_Callback_t dma_tx_callback)
{
BSP_UART_Port_LockInit(uart);
_UART_RxCallback = rx_callback;
_UART_RxIdleCallback = rx_idle_callback;
_UART_DMA_RxCallback = dma_rx_callback;
_UART_DMA_TxCallback = dma_tx_callback;
/**
* 敶?uart->handle 霈曄眏蝟餌𡝗𧒄嚗䔶憒?CubeMX 憪见嚗䔶誑銝贝雿𨀣糓敹? * 嚗屸䌊撌勗 uart->handle ? * 望迨嚗?BSP_UART_Port_Init ?UART 憭𤥁挽𡝗𧋦賣㺭憭銵?UART 憭𤥁挽滚虾靚? */
switch (uart->id)
{
#if (BSP_USING_UART1)
case BSP_UART1: uart->handle = UART1_HANDLE; break;
#endif
#if (BSP_USING_UART2)
case BSP_UART2: uart->handle = UART2_HANDLE; break;
#endif
#if (BSP_USING_UART2_RE)
case BSP_UART2_RE: uart->handle = UART2_HANDLE; break;
#endif
#if (BSP_USING_UART3)
case BSP_UART3: uart->handle = UART3_HANDLE; break;
#endif
#if (BSP_USING_UART3_RE)
case BSP_UART3_RE: uart->handle = UART3_HANDLE; break;
#endif
#if (BSP_USING_UART4)
case BSP_UART4: uart->handle = UART4_HANDLE; break;
#endif
#if (BSP_USING_UART5)
case BSP_UART5: uart->handle = UART5_HANDLE; break;
#endif
#if (BSP_USING_UART6)
case BSP_UART6: uart->handle = UART6_HANDLE; break;
#endif
default: break;
}
if (uart->handle.hdmatx)
uart->handle.hdmatx->Parent = &uart->handle;
/* Clean the input path */
__HAL_UART_FLUSH_DRREGISTER(&uart->handle);
}
/**
* @brief UART 亙藁帋縑? * @note
* @param[in] uart: UART 撖寡情
* @retval BSP_UART_ERR
*/
BSP_UART_ERR BSP_UART_Port_LockInit(struct UART_STRUCT *uart)
{
return BSP_UART_ERR_OK;
}
/**
* @brief UART 蝑匧交𤣰唳旿
* @note
* @param[in] uart: UART 撖寡情
* @retval BSP_UART_ERR
*/
inline BSP_UART_ERR BSP_UART_Port_RxLock(struct UART_STRUCT *uart)
{
return BSP_UART_ERR_OK;
}
/**
* @brief UART 交𤣰唳㺭靽∪噡? * @note
* @param[in] uart: UART 撖寡情
* @retval BSP_UART_ERR
*/
inline BSP_UART_ERR BSP_UART_Port_RxUnlock(struct UART_STRUCT *uart)
{
return BSP_UART_ERR_OK;
}
/**
* @brief UART
* @note
* @param[in] uart: UART 撖寡情
* @retval BSP_UART_ERR
*/
inline BSP_UART_ERR BSP_UART_Port_TxLock(struct UART_STRUCT *uart)
{
return BSP_UART_ERR_OK;
}
/**
* @brief UART 瘥閗圾? * @note
* @param[in] uart: UART 撖寡情
* @retval BSP_UART_ERR
*/
inline BSP_UART_ERR BSP_UART_Port_TxUnlock(struct UART_STRUCT *uart)
{
return BSP_UART_ERR_OK;
}
/**
* @brief 雿輯 UART 交𤣰唳旿
* @note
* @param[in] uart: UART 撖寡情
* @retval BSP_UART_ERR
*/
BSP_UART_ERR BSP_UART_Port_EnableReceive(struct UART_STRUCT *uart)
{
BSP_UART_ERR ret = BSP_UART_ERR_OK;
if (uart->handle.hdmarx)
uart->handle.hdmarx->Parent = &uart->handle;
_UART_Alternate(uart);
if (uart->handle.hdmarx)
ret = (BSP_UART_ERR)HAL_UART_Receive_DMA(&uart->handle, (uint8_t *)uart->rx_buff, uart->rx_buff_max_len);
else
__HAL_UART_ENABLE_IT(&uart->handle, UART_IT_RXNE);
/* 撘舐征脖葉?*/
__HAL_UART_ENABLE_IT(&uart->handle, UART_IT_IDLE);
return ret;
}
/**
* @brief 蝳迫 UART 交𤣰唳旿
* @note
* @param[in] uart: UART 撖寡情
* @retval BSP_UART_ERR
*/
BSP_UART_ERR BSP_UART_Port_DisableReceive(struct UART_STRUCT *uart)
{
BSP_UART_ERR ret = BSP_UART_ERR_OK;
if (uart->handle.hdmarx)
ret = (BSP_UART_ERR)HAL_UART_DMAPause(&uart->handle);
else
__HAL_UART_DISABLE_IT(&uart->handle, UART_IT_RXNE);
__HAL_UART_DISABLE_IT(&uart->handle, UART_IT_IDLE);
return ret;
}
/**
* @brief UART 撣扳㺭? * @note
* @param[in] uart: UART 撖寡情
* @param[in] data: 閬唳旿
* @param[in] len: 閬唳旿踹漲嚗雿?byte憭折鵭摨? 65535 byte
* @param[in] timeout: 憭批嗆𧒄 ms憭扳摰𡁏𧒄? 65535 ms
* @retval BSP_UART_ERR
*/
BSP_UART_ERR BSP_UART_Port_Send(struct UART_STRUCT *uart, const uint8_t *data, uint16_t len, uint16_t timeout)
{
_UART_Alternate(uart);
if (timeout == 0)
{
if (uart->handle.hdmatx)
return (BSP_UART_ERR)HAL_UART_Transmit_DMA(&uart->handle, (uint8_t *)data, len);
else
return (BSP_UART_ERR)HAL_UART_Transmit_IT(&uart->handle, (uint8_t *)data, len);
}
else
return (BSP_UART_ERR)HAL_UART_Transmit(&uart->handle, (uint8_t *)data, len, timeout);
}
/**
* @brief 隞?UART 銝芸唳旿
* @note
* @param[in] uart: UART 撖寡情
* @retval UART 唳旿
*/
inline uint32_t BSP_UART_Port_GetOneByte(struct UART_STRUCT *uart)
{
return uart->handle.Instance->DR;
}
/**
* @brief DMA 敶枏? * @note
* @param[in] uart: UART 撖寡情
* @retval 霈⊥㺭? */
inline uint32_t BSP_UART_Port_GetDmaCounter(struct UART_STRUCT *uart)
{
return __HAL_DMA_GET_COUNTER(uart->handle.hdmarx);
}
/**
* @brief UART ID UART 撖寡情
* @note
* @param[in] id: 銝脣藁 ID
* @retval NULL: ?ID NULL: UART 撖寡情
*/
struct UART_STRUCT *BSP_UART_Port_GetHandle(BSP_UART_ID id)
{
for (uint8_t i = 0; i < _uart_qty; i++)
{
if (_uart_group[i]->id == id)
{
return _uart_group[i];
}
}
return NULL;
}
/* Private functions ---------------------------------------------------------*/
/**
* @brief UART 銝剜鱏銝剖? * @note
* @param[in] uart: UART 撖寡情
* @retval None
*/
static inline void _UART_IntHandler(struct UART_STRUCT *uart)
{
if (uart->handle.Instance == NULL)
return;
if (__HAL_UART_GET_FLAG(&uart->handle, UART_FLAG_RXNE) != RESET)
{
/* RXNE 銝剜鱏雿滢刻粉?DR 撖瘜閧&摰?_UART_RxCallback 臬炏隡朞粉靝R撖
隞亙銁甇文餈𥡝甈⊥?*/
__HAL_UART_CLEAR_FLAG(&uart->handle, UART_FLAG_RXNE);
if (_UART_RxCallback)
_UART_RxCallback(uart);
}
else if ((__HAL_UART_GET_FLAG(&uart->handle, UART_FLAG_IDLE) != RESET)
&& (__HAL_UART_GET_IT_SOURCE(&uart->handle, UART_IT_IDLE) != RESET))
{
/* IDLE 銝剜鱏雿滚蘨質蔓隞嗆?*/
__HAL_UART_CLEAR_IDLEFLAG(&uart->handle);
if (_UART_RxIdleCallback)
_UART_RxIdleCallback(uart);
}
else
{
HAL_UART_IRQHandler(&(uart->handle));
}
}
/**
* @brief 銝脣藁憭滨鍂賣㺭
* @note
* @param[in] uart: UART 撖寡情
* @retval None
*/
static inline void _UART_Alternate(struct UART_STRUCT *uart)
{
#if (BSP_USING_UART2_RE || BSP_USING_UART3_RE)
switch (uart->id)
{
case BSP_UART2:
case BSP_UART2_RE:
{
if (_uart2_alter != uart->id) /* 憭滨鍂揢 */
{
if (uart->id == BSP_UART2)
{
BSP_GPIO_SetMode(GET_PIN(A, 2), GPIO_MODE_AF_PP, GPIO_PULLUP); /* TX */
BSP_GPIO_SetMode(GET_PIN(A, 3), GPIO_MODE_INPUT, GPIO_PULLUP); /* RX */
__HAL_AFIO_REMAP_USART2_DISABLE();
}
else
{
BSP_GPIO_SetMode(GET_PIN(D, 5), GPIO_MODE_AF_PP, GPIO_PULLUP); /* TX */
BSP_GPIO_SetMode(GET_PIN(D, 6), GPIO_MODE_INPUT, GPIO_PULLUP); /* RX */
__HAL_AFIO_REMAP_USART2_ENABLE();
}
_uart2_alter = uart->id;
}
break;
}
case BSP_UART3:
case BSP_UART3_RE:
{
if (_uart3_alter != uart->id) /* 憭滨鍂揢 */
{
if (uart->id == BSP_UART3)
{
BSP_GPIO_SetMode(GET_PIN(B, 10), GPIO_MODE_AF_PP, GPIO_PULLUP); /* TX */
BSP_GPIO_SetMode(GET_PIN(B, 11), GPIO_MODE_INPUT, GPIO_PULLUP); /* RX */
__HAL_AFIO_REMAP_USART3_DISABLE();
}
else
{
BSP_GPIO_SetMode(GET_PIN(D, 8), GPIO_MODE_AF_PP, GPIO_PULLUP); /* TX */
BSP_GPIO_SetMode(GET_PIN(D, 9), GPIO_MODE_INPUT, GPIO_PULLUP); /* RX */
__HAL_AFIO_REMAP_USART3_ENABLE();
}
_uart3_alter = uart->id;
}
break;
}
default: break;
}
#endif
}
/* Callback functions ---------------------------------------------------------*/
/* 隞乩 4 銝芸遆?HAL 摨?UART 剖遆賣㺭 */
/* UART DMA 交𤣰𦠜說銝剜鱏 */
void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)
{
struct UART_STRUCT *uart = (struct UART_STRUCT *)huart;
if (_UART_DMA_RxCallback)
_UART_DMA_RxCallback(uart);
}
/* UART DMA 交𤣰冽說銝剜鱏 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
struct UART_STRUCT *uart = (struct UART_STRUCT *)huart;
if (_UART_DMA_RxCallback)
_UART_DMA_RxCallback(uart);
}
/* UART DMA 𣂷葉?*/
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
struct UART_STRUCT *uart = (struct UART_STRUCT *)huart;
if (_UART_DMA_TxCallback)
_UART_DMA_TxCallback(uart);
}
/* UART 銝剜鱏璉瘚见躰秤?*/
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
struct UART_STRUCT *uart = (struct UART_STRUCT *)huart;
//printf("%s: %d %d\r\n", __FUNCTION__, uart->id, huart->ErrorCode);
}
/* Interrupt request functions ---------------------------------------------------------*/
#if (BSP_USING_UART1)
void USART1_IRQHandler(void)
{
BSP_INT_ENTER();
_UART_IntHandler(&UART(1));
BSP_INT_EXIT();
}
void UART1_DMA_RX_IRQHandler(void)
{
BSP_INT_ENTER();
if (UART(1).rx_init)
{
HAL_DMA_IRQHandler(UART(1).handle.hdmarx);
}
BSP_INT_EXIT();
}
void UART1_DMA_TX_IRQHandler(void)
{
BSP_INT_ENTER();
HAL_DMA_IRQHandler(UART(1).handle.hdmatx);
BSP_INT_EXIT();
}
#endif
#if (BSP_USING_UART2)
void USART2_IRQHandler(void)
{
BSP_INT_ENTER();
#if (BSP_USING_UART2_RE)
if (_uart2_alter == BSP_UART2)
_UART_IntHandler(&UART(2));
else
_UART_IntHandler(&UART(2_RE));
#else
_UART_IntHandler(&UART(2));
#endif
BSP_INT_EXIT();
}
void UART2_DMA_RX_IRQHandler(void)
{
BSP_INT_ENTER();
if (UART(2).rx_init)
{
#if (BSP_USING_UART2_RE)
if (_uart2_alter == BSP_UART2)
HAL_DMA_IRQHandler(UART(2).handle.hdmarx);
else
HAL_DMA_IRQHandler(UART(2_RE).handle.hdmarx);
#else
HAL_DMA_IRQHandler(UART(2).handle.hdmarx);
#endif
}
BSP_INT_EXIT();
}
void UART2_DMA_TX_IRQHandler(void)
{
BSP_INT_ENTER();
#if (BSP_USING_UART2_RE)
if (_uart2_alter == BSP_UART2)
HAL_DMA_IRQHandler(UART(2).handle.hdmatx);
else
HAL_DMA_IRQHandler(UART(2_RE).handle.hdmarx);
#else
HAL_DMA_IRQHandler(UART(2).handle.hdmarx);
#endif
BSP_INT_EXIT();
}
#endif
#if (BSP_USING_UART3)
void USART3_IRQHandler(void)
{
BSP_INT_ENTER();
#if (BSP_USING_UART3_RE)
if (_uart3_alter == BSP_UART3)
_UART_IntHandler(&UART(3));
else
_UART_IntHandler(&UART(3_RE));
#else
_UART_IntHandler(&UART(3));
#endif
BSP_INT_EXIT();
}
void UART3_DMA_RX_IRQHandler(void)
{
BSP_INT_ENTER();
if (UART(3).rx_init)
{
#if (BSP_USING_UART3_RE)
if (_uart3_alter == BSP_UART3)
HAL_DMA_IRQHandler(UART(3).handle.hdmarx);
else
HAL_DMA_IRQHandler(UART(3_RE).handle.hdmarx);
#else
HAL_DMA_IRQHandler(UART(3).handle.hdmarx);
#endif
}
BSP_INT_EXIT();
}
void UART3_DMA_TX_IRQHandler(void)
{
BSP_INT_ENTER();
#if (BSP_USING_UART3_RE)
if (_uart3_alter == BSP_UART3)
HAL_DMA_IRQHandler(UART(3).handle.hdmarx);
else
HAL_DMA_IRQHandler(UART(3_RE).handle.hdmarx);
#else
HAL_DMA_IRQHandler(UART(3).handle.hdmarx);
#endif
BSP_INT_EXIT();
}
#endif
#if (BSP_USING_UART4)
void UART4_IRQHandler(void)
{
BSP_INT_ENTER();
_UART_IntHandler(&UART(4));
BSP_INT_EXIT();
}
void UART4_DMA_RX_IRQHandler(void)
{
BSP_INT_ENTER();
if (UART(4).rx_init)
{
HAL_DMA_IRQHandler(UART(4).handle.hdmarx);
}
BSP_INT_EXIT();
}
void UART4_DMA_TX_IRQHandler(void)
{
BSP_INT_ENTER();
HAL_DMA_IRQHandler(UART(4).handle.hdmatx);
BSP_INT_EXIT();
}
#endif
#if (BSP_USING_UART5)
void UART5_IRQHandler(void)
{
BSP_INT_ENTER();
_UART_IntHandler(&UART(5));
BSP_INT_EXIT();
}
void UART5_DMA_RX_IRQHandler(void)
{
BSP_INT_ENTER();
if (UART(5).rx_init)
{
HAL_DMA_IRQHandler(UART(5).handle.hdmarx);
}
BSP_INT_EXIT();
}
void UART5_DMA_TX_IRQHandler(void)
{
BSP_INT_ENTER();
HAL_DMA_IRQHandler(UART(5).handle.hdmatx);
BSP_INT_EXIT();
}
#endif
#if (BSP_USING_UART6)
void USART6_IRQHandler(void)
{
BSP_INT_ENTER();
_UART_IntHandler(&UART(6));
BSP_INT_EXIT();
}
void UART6_DMA_RX_IRQHandler(void)
{
BSP_INT_ENTER();
if (UART(6).rx_init)
{
HAL_DMA_IRQHandler(UART(6).handle.hdmarx);
}
BSP_INT_EXIT();
}
void UART6_DMA_TX_IRQHandler(void)
{
BSP_INT_ENTER();
HAL_DMA_IRQHandler(UART(6).handle.hdmatx);
BSP_INT_EXIT();
}
#endif