libxr  1.0
Want to be the best embedded framework
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Data Fields | Static Public Attributes
LibXR::CH32UART Class Reference
Inheritance diagram for LibXR::CH32UART:
[legend]
Collaboration diagram for LibXR::CH32UART:
[legend]

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})
 
ErrorCode SetConfig (UART::Configuration config)
 设置 UART 配置 / Sets the UART configuration
 
- 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)
 
template<typename OperationType , typename = std::enable_if_t<std::is_base_of_v< ReadOperation, std::decay_t<OperationType>>>>
ErrorCode Read (RawData data, OperationType &&op)
 

Static Public Member Functions

static ErrorCode WriteFun (WritePort &port)
 
static ErrorCode ReadFun (ReadPort &port)
 
static void DmaIRQHandler (DMA_Channel_TypeDef *channel, ch32_uart_id_t id)
 

Data Fields

ch32_uart_id_t id_
 
uint16_t uart_mode_
 
ReadPort _read_port
 
WritePort _write_port
 
RawData dma_buff_rx_
 
DoubleBuffer dma_buff_tx_
 
WriteInfoBlock write_info_active_
 
size_t last_rx_pos_ = 0
 
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}
 

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

Definition at line 16 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} )

Definition at line 14 of file ch32_uart.cpp.

18 : UART(&_read_port, &_write_port),
19 id_(id),
20 _read_port(dma_rx.size_),
21 _write_port(tx_queue_size, dma_tx.size_ / 2),
22 dma_buff_rx_(dma_rx),
23 dma_buff_tx_(dma_tx),
24 instance_(CH32_UART_GetInstanceID(id)),
25 dma_rx_channel_(CH32_UART_RX_DMA_CHANNEL_MAP[id]),
26 dma_tx_channel_(CH32_UART_TX_DMA_CHANNEL_MAP[id])
27{
28 map[id] = this;
29
30 bool tx_enable = dma_tx.size_ > 1;
31 bool rx_enable = dma_rx.size_ > 0;
32
33 ASSERT(tx_enable || rx_enable);
34
35 /* GPIO配置（TX: 推挽输出，RX: 悬空输入） */
36 GPIO_InitTypeDef gpio_init = {};
37 gpio_init.GPIO_Speed = GPIO_Speed_50MHz;
38
39 if (tx_enable)
40 {
41 (*write_port_) = WriteFun;
42 gpio_init.GPIO_Pin = tx_gpio_pin;
43 gpio_init.GPIO_Mode = GPIO_Mode_AF_PP;
44 GPIO_Init(tx_gpio_port, &gpio_init);
45 RCC_APB2PeriphClockCmd(CH32GetGPIOPeriph(tx_gpio_port), ENABLE);
46 }
47
48 if (rx_enable)
49 {
50 (*read_port_) = ReadFun;
51 gpio_init.GPIO_Pin = rx_gpio_pin;
52 gpio_init.GPIO_Mode = GPIO_Mode_IN_FLOATING;
53 GPIO_Init(rx_gpio_port, &gpio_init);
54 RCC_APB2PeriphClockCmd(CH32GetGPIOPeriph(rx_gpio_port), ENABLE);
55 }
56
57 /* 可选：引脚重映射 */
58 if (pin_remap != 0)
59 {
60 RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
61 GPIO_PinRemapConfig(pin_remap, ENABLE);
62 }
63
64 /* 串口外设时钟使能 */
65 if (CH32_UART_APB_MAP[id] == 1)
66 {
67 RCC_APB1PeriphClockCmd(CH32_UART_RCC_PERIPH_MAP[id], ENABLE);
68 }
69 else if (CH32_UART_APB_MAP[id] == 2)
70 {
71 RCC_APB2PeriphClockCmd(CH32_UART_RCC_PERIPH_MAP[id], ENABLE);
72 }
73 else
74 {
75 ASSERT(false);
76 }
77 RCC_AHBPeriphClockCmd(CH32_UART_RCC_PERIPH_MAP_DMA[id], ENABLE);
78
79 // 3. USART 配置
80 USART_InitTypeDef usart_cfg = {};
81 usart_cfg.USART_BaudRate = config.baudrate;
82 usart_cfg.USART_StopBits =
83 (config.stop_bits == 2) ? USART_StopBits_2 : USART_StopBits_1;
84 switch (config.parity)
85 {
86 case UART::Parity::NO_PARITY:
87 usart_cfg.USART_Parity = USART_Parity_No;
88 usart_cfg.USART_WordLength = USART_WordLength_8b;
89 break;
90 case UART::Parity::EVEN:
91 usart_cfg.USART_Parity = USART_Parity_Even;
92 usart_cfg.USART_WordLength = USART_WordLength_9b;
93 break;
94 case UART::Parity::ODD:
95 usart_cfg.USART_Parity = USART_Parity_Odd;
96 usart_cfg.USART_WordLength = USART_WordLength_9b;
97 break;
98 default:
99 ASSERT(false);
100 }
101
102 usart_cfg.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
103 usart_cfg.USART_Mode =
104 (tx_enable ? USART_Mode_Tx : 0) | (rx_enable ? USART_Mode_Rx : 0);
105 uart_mode_ = usart_cfg.USART_Mode;
106 USART_Init(instance_, &usart_cfg);
107
108 /* DMA 配置 */
109 DMA_InitTypeDef dma_init = {};
110 dma_init.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
111 dma_init.DMA_MemoryInc = DMA_MemoryInc_Enable;
112 dma_init.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
113 dma_init.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
114 dma_init.DMA_Priority = DMA_Priority_High;
115 dma_init.DMA_M2M = DMA_M2M_Disable;
116
117 if (rx_enable)
118 {
119 DMA_DeInit(dma_rx_channel_);
120 dma_init.DMA_PeripheralBaseAddr = (uint32_t)&instance_->DATAR;
121 dma_init.DMA_MemoryBaseAddr = (uint32_t)dma_buff_rx_.addr_;
122 dma_init.DMA_DIR = DMA_DIR_PeripheralSRC;
123 dma_init.DMA_Mode = DMA_Mode_Circular;
124 dma_init.DMA_BufferSize = dma_buff_rx_.size_;
125 DMA_Init(dma_rx_channel_, &dma_init);
126 DMA_Cmd(dma_rx_channel_, ENABLE);
127 USART_DMACmd(instance_, USART_DMAReq_Rx, ENABLE);
128 }
129
130 if (tx_enable)
131 {
132 DMA_DeInit(dma_tx_channel_);
133 dma_init.DMA_PeripheralBaseAddr = (u32)(&instance_->DATAR);
134 dma_init.DMA_MemoryBaseAddr = 0;
135 dma_init.DMA_DIR = DMA_DIR_PeripheralDST;
136 dma_init.DMA_Mode = DMA_Mode_Normal;
137 dma_init.DMA_BufferSize = 0;
138 DMA_Init(dma_tx_channel_, &dma_init);
139 DMA_ITConfig(dma_tx_channel_, DMA_IT_TC, ENABLE);
140 USART_DMACmd(instance_, USART_DMAReq_Tx, ENABLE);
141 }
142
143 // 6. USART和相关中断
144 USART_Cmd(instance_, ENABLE);
145
146 if (rx_enable)
147 {
148 USART_ITConfig(instance_, USART_IT_IDLE, ENABLE);
149 }
150
151 if (tx_enable)
152 {
153 NVIC_EnableIRQ(CH32_DMA_IRQ_MAP[CH32_DMA_GetID(dma_tx_channel_)]);
154 }
155
156 NVIC_EnableIRQ(CH32_UART_IRQ_MAP[id]);
157}
LibXR::RawData::size_
size_t size_
数据大小（字节）。 The size of the data (in bytes).
Definition libxr_type.hpp:115
LibXR::RawData::addr_
void * addr_
数据存储地址。 The storage address of the data.
Definition libxr_type.hpp:114
LibXR::UART::Parity::NO_PARITY
@ NO_PARITY
无校验 / No parity
LibXR::UART::Parity::ODD
@ ODD
奇校验 / Odd parity
LibXR::UART::Parity::EVEN
@ EVEN
偶校验 / Even parity
LibXR::UART::UART
UART(ReadPortType *read_port, WritePortType *write_port)
UART 构造函数 / UART constructor.
Definition uart.hpp:64
LibXR::ReadFun
ErrorCode(* ReadFun)(ReadPort &port)
Function pointer type for read operations.
Definition libxr_rw.hpp:247
LibXR::WriteFun
ErrorCode(* WriteFun)(WritePort &port)
Function pointer type for write operations.
Definition libxr_rw.hpp:243
LibXR::UART::Configuration::stop_bits
uint8_t stop_bits
停止位长度 / Number of stop bits
Definition uart.hpp:48
LibXR::UART::Configuration::parity
Parity parity
校验模式 / Parity mode
Definition uart.hpp:46
LibXR::UART::Configuration::baudrate
uint32_t baudrate
波特率 / Baud rate
Definition uart.hpp:45

