LibXR::STM32SPI Class Reference

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

#include <stm32_spi.hpp>

Inheritance diagram for LibXR::STM32SPI:

Collaboration diagram for LibXR::STM32SPI:

Public Member Functions
	STM32SPI (SPI_HandleTypeDef *spi_handle, RawData dma_buff_rx, RawData dma_buff_tx, uint32_t dma_enable_min_size=3)
	构造 SPI 对象 / Construct SPI object
ErrorCode	ReadAndWrite (RawData read_data, ConstRawData write_data, OperationRW &op, bool in_isr) 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, 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.
uint32_t	GetMaxBusSpeed () const override
	获取 SPI 设备的最大时钟速度。Gets the maximum clock speed of the SPI device.
Prescaler	GetMaxPrescaler () const override
	获取 SPI 设备的最大分频系数。Gets the maximum prescaler 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).
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_HandleTypeDef *	spi_handle_
stm32_spi_id_t	id_ = STM32_SPI_ID_ERROR
uint32_t	dma_enable_min_size_ = 3
OperationRW	rw_op_
RawData	read_buff_
bool	mem_read_ = false
AsyncBlockWait	block_wait_ {}

Static Public Attributes
static STM32SPI *	map [STM32_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

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

Definition at line 54 of file stm32_spi.hpp.

Constructor & Destructor Documentation

STM32SPI()

STM32SPI::STM32SPI	(	SPI_HandleTypeDef *	spi_handle,
		RawData	dma_buff_rx,
		RawData	dma_buff_tx,
		uint32_t	dma_enable_min_size = 3 )

构造 SPI 对象 / Construct SPI object

Definition at line 72 of file stm32_spi.cpp.

    : SPI(rx, tx),
      spi_handle_(spi_handle),
      id_(STM32_SPI_GetID(spi_handle_->Instance)),
      dma_enable_min_size_(dma_enable_min_size)
{
  ASSERT(id_ != STM32_SPI_ID_ERROR);
 
  map[id_] = this;
}

Member Function Documentation

GetMaxBusSpeed()

uint32_t STM32SPI::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 485 of file stm32_spi.cpp.

{
  SPI_TypeDef* inst = spi_handle_ ? spi_handle_->Instance : nullptr;
  if (!inst)
  {
    return 0u;
  }
 
#if defined(HAL_RCC_MODULE_ENABLED)
// 1) 优先读取独立 SPI 内核时钟。
// 1) Prefer dedicated SPI kernel clock when available.
// H7: 分组宏 SPI123 / SPI45 / SPI6
#if defined(RCC_PERIPHCLK_SPI123) || defined(RCC_PERIPHCLK_SPI45) || \
    defined(RCC_PERIPHCLK_SPI6)
  // SPI1/2/3 → RCC_PERIPHCLK_SPI123
  if (
#ifdef SPI1
      inst == SPI1 ||
#endif
#ifdef SPI2
      inst == SPI2 ||
#endif
#ifdef SPI3
      inst == SPI3 ||
#endif
      false)
  {
#ifdef RCC_PERIPHCLK_SPI123
    return HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI123);
#endif
  }
  // SPI4/5 → RCC_PERIPHCLK_SPI45
  if (
#ifdef SPI4
      inst == SPI4 ||
#endif
#ifdef SPI5
      inst == SPI5 ||
#endif
      false)
  {
#ifdef RCC_PERIPHCLK_SPI45
    return HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI45);
#endif
  }
// SPI6 → RCC_PERIPHCLK_SPI6
#ifdef SPI6
  if (inst == SPI6)
  {
#ifdef RCC_PERIPHCLK_SPI6
    return HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI6);
#endif
  }
#endif
#endif  // H7 分组
 
// 其它系列：通常是逐个 SPIx 宏
#if defined(RCC_PERIPHCLK_SPI1)
#ifdef SPI1
  if (inst == SPI1) return HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI1);
#endif
#endif
#if defined(RCC_PERIPHCLK_SPI2)
#ifdef SPI2
  if (inst == SPI2) return HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI2);
