LibXR::CH32SPI Class Reference

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

#include <ch32_spi.hpp>

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})
	构造 SPI 对象 / Construct SPI object
ErrorCode	ReadAndWrite (RawData read_data, ConstRawData write_data, OperationRW &op, bool in_isr) override
	SPI 接口实现 / SPI interface overrides.
ErrorCode	SetConfig (SPI::Configuration config) override
	设置 SPI 配置参数 / Sets SPI configuration parameters.
ErrorCode	MemRead (uint16_t reg, RawData read_data, OperationRW &op, bool in_isr) override
	从 SPI 设备的寄存器读取数据。 Reads data from a specific register of the SPI device.
ErrorCode	MemWrite (uint16_t reg, ConstRawData write_data, OperationRW &op, bool in_isr) override
	向 SPI 设备的寄存器写入数据。 Writes data to a specific register of the SPI device.
ErrorCode	Transfer (size_t size, OperationRW &op, bool in_isr) 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 ()
	DMA 中断回调 / DMA interrupt callbacks.
void	TxDmaIRQHandler ()
ErrorCode	PollingTransfer (uint8_t *rx, const uint8_t *tx, uint32_t len)
	轮询传输辅助函数 / Polling transfer helper
Public Member Functions inherited from LibXR::SPI
	SPI (RawData rx_buffer, RawData tx_buffer)
	构造函数 / Constructor.
virtual ErrorCode	Read (RawData read_data, OperationRW &op, bool in_isr=false)
	进行 SPI 读取操作 / Performs SPI read operation.
virtual ErrorCode	Write (ConstRawData write_data, OperationRW &op, bool in_isr=false)
	进行 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.

Public Attributes
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_
	运行时状态 / Runtime state
RawData	read_buff_
bool	mem_read_ = false
bool	busy_ = false
uint16_t	mode_
	SPI 寄存器配置缓存 / Cached SPI register configuration.
uint16_t	datasize_
	SPI_DataSize_8b by default.
uint16_t	firstbit_
	SPI_FirstBit_MSB / SPI_FirstBit_LSB.
uint16_t	prescaler_
	SPI_BaudRatePrescaler_x.
uint16_t	nss_ = SPI_NSS_Soft
GPIO_TypeDef *	sck_port_
	GPIO 配置 / GPIO configuration.
uint16_t	sck_pin_
GPIO_TypeDef *	miso_port_
uint16_t	miso_pin_
GPIO_TypeDef *	mosi_port_
uint16_t	mosi_pin_
AsyncBlockWait	block_wait_ {}

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

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

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

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

构造 SPI 对象 / Construct SPI object

