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

#include <ch32_uart.hpp>

Inheritance diagram for LibXR::CH32UART:

Collaboration diagram for LibXR::CH32UART:

Public Member Functions
	CH32UART (ch32_uart_id_t id, RawData dma_rx, RawData dma_tx, GPIO_TypeDef tx_gpio_port, uint16_t tx_gpio_pin, GPIO_TypeDef rx_gpio_port, uint16_t rx_gpio_pin, uint32_t pin_remap=0, uint32_t tx_queue_size=5, UART::Configuration config={115200, UART::Parity::NO_PARITY, 8, 1})
	构造 UART 对象 / Construct UART object

ErrorCode	SetConfig (UART::Configuration config)
	设置 UART 配置 / Sets the UART configuration

void	TxDmaIRQHandler ()

void	RxDmaIRQHandler ()
	DMA中断处理函数

void	OnRxDataAvailable (bool in_isr)

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
ch32_uart_id_t	id_

uint16_t	uart_mode_

ReadPort	_read_port

WritePort	_write_port

LatestSnapshot< UART::Configuration >	requested_config_

UartRxConfigGate	rx_config_gate_

UartCircularDmaRxModel	rx_dma_model_

UartDmaTxModel< CH32UART >	tx_dma_model_

USART_TypeDef *	instance_

DMA_Channel_TypeDef *	dma_rx_channel_

DMA_Channel_TypeDef *	dma_tx_channel_

Data Fields inherited from LibXR::UART
ReadPort *	read_port_
	读取端口 / Read port

WritePort *	write_port_
	写入端口 / Write port

Static Public Attributes
static CH32UART *	map_ [CH32_UART_NUMBER] = {nullptr}

Private Member Functions
void	OnConfigRequested ()

bool	ApplyPendingConfig (bool in_isr)

bool	OnConfigApplied (bool)

void	StartCircularDmaRx (uint8_t *data, size_t size)
	配置并启动 CH32 UART 循环 RX DMA 通道 / Configure and start the CH32 UART circular RX DMA channel

size_t	GetCircularDmaRxRemaining () const
	获取 CH32 RX DMA 剩余传输计数 / Get the CH32 RX DMA remaining count

void	PrepareCircularDmaRxForCpu (uint8_t *, size_t)
	为 CPU 访问准备 CH32 循环 DMA RX 存储区 / Prepare CH32 circular DMA RX storage for CPU access

bool	StartDmaTx (uint8_t *data, size_t size, int block)
	配置并启动一个 active UART TX DMA 载荷 / Configure and start one active UART TX DMA payload

Friends
class	UartCircularDmaRxModel

class	UartDmaTxModel< CH32UART >

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

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

Warning: 使用循环 RX DMA 时，USART/UART IDLE 中断与对应 RX DMA HT/TC 中断必须配置为相同的抢占优先级。本驱动依赖该优先级契约保证所有 RX 事件入口不重入，使 RX model 保持唯一 producer。 When circular RX DMA is enabled, the USART/UART IDLE IRQ and its RX DMA HT/TC IRQ must use the same preemption priority and, on multicore devices, the same target core. This keeps all RX event entries one logical producer; runtime configuration may execute on another core and is coordinated separately by UartRxConfigGate.

Definition at line 28 of file ch32_uart.hpp.

Constructor & Destructor Documentation

◆ CH32UART()

CH32UART::CH32UART	(	ch32_uart_id_t	id,
		RawData	dma_rx,
		RawData	dma_tx,
		GPIO_TypeDef *	tx_gpio_port,
		uint16_t	tx_gpio_pin,
		GPIO_TypeDef *	rx_gpio_port,
		uint16_t	rx_gpio_pin,
		uint32_t	pin_remap = 0,
		uint32_t	tx_queue_size = 5,
		UART::Configuration	config = {115200, UART::Parity::NO_PARITY, 8, 1} )

构造 UART 对象 / Construct UART object

