Inheritance diagram for LibXR::CH32SPI:

Collaboration diagram for LibXR::CH32SPI:

Public Member Functions
	CH32SPI (ch32_spi_id_t id, RawData dma_rx, RawData dma_tx, GPIO_TypeDef sck_port, uint16_t sck_pin, GPIO_TypeDef miso_port, uint16_t miso_pin, GPIO_TypeDef *mosi_port, uint16_t mosi_pin, uint32_t pin_remap=0, bool master_mode=true, bool firstbit_msb=true, uint16_t prescaler=SPI_BaudRatePrescaler_64, uint32_t dma_enable_min_size=3, SPI::Configuration config={SPI::ClockPolarity::LOW, SPI::ClockPhase::EDGE_1})

ErrorCode	ReadAndWrite (RawData read_data, ConstRawData write_data, OperationRW &op) override
	进行 SPI 读写操作。Performs SPI read and write operations.

ErrorCode	SetConfig (SPI::Configuration config) override
	设置 SPI 配置参数。Sets SPI configuration parameters.

ErrorCode	MemRead (uint16_t reg, RawData read_data, OperationRW &op) override
	从 SPI 设备的寄存器读取数据。 Reads data from a specific register of the SPI device.

ErrorCode	MemWrite (uint16_t reg, ConstRawData write_data, OperationRW &op) override
	向 SPI 设备的寄存器写入数据。 Writes data to a specific register of the SPI device.

ErrorCode	Transfer (size_t size, OperationRW &op) override
	进行一次SPI传输（使用当前缓冲区数据，零拷贝，支持双缓冲）。 Performs a SPI transfer (zero-copy, supports double buffering).

uint32_t	GetMaxBusSpeed () const override
	获取 SPI 设备的最大时钟速度。Gets the maximum clock speed of the SPI device.

SPI::Prescaler	GetMaxPrescaler () const override
	获取 SPI 设备的最大分频系数。Gets the maximum prescaler of the SPI device.

void	RxDmaIRQHandler ()

void	TxDmaIRQHandler ()

ErrorCode	PollingTransfer (uint8_t rx, const uint8_t tx, uint32_t len)

Public Member Functions inherited from LibXR::SPI
	SPI (RawData rx_buffer, RawData tx_buffer)
	构造函数。Constructor.

virtual ErrorCode	Read (RawData read_data, OperationRW &op)
	进行 SPI 读取操作。Performs SPI read operation.

virtual ErrorCode	Write (ConstRawData write_data, OperationRW &op)
	进行 SPI 写入操作。Performs SPI write operation.

uint32_t	GetBusSpeed () const
	获取 SPI 设备的当前总线速度。Gets the current bus speed of the SPI device.

Prescaler	CalcPrescaler (uint32_t target_max_bus_speed, uint32_t target_min_bus_speed, bool increase)
	计算 SPI 分频系数。Calculates the SPI prescaler.

RawData	GetRxBuffer ()
	获取接收数据的缓冲区。Gets the buffer for storing received data.

RawData	GetTxBuffer ()
	获取发送数据的缓冲区。Gets the buffer for storing data to be sent.

void	SwitchBuffer ()
	切换缓冲区。Switches the buffer.

void	SetActiveLength (size_t len)
	设置缓冲区的有效数据长度。Sets the length of valid data in the buffer.

size_t	GetActiveLength () const
	获取缓冲区的有效数据长度。Gets the length of valid data in the buffer.

Configuration &	GetConfig ()
	获取 SPI 配置参数。Gets the SPI configuration parameters.

bool	IsDoubleBuffer () const
	检查是否使用双缓冲区。Checks if double buffering is enabled.

Data Fields
SPI_TypeDef *	instance_

DMA_Channel_TypeDef *	dma_rx_channel_

DMA_Channel_TypeDef *	dma_tx_channel_

ch32_spi_id_t	id_

uint32_t	dma_enable_min_size_

OperationRW	rw_op_

RawData	read_buff_

bool	mem_read_ = false

bool	busy_ = false

uint16_t	mode_

uint16_t	datasize_

uint16_t	firstbit_

uint16_t	prescaler_

uint16_t	nss_ = SPI_NSS_Soft

GPIO_TypeDef *	sck_port_

uint16_t	sck_pin_

GPIO_TypeDef *	miso_port_

uint16_t	miso_pin_

GPIO_TypeDef *	mosi_port_

uint16_t	mosi_pin_

Static Public Attributes
static CH32SPI *	map [CH32_SPI_NUMBER] = {nullptr}

Private Member Functions
bool	DmaBusy () const

void	StartDmaDuplex (uint32_t count)

void	StopDma ()

void	PrepareTxBuffer (ConstRawData write_data, uint32_t need_len, uint32_t prefix=0, uint8_t dummy=0x00)

Static Private Member Functions
static SPI::Prescaler	MapCH32PrescalerToEnum (uint16_t p)

static bool	MapEnumToCH32Prescaler (SPI::Prescaler p, uint16_t &out)