Definition at line 62 of file ch32_spi.cpp.

    : SPI(dma_rx, dma_tx),
      instance_(ch32_spi_get_instance_id(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;
 
  // 时钟配置。
  // Clock configuration.
  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
  {
    DEV_ASSERT(false);
  }
  RCC_AHBPeriphClockCmd(CH32_SPI_RCC_PERIPH_MAP_DMA[id], ENABLE);
 
  // GPIO 配置。
  // GPIO configuration.
  {
    GPIO_InitTypeDef gpio = {};
    gpio.GPIO_Speed = GPIO_Speed_50MHz;
 
    // SCK 引脚。
    // SCK.
    RCC_APB2PeriphClockCmd(ch32_get_gpio_periph(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 引脚。
    // MISO.
    RCC_APB2PeriphClockCmd(ch32_get_gpio_periph(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 引脚。
    // MOSI.
    RCC_APB2PeriphClockCmd(ch32_get_gpio_periph(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 base configuration.
  {
    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 在运行时设置）。
  // DMA channel base configuration (MADDR/CNTR set at runtime).
  {
    // RX 通道。
    // RX.
    {
      ch32_dma_callback_t cb = [](void* arg)
      { reinterpret_cast<CH32SPI*>(arg)->RxDmaIRQHandler(); };
      ch32_dma_register_callback(ch32_dma_get_id(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_get_id(dma_rx_channel_)]);
    }
    // TX 通道。
    // TX.
    {
      ch32_dma_callback_t cb = [](void* arg)
      { reinterpret_cast<CH32SPI*>(arg)->TxDmaIRQHandler(); };
      ch32_dma_register_callback(ch32_dma_get_id(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_get_id(dma_tx_channel_)]);
    }
  }
 
  // 同步基类配置，供速率查询辅助逻辑使用。
  // Sync the base-class configuration for rate-query helpers.
  GetConfig() = config;
  GetConfig().prescaler = MapCH32PrescalerToEnum(prescaler_);
}

Member Function Documentation

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 695 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 713 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
}

MemRead()

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

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).
in_isr	是否在中断中进行操作 / Whether the operation is performed in an ISR.

Returns

操作结果的错误码 / Error code indicating success or failure.

Implements LibXR::SPI.

Definition at line 386 of file ch32_spi.cpp.

{
  const uint32_t N = read_data.size_;
  if (N == 0)
  {
    if (op.type != OperationRW::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, 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);
    Memory::FastSet(txp + 1, 0x00, N);
 
    mem_read_ = true;
    read_buff_ = read_data;
    rw_op_ = op;
    busy_ = true;
 
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      block_wait_.Start(*op.data.sem_info.sem);
    }
    StartDmaDuplex(TOTAL);
    op.MarkAsRunning();
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return block_wait_.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);
    Memory::FastSet(txp + 1, 0x00, N);
 
    ErrorCode ec = PollingTransfer(rxp, txp, TOTAL);
    Memory::FastCopy(read_data.addr_, rxp + 1, N);
 
    SwitchBuffer();
 
    if (op.type != OperationRW::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ec);
    }
    return ec;
  }
}

MemWrite()

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

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).
in_isr	是否在中断中进行操作 / Whether the operation is performed in an ISR.

Returns

操作结果的错误码 / Error code indicating success or failure.

Implements LibXR::SPI.

Definition at line 455 of file ch32_spi.cpp.

{
  const uint32_t N = write_data.size_;
  if (N == 0)
  {
    if (op.type != OperationRW::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, 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);
    Memory::FastCopy(txp + 1, write_data.addr_, N);
 
    mem_read_ = false;
    read_buff_ = {nullptr, 0};
    rw_op_ = op;
    busy_ = true;
 
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      block_wait_.Start(*op.data.sem_info.sem);
    }
    StartDmaDuplex(TOTAL);
 
    op.MarkAsRunning();
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return block_wait_.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);
    Memory::FastCopy(txp + 1, write_data.addr_, N);
 
    ErrorCode ec = PollingTransfer(rxp, txp, TOTAL);
 
    SwitchBuffer();
 
    if (op.type != OperationRW::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ec);
    }
    return ec;
  }
}

PollingTransfer()

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

轮询传输辅助函数 / Polling transfer helper

Definition at line 279 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;
}

ReadAndWrite()

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

overridevirtual

SPI 接口实现 / SPI interface overrides.

Implements LibXR::SPI.

Definition at line 300 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(in_isr, 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);
 
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      block_wait_.Start(*op.data.sem_info.sem);
    }
    StartDmaDuplex(NEED);
 
    op.MarkAsRunning();
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return block_wait_.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)
    {
      Memory::FastCopy(txp, write_data.addr_, WSZ);
      if (NEED > WSZ)
      {
        Memory::FastSet(txp + WSZ, 0x00, NEED - WSZ);
      }
    }
    else
    {
      Memory::FastSet(txp, 0x00, NEED);
    }
 
    ErrorCode ec = PollingTransfer(rxp, txp, NEED);
 
    if (RSZ)
    {
      Memory::FastCopy(read_data.addr_, rxp, RSZ);
    }
 
    SwitchBuffer();
 
    if (op.type != OperationRW::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ec);
    }
    return ec;
  }
}

RxDmaIRQHandler()

void CH32SPI::RxDmaIRQHandler

(

)

DMA 中断回调 / DMA interrupt callbacks.

Definition at line 571 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 (!busy_)
  {
    return;
  }
 
  // 拷贝读数据（若有）
  const bool has_user_read_copy = (read_buff_.size_ > 0);
  if (has_user_read_copy)
  {
    RawData rx = GetRxBuffer();
    uint8_t* rxp = static_cast<uint8_t*>(rx.addr_);
    if (mem_read_)
    {
      Memory::FastCopy(read_buff_.addr_, rxp + 1, read_buff_.size_);
    }
    else
    {
      Memory::FastCopy(read_buff_.addr_, rxp, read_buff_.size_);
    }
    read_buff_.size_ = 0;
  }
 
  // 双缓冲切换与状态更新
  SwitchBuffer();
  busy_ = false;
  if (rw_op_.type == OperationRW::OperationType::BLOCK)
  {
    (void)block_wait_.TryPost(true, ErrorCode::OK);
  }
  else
  {
    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 243 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;
}