Definition at line 15 of file ch32_uart.cpp.

    : UART(&_read_port, &_write_port),
      id_(id),
      _read_port(dma_rx.size_),
      _write_port(tx_queue_size, dma_tx.size_ / 2),
      requested_config_(config),
      rx_dma_model_(dma_rx),
      tx_dma_model_(*this, _write_port, dma_tx),
      instance_(ch32_uart_get_instance_id(id)),
      dma_rx_channel_(CH32_UART_RX_DMA_CHANNEL_MAP[id]),
      dma_tx_channel_(CH32_UART_TX_DMA_CHANNEL_MAP[id])
{
  map_[id] = this;
 
  bool tx_enable = dma_tx.size_ > 1;
  bool rx_enable = dma_rx.size_ > 0;
 
  ASSERT(tx_enable || rx_enable);
  if (tx_enable)
  {
    ASSERT(dma_tx_channel_ != nullptr);
    ASSERT(CH32_UART_TX_DMA_IT_MAP[id] != 0);
  }
  if (rx_enable)
  {
    ASSERT(dma_rx_channel_ != nullptr);
    ASSERT(CH32_UART_RX_DMA_IT_TC_MAP[id] != 0);
    ASSERT(CH32_UART_RX_DMA_IT_HT_MAP[id] != 0);
  }
 
  /* GPIO配置（TX: 推挽输出，RX: 悬空输入） */
  GPIO_InitTypeDef gpio_init = {};
  gpio_init.GPIO_Speed = GPIO_Speed_50MHz;
 
  if (tx_enable)
  {
    RCC_APB2PeriphClockCmd(ch32_get_gpio_periph(tx_gpio_port), ENABLE);
    gpio_init.GPIO_Pin = tx_gpio_pin;
    gpio_init.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_Init(tx_gpio_port, &gpio_init);
    (*write_port_) = WriteFun;
  }
 
  if (rx_enable)
  {
    RCC_APB2PeriphClockCmd(ch32_get_gpio_periph(rx_gpio_port), ENABLE);
    gpio_init.GPIO_Pin = rx_gpio_pin;
    gpio_init.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(rx_gpio_port, &gpio_init);
    (*read_port_) = ReadFun;
  }
 
  /* 可选：引脚重映射 */
  if (pin_remap != 0)
  {
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
    GPIO_PinRemapConfig(pin_remap, ENABLE);
  }
 
  /* 串口外设时钟使能 */
  if (CH32_UART_APB_MAP[id] == 1)
  {
    RCC_APB1PeriphClockCmd(CH32_UART_RCC_PERIPH_MAP[id], ENABLE);
  }
  else if (CH32_UART_APB_MAP[id] == 2)
  {
    RCC_APB2PeriphClockCmd(CH32_UART_RCC_PERIPH_MAP[id], ENABLE);
  }
  else
  {
    ASSERT(false);
  }
  RCC_AHBPeriphClockCmd(CH32_UART_RCC_PERIPH_MAP_DMA[id], ENABLE);
 
  // 3. USART 配置
  USART_InitTypeDef usart_cfg = {};
  usart_cfg.USART_BaudRate = config.baudrate;
  usart_cfg.USART_StopBits =
      (config.stop_bits == 2) ? USART_StopBits_2 : USART_StopBits_1;
  switch (config.parity)
  {
    case UART::Parity::NO_PARITY:
      usart_cfg.USART_Parity = USART_Parity_No;
      usart_cfg.USART_WordLength = USART_WordLength_8b;
      break;
    case UART::Parity::EVEN:
      usart_cfg.USART_Parity = USART_Parity_Even;
      usart_cfg.USART_WordLength = USART_WordLength_9b;
      break;
    case UART::Parity::ODD:
      usart_cfg.USART_Parity = USART_Parity_Odd;
      usart_cfg.USART_WordLength = USART_WordLength_9b;
      break;
    default:
      ASSERT(false);
  }
 
  usart_cfg.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  usart_cfg.USART_Mode =
      (tx_enable ? USART_Mode_Tx : 0) | (rx_enable ? USART_Mode_Rx : 0);
  uart_mode_ = usart_cfg.USART_Mode;
  USART_Init(instance_, &usart_cfg);
 
  /* DMA 配置 */
  DMA_InitTypeDef dma_init = {};
  dma_init.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  dma_init.DMA_MemoryInc = DMA_MemoryInc_Enable;
  dma_init.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  dma_init.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  dma_init.DMA_Priority = DMA_Priority_High;
  dma_init.DMA_M2M = DMA_M2M_Disable;
 
  if (rx_enable)
  {
    ch32_dma_callback_t rx_cb_fun = [](void* arg)
    { reinterpret_cast<CH32UART*>(arg)->RxDmaIRQHandler(); };
 
    ch32_dma_register_callback(ch32_dma_get_id(CH32_UART_RX_DMA_CHANNEL_MAP[id]),
                               rx_cb_fun, this);
 
    DMA_DeInit(dma_rx_channel_);
    dma_init.DMA_PeripheralBaseAddr = (uint32_t)&instance_->DATAR;
    dma_init.DMA_MemoryBaseAddr = (uint32_t)rx_dma_model_.Buffer();
    dma_init.DMA_DIR = DMA_DIR_PeripheralSRC;
    dma_init.DMA_Mode = DMA_Mode_Circular;
    dma_init.DMA_BufferSize = rx_dma_model_.BufferSize();
    DMA_Init(dma_rx_channel_, &dma_init);
    rx_dma_model_.Start(*this);
    DMA_ITConfig(dma_rx_channel_, DMA_IT_TC, ENABLE);
    DMA_ITConfig(dma_rx_channel_, DMA_IT_HT, ENABLE);
    USART_DMACmd(instance_, USART_DMAReq_Rx, ENABLE);
  }
 
  if (tx_enable)
  {
    ch32_dma_callback_t tx_cb_fun = [](void* arg)
    { reinterpret_cast<CH32UART*>(arg)->TxDmaIRQHandler(); };
 
    ch32_dma_register_callback(ch32_dma_get_id(CH32_UART_TX_DMA_CHANNEL_MAP[id]),
                               tx_cb_fun, this);
    DMA_DeInit(dma_tx_channel_);
    dma_init.DMA_PeripheralBaseAddr = (u32)(&instance_->DATAR);
    dma_init.DMA_MemoryBaseAddr = 0;
    dma_init.DMA_DIR = DMA_DIR_PeripheralDST;
    dma_init.DMA_Mode = DMA_Mode_Normal;
    dma_init.DMA_BufferSize = 0;
    DMA_Init(dma_tx_channel_, &dma_init);
    DMA_ITConfig(dma_tx_channel_, DMA_IT_TC, ENABLE);
    USART_DMACmd(instance_, USART_DMAReq_Tx, ENABLE);
  }
 
  // 6. USART和相关中断
  USART_Cmd(instance_, ENABLE);
 
  if (rx_enable)
  {
    USART_ITConfig(instance_, USART_IT_IDLE, ENABLE);
    NVIC_EnableIRQ(CH32_DMA_IRQ_MAP[ch32_dma_get_id(dma_rx_channel_)]);
  }
 
  if (tx_enable)
  {
    NVIC_EnableIRQ(CH32_DMA_IRQ_MAP[ch32_dma_get_id(dma_tx_channel_)]);
  }
 
  NVIC_EnableIRQ(CH32_UART_IRQ_MAP[id]);
}