Additional Inherited Members
Public Types inherited from LibXR::SPI
enum class	ClockPolarity : uint8_t { LOW = 0 , HIGH = 1 }
	定义 SPI 时钟极性。Defines the SPI clock polarity. More...

enum class	ClockPhase : uint8_t { EDGE_1 = 0 , EDGE_2 = 1 }
	定义 SPI 时钟相位。Defines the SPI clock phase. More...

enum class	Prescaler : uint8_t { DIV_1 = 0 , DIV_2 = 1 , DIV_4 = 2 , DIV_8 = 3 , DIV_16 = 4 , DIV_32 = 5 , DIV_64 = 6 , DIV_128 = 7 , DIV_256 = 8 , DIV_512 = 9 , DIV_1024 = 10 , DIV_2048 = 11 , DIV_4096 = 12 , DIV_8192 = 13 , DIV_16384 = 14 , DIV_32768 = 15 , DIV_65536 = 16 , UNKNOWN = 0xFF }

using	OperationRW = WriteOperation
	定义读写操作类型的别名。Defines an alias for the read/write operation type.

Static Public Member Functions inherited from LibXR::SPI
static constexpr uint32_t	PrescalerToDiv (Prescaler prescaler)
	将分频系数转换为除数。Converts a prescaler to a divisor.

Detailed Description

Definition at line 16 of file ch32_spi.hpp.

Constructor & Destructor Documentation

◆ CH32SPI()

CH32SPI::CH32SPI	(	ch32_spi_id_t	id,
		RawData	dma_rx,
		RawData	dma_tx,
		GPIO_TypeDef *	sck_port,
		uint16_t	sck_pin,
		GPIO_TypeDef *	miso_port,
		uint16_t	miso_pin,
		GPIO_TypeDef *	mosi_port,
		uint16_t	mosi_pin,
		uint32_t	pin_remap = 0,
		bool	master_mode = true,
		bool	firstbit_msb = true,
		uint16_t	prescaler = SPI_BaudRatePrescaler_64,
		uint32_t	dma_enable_min_size = 3,
		SPI::Configuration	config = {SPI::ClockPolarity::LOW, SPI::ClockPhase::EDGE_1} )

