LibXR::STM32UART Class Reference

STM32 UART 驱动实现 / STM32 UART driver implementation. More...

#include <stm32_uart.hpp>

Inheritance diagram for LibXR::STM32UART:

Collaboration diagram for LibXR::STM32UART:

Public Member Functions
	STM32UART (UART_HandleTypeDef *uart_handle, RawData dma_buff_rx, RawData dma_buff_tx, uint32_t tx_queue_size=5)
	构造 UART 对象 / Construct UART object
ErrorCode	SetConfig (UART::Configuration config)
	设置 UART 配置 / Sets the UART configuration
void	SetRxDMA ()
Public Member Functions inherited from LibXR::UART
template<typename ReadPortType = ReadPort, typename WritePortType = WritePort>
	UART (ReadPortType *read_port, WritePortType *write_port)
	UART 构造函数 / UART constructor.
template<typename OperationType , typename = std::enable_if_t<std::is_base_of_v< WriteOperation, std::decay_t<OperationType>>>>
ErrorCode	Write (ConstRawData data, OperationType &&op, bool in_isr=false)
template<typename OperationType , typename = std::enable_if_t<std::is_base_of_v< ReadOperation, std::decay_t<OperationType>>>>
ErrorCode	Read (RawData data, OperationType &&op, bool in_isr=false)

Static Public Member Functions
static ErrorCode	WriteFun (WritePort &port, bool in_isr)
static ErrorCode	ReadFun (ReadPort &port, bool in_isr)

Data Fields
ReadPort	_read_port
WritePort	_write_port
RawData	dma_buff_rx_
DoubleBuffer	dma_buff_tx_
WriteInfoBlock	write_info_active_
size_t	last_rx_pos_ = 0
UART_HandleTypeDef *	uart_handle_
Flag::Plain	in_tx_isr
Flag::Plain	tx_busy_
stm32_uart_id_t	id_ = STM32_UART_ID_ERROR
Data Fields inherited from LibXR::UART
ReadPort *	read_port_
	读取端口 / Read port
WritePort *	write_port_
	写入端口 / Write port

Static Public Attributes
static STM32UART *	map [STM32_UART_NUMBER] = {nullptr}

Additional Inherited Members
Public Types inherited from LibXR::UART
enum class	Parity : uint8_t { NO_PARITY = 0 , EVEN = 1 , ODD = 2 }
	奇偶校验模式 / Parity mode More...

Detailed Description

STM32 UART 驱动实现 / STM32 UART driver implementation.

Definition at line 117 of file stm32_uart.hpp.

Constructor & Destructor Documentation

STM32UART()

STM32UART::STM32UART	(	UART_HandleTypeDef *	uart_handle,
		RawData	dma_buff_rx,
		RawData	dma_buff_tx,
		uint32_t	tx_queue_size = 5 )

构造 UART 对象 / Construct UART object

Definition at line 274 of file stm32_uart.cpp.

    : UART(&_read_port, &_write_port),
      _read_port(dma_buff_rx.size_),
      _write_port(tx_queue_size, dma_buff_tx.size_ / 2),
      dma_buff_rx_(dma_buff_rx),
      dma_buff_tx_(dma_buff_tx),
      uart_handle_(uart_handle),
      id_(stm32_uart_get_id(uart_handle_->Instance))
{
  ASSERT(id_ != STM32_UART_ID_ERROR);
 
  map[id_] = this;
 
  if ((uart_handle->Init.Mode & UART_MODE_TX) == UART_MODE_TX)
  {
    ASSERT(uart_handle_->hdmatx != NULL);
    _write_port = WriteFun;
  }
 
  SetRxDMA();
}

Member Function Documentation

ReadFun()

ErrorCode STM32UART::ReadFun ( ReadPort & port, bool in_isr )

static

Definition at line 272 of file stm32_uart.cpp.

{ return ErrorCode::PENDING; }

SetConfig()

ErrorCode STM32UART::SetConfig ( UART::Configuration config )

virtual

设置 UART 配置 / Sets the UART configuration

Parameters

config

UART 配置信息 / UART configuration settings

Returns

返回操作状态，成功时返回 ErrorCode::OK，否则返回相应错误码 / Returns the operation status, ErrorCode::OK if successful, otherwise an error code

该方法为纯虚函数，子类必须实现具体的 UART 配置逻辑。 This is a pure virtual function. Subclasses must implement the specific UART configuration logic.

Implements LibXR::UART.

Definition at line 297 of file stm32_uart.cpp.

{
  HAL_UART_DeInit(uart_handle_);
  uart_handle_->Init.BaudRate = config.baudrate;
 
  switch (config.parity)
  {
    case UART::Parity::NO_PARITY:
      uart_handle_->Init.Parity = UART_PARITY_NONE;
      uart_handle_->Init.WordLength = UART_WORDLENGTH_8B;
      break;
    case UART::Parity::EVEN:
      uart_handle_->Init.Parity = UART_PARITY_EVEN;
      uart_handle_->Init.WordLength = UART_WORDLENGTH_9B;
      break;
    case UART::Parity::ODD:
      uart_handle_->Init.Parity = UART_PARITY_ODD;
      uart_handle_->Init.WordLength = UART_WORDLENGTH_9B;
      break;
    default:
      ASSERT(false);
  }
 
  switch (config.stop_bits)
  {
    case 1:
      uart_handle_->Init.StopBits = UART_STOPBITS_1;
      break;
    case 2:
      uart_handle_->Init.StopBits = UART_STOPBITS_2;
      break;
    default:
      ASSERT(false);
  }
 
  if (HAL_UART_Init(uart_handle_) != HAL_OK)
  {
    return ErrorCode::INIT_ERR;
  }
 
  last_rx_pos_ = 0;
 
  SetRxDMA();
 
  if (tx_busy_.IsSet())
  {
    HAL_UART_Transmit_DMA(uart_handle_, dma_buff_tx_.ActiveBuffer(),
                          dma_buff_tx_.GetActiveLength());
  }
 
  return ErrorCode::OK;
}

