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.

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_
	运行时状态 / 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}

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

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
  {
    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

DmaBusy()

bool LibXR::CH32SPI::DmaBusy ( ) const

inlineprivate

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

MapCH32PrescalerToEnum()

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

staticprivate

Definition at line 740 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 13 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, 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;
}

PrepareTxBuffer()

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

private

Definition at line 525 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_;
    Memory::FastCopy(txp + prefix, write_data.addr_, COPY);
    if (prefix + COPY < need_len)
    {
      Memory::FastSet(txp + prefix + COPY, dummy, need_len - prefix - COPY);
    }
  }
  else
  {
    Memory::FastSet(txp + prefix, dummy, need_len - prefix);
  }
}

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;
}

StartDmaDuplex()

void CH32SPI::StartDmaDuplex ( uint32_t count )

private

Definition at line 547 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 565 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, 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;
  }
}

Field 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