Drone/User/bsp/uart.c

/* Includes ----------------------------------------------------------------- */
#include <usart.h>

#include "bsp/uart.h"

/* USER INCLUDE BEGIN */

/* USER INCLUDE END */

/* Private define ----------------------------------------------------------- */
/* USER DEFINE BEGIN */

/* USER DEFINE END */

/* Private macro ------------------------------------------------------------ */
/* Private typedef ---------------------------------------------------------- */
/* USER STRUCT BEGIN */

/* USER STRUCT END */

/* 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 == USART1)
    return BSP_UART_REF;
  else if (huart->Instance == USART3)
    return BSP_UART_DR16;
  else if (huart->Instance == USART6)
    return BSP_UART_AI;
  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_REF:
      return &huart1;
    case BSP_UART_DR16:
      return &huart3;
    case BSP_UART_AI:
      return &huart6;
    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;
  if (uart >= BSP_UART_NUM || type >= BSP_UART_CB_NUM) return BSP_ERR;
  UART_Callback[uart][type] = callback;
  return BSP_OK;
}

int8_t BSP_UART_Transmit(BSP_UART_t uart, uint8_t *data, uint16_t size, bool dma) {
  if (uart >= BSP_UART_NUM) return BSP_ERR;
  if (data == NULL || size == 0) return BSP_ERR_NULL;

  if (dma) {
    return HAL_UART_Transmit_DMA(BSP_UART_GetHandle(uart), data, size);
  } else {
    return HAL_UART_Transmit_IT(BSP_UART_GetHandle(uart), data, size);
  }
}

int8_t BSP_UART_Receive(BSP_UART_t uart, uint8_t *data, uint16_t size, bool dma) {
  if (uart >= BSP_UART_NUM) return BSP_ERR;
  if (data == NULL || size == 0) return BSP_ERR_NULL;

  if (dma) {
    return HAL_UART_Receive_DMA(BSP_UART_GetHandle(uart), data, size);
  } else {
    return HAL_UART_Receive_IT(BSP_UART_GetHandle(uart), data, size);
  }
}

/* USER FUNCTION BEGIN */


/**
 * @brief  开启串口空闲中断 + DMA 接收
 * @note   调用 HAL 库原生的接收函数，配合自定义的 IDLE 中断处理使用
 */
int8_t BSP_UART_Receive_IDLE(BSP_UART_t uart, uint8_t *data, uint16_t size) {
  if (uart >= BSP_UART_NUM) return BSP_ERR;
  if (data == NULL || size == 0) return BSP_ERR_NULL;

  /* 使用标准 DMA 接收，IDLE 标志将在你的 BSP_UART_IRQHandler 中被处理 */
  if (HAL_UART_Receive_DMA(BSP_UART_GetHandle(uart), data, size) != HAL_OK) {
    return BSP_ERR;
  }
  return BSP_OK;
}

/**
 * @brief  获取 DMA 当前实际接收到的数据长度
 * @param  max_size 开启 DMA 接收时传入的最大缓冲区长度
 */
uint16_t BSP_UART_GetRxCount(BSP_UART_t uart, uint16_t max_size) {
  UART_HandleTypeDef *huart = BSP_UART_GetHandle(uart);
  if (huart == NULL || huart->hdmarx == NULL) return 0;
  
  /* 实际接收长度 = 缓冲区总容量 - DMA通道剩余未传输数据量 */
  return max_size - __HAL_DMA_GET_COUNTER(huart->hdmarx);
}


/* USER FUNCTION END */