#endif
#endif
#if defined(RCC_PERIPHCLK_SPI3)
#ifdef SPI3
  if (inst == SPI3) return HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI3);
#endif
#endif
#if defined(RCC_PERIPHCLK_SPI4)
#ifdef SPI4
  if (inst == SPI4) return HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI4);
#endif
#endif
#if defined(RCC_PERIPHCLK_SPI5)
#ifdef SPI5
  if (inst == SPI5) return HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI5);
#endif
#endif
#if defined(RCC_PERIPHCLK_SPI6)
#ifdef SPI6
  if (inst == SPI6) return HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI6);
#endif
#endif
#endif  // HAL_RCC_MODULE_ENABLED
 
  // 2) 回退到所在 APB 的 PCLK。
  // 2) Fallback to APB PCLK if no dedicated kernel clock is available.
#if defined(STM32H7) && defined(SPI6)
  if (inst == SPI6)
  {
#if defined(HAL_RCC_GetPCLK4Freq)
    return HAL_RCC_GetPCLK4Freq();
#else
    return HAL_RCC_GetHCLKFreq();
#endif
  }
#endif
 
  // 大多数系列：SPI1/4/5/6/7/8 → APB2；SPI2/3 → APB1
  if (
#ifdef SPI1
      inst == SPI1 ||
#endif
#ifdef SPI4
      inst == SPI4 ||
#endif
#ifdef SPI5
      inst == SPI5 ||
#endif
#ifdef SPI6
      inst == SPI6 ||
#endif
#ifdef SPI7
      inst == SPI7 ||
#endif
#ifdef SPI8
      inst == SPI8 ||
#endif
      false)
  {
#if defined(HAL_RCC_GetPCLK2Freq)
    return HAL_RCC_GetPCLK2Freq();
#elif defined(HAL_RCC_GetPCLK1Freq)
    return HAL_RCC_GetPCLK1Freq();  // 低端/单APB系列兜底
#else
    return HAL_RCC_GetHCLKFreq();
#endif
  }
  else
  {
#if defined(HAL_RCC_GetPCLK1Freq)
    return HAL_RCC_GetPCLK1Freq();
#elif defined(HAL_RCC_GetPCLK2Freq)
    return HAL_RCC_GetPCLK2Freq();
#else
    return HAL_RCC_GetHCLKFreq();
#endif
  }
}

GetMaxPrescaler()

STM32SPI::Prescaler STM32SPI::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 629 of file stm32_spi.cpp.

{
#if defined(SPI_BAUDRATEPRESCALER_1024)
  return Prescaler::DIV_1024;
#elif defined(SPI_BAUDRATEPRESCALER_512)
  return Prescaler::DIV_512;
#elif defined(SPI_BAUDRATEPRESCALER_256)
  return Prescaler::DIV_256;
#elif defined(SPI_BAUDRATEPRESCALER_128)
  return Prescaler::DIV_128;
#elif defined(SPI_BAUDRATEPRESCALER_64)
  return Prescaler::DIV_64;
#elif defined(SPI_BAUDRATEPRESCALER_32)
  return Prescaler::DIV_32;
#elif defined(SPI_BAUDRATEPRESCALER_16)
  return Prescaler::DIV_16;
#elif defined(SPI_BAUDRATEPRESCALER_8)
  return Prescaler::DIV_8;
#elif defined(SPI_BAUDRATEPRESCALER_4)
  return Prescaler::DIV_4;
#elif defined(SPI_BAUDRATEPRESCALER_2)
  return Prescaler::DIV_2;
#elif defined(SPI_BAUDRATEPRESCALER_1)
  return Prescaler::DIV_1;
#else
  return Prescaler::UNKNOWN;
#endif
}

MemRead()

ErrorCode STM32SPI::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 341 of file stm32_spi.cpp.

