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.

Public Attributes
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 484 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 628 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 340 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 417 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;
  }
 
  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 657 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;
}

Member Data 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