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.

void	RxDmaIRQHandler ()

void	TxDmaIRQHandler ()

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

Public Member Functions inherited from LibXR::SPI
	SPI ()
	默认构造函数。Default 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.

Data Fields
RawData	dma_buff_rx_

RawData	dma_buff_tx_

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=0xFF)

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

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

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 12 of file ch32_spi.cpp.

    : SPI(),
      dma_buff_rx_(dma_rx),
      dma_buff_tx_(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);
  ASSERT(dma_buff_tx_.size_ >= 1);
  // 读至少给 1 字节，便于 MemRead 的“命令 + N 字节” DMA 长度
  ASSERT(dma_buff_rx_.size_ >= 1);
 
  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_buff_rx_.addr_;
      di.DMA_DIR = DMA_DIR_PeripheralSRC;
      di.DMA_BufferSize = 0;  // run-time 填
      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;  // run-time 填
      di.DMA_DIR = DMA_DIR_PeripheralDST;
      di.DMA_BufferSize = 0;  // run-time 填
      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_)]);
    }
  }
}

Member Function Documentation

◆ DmaBusy()

bool LibXR::CH32SPI::DmaBusy ( ) const

inlineprivate

Definition at line 40 of file ch32_spi.hpp.

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

◆ 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 298 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;
 
  const uint32_t total = n + 1;  // 含首字节命令
  if (total > dma_enable_min_size_)
  {
    ASSERT(dma_buff_tx_.size_ >= total);
    ASSERT(dma_buff_rx_.size_ >= total);
 
    uint8_t *tx = static_cast<uint8_t *>(dma_buff_tx_.addr_);
    tx[0] = static_cast<uint8_t>(reg | 0x80);
    memset(tx + 1, 0xFF, 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 *rx = static_cast<uint8_t *>(dma_buff_rx_.addr_);
    uint8_t *tx = static_cast<uint8_t *>(dma_buff_tx_.addr_);
    tx[0] = static_cast<uint8_t>(reg | 0x80);
    memset(tx + 1, 0xFF, n);
 
    ErrorCode ec = PollingTransfer(rx, tx, n + 1);
    memcpy(read_data.addr_, rx + 1, n);
 
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return ec;
    }
 
    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 356 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;
 
  const uint32_t total = n + 1;
  if (total > dma_enable_min_size_)
  {
    ASSERT(dma_buff_tx_.size_ >= total);
    ASSERT(dma_buff_rx_.size_ >= total);  // RX 用于丢弃
 
    uint8_t *tx = static_cast<uint8_t *>(dma_buff_tx_.addr_);
    tx[0] = static_cast<uint8_t>(reg & 0x7F);
    memcpy(tx + 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 *rx = static_cast<uint8_t *>(dma_buff_rx_.addr_);
    uint8_t *tx = static_cast<uint8_t *>(dma_buff_tx_.addr_);
    tx[0] = static_cast<uint8_t>(reg & 0x7F);
    memcpy(tx + 1, write_data.addr_, n);
 
    ErrorCode ec = PollingTransfer(rx, tx, n + 1);
 
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return ec;
    }
 
    op.UpdateStatus(false, ec);
 
    return ec;
  }
}

◆ PollingTransfer()

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

Definition at line 205 of file ch32_spi.cpp.