Member Function Documentation

◆ DmaIRQHandler()

void CH32UART::DmaIRQHandler ( DMA_Channel_TypeDef * channel,
ch32_uart_id_t id )
static

Definition at line 369 of file ch32_uart.cpp.

370{
371 if (DMA_GetITStatus(CH32_UART_TX_DMA_IT_MAP[id]) == RESET) return;
372
373 if (channel->CNTR == 0) CH32_UART_ISR_Handler_TX_CPLT(id);
374}

◆ ReadFun()

ErrorCode CH32UART::ReadFun ( ReadPort & port)
static

Definition at line 268 of file ch32_uart.cpp.

269{
270 UNUSED(port);
271 // 接收由 IDLE 中断驱动，读取在 ISR 中完成
272 return ErrorCode::EMPTY;
273}

◆ SetConfig()

ErrorCode CH32UART::SetConfig ( UART::Configuration config)
virtual

设置 UART 配置 / Sets the UART configuration

Parameters
configUART 配置信息 / 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 160 of file ch32_uart.cpp.

161{
162 USART_InitTypeDef usart_cfg = {};
163 usart_cfg.USART_BaudRate = config.baudrate;
164 usart_cfg.USART_StopBits =
165 (config.stop_bits == 2) ? USART_StopBits_2 : USART_StopBits_1;
166
167 switch (config.parity)
168 {
169 case UART::Parity::NO_PARITY:
170 usart_cfg.USART_Parity = USART_Parity_No;
171 usart_cfg.USART_WordLength = USART_WordLength_8b;
172 break;
173 case UART::Parity::EVEN:
174 usart_cfg.USART_Parity = USART_Parity_Even;
175 usart_cfg.USART_WordLength = USART_WordLength_9b;
176 break;
177 case UART::Parity::ODD:
178 usart_cfg.USART_Parity = USART_Parity_Odd;
179 usart_cfg.USART_WordLength = USART_WordLength_9b;
180 break;
181 default:
182 return ErrorCode::NOT_SUPPORT;
183 }
184
185 usart_cfg.USART_Mode = uart_mode_;
186 usart_cfg.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
187 USART_DeInit(instance_);
188 USART_Init(instance_, &usart_cfg);
189
190 if (uart_mode_ & USART_Mode_Rx)
191 {
192 USART_DMACmd(instance_, USART_DMAReq_Rx, ENABLE);
193 USART_ITConfig(instance_, USART_IT_IDLE, ENABLE);
194 }
195
196 if (uart_mode_ & USART_Mode_Tx)
197 {
198 USART_DMACmd(instance_, USART_DMAReq_Tx, ENABLE);
199 }
200
201 USART_Cmd(instance_, ENABLE);
202
203 return ErrorCode::OK;
204}

