libxr 1.0
Want to be the best embedded framework
Loading...
Searching...
No Matches
Public Member Functions | Data Fields | Static Public Attributes
LibXR::STM32SPI Class Reference
Inheritance diagram for LibXR::STM32SPI:
Inheritance graph
[legend]
Collaboration diagram for LibXR::STM32SPI:
Collaboration graph
[legend]

Public Member Functions

 STM32SPI (SPI_HandleTypeDef *spi_handle, RawData dma_buff_rx, RawData dma_buff_tx, uint32_t dma_enable_min_size=3)
 
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.
 
- 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_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
 

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...
 
using OperationRW = WriteOperation
 定义读写操作类型的别名。Defines an alias for the read/write operation type.
 

Detailed Description

Definition at line 49 of file stm32_spi.hpp.

Constructor & Destructor Documentation

◆ STM32SPI()

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

Definition at line 52 of file stm32_spi.hpp.

54 : SPI(),
55 dma_buff_rx_(dma_buff_rx),
56 dma_buff_tx_(dma_buff_tx),
57 spi_handle_(spi_handle),
58 id_(STM32_SPI_GetID(spi_handle_->Instance)),
59 dma_enable_min_size_(dma_enable_min_size)
60 {
61 ASSERT(id_ != STM32_SPI_ID_ERROR);
62
63 map[id_] = this;
64 }
LibXR::SPI::SPI
SPI()
默认构造函数。Default constructor.
Definition spi.hpp:66
LibXR::min
constexpr auto min(T1 a, T2 b) -> typename std::common_type< T1, T2 >::type
计算两个数的最小值
Definition libxr_def.hpp:161

Member Function Documentation

◆ MemRead()

ErrorCode LibXR::STM32SPI::MemRead ( uint16_t  reg,
RawData  read_data,
OperationRW &  op 
)
inlineoverridevirtual

从 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 145 of file stm32_spi.hpp.

146 {
147 uint32_t need_read = read_data.size_;
148
149 if (spi_handle_->State != HAL_SPI_STATE_READY)
150 {
151 return ErrorCode::BUSY;
152 }
153
154 mem_read_ = false;
155
156 uint8_t *dma_buffer_rx = reinterpret_cast<uint8_t *>(dma_buff_rx_.addr_);
157 uint8_t *dma_buffer_tx = reinterpret_cast<uint8_t *>(dma_buff_tx_.addr_);
158
159 if (need_read + 1 > dma_enable_min_size_)
160 {
161 memset(dma_buff_rx_.addr_, 0, need_read + 1);
162 memset(dma_buff_tx_.addr_, 0, need_read + 1);
163 dma_buffer_tx[0] = reg | 0x80;
164 rw_op_ = op;
165 read_buff_ = read_data;
166
167 mem_read_ = true;
168
169 HAL_SPI_TransmitReceive_DMA(spi_handle_, static_cast<uint8_t *>(dma_buff_tx_.addr_),
170 static_cast<uint8_t *>(dma_buff_rx_.addr_),
171 need_read + 1);
172
173 op.MarkAsRunning();
174 if (op.type == OperationRW::OperationType::BLOCK)
175 {
176 return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
177 }
178 return ErrorCode::OK;
179 }
180 else
181 {
182 memset(dma_buff_rx_.addr_, 0, need_read + 1);
183 memset(dma_buff_tx_.addr_, 0, need_read + 1);
184 dma_buffer_tx[0] = reg | 0x80;
185 ErrorCode ans =
186 HAL_SPI_TransmitReceive(spi_handle_, static_cast<uint8_t *>(dma_buff_tx_.addr_),
187 static_cast<uint8_t *>(dma_buff_rx_.addr_),
188 need_read + 1, 20) == HAL_OK
189 ? ErrorCode::OK
190 : ErrorCode::BUSY;
191
192 memcpy(read_data.addr_, dma_buffer_rx + 1, read_data.size_);
193
194 op.UpdateStatus(false, std::forward<ErrorCode>(ans));
195
196 if (op.type == OperationRW::OperationType::BLOCK)
197 {
198 return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
199 }
200
201 return ans;
202 }
203 }
LibXR::RawData::addr_
void * addr_
数据存储地址。 The storage address of the data.
Definition libxr_type.hpp:114