Member Function Documentation

◆ ApplyPendingConfig()

bool CH32UART::ApplyPendingConfig ( bool in_isr )

private

Definition at line 204 of file ch32_uart.cpp.

{
  UNUSED(in_isr);
  if (!rx_config_gate_.TryEnterConfig())
  {
    return false;
  }
 
  UART::Configuration config{};
  (void)requested_config_.LoadLatest(config);
 
  if (uart_mode_ & USART_Mode_Tx)
  {
    USART_DMACmd(instance_, USART_DMAReq_Tx, DISABLE);
    DMA_Cmd(dma_tx_channel_, DISABLE);
    DMA_ClearITPendingBit(CH32_UART_TX_DMA_IT_MAP[id_]);
  }
  if (uart_mode_ & USART_Mode_Rx)
  {
    USART_DMACmd(instance_, USART_DMAReq_Rx, DISABLE);
    DMA_Cmd(dma_rx_channel_, DISABLE);
    DMA_ClearITPendingBit(CH32_UART_RX_DMA_IT_HT_MAP[id_]);
    DMA_ClearITPendingBit(CH32_UART_RX_DMA_IT_TC_MAP[id_]);
  }
 
  USART_InitTypeDef usart_cfg = {};
  usart_cfg.USART_BaudRate = config.baudrate;
  usart_cfg.USART_StopBits =
      (config.stop_bits == 2) ? USART_StopBits_2 : USART_StopBits_1;
 
  switch (config.parity)
  {
    case UART::Parity::NO_PARITY:
      usart_cfg.USART_Parity = USART_Parity_No;
      usart_cfg.USART_WordLength = USART_WordLength_8b;
      break;
    case UART::Parity::EVEN:
      usart_cfg.USART_Parity = USART_Parity_Even;
      usart_cfg.USART_WordLength = USART_WordLength_9b;
      break;
    case UART::Parity::ODD:
      usart_cfg.USART_Parity = USART_Parity_Odd;
      usart_cfg.USART_WordLength = USART_WordLength_9b;
      break;
    default:
      ASSERT(false);
      return true;
  }
 
  usart_cfg.USART_Mode = uart_mode_;
  usart_cfg.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  USART_DeInit(instance_);
  USART_Init(instance_, &usart_cfg);
 
  if (uart_mode_ & USART_Mode_Rx)
  {
    rx_dma_model_.Start(*this);
    USART_DMACmd(instance_, USART_DMAReq_Rx, ENABLE);
    USART_ITConfig(instance_, USART_IT_IDLE, ENABLE);
  }
 
  if (uart_mode_ & USART_Mode_Tx)
  {
    USART_DMACmd(instance_, USART_DMAReq_Tx, ENABLE);
  }
 
  USART_Cmd(instance_, ENABLE);
  return true;
}