{
  uint32_t need_read = read_data.size_;
 
  if (spi_handle_->State != HAL_SPI_STATE_READY)
  {
    return ErrorCode::BUSY;
  }
 
  RawData rx = GetRxBuffer();
  RawData tx = GetTxBuffer();
 
  ASSERT(rx.size_ >= need_read + 1);
  ASSERT(tx.size_ >= need_read + 1);
 
  if (need_read + 1 > dma_enable_min_size_)
  {
    mem_read_ = true;
    rw_op_ = op;
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      block_wait_.Start(*op.data.sem_info.sem);
    }
 
    uint8_t* txb = reinterpret_cast<uint8_t*>(tx.addr_);
    Memory::FastSet(txb, 0, need_read + 1);
    txb[0] = static_cast<uint8_t>(reg | 0x80);
    STM32_CleanDCacheByAddr(tx.addr_, need_read + 1);
    read_buff_ = read_data;
 
    HAL_StatusTypeDef st =
        HAL_SPI_TransmitReceive_DMA(spi_handle_, static_cast<uint8_t*>(tx.addr_),
                                    static_cast<uint8_t*>(rx.addr_), need_read + 1);
 
    if (st != HAL_OK)
    {
      if (op.type == OperationRW::OperationType::BLOCK)
      {
        block_wait_.Cancel();
      }
      return ErrorCode::BUSY;
    }
 
    op.MarkAsRunning();
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return block_wait_.Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
 
  mem_read_ = false;
  uint8_t* txb = reinterpret_cast<uint8_t*>(tx.addr_);
  Memory::FastSet(txb, 0, need_read + 1);
  txb[0] = static_cast<uint8_t>(reg | 0x80);
  STM32_CleanDCacheByAddr(tx.addr_, need_read + 1);
 
  ErrorCode ans = (HAL_SPI_TransmitReceive(spi_handle_, static_cast<uint8_t*>(tx.addr_),
                                           static_cast<uint8_t*>(rx.addr_), need_read + 1,
                                           20) == HAL_OK)
                      ? ErrorCode::OK
                      : ErrorCode::BUSY;
 
  if (ans == ErrorCode::OK)
  {
    uint8_t* rxb = reinterpret_cast<uint8_t*>(rx.addr_);
    Memory::FastCopy(read_data.addr_, rxb + 1, need_read);
  }
  SwitchBuffer();
 
  if (op.type != OperationRW::OperationType::BLOCK)
  {
    op.UpdateStatus(in_isr, ans);
  }
  return ans;
}

MemWrite()

ErrorCode STM32SPI::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 418 of file stm32_spi.cpp.

{
  uint32_t need_write = write_data.size_;
 
  if (spi_handle_->State != HAL_SPI_STATE_READY)
  {
    return ErrorCode::BUSY;
  }
 
  RawData tx = GetTxBuffer();
  ASSERT(tx.size_ >= need_write + 1);
 
  if (need_write + 1 > dma_enable_min_size_)
  {
    mem_read_ = false;
    rw_op_ = op;
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      block_wait_.Start(*op.data.sem_info.sem);
    }
 
    uint8_t* txb = reinterpret_cast<uint8_t*>(tx.addr_);
    txb[0] = static_cast<uint8_t>(reg & 0x7F);
    Memory::FastCopy(txb + 1, write_data.addr_, need_write);
    STM32_CleanDCacheByAddr(tx.addr_, need_write + 1);
    read_buff_ = {nullptr, 0};
 
    HAL_StatusTypeDef st = HAL_SPI_Transmit_DMA(
        spi_handle_, static_cast<uint8_t*>(tx.addr_), need_write + 1);
 
    if (st != HAL_OK)
    {
      if (op.type == OperationRW::OperationType::BLOCK)
      {
        block_wait_.Cancel();
      }
      return ErrorCode::BUSY;
    }
 
    op.MarkAsRunning();
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return block_wait_.Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
 
  uint8_t* txb = reinterpret_cast<uint8_t*>(tx.addr_);
  txb[0] = static_cast<uint8_t>(reg & 0x7F);
  Memory::FastCopy(txb + 1, write_data.addr_, need_write);
  STM32_CleanDCacheByAddr(tx.addr_, need_write + 1);
 
  ErrorCode ans = (HAL_SPI_Transmit(spi_handle_, static_cast<uint8_t*>(tx.addr_),
                                    need_write + 1, 20) == HAL_OK)
                      ? ErrorCode::OK
                      : ErrorCode::BUSY;
 
  SwitchBuffer();
 
  if (op.type != OperationRW::OperationType::BLOCK)
  {
    op.UpdateStatus(in_isr, ans);
  }
  return ans;
}