◆ MemWrite()

ErrorCode LibXR::STM32SPI::MemWrite ( uint16_t  reg,
ConstRawData  write_data,
OperationRW &  op 
)
inlineoverridevirtual

向 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 205 of file stm32_spi.hpp.

206 {
207 uint32_t need_write = write_data.size_;
208
209 if (spi_handle_->State != HAL_SPI_STATE_READY)
210 {
211 return ErrorCode::BUSY;
212 }
213
214 mem_read_ = false;
215
216 uint8_t *dma_buffer_tx = reinterpret_cast<uint8_t *>(dma_buff_tx_.addr_);
217
218 if (need_write + 1 > dma_enable_min_size_)
219 {
220 memcpy(dma_buffer_tx + 1, write_data.addr_, need_write);
221 *dma_buffer_tx = reg & 0x7f;
222
223 rw_op_ = op;
224 read_buff_ = {nullptr, 0};
225
226 HAL_SPI_TransmitReceive_DMA(spi_handle_, static_cast<uint8_t *>(dma_buff_tx_.addr_),
227 static_cast<uint8_t *>(dma_buff_rx_.addr_),
228 need_write + 1);
229
230 op.MarkAsRunning();
231 if (op.type == OperationRW::OperationType::BLOCK)
232 {
233 return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
234 }
235 return ErrorCode::OK;
236 }
237 else
238 {
239 memcpy(dma_buffer_tx + 1, write_data.addr_, need_write);
240 *dma_buffer_tx = reg & 0x7f;
241 ErrorCode ans =
242 HAL_SPI_TransmitReceive(spi_handle_, static_cast<uint8_t *>(dma_buff_tx_.addr_),
243 static_cast<uint8_t *>(dma_buff_rx_.addr_),
244 need_write + 1, 20) == HAL_OK
245 ? ErrorCode::OK
246 : ErrorCode::BUSY;
247
248 op.UpdateStatus(false, std::forward<ErrorCode>(ans));
249
250 if (op.type == OperationRW::OperationType::BLOCK)
251 {
252 return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
253 }
254
255 return ans;
256 }
257 }

◆ ReadAndWrite()

ErrorCode LibXR::STM32SPI::ReadAndWrite ( RawData  read_data,
ConstRawData  write_data,
OperationRW &  op 
)
inlineoverridevirtual

进行 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 66 of file stm32_spi.hpp.

68 {
69 uint32_t need_write = max(write_data.size_, read_data.size_);
70 ASSERT(need_write <= dma_buff_rx_.size_ && need_write <= dma_buff_tx_.size_);
71
72 if (spi_handle_->State != HAL_SPI_STATE_READY)
73 {
74 return ErrorCode::BUSY;
75 }
76
77 mem_read_ = false;
78
79 if (need_write > dma_enable_min_size_)
80 {
81 memcpy(dma_buff_tx_.addr_, write_data.addr_, need_write);
82 memset(dma_buff_rx_.addr_, 0, need_write);
83 rw_op_ = op;
84 read_buff_ = read_data;
85
86 HAL_SPI_TransmitReceive_DMA(spi_handle_, static_cast<uint8_t *>(dma_buff_tx_.addr_),
87 static_cast<uint8_t *>(dma_buff_rx_.addr_), need_write);
88
89 op.MarkAsRunning();
90 if (op.type == OperationRW::OperationType::BLOCK)
91 {
92 return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
93 }
94 return ErrorCode::OK;
95 }
96 else
97 {
98 memcpy(dma_buff_tx_.addr_, write_data.addr_, write_data.size_);
99 memset(dma_buff_rx_.addr_, 0, write_data.size_);
100 ErrorCode ans =
101 HAL_SPI_TransmitReceive(spi_handle_, static_cast<uint8_t *>(dma_buff_tx_.addr_),
102 static_cast<uint8_t *>(dma_buff_rx_.addr_), need_write,
103 20) == HAL_OK
104 ? ErrorCode::OK
105 : ErrorCode::BUSY;
106
107 memcpy(read_data.addr_, dma_buff_rx_.addr_, read_data.size_);
108
109 op.UpdateStatus(false, std::forward<ErrorCode>(ans));
110
111 if (op.type == OperationRW::OperationType::BLOCK)
112 {
113 return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
114 }
115
116 return ans;
117 }
118 }
LibXR::RawData::size_
size_t size_
数据大小（字节）。 The size of the data (in bytes).
Definition libxr_type.hpp:115
LibXR::max
constexpr auto max(T1 a, T2 b) -> typename std::common_type< T1, T2 >::type
计算两个数的最大值
Definition libxr_def.hpp:146