◆ GetCircularDmaRxRemaining()

size_t LibXR::CH32UART::GetCircularDmaRxRemaining ( ) const

inlinenodiscardprivate

获取 CH32 RX DMA 剩余传输计数 / Get the CH32 RX DMA remaining count

Returns: DMA 尚未写入的字节数 / Number of bytes not yet written by DMA

Definition at line 94 of file ch32_uart.hpp.

94{ return dma_rx_channel_->CNTR; }

◆ OnConfigApplied()

bool LibXR::CH32UART::OnConfigApplied ( bool )

inlineprivate

Definition at line 71 of file ch32_uart.hpp.

  {
    rx_config_gate_.LeaveConfig();
    return true;
  }

◆ OnConfigRequested()

void LibXR::CH32UART::OnConfigRequested ( )

inlineprivate

Definition at line 69 of file ch32_uart.hpp.

69{ rx_config_gate_.RequestConfig(); }

◆ OnRxDataAvailable()

void CH32UART::OnRxDataAvailable ( bool in_isr )

Definition at line 299 of file ch32_uart.cpp.

{
  if (!rx_config_gate_.TryEnterRx())
  {
    return;
  }
 
  rx_dma_model_.OnDataAvailable(*this, _read_port, in_isr);
  if (rx_config_gate_.LeaveRx())
  {
    tx_dma_model_.RequestConfig(in_isr);
  }
}

◆ PrepareCircularDmaRxForCpu()

void LibXR::CH32UART::PrepareCircularDmaRxForCpu	(	uint8_t *	,
		size_t	)