ReadAndWrite()

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

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.
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 84 of file stm32_spi.cpp.

{
  uint32_t need_write = max(write_data.size_, read_data.size_);
 
  RawData rx = GetRxBuffer();
  RawData tx = GetTxBuffer();
 
  if (rx.size_ > 0)
  {
    ASSERT(need_write <= rx.size_);
  }
  if (tx.size_ > 0)
  {
    ASSERT(need_write <= tx.size_);
  }
 
  if (spi_handle_->State != HAL_SPI_STATE_READY)
  {
    return ErrorCode::BUSY;
  }
 
  mem_read_ = false;
 
  if (need_write > dma_enable_min_size_)
  {
    rw_op_ = op;
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      block_wait_.Start(*op.data.sem_info.sem);
    }
 
    HAL_StatusTypeDef st = HAL_OK;
 
    if (write_data.size_ > 0 && read_data.size_ > 0)
    {
      Memory::FastCopy(tx.addr_, write_data.addr_, write_data.size_);
      if (write_data.size_ < need_write)
      {
        Memory::FastSet(reinterpret_cast<uint8_t*>(tx.addr_) + write_data.size_, 0,
                        need_write - write_data.size_);
      }
      STM32_CleanDCacheByAddr(tx.addr_, need_write);
      read_buff_ = read_data;
 
      st = HAL_SPI_TransmitReceive_DMA(spi_handle_, static_cast<uint8_t*>(tx.addr_),
                                       static_cast<uint8_t*>(rx.addr_), need_write);
    }
    else if (write_data.size_ > 0)
    {
      Memory::FastCopy(tx.addr_, write_data.addr_, write_data.size_);
      if (write_data.size_ < need_write)
      {
        Memory::FastSet(reinterpret_cast<uint8_t*>(tx.addr_) + write_data.size_, 0,
                        need_write - write_data.size_);
      }
      STM32_CleanDCacheByAddr(tx.addr_, need_write);
      read_buff_ = {nullptr, 0};
 
      st = HAL_SPI_Transmit_DMA(spi_handle_, static_cast<uint8_t*>(tx.addr_), need_write);
    }
    else if (read_data.size_ > 0)
    {
      read_buff_ = read_data;
 
      st = HAL_SPI_Receive_DMA(spi_handle_, static_cast<uint8_t*>(rx.addr_),
                               read_data.size_);
    }
    else
    {
      if (op.type != OperationRW::OperationType::BLOCK)
      {
        op.UpdateStatus(in_isr, ErrorCode::OK);
      }
      return ErrorCode::OK;
    }
 
    if (st != HAL_OK)
    {
      if (op.type == OperationRW::OperationType::BLOCK)
      {
        block_wait_.Cancel();
      }
      return ErrorCode::BUSY;
    }
 
    op.MarkAsRunning();
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return block_wait_.Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
 
  ErrorCode ans = ErrorCode::OK;
 
  if (write_data.size_ > 0 && read_data.size_ > 0)
  {
    Memory::FastCopy(tx.addr_, write_data.addr_, write_data.size_);
    if (write_data.size_ < need_write)
    {
      Memory::FastSet(reinterpret_cast<uint8_t*>(tx.addr_) + write_data.size_, 0,
                      need_write - write_data.size_);
    }
    STM32_CleanDCacheByAddr(tx.addr_, need_write);
    ans = (HAL_SPI_TransmitReceive(spi_handle_, static_cast<uint8_t*>(tx.addr_),
                                   static_cast<uint8_t*>(rx.addr_), need_write,
                                   20) == HAL_OK)
              ? ErrorCode::OK
              : ErrorCode::BUSY;
 
    if (ans == ErrorCode::OK)
    {
      Memory::FastCopy(read_data.addr_, rx.addr_, read_data.size_);
    }
    SwitchBuffer();
  }
  else if (read_data.size_ > 0)
  {
    ans = (HAL_SPI_Receive(spi_handle_, static_cast<uint8_t*>(rx.addr_), read_data.size_,
                           20) == HAL_OK)
              ? ErrorCode::OK
              : ErrorCode::BUSY;
 
    if (ans == ErrorCode::OK)
    {
      Memory::FastCopy(read_data.addr_, rx.addr_, read_data.size_);
    }
    SwitchBuffer();
  }
  else if (write_data.size_ > 0)
  {
    Memory::FastCopy(tx.addr_, write_data.addr_, write_data.size_);
    STM32_CleanDCacheByAddr(tx.addr_, need_write);
    ans = (HAL_SPI_Transmit(spi_handle_, static_cast<uint8_t*>(tx.addr_),
                            write_data.size_, 20) == HAL_OK)
              ? ErrorCode::OK
              : ErrorCode::BUSY;
 
    SwitchBuffer();
  }
  else
  {
    if (op.type != OperationRW::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ErrorCode::OK);
    }
    return ErrorCode::OK;
  }
 
  if (op.type != OperationRW::OperationType::BLOCK)
  {
    op.UpdateStatus(in_isr, ans);
  }
  return ans;
}