Definition at line 61 of file ch32_spi.cpp.

    : SPI(dma_rx, dma_tx),
      instance_(CH32_SPI_GetInstanceID(id)),
      dma_rx_channel_(CH32_SPI_RX_DMA_CHANNEL_MAP[id]),
      dma_tx_channel_(CH32_SPI_TX_DMA_CHANNEL_MAP[id]),
      id_(id),
      dma_enable_min_size_(dma_enable_min_size),
      mode_(master_mode ? SPI_Mode_Master : SPI_Mode_Slave),
      datasize_(SPI_DataSize_8b),
      firstbit_(firstbit_msb ? SPI_FirstBit_MSB : SPI_FirstBit_LSB),
      prescaler_(prescaler),
      sck_port_(sck_port),
      sck_pin_(sck_pin),
      miso_port_(miso_port),
      miso_pin_(miso_pin),
      mosi_port_(mosi_port),
      mosi_pin_(mosi_pin)
{
  ASSERT(instance_ != nullptr);
 
  map[id] = this;
 
  // === 时钟 ===
  if (CH32_SPI_APB_MAP[id] == 1)
  {
    RCC_APB1PeriphClockCmd(CH32_SPI_RCC_PERIPH_MAP[id], ENABLE);
  }
  else if (CH32_SPI_APB_MAP[id] == 2)
  {
    RCC_APB2PeriphClockCmd(CH32_SPI_RCC_PERIPH_MAP[id], ENABLE);
  }
  else
  {
    ASSERT(false);
  }
  RCC_AHBPeriphClockCmd(CH32_SPI_RCC_PERIPH_MAP_DMA[id], ENABLE);
 
  // === GPIO ===
  {
    GPIO_InitTypeDef gpio = {};
    gpio.GPIO_Speed = GPIO_Speed_50MHz;
 
    // SCK
    RCC_APB2PeriphClockCmd(CH32GetGPIOPeriph(sck_port_), ENABLE);
    if (mode_ == SPI_Mode_Master)
    {
      gpio.GPIO_Pin = sck_pin_;
      gpio.GPIO_Mode = GPIO_Mode_AF_PP;
    }
    else
    {
      gpio.GPIO_Pin = sck_pin_;
      gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    }
    GPIO_Init(sck_port_, &gpio);
 
    // MISO
    RCC_APB2PeriphClockCmd(CH32GetGPIOPeriph(miso_port_), ENABLE);
    if (mode_ == SPI_Mode_Master)
    {
      gpio.GPIO_Pin = miso_pin_;
      gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    }
    else
    {
      gpio.GPIO_Pin = miso_pin_;
      gpio.GPIO_Mode = GPIO_Mode_AF_PP;
    }
    GPIO_Init(miso_port_, &gpio);
 
    // MOSI
    RCC_APB2PeriphClockCmd(CH32GetGPIOPeriph(mosi_port_), ENABLE);
    if (mode_ == SPI_Mode_Master)
    {
      gpio.GPIO_Pin = mosi_pin_;
      gpio.GPIO_Mode = GPIO_Mode_AF_PP;
    }
    else
    {
      gpio.GPIO_Pin = mosi_pin_;
      gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    }
    GPIO_Init(mosi_port_, &gpio);
 
    if (pin_remap != 0)
    {
      RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
      GPIO_PinRemapConfig(pin_remap, ENABLE);
    }
  }
 
  // === SPI 基本配置 ===
  {
    SPI_InitTypeDef init = {};
    init.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    init.SPI_Mode = mode_;
    init.SPI_DataSize = datasize_;
    init.SPI_CPOL =
        (config.clock_polarity == SPI::ClockPolarity::LOW) ? SPI_CPOL_Low : SPI_CPOL_High;
    init.SPI_CPHA =
        (config.clock_phase == SPI::ClockPhase::EDGE_1) ? SPI_CPHA_1Edge : SPI_CPHA_2Edge;
    init.SPI_NSS = nss_;
    init.SPI_BaudRatePrescaler = prescaler_;
    init.SPI_FirstBit = firstbit_;
    init.SPI_CRCPolynomial = 7;
 
    SPI_Init(instance_, &init);
    SPI_Cmd(instance_, ENABLE);
  }
 
  // === DMA 通道基础配置（MADDR/CNTR 运行时再设） ===
  {
    // RX
    {
      ch32_dma_callback_t cb = [](void* arg)
      { reinterpret_cast<CH32SPI*>(arg)->RxDmaIRQHandler(); };
      CH32_DMA_RegisterCallback(CH32_DMA_GetID(dma_rx_channel_), cb, this);
 
      DMA_InitTypeDef di = {};
      DMA_DeInit(dma_rx_channel_);
      di.DMA_PeripheralBaseAddr = (uint32_t)&instance_->DATAR;
      di.DMA_MemoryBaseAddr = (uint32_t)dma_rx.addr_;
      di.DMA_DIR = DMA_DIR_PeripheralSRC;
      di.DMA_BufferSize = 0;
      di.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
      di.DMA_MemoryInc = DMA_MemoryInc_Enable;
      di.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
      di.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
      di.DMA_Mode = DMA_Mode_Normal;
      di.DMA_Priority = DMA_Priority_High;
      di.DMA_M2M = DMA_M2M_Disable;
      DMA_Init(dma_rx_channel_, &di);
      DMA_ITConfig(dma_rx_channel_, DMA_IT_TC, ENABLE);
      NVIC_EnableIRQ(CH32_DMA_IRQ_MAP[CH32_DMA_GetID(dma_rx_channel_)]);
    }
    // TX
    {
      ch32_dma_callback_t cb = [](void* arg)
      { reinterpret_cast<CH32SPI*>(arg)->TxDmaIRQHandler(); };
      CH32_DMA_RegisterCallback(CH32_DMA_GetID(dma_tx_channel_), cb, this);
 
      DMA_InitTypeDef di = {};
      DMA_DeInit(dma_tx_channel_);
      di.DMA_PeripheralBaseAddr = (uint32_t)&instance_->DATAR;
      di.DMA_MemoryBaseAddr = 0;
      di.DMA_DIR = DMA_DIR_PeripheralDST;
      di.DMA_BufferSize = 0;
      di.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
      di.DMA_MemoryInc = DMA_MemoryInc_Enable;
      di.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
      di.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
      di.DMA_Mode = DMA_Mode_Normal;
      di.DMA_Priority = DMA_Priority_VeryHigh;
      di.DMA_M2M = DMA_M2M_Disable;
      DMA_Init(dma_tx_channel_, &di);
      DMA_ITConfig(dma_tx_channel_, DMA_IT_TC, ENABLE);
      NVIC_EnableIRQ(CH32_DMA_IRQ_MAP[CH32_DMA_GetID(dma_tx_channel_)]);
    }
  }
 
  // === 同步基类配置用于速率查询 ===
  GetConfig() = config;
  GetConfig().prescaler = MapCH32PrescalerToEnum(prescaler_);
}

Member Function Documentation

◆ DmaBusy()

bool LibXR::CH32SPI::DmaBusy ( ) const

inlineprivate

Definition at line 47 of file ch32_spi.hpp.

  {
    return (dma_rx_channel_->CNTR != 0) || (dma_tx_channel_->CNTR != 0) || busy_;
  }

◆ GetMaxBusSpeed()

uint32_t CH32SPI::GetMaxBusSpeed ( ) const

overridevirtual

获取 SPI 设备的最大时钟速度。Gets the maximum clock speed of the SPI device.

Returns: SPI 设备的最大时钟速度（单位：Hz）。The maximum clock speed of the SPI device (in Hz).

Implements LibXR::SPI.