{
  for (uint32_t i = 0; i < len; ++i)
  {
    // 等待 TXE
    while (SPI_I2S_GetFlagStatus(instance_, SPI_I2S_FLAG_TXE) == RESET)
    {
    }
    SPI_I2S_SendData(instance_, tx ? tx[i] : 0xFF);
 
    // 等待 RXNE
    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 = 0xFF )

private

Definition at line 413 of file ch32_spi.cpp.

{
  uint8_t *tx = static_cast<uint8_t *>(dma_buff_tx_.addr_);
  if (write_data.size_ > 0)
  {
    const uint32_t copy =
        (write_data.size_ > need_len - prefix) ? (need_len - prefix) : write_data.size_;
    memcpy(tx + prefix, write_data.addr_, copy);
    if (prefix + copy < need_len)
    {
      memset(tx + prefix + copy, dummy, need_len - prefix - copy);
    }
  }
  else
  {
    memset(tx + 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 225 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;
 
  if (need > dma_enable_min_size_)
  {
    ASSERT(dma_buff_tx_.size_ >= need);
    ASSERT(dma_buff_rx_.size_ >= need);
 
    mem_read_ = false;
    read_buff_ = read_data;
    rw_op_ = op;
    busy_ = true;
 
    PrepareTxBuffer(write_data, need);
 
    // 配置 DMA 长度与地址并启动
    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 *rx = static_cast<uint8_t *>(dma_buff_rx_.addr_);
    uint8_t *tx = static_cast<uint8_t *>(dma_buff_tx_.addr_);
 
    // 准备 tx
    if (wsz)
    {
      memcpy(tx, write_data.addr_, wsz);
      if (need > wsz) memset(tx + wsz, 0xFF, need - wsz);
    }
    else
    {
      memset(tx, 0xFF, need);
    }
 
    ErrorCode ec = PollingTransfer(rsz ? rx : nullptr, tx, need);
 
    if (rsz)
    {
      memcpy(read_data.addr_, rx, rsz);
    }
 
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return ec;
    }
 
    op.UpdateStatus(false, ec);
 
    return ec;
  }
}

◆ RxDmaIRQHandler()

void CH32SPI::RxDmaIRQHandler ( )

Definition at line 455 of file ch32_spi.cpp.

{
  // 只在 TC 时处理
  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)
  {
    uint8_t *rx = static_cast<uint8_t *>(dma_buff_rx_.addr_);
    if (mem_read_)
    {
      // 丢首字节命令
      memcpy(read_buff_.addr_, rx + 1, read_buff_.size_);
    }
    else
    {
      memcpy(read_buff_.addr_, rx, read_buff_.size_);
    }
  }
 
  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 183 of file ch32_spi.cpp.

{
  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 = prescaler_;
  init.SPI_FirstBit = firstbit_;
  init.SPI_CRCPolynomial = 7;
  SPI_Init(instance_, &init);
  SPI_Cmd(instance_, ENABLE);
  return ErrorCode::OK;
}

◆ StartDmaDuplex()

void CH32SPI::StartDmaDuplex ( uint32_t count )

private

Definition at line 433 of file ch32_spi.cpp.

{
  // 配置长度与地址
  dma_rx_channel_->MADDR = reinterpret_cast<uint32_t>(dma_buff_rx_.addr_);
  dma_rx_channel_->CNTR = count;
 
  dma_tx_channel_->MADDR = reinterpret_cast<uint32_t>(dma_buff_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 449 of file ch32_spi.cpp.

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

◆ TxDmaIRQHandler()

void CH32SPI::TxDmaIRQHandler ( )

Definition at line 484 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 64 of file ch32_spi.hpp.

◆ datasize_

uint16_t LibXR::CH32SPI::datasize_

Definition at line 68 of file ch32_spi.hpp.

◆ dma_buff_rx_

RawData LibXR::CH32SPI::dma_buff_rx_

Definition at line 52 of file ch32_spi.hpp.

◆ dma_buff_tx_

RawData LibXR::CH32SPI::dma_buff_tx_

Definition at line 53 of file ch32_spi.hpp.

◆ dma_enable_min_size_

uint32_t LibXR::CH32SPI::dma_enable_min_size_

Definition at line 58 of file ch32_spi.hpp.

◆ dma_rx_channel_

DMA_Channel_TypeDef* LibXR::CH32SPI::dma_rx_channel_

Definition at line 55 of file ch32_spi.hpp.

◆ dma_tx_channel_

DMA_Channel_TypeDef* LibXR::CH32SPI::dma_tx_channel_

Definition at line 56 of file ch32_spi.hpp.

◆ firstbit_

uint16_t LibXR::CH32SPI::firstbit_

Definition at line 69 of file ch32_spi.hpp.

◆ id_

ch32_spi_id_t LibXR::CH32SPI::id_

Definition at line 57 of file ch32_spi.hpp.

◆ instance_

SPI_TypeDef* LibXR::CH32SPI::instance_

Definition at line 54 of file ch32_spi.hpp.

◆ map

CH32SPI * CH32SPI::map = {nullptr}

static

Definition at line 37 of file ch32_spi.hpp.

◆ mem_read_

bool LibXR::CH32SPI::mem_read_ = false

Definition at line 63 of file ch32_spi.hpp.

◆ miso_pin_

uint16_t LibXR::CH32SPI::miso_pin_

Definition at line 77 of file ch32_spi.hpp.

◆ miso_port_

GPIO_TypeDef* LibXR::CH32SPI::miso_port_

Definition at line 76 of file ch32_spi.hpp.

◆ mode_

uint16_t LibXR::CH32SPI::mode_

Definition at line 67 of file ch32_spi.hpp.

◆ mosi_pin_

uint16_t LibXR::CH32SPI::mosi_pin_

Definition at line 79 of file ch32_spi.hpp.

◆ mosi_port_

GPIO_TypeDef* LibXR::CH32SPI::mosi_port_

Definition at line 78 of file ch32_spi.hpp.

◆ nss_

uint16_t LibXR::CH32SPI::nss_ = SPI_NSS_Soft

Definition at line 71 of file ch32_spi.hpp.

◆ prescaler_

uint16_t LibXR::CH32SPI::prescaler_

Definition at line 70 of file ch32_spi.hpp.

◆ read_buff_

RawData LibXR::CH32SPI::read_buff_

Definition at line 62 of file ch32_spi.hpp.

◆ rw_op_

OperationRW LibXR::CH32SPI::rw_op_

Definition at line 61 of file ch32_spi.hpp.

◆ sck_pin_

uint16_t LibXR::CH32SPI::sck_pin_

Definition at line 75 of file ch32_spi.hpp.

◆ sck_port_

GPIO_TypeDef* LibXR::CH32SPI::sck_port_

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

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CH32SPI()

Member Function Documentation

◆ DmaBusy()

◆ MemRead()

◆ MemWrite()

◆ PollingTransfer()

◆ PrepareTxBuffer()

◆ ReadAndWrite()

◆ RxDmaIRQHandler()

◆ SetConfig()

◆ StartDmaDuplex()

◆ StopDma()

◆ TxDmaIRQHandler()

Field Documentation

◆ busy_

◆ datasize_

◆ dma_buff_rx_

◆ dma_buff_tx_

◆ 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_