SetConfig()

ErrorCode STM32SPI::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 241 of file stm32_spi.cpp.

{
  switch (config.clock_polarity)
  {
    case SPI::ClockPolarity::LOW:
      spi_handle_->Init.CLKPolarity = SPI_POLARITY_LOW;
      break;
    case SPI::ClockPolarity::HIGH:
      spi_handle_->Init.CLKPolarity = SPI_POLARITY_HIGH;
      break;
  }
 
  switch (config.clock_phase)
  {
    case SPI::ClockPhase::EDGE_1:
      spi_handle_->Init.CLKPhase = SPI_PHASE_1EDGE;
      break;
    case SPI::ClockPhase::EDGE_2:
      spi_handle_->Init.CLKPhase = SPI_PHASE_2EDGE;
      break;
  }
 
  bool ok = true;
  uint32_t hal_presc = 0;
 
  switch (config.prescaler)
  {
#ifdef SPI_BAUDRATEPRESCALER_1
    case Prescaler::DIV_1:
      hal_presc = SPI_BAUDRATEPRESCALER_1;
      break;
#endif
#ifdef SPI_BAUDRATEPRESCALER_2
    case Prescaler::DIV_2:
      hal_presc = SPI_BAUDRATEPRESCALER_2;
      break;
#endif
#ifdef SPI_BAUDRATEPRESCALER_4
    case Prescaler::DIV_4:
      hal_presc = SPI_BAUDRATEPRESCALER_4;
      break;
#endif
#ifdef SPI_BAUDRATEPRESCALER_8
    case Prescaler::DIV_8:
      hal_presc = SPI_BAUDRATEPRESCALER_8;
      break;
#endif
#ifdef SPI_BAUDRATEPRESCALER_16
    case Prescaler::DIV_16:
      hal_presc = SPI_BAUDRATEPRESCALER_16;
      break;
#endif
#ifdef SPI_BAUDRATEPRESCALER_32
    case Prescaler::DIV_32:
      hal_presc = SPI_BAUDRATEPRESCALER_32;
      break;
#endif
#ifdef SPI_BAUDRATEPRESCALER_64
    case Prescaler::DIV_64:
      hal_presc = SPI_BAUDRATEPRESCALER_64;
      break;
#endif
#ifdef SPI_BAUDRATEPRESCALER_128
    case Prescaler::DIV_128:
      hal_presc = SPI_BAUDRATEPRESCALER_128;
      break;
#endif
#ifdef SPI_BAUDRATEPRESCALER_256
    case Prescaler::DIV_256:
      hal_presc = SPI_BAUDRATEPRESCALER_256;
      break;
#endif
#ifdef SPI_BAUDRATEPRESCALER_512
    case Prescaler::DIV_512:
      hal_presc = SPI_BAUDRATEPRESCALER_512;
      break;
#endif
#ifdef SPI_BAUDRATEPRESCALER_1024
    case Prescaler::DIV_1024:
      hal_presc = SPI_BAUDRATEPRESCALER_1024;
      break;
#endif
    default:
      ok = false;
      break;
  }
 
  ASSERT(ok);
  if (!ok)
  {
    return ErrorCode::NOT_SUPPORT;
  }
 
  spi_handle_->Init.BaudRatePrescaler = hal_presc;
 
  GetConfig() = config;
 
  return (HAL_SPI_Init(spi_handle_) == HAL_OK) ? ErrorCode::OK : ErrorCode::BUSY;
}