◆ WriteFun()

ErrorCode CH32UART::WriteFun ( WritePort & port)
static

Definition at line 207 of file ch32_uart.cpp.

208{
209 CH32UART *uart = CONTAINER_OF(&port, CH32UART, _write_port);
210 if (!uart->dma_buff_tx_.HasPending())
211 {
212 WriteInfoBlock info;
213 if (port.queue_info_->Peek(info) != ErrorCode::OK)
214 {
215 return ErrorCode::EMPTY;
216 }
217
218 uint8_t *buffer = nullptr;
219 bool use_pending = false;
220
221 // DMA空闲判断
222 bool dma_ready = uart->dma_tx_channel_->CNTR == 0;
223 if (dma_ready)
224 {
225 buffer = reinterpret_cast<uint8_t *>(uart->dma_buff_tx_.ActiveBuffer());
226 }
227 else
228 {
229 buffer = reinterpret_cast<uint8_t *>(uart->dma_buff_tx_.PendingBuffer());
230 use_pending = true;
231 }
232
233 if (port.queue_data_->PopBatch(buffer, info.data.size_) != ErrorCode::OK)
234 {
235 ASSERT(false);
236 return ErrorCode::EMPTY;
237 }
238
239 if (use_pending)
240 {
241 uart->dma_buff_tx_.EnablePending();
242 // 检查当前DMA是否可切换
243 bool dma_ready = uart->dma_tx_channel_->CNTR == 0;
244 if (dma_ready && uart->dma_buff_tx_.HasPending())
245 {
246 uart->dma_buff_tx_.Switch();
247 }
248 else
249 {
250 return ErrorCode::FAILED;
251 }
252 }
253
254 port.queue_info_->Pop(uart->write_info_active_);
255
256 DMA_Cmd(uart->dma_tx_channel_, DISABLE);
257 uart->dma_tx_channel_->MADDR =
258 reinterpret_cast<uint32_t>(uart->dma_buff_tx_.ActiveBuffer());
259 uart->dma_tx_channel_->CNTR = info.data.size_;
260 DMA_Cmd(uart->dma_tx_channel_, ENABLE);
261
262 return ErrorCode::FAILED; // 实际是发起传输成功，但等待DMA完成
263 }
264 return ErrorCode::FAILED;
265}
LibXR::ConstRawData::size_
size_t size_
数据大小（字节）。 The size of the data (in bytes).
Definition libxr_type.hpp:215
LibXR::DoubleBuffer::HasPending
bool HasPending() const
判断是否有待切换的缓冲区 Checks whether a pending buffer is ready
Definition double_buffer.hpp:81
LibXR::DoubleBuffer::ActiveBuffer
uint8_t * ActiveBuffer()
获取当前正在使用的缓冲区指针 Returns the currently active buffer
Definition double_buffer.hpp:41
LibXR::DoubleBuffer::Switch
void Switch()
切换到备用缓冲区（若其有效） Switches to the pending buffer if it's valid
Definition double_buffer.hpp:66
LibXR::DoubleBuffer::PendingBuffer
uint8_t * PendingBuffer()
获取备用缓冲区的指针 Returns the pending (inactive) buffer
Definition double_buffer.hpp:49
LibXR::DoubleBuffer::EnablePending
void EnablePending()
手动启用 pending 状态 Manually sets the pending state to true
Definition double_buffer.hpp:129
LibXR::LockFreeQueue::PopBatch
ErrorCode PopBatch(Data *data, size_t size)
批量弹出数据 / Pops multiple elements from the queue
Definition lockfree_queue.hpp:243