SetRxDMA()

void STM32UART::SetRxDMA

(

)

Definition at line 350 of file stm32_uart.cpp.

{
  if ((uart_handle_->Init.Mode & UART_MODE_RX) == UART_MODE_RX)
  {
    ASSERT(uart_handle_->hdmarx != NULL);
 
    uart_handle_->hdmarx->Init.Mode = DMA_CIRCULAR;
    HAL_DMA_Init(uart_handle_->hdmarx);
 
    HAL_UARTEx_ReceiveToIdle_DMA(
        uart_handle_, reinterpret_cast<uint8_t*>(dma_buff_rx_.addr_), dma_buff_rx_.size_);
    _read_port = ReadFun;
  }
}

WriteFun()

ErrorCode STM32UART::WriteFun ( WritePort & port, bool in_isr )

static

Definition at line 196 of file stm32_uart.cpp.

{
  auto* uart = LibXR::ContainerOf(&port, &STM32UART::_write_port);
 
  if (uart->in_tx_isr.IsSet())
  {
    return ErrorCode::PENDING;
  }
 
  if (!uart->dma_buff_tx_.HasPending())
  {
    WriteInfoBlock info;
    if (port.queue_info_->Peek(info) != ErrorCode::OK)
    {
      return ErrorCode::PENDING;
    }
 
    uint8_t* buffer = nullptr;
    bool use_pending = false;
 
    if (uart->uart_handle_->gState == HAL_UART_STATE_READY)
    {
      buffer = reinterpret_cast<uint8_t*>(uart->dma_buff_tx_.ActiveBuffer());
    }
    else
    {
      buffer = reinterpret_cast<uint8_t*>(uart->dma_buff_tx_.PendingBuffer());
      use_pending = true;
    }
 
    if (port.queue_data_->PopBatch(reinterpret_cast<uint8_t*>(buffer), info.data.size_) !=
        ErrorCode::OK)
    {
      ASSERT(false);
      return ErrorCode::EMPTY;
    }
 
    if (use_pending)
    {
      uart->dma_buff_tx_.SetPendingLength(info.data.size_);
      uart->dma_buff_tx_.EnablePending();
      if (uart->uart_handle_->gState == HAL_UART_STATE_READY &&
          uart->dma_buff_tx_.HasPending())
      {
        uart->dma_buff_tx_.Switch();
      }
      else
      {
        return ErrorCode::PENDING;
      }
    }
 
    port.queue_info_->Pop(uart->write_info_active_);
 
    STM32_CleanDCacheByAddr(uart->dma_buff_tx_.ActiveBuffer(), info.data.size_);
 
    uart->dma_buff_tx_.SetActiveLength(info.data.size_);
    uart->tx_busy_.Set();
    auto ans = HAL_UART_Transmit_DMA(
        uart->uart_handle_, static_cast<uint8_t*>(uart->dma_buff_tx_.ActiveBuffer()),
        info.data.size_);
 
    if (ans != HAL_OK)
    {
      uart->tx_busy_.Clear();
      return ErrorCode::FAILED;
    }
    else
    {
      return ErrorCode::OK;
    }
  }
 
  return ErrorCode::PENDING;
}

Field Documentation

_read_port

ReadPort LibXR::STM32UART::_read_port

Definition at line 134 of file stm32_uart.hpp.

_write_port

WritePort LibXR::STM32UART::_write_port

Definition at line 135 of file stm32_uart.hpp.

dma_buff_rx_

RawData LibXR::STM32UART::dma_buff_rx_

Definition at line 137 of file stm32_uart.hpp.

dma_buff_tx_

DoubleBuffer LibXR::STM32UART::dma_buff_tx_

Definition at line 138 of file stm32_uart.hpp.

id_

stm32_uart_id_t LibXR::STM32UART::id_ = STM32_UART_ID_ERROR

Definition at line 147 of file stm32_uart.hpp.

in_tx_isr

Flag::Plain LibXR::STM32UART::in_tx_isr

Definition at line 145 of file stm32_uart.hpp.

last_rx_pos_

size_t LibXR::STM32UART::last_rx_pos_ = 0

Definition at line 141 of file stm32_uart.hpp.

map

STM32UART * STM32UART::map = {nullptr}

static

Definition at line 149 of file stm32_uart.hpp.

tx_busy_

Flag::Plain LibXR::STM32UART::tx_busy_

Definition at line 145 of file stm32_uart.hpp.

uart_handle_

UART_HandleTypeDef* LibXR::STM32UART::uart_handle_

Definition at line 143 of file stm32_uart.hpp.

write_info_active_

WriteInfoBlock LibXR::STM32UART::write_info_active_

Definition at line 139 of file stm32_uart.hpp.

---

The documentation for this class was generated from the following files:

• driver/st/stm32_uart.hpp
• driver/st/stm32_uart.cpp