◆ SetConfig()

ErrorCode LibXR::STM32SPI::SetConfig ( SPI::Configuration  config)
inlineoverridevirtual

设置 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 120 of file stm32_spi.hpp.

121 {
122 switch (config.clock_polarity)
123 {
124 case SPI::ClockPolarity::LOW:
125 spi_handle_->Init.CLKPolarity = SPI_POLARITY_LOW;
126 break;
127 case SPI::ClockPolarity::HIGH:
128 spi_handle_->Init.CLKPolarity = SPI_POLARITY_HIGH;
129 break;
130 }
131
132 switch (config.clock_phase)
133 {
134 case SPI::ClockPhase::EDGE_1:
135 spi_handle_->Init.CLKPhase = SPI_PHASE_1EDGE;
136 break;
137 case SPI::ClockPhase::EDGE_2:
138 spi_handle_->Init.CLKPhase = SPI_PHASE_2EDGE;
139 break;
140 }
141
142 return HAL_SPI_Init(spi_handle_) == HAL_OK ? ErrorCode::OK : ErrorCode::BUSY;
143 }
LibXR::SPI::ClockPhase::EDGE_2
@ EDGE_2
在第二个时钟边沿采样数据。Data sampled on the second clock edge.
LibXR::SPI::ClockPhase::EDGE_1
@ EDGE_1
在第一个时钟边沿采样数据。Data sampled on the first clock edge.
LibXR::SPI::ClockPolarity::LOW
@ LOW
时钟空闲时为低电平。Clock idle low.
LibXR::SPI::ClockPolarity::HIGH
@ HIGH
时钟空闲时为高电平。Clock idle high.

Field Documentation

◆ dma_buff_rx_

RawData LibXR::STM32SPI::dma_buff_rx_

Definition at line 259 of file stm32_spi.hpp.

◆ dma_buff_tx_

RawData LibXR::STM32SPI::dma_buff_tx_

Definition at line 259 of file stm32_spi.hpp.

◆ dma_enable_min_size_

uint32_t LibXR::STM32SPI::dma_enable_min_size_ = 3

Definition at line 265 of file stm32_spi.hpp.

◆ id_

stm32_spi_id_t LibXR::STM32SPI::id_ = STM32_SPI_ID_ERROR

Definition at line 263 of file stm32_spi.hpp.

◆ map

STM32SPI * STM32SPI::map = {nullptr}
static

Definition at line 273 of file stm32_spi.hpp.

◆ mem_read_

bool LibXR::STM32SPI::mem_read_ = false

Definition at line 271 of file stm32_spi.hpp.

◆ read_buff_

RawData LibXR::STM32SPI::read_buff_

Definition at line 269 of file stm32_spi.hpp.

◆ rw_op_

OperationRW LibXR::STM32SPI::rw_op_

Definition at line 267 of file stm32_spi.hpp.

◆ spi_handle_

SPI_HandleTypeDef* LibXR::STM32SPI::spi_handle_

Definition at line 261 of file stm32_spi.hpp.

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