Transfer()

ErrorCode STM32SPI::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 658 of file stm32_spi.cpp.

{
  if (spi_handle_->State != HAL_SPI_STATE_READY)
  {
    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();
 
  const uint16_t xfer = static_cast<uint16_t>(size);
 
  if (size > dma_enable_min_size_)
  {
    rw_op_ = op;
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      block_wait_.Start(*op.data.sem_info.sem);
    }
 
    STM32_CleanDCacheByAddr(tx.addr_, xfer);
    STM32_InvalidateDCacheByAddr(rx.addr_, xfer);
 
    HAL_StatusTypeDef st =
        HAL_SPI_TransmitReceive_DMA(spi_handle_, static_cast<uint8_t*>(tx.addr_),
                                    static_cast<uint8_t*>(rx.addr_), xfer);
 
    if (st != HAL_OK)
    {
      if (op.type == OperationRW::OperationType::BLOCK)
      {
        block_wait_.Cancel();
      }
      return ErrorCode::BUSY;
    }
 
    op.MarkAsRunning();
    if (op.type == OperationRW::OperationType::BLOCK)
    {
      return block_wait_.Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
 
  ErrorCode ans =
      (HAL_SPI_TransmitReceive(spi_handle_, static_cast<uint8_t*>(tx.addr_),
                               static_cast<uint8_t*>(rx.addr_), xfer, 20) == HAL_OK)
          ? ErrorCode::OK
          : ErrorCode::BUSY;
 
  STM32_InvalidateDCacheByAddr(rx.addr_, xfer);
 
  SwitchBuffer();
 
  if (op.type != OperationRW::OperationType::BLOCK)
  {
    op.UpdateStatus(in_isr, ans);
  }
  return ans;
}

Field Documentation

block_wait_

AsyncBlockWait LibXR::STM32SPI::block_wait_ {}

Definition at line 91 of file stm32_spi.hpp.

{};

dma_enable_min_size_

uint32_t LibXR::STM32SPI::dma_enable_min_size_ = 3

Definition at line 84 of file stm32_spi.hpp.

id_

stm32_spi_id_t LibXR::STM32SPI::id_ = STM32_SPI_ID_ERROR

Definition at line 82 of file stm32_spi.hpp.

map

STM32SPI * STM32SPI::map = {nullptr}

static

Definition at line 93 of file stm32_spi.hpp.

mem_read_

bool LibXR::STM32SPI::mem_read_ = false

Definition at line 90 of file stm32_spi.hpp.

read_buff_

RawData LibXR::STM32SPI::read_buff_

Definition at line 88 of file stm32_spi.hpp.

rw_op_

OperationRW LibXR::STM32SPI::rw_op_

Definition at line 86 of file stm32_spi.hpp.

spi_handle_

SPI_HandleTypeDef* LibXR::STM32SPI::spi_handle_

Definition at line 80 of file stm32_spi.hpp.

---

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

• driver/st/stm32_spi.hpp
• driver/st/stm32_spi.cpp