Field Documentation

◆ _read_port

ReadPort LibXR::CH32UART::_read_port

Definition at line 34 of file ch32_uart.hpp.

◆ _write_port

WritePort LibXR::CH32UART::_write_port

Definition at line 35 of file ch32_uart.hpp.

◆ dma_buff_rx_

RawData LibXR::CH32UART::dma_buff_rx_

Definition at line 37 of file ch32_uart.hpp.

◆ dma_buff_tx_

DoubleBuffer LibXR::CH32UART::dma_buff_tx_

Definition at line 38 of file ch32_uart.hpp.

◆ dma_rx_channel_

DMA_Channel_TypeDef* LibXR::CH32UART::dma_rx_channel_

Definition at line 44 of file ch32_uart.hpp.

◆ dma_tx_channel_

DMA_Channel_TypeDef* LibXR::CH32UART::dma_tx_channel_

Definition at line 45 of file ch32_uart.hpp.

◆ id_

ch32_uart_id_t LibXR::CH32UART::id_

Definition at line 31 of file ch32_uart.hpp.

◆ instance_

USART_TypeDef* LibXR::CH32UART::instance_

Definition at line 43 of file ch32_uart.hpp.

◆ last_rx_pos_

size_t LibXR::CH32UART::last_rx_pos_ = 0

Definition at line 41 of file ch32_uart.hpp.

◆ map

CH32UART * CH32UART::map = {nullptr}
static

Definition at line 47 of file ch32_uart.hpp.

◆ uart_mode_

uint16_t LibXR::CH32UART::uart_mode_

Definition at line 32 of file ch32_uart.hpp.

◆ write_info_active_

WriteInfoBlock LibXR::CH32UART::write_info_active_

Definition at line 39 of file ch32_uart.hpp.

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