Transfer()

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

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.
in_isr	是否在中断中进行操作 / Whether the operation is performed in an ISR.

Returns

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

Implements LibXR::SPI.

Definition at line 637 of file ch32_spi.cpp.

{
  if (DmaBusy())
  {
    return ErrorCode::BUSY;
  }
 
  if (size == 0)
  {
    if (op.type != OperationRW::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, 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;
 
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      block_wait_.Start(*op.data.sem_info.sem);
    }
    StartDmaDuplex(static_cast<uint32_t>(size));
 
    op.MarkAsRunning();
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return block_wait_.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(in_isr, ec);
  }
  return ec;
}

TxDmaIRQHandler()

void CH32SPI::TxDmaIRQHandler

(

)

Definition at line 618 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);
 
  if (!busy_)
  {
    return;
  }
}

Member Data Documentation

block_wait_

AsyncBlockWait LibXR::CH32SPI::block_wait_ {}

Definition at line 97 of file ch32_spi.hpp.

{};

busy_

bool LibXR::CH32SPI::busy_ = false

Definition at line 80 of file ch32_spi.hpp.

datasize_

uint16_t LibXR::CH32SPI::datasize_

SPI_DataSize_8b by default.

Definition at line 84 of file ch32_spi.hpp.

dma_enable_min_size_

uint32_t LibXR::CH32SPI::dma_enable_min_size_

Definition at line 74 of file ch32_spi.hpp.

dma_rx_channel_

DMA_Channel_TypeDef* LibXR::CH32SPI::dma_rx_channel_

Definition at line 71 of file ch32_spi.hpp.

dma_tx_channel_

DMA_Channel_TypeDef* LibXR::CH32SPI::dma_tx_channel_

Definition at line 72 of file ch32_spi.hpp.

firstbit_

uint16_t LibXR::CH32SPI::firstbit_

SPI_FirstBit_MSB / SPI_FirstBit_LSB.

Definition at line 85 of file ch32_spi.hpp.

id_

ch32_spi_id_t LibXR::CH32SPI::id_

Definition at line 73 of file ch32_spi.hpp.

instance_

SPI_TypeDef* LibXR::CH32SPI::instance_

Definition at line 70 of file ch32_spi.hpp.

map_

CH32SPI * CH32SPI::map_ = {nullptr}

static

Definition at line 52 of file ch32_spi.hpp.

mem_read_

bool LibXR::CH32SPI::mem_read_ = false

Definition at line 79 of file ch32_spi.hpp.

miso_pin_

uint16_t LibXR::CH32SPI::miso_pin_

Definition at line 93 of file ch32_spi.hpp.

miso_port_

GPIO_TypeDef* LibXR::CH32SPI::miso_port_

Definition at line 92 of file ch32_spi.hpp.

mode_

uint16_t LibXR::CH32SPI::mode_

SPI 寄存器配置缓存 / Cached SPI register configuration.

SPI_Mode_Master / SPI_Mode_Slave

Definition at line 83 of file ch32_spi.hpp.

mosi_pin_

uint16_t LibXR::CH32SPI::mosi_pin_

Definition at line 95 of file ch32_spi.hpp.

mosi_port_

GPIO_TypeDef* LibXR::CH32SPI::mosi_port_

Definition at line 94 of file ch32_spi.hpp.

nss_

uint16_t LibXR::CH32SPI::nss_ = SPI_NSS_Soft

Definition at line 87 of file ch32_spi.hpp.

prescaler_

uint16_t LibXR::CH32SPI::prescaler_

SPI_BaudRatePrescaler_x.

Definition at line 86 of file ch32_spi.hpp.

read_buff_

RawData LibXR::CH32SPI::read_buff_

Definition at line 78 of file ch32_spi.hpp.

rw_op_

OperationRW LibXR::CH32SPI::rw_op_

运行时状态 / Runtime state

Definition at line 77 of file ch32_spi.hpp.

sck_pin_

uint16_t LibXR::CH32SPI::sck_pin_

Definition at line 91 of file ch32_spi.hpp.

sck_port_

GPIO_TypeDef* LibXR::CH32SPI::sck_port_

GPIO 配置 / GPIO configuration.

Definition at line 90 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