inlineprivate

为 CPU 访问准备 CH32 循环 DMA RX 存储区 / Prepare CH32 circular DMA RX storage for CPU access

Parameters

data	DMA 接收缓冲区起始地址 / DMA receive buffer start address
size	接收缓冲区字节数 / Receive buffer capacity in bytes

Note: 该 CH32 缓冲区不需要缓存维护 / This CH32 buffer requires no cache maintenance

Definition at line 103 of file ch32_uart.hpp.

103{}

◆ ReadFun()

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

static

Definition at line 291 of file ch32_uart.cpp.

{
  // 接收由 IDLE 中断驱动，读取在 ISR 中完成
  return ErrorCode::PENDING;
}

◆ RxDmaIRQHandler()

void CH32UART::RxDmaIRQHandler ( )

DMA中断处理函数

如果DMA中断触发，且中断状态为半满或传输完成，清除中断标志，并调用对应的中断处理函数

Parameters

[in] id UART的ID

Definition at line 362 of file ch32_uart.cpp.

{
  if (DMA_GetITStatus(CH32_UART_RX_DMA_IT_HT_MAP[id_]) == SET)
  {
    DMA_ClearITPendingBit(CH32_UART_RX_DMA_IT_HT_MAP[id_]);
    ch32_uart_rx_isr_handler(this);
  }
 
  if (DMA_GetITStatus(CH32_UART_RX_DMA_IT_TC_MAP[id_]) == SET)
  {
    DMA_ClearITPendingBit(CH32_UART_RX_DMA_IT_TC_MAP[id_]);
    ch32_uart_rx_isr_handler(this);
  }
}

◆ SetConfig()

ErrorCode CH32UART::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 187 of file ch32_uart.cpp.

{
  if ((config.stop_bits != 1U) && (config.stop_bits != 2U))
  {
    return ErrorCode::ARG_ERR;
  }
  if ((config.parity != UART::Parity::NO_PARITY) &&
      (config.parity != UART::Parity::EVEN) && (config.parity != UART::Parity::ODD))
  {
    return ErrorCode::ARG_ERR;
  }
 
  requested_config_.Store(config);
  tx_dma_model_.RequestConfig(false);
  return ErrorCode::OK;
}

◆ StartCircularDmaRx()

void LibXR::CH32UART::StartCircularDmaRx	(	uint8_t *	data,
		size_t	size )

inlineprivate

配置并启动 CH32 UART 循环 RX DMA 通道 / Configure and start the CH32 UART circular RX DMA channel

Parameters

data	DMA 可写的接收缓冲区 / DMA-writable receive buffer
size	接收缓冲区字节数 / Receive buffer capacity in bytes

Definition at line 83 of file ch32_uart.hpp.

  {
    dma_rx_channel_->MADDR = reinterpret_cast<uint32_t>(data);
    dma_rx_channel_->CNTR = size;
    DMA_Cmd(dma_rx_channel_, ENABLE);
  }

◆ StartDmaTx()

bool CH32UART::StartDmaTx	(	uint8_t *	data,
		size_t	size,
		int	block )

private

配置并启动一个 active UART TX DMA 载荷 / Configure and start one active UART TX DMA payload

Parameters

data	DMA 可读的载荷缓冲区 / DMA-readable payload buffer
size	载荷字节数 / Payload size in bytes
block	active 双缓冲块索引，CH32 DMA 不使用 / Active double-buffer block index, unused by CH32 DMA

Returns: DMA 通道启用后返回 true / True after the DMA channel is enabled

Definition at line 281 of file ch32_uart.cpp.

{
  DMA_Cmd(dma_tx_channel_, DISABLE);
  dma_tx_channel_->MADDR = reinterpret_cast<uint32_t>(data);
  dma_tx_channel_->CNTR = size;
  DMA_Cmd(dma_tx_channel_, ENABLE);
  return true;
}

◆ TxDmaIRQHandler()