Definition at line 603 of file ch32_spi.cpp.

{
  RCC_ClocksTypeDef clocks{};
  RCC_GetClocksFreq(&clocks);
 
  if (CH32_SPI_APB_MAP[id_] == 2)
  {
    return clocks.PCLK2_Frequency;
  }
  else if (CH32_SPI_APB_MAP[id_] == 1)
  {
    return clocks.PCLK1_Frequency;
  }
  return 0u;
}

◆ GetMaxPrescaler()

SPI::Prescaler CH32SPI::GetMaxPrescaler ( ) const

overridevirtual

获取 SPI 设备的最大分频系数。Gets the maximum prescaler of the SPI device.

Returns: SPI 设备的最大分频系数。The maximum prescaler of the SPI device.

Implements LibXR::SPI.

Definition at line 620 of file ch32_spi.cpp.

{
#if defined(SPI_BaudRatePrescaler_1024)
  return SPI::Prescaler::DIV_1024;
#elif defined(SPI_BaudRatePrescaler_512)
  return SPI::Prescaler::DIV_512;
#elif defined(SPI_BaudRatePrescaler_256)
  return SPI::Prescaler::DIV_256;
#elif defined(SPI_BaudRatePrescaler_128)
  return SPI::Prescaler::DIV_128;
#elif defined(SPI_BaudRatePrescaler_64)
  return SPI::Prescaler::DIV_64;
#elif defined(SPI_BaudRatePrescaler_32)
  return SPI::Prescaler::DIV_32;
#elif defined(SPI_BaudRatePrescaler_16)
  return SPI::Prescaler::DIV_16;
#elif defined(SPI_BaudRatePrescaler_8)
  return SPI::Prescaler::DIV_8;
#elif defined(SPI_BaudRatePrescaler_4)
  return SPI::Prescaler::DIV_4;
#elif defined(SPI_BaudRatePrescaler_2)
  return SPI::Prescaler::DIV_2;
#else
  return SPI::Prescaler::UNKNOWN;
#endif
}

◆ MapCH32PrescalerToEnum()

SPI::Prescaler CH32SPI::MapCH32PrescalerToEnum ( uint16_t p )

staticprivate

Definition at line 647 of file ch32_spi.cpp.

{
  switch (p)
  {
#if defined(SPI_BaudRatePrescaler_2)
    case SPI_BaudRatePrescaler_2:
      return SPI::Prescaler::DIV_2;
#endif
#if defined(SPI_BaudRatePrescaler_4)
    case SPI_BaudRatePrescaler_4:
      return SPI::Prescaler::DIV_4;
#endif
#if defined(SPI_BaudRatePrescaler_8)
    case SPI_BaudRatePrescaler_8:
      return SPI::Prescaler::DIV_8;
#endif
#if defined(SPI_BaudRatePrescaler_16)
    case SPI_BaudRatePrescaler_16:
      return SPI::Prescaler::DIV_16;
#endif
#if defined(SPI_BaudRatePrescaler_32)
    case SPI_BaudRatePrescaler_32:
      return SPI::Prescaler::DIV_32;
#endif
#if defined(SPI_BaudRatePrescaler_64)
    case SPI_BaudRatePrescaler_64:
      return SPI::Prescaler::DIV_64;
#endif
#if defined(SPI_BaudRatePrescaler_128)
    case SPI_BaudRatePrescaler_128:
      return SPI::Prescaler::DIV_128;
#endif
#if defined(SPI_BaudRatePrescaler_256)
    case SPI_BaudRatePrescaler_256:
      return SPI::Prescaler::DIV_256;
#endif
    default:
      return SPI::Prescaler::UNKNOWN;
  }
}

◆ MapEnumToCH32Prescaler()

bool CH32SPI::MapEnumToCH32Prescaler	(	SPI::Prescaler	p,
		uint16_t &	out )

staticprivate

Definition at line 12 of file ch32_spi.cpp.

{
  switch (p)
  {
#if defined(SPI_BaudRatePrescaler_2)
    case SPI::Prescaler::DIV_2:
      out = SPI_BaudRatePrescaler_2;
      return true;
#endif
#if defined(SPI_BaudRatePrescaler_4)
    case SPI::Prescaler::DIV_4:
      out = SPI_BaudRatePrescaler_4;
      return true;
#endif
#if defined(SPI_BaudRatePrescaler_8)
    case SPI::Prescaler::DIV_8:
      out = SPI_BaudRatePrescaler_8;
      return true;
#endif
#if defined(SPI_BaudRatePrescaler_16)
    case SPI::Prescaler::DIV_16:
      out = SPI_BaudRatePrescaler_16;
      return true;
#endif
#if defined(SPI_BaudRatePrescaler_32)
    case SPI::Prescaler::DIV_32:
      out = SPI_BaudRatePrescaler_32;
      return true;
#endif
#if defined(SPI_BaudRatePrescaler_64)
    case SPI::Prescaler::DIV_64:
      out = SPI_BaudRatePrescaler_64;
      return true;
#endif
#if defined(SPI_BaudRatePrescaler_128)
    case SPI::Prescaler::DIV_128:
      out = SPI_BaudRatePrescaler_128;
      return true;
#endif
#if defined(SPI_BaudRatePrescaler_256)
    case SPI::Prescaler::DIV_256:
      out = SPI_BaudRatePrescaler_256;
      return true;
#endif
    default:
      return false;  // 不支持 DIV_1 或 >256 的枚举
  }
}

