ch32_uart.hpp

#pragma once
 
#include "libxr.hpp"
#include DEF2STR(LIBXR_CH32_CONFIG_FILE)
 
#include "ch32_uart_def.hpp"
#include "latest_snapshot.hpp"
#include "libxr_def.hpp"
#include "libxr_rw.hpp"
#include "model/uart_circular_dma_rx_model.hpp"
#include "model/uart_dma_tx_model.hpp"
#include "model/uart_rx_config_gate.hpp"
#include "uart.hpp"
 
namespace LibXR
{
 
class CH32UART : public UART
{
  friend class UartCircularDmaRxModel;
  friend class UartDmaTxModel<CH32UART>;
 
 public:
  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);
 
  static ErrorCode WriteFun(WritePort& port, bool in_isr);
  static ErrorCode ReadFun(ReadPort& port, bool in_isr);
 
  void TxDmaIRQHandler();
  void RxDmaIRQHandler();
  void OnRxDataAvailable(bool in_isr);
 
  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_;
 
  static CH32UART* map_[CH32_UART_NUMBER];
 
 private:
  void OnConfigRequested() { rx_config_gate_.RequestConfig(); }
  bool ApplyPendingConfig(bool in_isr);
  bool OnConfigApplied(bool)
  {
    rx_config_gate_.LeaveConfig();
    return true;
  }
 
  void StartCircularDmaRx(uint8_t* data, size_t size)
  {
    dma_rx_channel_->MADDR = reinterpret_cast<uint32_t>(data);
    dma_rx_channel_->CNTR = size;
    DMA_Cmd(dma_rx_channel_, ENABLE);
  }
 
  [[nodiscard]] size_t GetCircularDmaRxRemaining() const { return dma_rx_channel_->CNTR; }
 
  void PrepareCircularDmaRxForCpu(uint8_t*, size_t) {}
 
  bool StartDmaTx(uint8_t* data, size_t size, int block);
};
 
}  // namespace LibXR