void CH32UART::TxDmaIRQHandler ( )

Definition at line 341 of file ch32_uart.cpp.

{
  if (DMA_GetITStatus(CH32_UART_TX_DMA_IT_MAP[id_]) == RESET)
  {
    return;
  }
 
  if (dma_tx_channel_->CNTR == 0)
  {
    ch32_uart_isr_handler_tx_cplt(this);
  }
}

◆ WriteFun()

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

static

Definition at line 275 of file ch32_uart.cpp.

{
  auto* uart = LibXR::ContainerOf(&port, &CH32UART::_write_port);
  return uart->tx_dma_model_.Submit(in_isr);
}

Friends And Related Symbol Documentation

◆ UartCircularDmaRxModel

friend class UartCircularDmaRxModel

friend

Definition at line 30 of file ch32_uart.hpp.

◆ UartDmaTxModel< CH32UART >

friend class UartDmaTxModel< CH32UART >

friend

Definition at line 30 of file ch32_uart.hpp.

Field Documentation

◆ _read_port

ReadPort LibXR::CH32UART::_read_port

Definition at line 54 of file ch32_uart.hpp.

◆ _write_port

WritePort LibXR::CH32UART::_write_port

Definition at line 55 of file ch32_uart.hpp.

◆ dma_rx_channel_

DMA_Channel_TypeDef* LibXR::CH32UART::dma_rx_channel_

Definition at line 63 of file ch32_uart.hpp.

◆ dma_tx_channel_

DMA_Channel_TypeDef* LibXR::CH32UART::dma_tx_channel_

Definition at line 64 of file ch32_uart.hpp.

◆ id_

ch32_uart_id_t LibXR::CH32UART::id_

Definition at line 51 of file ch32_uart.hpp.

◆ instance_

USART_TypeDef* LibXR::CH32UART::instance_

Definition at line 62 of file ch32_uart.hpp.

◆ map_

CH32UART * CH32UART::map_ = {nullptr}

static

Definition at line 66 of file ch32_uart.hpp.

◆ requested_config_

LatestSnapshot<UART::Configuration> LibXR::CH32UART::requested_config_

Definition at line 57 of file ch32_uart.hpp.

◆ rx_config_gate_

UartRxConfigGate LibXR::CH32UART::rx_config_gate_

Definition at line 58 of file ch32_uart.hpp.

◆ rx_dma_model_

UartCircularDmaRxModel LibXR::CH32UART::rx_dma_model_

Definition at line 59 of file ch32_uart.hpp.

◆ tx_dma_model_

UartDmaTxModel<CH32UART> LibXR::CH32UART::tx_dma_model_

Definition at line 60 of file ch32_uart.hpp.

◆ uart_mode_

uint16_t LibXR::CH32UART::uart_mode_

Definition at line 52 of file ch32_uart.hpp.

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

driver/ch/ch32_uart.hpp
driver/ch/ch32_uart.cpp

Public Member Functions

Static Public Member Functions

Data Fields

Static Public Attributes

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CH32UART()

Member Function Documentation

◆ ApplyPendingConfig()

◆ GetCircularDmaRxRemaining()

◆ OnConfigApplied()

◆ OnConfigRequested()

◆ OnRxDataAvailable()

◆ PrepareCircularDmaRxForCpu()

◆ ReadFun()

◆ RxDmaIRQHandler()

◆ SetConfig()

◆ StartCircularDmaRx()

◆ StartDmaTx()

◆ TxDmaIRQHandler()

◆ WriteFun()

Friends And Related Symbol Documentation

◆ UartCircularDmaRxModel

◆ UartDmaTxModel< CH32UART >

Field Documentation

◆ _read_port

◆ _write_port

◆ dma_rx_channel_

◆ dma_tx_channel_

◆ id_

◆ instance_

◆ map_

◆ requested_config_

◆ rx_config_gate_

◆ rx_dma_model_

◆ tx_dma_model_

◆ uart_mode_