◆ MemRead()

ErrorCode CH32SPI::MemRead	(	uint16_t	reg,
		RawData	read_data,
		OperationRW &	op )

overridevirtual

从 SPI 设备的寄存器读取数据。 Reads data from a specific register of the SPI device.

Parameters

reg	寄存器地址。Register address.
read_data	读取的数据缓冲区。Buffer to store read data.
op	操作类型（同步/异步）。Operation mode (sync/async).

Returns: 操作结果的错误码。Error code indicating success or failure.

Implements LibXR::SPI.

Definition at line 356 of file ch32_spi.cpp.

{
  const uint32_t n = read_data.size_;
  if (n == 0)
  {
    if (op.type != OperationRW::OperationType::BLOCK)
      op.UpdateStatus(false, ErrorCode::OK);
    return ErrorCode::OK;
  }
 
  if (DmaBusy()) return ErrorCode::BUSY;
 
  RawData rx = GetRxBuffer();
  RawData tx = GetTxBuffer();
 
  ASSERT(rx.size_ >= n + 1);
  ASSERT(tx.size_ >= n + 1);
 
  const uint32_t total = n + 1;
 
  if (total > dma_enable_min_size_)
  {
    uint8_t* txp = static_cast<uint8_t*>(tx.addr_);
    txp[0] = static_cast<uint8_t>(reg | 0x80);
    memset(txp + 1, 0x00, n);
 
    mem_read_ = true;
    read_buff_ = read_data;
    rw_op_ = op;
    busy_ = true;
 
    StartDmaDuplex(total);
 
    op.MarkAsRunning();
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
  else
  {
    // 轮询
    uint8_t* rxp = static_cast<uint8_t*>(rx.addr_);
    uint8_t* txp = static_cast<uint8_t*>(tx.addr_);
    txp[0] = static_cast<uint8_t>(reg | 0x80);
    memset(txp + 1, 0x00, n);
 
    ErrorCode ec = PollingTransfer(rxp, txp, total);
    memcpy(read_data.addr_, rxp + 1, n);
 
    SwitchBuffer();
 
    if (op.type != OperationRW::OperationType::BLOCK) op.UpdateStatus(false, ec);
    return ec;
  }
}

◆ MemWrite()

ErrorCode CH32SPI::MemWrite	(	uint16_t	reg,
		ConstRawData	write_data,
		OperationRW &	op )

overridevirtual

向 SPI 设备的寄存器写入数据。 Writes data to a specific register of the SPI device.

Parameters

reg	寄存器地址。Register address.
write_data	写入的数据缓冲区。Buffer containing data to write.
op	操作类型（同步/异步）。Operation mode (sync/async).

Returns: 操作结果的错误码。Error code indicating success or failure.

Implements LibXR::SPI.

Definition at line 414 of file ch32_spi.cpp.

{
  const uint32_t n = write_data.size_;
  if (n == 0)
  {
    if (op.type != OperationRW::OperationType::BLOCK)
      op.UpdateStatus(false, ErrorCode::OK);
    return ErrorCode::OK;
  }
 
  if (DmaBusy()) return ErrorCode::BUSY;
 
  RawData rx = GetRxBuffer();
  RawData tx = GetTxBuffer();
  (void)rx;  // RX 仅用于丢弃
 
  ASSERT(tx.size_ >= n + 1);
 
  const uint32_t total = n + 1;
 
  if (total > dma_enable_min_size_)
  {
    uint8_t* txp = static_cast<uint8_t*>(tx.addr_);
    txp[0] = static_cast<uint8_t>(reg & 0x7F);
    memcpy(txp + 1, write_data.addr_, n);
 
    mem_read_ = false;
    read_buff_ = {nullptr, 0};
    rw_op_ = op;
    busy_ = true;
 
    StartDmaDuplex(total);
 
    op.MarkAsRunning();
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
  else
  {
    // 轮询
    uint8_t* rxp = static_cast<uint8_t*>(rx.addr_);
    uint8_t* txp = static_cast<uint8_t*>(tx.addr_);
    txp[0] = static_cast<uint8_t>(reg & 0x7F);
    memcpy(txp + 1, write_data.addr_, n);
 
    ErrorCode ec = PollingTransfer(rxp, txp, total);
 
    SwitchBuffer();
 
    if (op.type != OperationRW::OperationType::BLOCK) op.UpdateStatus(false, ec);
    return ec;
  }
}

◆ PollingTransfer()

ErrorCode CH32SPI::PollingTransfer	(	uint8_t *	rx,
		const uint8_t *	tx,
		uint32_t	len )

Definition at line 267 of file ch32_spi.cpp.

{
  for (uint32_t i = 0; i < len; ++i)
  {
    while (SPI_I2S_GetFlagStatus(instance_, SPI_I2S_FLAG_TXE) == RESET)
    {
    }
    SPI_I2S_SendData(instance_, tx ? tx[i] : 0x00);
 
    while (SPI_I2S_GetFlagStatus(instance_, SPI_I2S_FLAG_RXNE) == RESET)
    {
    }
    uint16_t d = SPI_I2S_ReceiveData(instance_);
    if (rx) rx[i] = static_cast<uint8_t>(d & 0xff);
  }
  return ErrorCode::OK;
}

◆ PrepareTxBuffer()

void CH32SPI::PrepareTxBuffer	(	ConstRawData	write_data,
		uint32_t	need_len,
		uint32_t	prefix = 0,
		uint8_t	dummy = 0x00 )

private

Definition at line 471 of file ch32_spi.cpp.

{
  RawData tx = GetTxBuffer();
  uint8_t* txp = static_cast<uint8_t*>(tx.addr_);
 
  if (write_data.size_ > 0)
  {
    const uint32_t copy =
        (write_data.size_ > need_len - prefix) ? (need_len - prefix) : write_data.size_;
    memcpy(txp + prefix, write_data.addr_, copy);
    if (prefix + copy < need_len)
    {
      memset(txp + prefix + copy, dummy, need_len - prefix - copy);
    }
  }
  else
  {
    memset(txp + prefix, dummy, need_len - prefix);
  }
}

◆ ReadAndWrite()

ErrorCode CH32SPI::ReadAndWrite	(	RawData	read_data,
		ConstRawData	write_data,
		OperationRW &	op )

overridevirtual

进行 SPI 读写操作。Performs SPI read and write operations.

Parameters

read_data	存储读取数据的缓冲区。Buffer to store the read data.
write_data	需要写入的数据缓冲区。Buffer containing the data to be written.
op	读写操作类型。Type of read/write operation.

Returns: 操作结果的错误码。Error code indicating the result of the operation.

Implements LibXR::SPI.

Definition at line 285 of file ch32_spi.cpp.

{
  const uint32_t rsz = read_data.size_;
  const uint32_t wsz = write_data.size_;
  const uint32_t need = (rsz > wsz) ? rsz : wsz;
 
  if (need == 0)
  {
    if (op.type != OperationRW::OperationType::BLOCK)
      op.UpdateStatus(false, ErrorCode::OK);
    return ErrorCode::OK;
  }
 
  if (DmaBusy()) return ErrorCode::BUSY;
 
  RawData rx = GetRxBuffer();
  RawData tx = GetTxBuffer();
 
  ASSERT(rx.size_ >= need);
  ASSERT(tx.size_ >= need);
 
  if (need > dma_enable_min_size_)
  {
    mem_read_ = false;
    read_buff_ = read_data;
    rw_op_ = op;
    busy_ = true;
 
    PrepareTxBuffer(write_data, need);
 
    StartDmaDuplex(need);
 
    op.MarkAsRunning();
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
  else
  {
    // 轮询路径（使用活动缓冲）
    uint8_t* rxp = static_cast<uint8_t*>(rx.addr_);
    uint8_t* txp = static_cast<uint8_t*>(tx.addr_);
 
    // 准备 tx
    if (wsz)
    {
      memcpy(txp, write_data.addr_, wsz);
      if (need > wsz) memset(txp + wsz, 0x00, need - wsz);
    }
    else
    {
      memset(txp, 0x00, need);
    }
 
    ErrorCode ec = PollingTransfer(rxp, txp, need);
 
    if (rsz)
    {
      memcpy(read_data.addr_, rxp, rsz);
    }
 
    SwitchBuffer();
 
    if (op.type != OperationRW::OperationType::BLOCK) op.UpdateStatus(false, ec);
    return ec;
  }
}

◆ RxDmaIRQHandler()

void CH32SPI::RxDmaIRQHandler ( )

Definition at line 517 of file ch32_spi.cpp.

{
  if (DMA_GetITStatus(CH32_SPI_RX_DMA_IT_MAP[id_]) == RESET) return;
 
  DMA_ClearITPendingBit(CH32_SPI_RX_DMA_IT_MAP[id_]);
 
  SPI_I2S_DMACmd(instance_, SPI_I2S_DMAReq_Rx, DISABLE);
  DMA_Cmd(dma_rx_channel_, DISABLE);
 
  // 拷贝读数据（若有）
  if (read_buff_.size_ > 0)
  {
    RawData rx = GetRxBuffer();
    uint8_t* rxp = static_cast<uint8_t*>(rx.addr_);
    if (mem_read_)
    {
      memcpy(read_buff_.addr_, rxp + 1, read_buff_.size_);
    }
    else
    {
      memcpy(read_buff_.addr_, rxp, read_buff_.size_);
    }
    read_buff_.size_ = 0;
  }
 
  // 双缓冲切换与状态更新
  SwitchBuffer();
  busy_ = false;
  rw_op_.UpdateStatus(true, ErrorCode::OK);
}

◆ SetConfig()

ErrorCode CH32SPI::SetConfig ( SPI::Configuration config )

overridevirtual

设置 SPI 配置参数。Sets SPI configuration parameters.

Parameters

config 需要应用的 SPI 配置。The SPI configuration to apply.

Returns: 操作结果的错误码。Error code indicating the result of the operation.

Implements LibXR::SPI.

Definition at line 231 of file ch32_spi.cpp.

{
  // 1) 把 SPI::Prescaler → CH32 Prescaler 宏
  uint16_t ch32_presc = 0;
  if (!MapEnumToCH32Prescaler(config.prescaler, ch32_presc))
  {
    return ErrorCode::NOT_SUPPORT;
  }
 
  // 2) 关 / 复位 / 重新初始化
  SPI_Cmd(instance_, DISABLE);
  SPI_I2S_DeInit(instance_);
 
  SPI_InitTypeDef init = {};
  init.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  init.SPI_Mode = mode_;
  init.SPI_DataSize = datasize_;
  init.SPI_CPOL =
      (config.clock_polarity == SPI::ClockPolarity::LOW) ? SPI_CPOL_Low : SPI_CPOL_High;
  init.SPI_CPHA =
      (config.clock_phase == SPI::ClockPhase::EDGE_1) ? SPI_CPHA_1Edge : SPI_CPHA_2Edge;
  init.SPI_NSS = nss_;
  init.SPI_BaudRatePrescaler = ch32_presc;
  init.SPI_FirstBit = firstbit_;
  init.SPI_CRCPolynomial = 7;
 
  SPI_Init(instance_, &init);
  SPI_Cmd(instance_, ENABLE);
 
  // 3) 同步本地缓存与基类配置（影响 GetBusSpeed/IsDoubleBuffer）
  prescaler_ = ch32_presc;
  GetConfig() = config;
 
  return ErrorCode::OK;
}

◆ StartDmaDuplex()

void CH32SPI::StartDmaDuplex ( uint32_t count )

private

Definition at line 493 of file ch32_spi.cpp.

{
  RawData rx = GetRxBuffer();
  RawData tx = GetTxBuffer();
 
  dma_rx_channel_->MADDR = reinterpret_cast<uint32_t>(rx.addr_);
  dma_rx_channel_->CNTR = count;
 
  dma_tx_channel_->MADDR = reinterpret_cast<uint32_t>(tx.addr_);
  dma_tx_channel_->CNTR = count;
 
  SPI_I2S_DMACmd(instance_, SPI_I2S_DMAReq_Rx, ENABLE);
  SPI_I2S_DMACmd(instance_, SPI_I2S_DMAReq_Tx, ENABLE);
 
  DMA_Cmd(dma_rx_channel_, ENABLE);
  DMA_Cmd(dma_tx_channel_, ENABLE);
}

◆ StopDma()

void CH32SPI::StopDma ( )

private

Definition at line 511 of file ch32_spi.cpp.

{
  DMA_Cmd(dma_tx_channel_, DISABLE);
  DMA_Cmd(dma_rx_channel_, DISABLE);
}

◆ Transfer()

ErrorCode CH32SPI::Transfer	(	size_t	size,
		OperationRW &	op )

overridevirtual

进行一次SPI传输（使用当前缓冲区数据，零拷贝，支持双缓冲）。 Performs a SPI transfer (zero-copy, supports double buffering).

Parameters

size	需要传输的数据大小。The size of the data to be transferred.
op	读写操作类型。Type of read/write operation.

Returns: 操作结果的错误码。Error code indicating the result of the operation.

Implements LibXR::SPI.

Definition at line 558 of file ch32_spi.cpp.

{
  if (DmaBusy()) return ErrorCode::BUSY;
 
  if (size == 0)
  {
    if (op.type != OperationRW::OperationType::BLOCK)
      op.UpdateStatus(false, ErrorCode::OK);
    return ErrorCode::OK;
  }
 
  RawData rx = GetRxBuffer();
  RawData tx = GetTxBuffer();
  ASSERT(rx.size_ >= size);
  ASSERT(tx.size_ >= size);
 
  if (size > dma_enable_min_size_)
  {
    rw_op_ = op;
    read_buff_ = {nullptr, 0};
    mem_read_ = false;
    busy_ = true;
 
    StartDmaDuplex(static_cast<uint32_t>(size));
 
    op.MarkAsRunning();
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
 
  // 小包轮询
  ErrorCode ec =
      PollingTransfer(static_cast<uint8_t*>(rx.addr_),
                      static_cast<const uint8_t*>(tx.addr_), static_cast<uint32_t>(size));
 
  SwitchBuffer();
 
  if (op.type != OperationRW::OperationType::BLOCK) op.UpdateStatus(false, ec);
  return ec;
}

◆ TxDmaIRQHandler()

void CH32SPI::TxDmaIRQHandler ( )

Definition at line 548 of file ch32_spi.cpp.

{
  if (DMA_GetITStatus(CH32_SPI_TX_DMA_IT_MAP[id_]) == RESET) return;
  DMA_ClearITPendingBit(CH32_SPI_TX_DMA_IT_MAP[id_]);
 
  SPI_I2S_DMACmd(instance_, SPI_I2S_DMAReq_Tx, DISABLE);
  DMA_Cmd(dma_tx_channel_, DISABLE);
}

Field Documentation

◆ busy_

bool LibXR::CH32SPI::busy_ = false

Definition at line 72 of file ch32_spi.hpp.

◆ datasize_

uint16_t LibXR::CH32SPI::datasize_

Definition at line 76 of file ch32_spi.hpp.

◆ dma_enable_min_size_

uint32_t LibXR::CH32SPI::dma_enable_min_size_

Definition at line 66 of file ch32_spi.hpp.

◆ dma_rx_channel_

DMA_Channel_TypeDef* LibXR::CH32SPI::dma_rx_channel_

Definition at line 63 of file ch32_spi.hpp.

◆ dma_tx_channel_

DMA_Channel_TypeDef* LibXR::CH32SPI::dma_tx_channel_

Definition at line 64 of file ch32_spi.hpp.

◆ firstbit_

uint16_t LibXR::CH32SPI::firstbit_

Definition at line 77 of file ch32_spi.hpp.

◆ id_

ch32_spi_id_t LibXR::CH32SPI::id_

Definition at line 65 of file ch32_spi.hpp.

◆ instance_

SPI_TypeDef* LibXR::CH32SPI::instance_

Definition at line 62 of file ch32_spi.hpp.

◆ map

CH32SPI * CH32SPI::map = {nullptr}

static

Definition at line 44 of file ch32_spi.hpp.

◆ mem_read_

bool LibXR::CH32SPI::mem_read_ = false

Definition at line 71 of file ch32_spi.hpp.

◆ miso_pin_

uint16_t LibXR::CH32SPI::miso_pin_

Definition at line 85 of file ch32_spi.hpp.

◆ miso_port_

GPIO_TypeDef* LibXR::CH32SPI::miso_port_

Definition at line 84 of file ch32_spi.hpp.

◆ mode_

uint16_t LibXR::CH32SPI::mode_

Definition at line 75 of file ch32_spi.hpp.

◆ mosi_pin_

uint16_t LibXR::CH32SPI::mosi_pin_

Definition at line 87 of file ch32_spi.hpp.

◆ mosi_port_

GPIO_TypeDef* LibXR::CH32SPI::mosi_port_

Definition at line 86 of file ch32_spi.hpp.

◆ nss_

uint16_t LibXR::CH32SPI::nss_ = SPI_NSS_Soft

Definition at line 79 of file ch32_spi.hpp.

◆ prescaler_

uint16_t LibXR::CH32SPI::prescaler_

Definition at line 78 of file ch32_spi.hpp.

◆ read_buff_

RawData LibXR::CH32SPI::read_buff_

Definition at line 70 of file ch32_spi.hpp.

◆ rw_op_

OperationRW LibXR::CH32SPI::rw_op_

Definition at line 69 of file ch32_spi.hpp.

◆ sck_pin_

uint16_t LibXR::CH32SPI::sck_pin_

Definition at line 83 of file ch32_spi.hpp.

◆ sck_port_

GPIO_TypeDef* LibXR::CH32SPI::sck_port_

Definition at line 82 of file ch32_spi.hpp.

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

driver/ch/ch32_spi.hpp
driver/ch/ch32_spi.cpp

Public Member Functions

Data Fields

Static Public Attributes

Private Member Functions

Static Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CH32SPI()

Member Function Documentation

◆ DmaBusy()

◆ GetMaxBusSpeed()

◆ GetMaxPrescaler()

◆ MapCH32PrescalerToEnum()

◆ MapEnumToCH32Prescaler()

◆ MemRead()

◆ MemWrite()

◆ PollingTransfer()

◆ PrepareTxBuffer()

◆ ReadAndWrite()

◆ RxDmaIRQHandler()

◆ SetConfig()

◆ StartDmaDuplex()

◆ StopDma()

◆ Transfer()

◆ TxDmaIRQHandler()

Field Documentation

◆ busy_

◆ datasize_

◆ dma_enable_min_size_

◆ dma_rx_channel_

◆ dma_tx_channel_

◆ firstbit_

◆ id_

◆ instance_

◆ map

◆ mem_read_

◆ miso_pin_

◆ miso_port_

◆ mode_

◆ mosi_pin_

◆ mosi_port_

◆ nss_

◆ prescaler_

◆ read_buff_

◆ rw_op_

◆ sck_pin_

◆ sck_port_