libxr 1.0
Want to be the best embedded framework
Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes
LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR > Class Template Reference

STM32Flash 通用类，构造时传入扇区列表，自动判断编程粒度。 More...

#include <stm32_flash.hpp>

Inheritance diagram for LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >:
Inheritance graph
[legend]
Collaboration diagram for LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >:
Collaboration graph
[legend]

Public Member Functions

 STM32Flash (const FlashSector(&sectors)[SECTOR_COUNT])
 STM32Flash 类，构造时传入扇区列表，自动判断编程粒度。
 
ErrorCode Erase (size_t offset, size_t size) override
 Erases a section of the flash memory. 擦除闪存的指定区域。
 
ErrorCode Write (size_t offset, ConstRawData data) override
 Writes data to the flash memory. 向闪存写入数据。
 
- Public Member Functions inherited from LibXR::Flash
 Flash (size_t min_erase_size, size_t min_write_size, RawData flash_area)
 Constructs a Flash object with specified properties. 构造函数，初始化闪存属性。
 

Private Member Functions

bool IsInRange (uint32_t addr, size_t size) const
 

Static Private Member Functions

static constexpr uint32_t DetermineProgramType ()
 
static constexpr size_t DetermineMinWriteSize ()
 

Private Attributes

const FlashSector * sectors_
 
uint32_t base_address_
 
uint32_t program_type_
 

Additional Inherited Members

- Data Fields inherited from LibXR::Flash
size_t min_erase_size_
 Minimum erasable block size in bytes. 最小可擦除块大小（字节）。
 
size_t min_write_size_
 Minimum writable block size in bytes. 最小可写块大小（字节）。
 
RawData flash_area_
 

Detailed Description

template<size_t SECTOR_COUNT, size_t START_SECTOR>
class LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >

STM32Flash 通用类，构造时传入扇区列表，自动判断编程粒度。

Template Parameters
SECTOR_COUNT扇区数量
START_SECTOR起始扇区索引（用于擦除编号）

Definition at line 83 of file stm32_flash.hpp.

Constructor & Destructor Documentation

◆ STM32Flash()

template<size_t SECTOR_COUNT, size_t START_SECTOR>
LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >::STM32Flash ( const FlashSector(&)  sectors[SECTOR_COUNT])
inline

STM32Flash 类，构造时传入扇区列表，自动判断编程粒度。

Parameters
sectors扇区列表

Definition at line 91 of file stm32_flash.hpp.

92 : Flash(sectors[START_SECTOR - 1].size, DetermineMinWriteSize(),
93 {reinterpret_cast<void*>(sectors[START_SECTOR - 1].address),
94 sectors[SECTOR_COUNT - 1].address - sectors[START_SECTOR - 1].address +
95 sectors[SECTOR_COUNT - 1].size}),
96 sectors_(sectors),
97 base_address_(sectors[START_SECTOR - 1].address),
98 program_type_(DetermineProgramType())
99 {
100 }
LibXR::Flash::Flash
Flash(size_t min_erase_size, size_t min_write_size, RawData flash_area)
Constructs a Flash object with specified properties. 构造函数，初始化闪存属性。
Definition flash.hpp:27
LibXR::min
constexpr auto min(T1 a, T2 b) -> typename std::common_type< T1, T2 >::type
计算两个数的最小值
Definition libxr_def.hpp:161

Member Function Documentation

◆ DetermineMinWriteSize()

template<size_t SECTOR_COUNT, size_t START_SECTOR>
static constexpr size_t LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >::DetermineMinWriteSize ( )
inlinestaticconstexprprivate

Definition at line 250 of file stm32_flash.hpp.

251 {
252#ifdef FLASH_TYPEPROGRAM_BYTE
253 return 1;
254#elif defined(FLASH_TYPEPROGRAM_HALFWORD)
255 return 2;
256#elif defined(FLASH_TYPEPROGRAM_WORD)
257 return 4;
258#elif defined(FLASH_TYPEPROGRAM_DOUBLEWORD)
259 return 8;
260#elif defined(FLASH_TYPEPROGRAM_FLASHWORD)
261 return FLASH_NB_32BITWORD_IN_FLASHWORD * 4;
262#else
263#error "No supported FLASH_TYPEPROGRAM_xxx defined"
264#endif
265 }

◆ DetermineProgramType()

template<size_t SECTOR_COUNT, size_t START_SECTOR>
static constexpr uint32_t LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >::DetermineProgramType ( )
inlinestaticconstexprprivate

Definition at line 233 of file stm32_flash.hpp.

234 {
235#ifdef FLASH_TYPEPROGRAM_BYTE
236 return FLASH_TYPEPROGRAM_BYTE;
237#elif defined(FLASH_TYPEPROGRAM_HALFWORD)
238 return FLASH_TYPEPROGRAM_HALFWORD;
239#elif defined(FLASH_TYPEPROGRAM_WORD)
240 return FLASH_TYPEPROGRAM_WORD;
241#elif defined(FLASH_TYPEPROGRAM_DOUBLEWORD)
242 return FLASH_TYPEPROGRAM_DOUBLEWORD;
243#elif defined(FLASH_TYPEPROGRAM_FLASHWORD)
244 return FLASH_TYPEPROGRAM_FLASHWORD;
245#else
246#error "No supported FLASH_TYPEPROGRAM_xxx defined"
247#endif
248 }

◆ Erase()

template<size_t SECTOR_COUNT, size_t START_SECTOR>
ErrorCode LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >::Erase ( size_t  offset,
size_t  size 
)
inlineoverridevirtual

Erases a section of the flash memory. 擦除闪存的指定区域。

Parameters
offsetThe starting offset of the section to erase. 要擦除的起始偏移地址。
sizeThe size of the section to erase. 要擦除的区域大小。
Returns
ErrorCode indicating success or failure. 返回操作结果的错误码。

Implements LibXR::Flash.

Definition at line 102 of file stm32_flash.hpp.

103 {
104 if (size == 0)
105 {
106 return ErrorCode::ARG_ERR;
107 }
108
109 uint32_t start_addr = base_address_ + offset;
110 uint32_t end_addr = start_addr + size;
111
112 HAL_FLASH_Unlock();
113
114 for (size_t i = 0; i < SECTOR_COUNT; ++i)
115 {
116 const auto& sector = sectors_[i];
117 if (sector.address + sector.size <= start_addr)
118 {
119 continue;
120 }
121 if (sector.address >= end_addr)
122 {
123 break;
124 }
125 FLASH_EraseInitTypeDef erase_init = {};
126
127#if defined(FLASH_TYPEERASE_PAGES) && defined(FLASH_PAGE_SIZE) // STM32F1/G4... series
128 erase_init.TypeErase = FLASH_TYPEERASE_PAGES;
129 SetNbPages(erase_init, sector.address, i);
130 erase_init.NbPages = 1;
131 SetBanks(erase_init);
132#elif defined(FLASH_TYPEERASE_SECTORS) // STM32F4/F7/H7... series
133 erase_init.TypeErase = FLASH_TYPEERASE_SECTORS;
134 erase_init.Sector = static_cast<uint32_t>(i);
135 erase_init.NbSectors = 1;
136 erase_init.Banks = FLASH_BANK_1;
137#else
138 return ErrorCode::NOT_SUPPORT;
139#endif
140
141 uint32_t error = 0;
142 HAL_StatusTypeDef status = HAL_FLASHEx_Erase(&erase_init, &error);
143 if (status != HAL_OK || error != 0xFFFFFFFFU)
144 {
145 HAL_FLASH_Lock();
146 return ErrorCode::FAILED;
147 }
148 }
149
150 HAL_FLASH_Lock();
151 return ErrorCode::OK;
152 }

◆ IsInRange()

template<size_t SECTOR_COUNT, size_t START_SECTOR>
bool LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >::IsInRange ( uint32_t  addr,
size_t  size 
) const
inlineprivate

Definition at line 267 of file stm32_flash.hpp.

268 {
269 uint32_t end = addr + size;
270 for (size_t i = 0; i < SECTOR_COUNT; ++i)
271 {
272 const auto& s = sectors_[i];
273 if (addr >= s.address && end <= s.address + s.size)
274 {
275 return true;
276 }
277 }
278 return false;
279 }

◆ Write()

template<size_t SECTOR_COUNT, size_t START_SECTOR>
ErrorCode LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >::Write ( size_t  offset,
ConstRawData  data 
)
inlineoverridevirtual

Writes data to the flash memory. 向闪存写入数据。

Parameters
offsetThe starting offset to write data. 数据写入的起始偏移地址。
dataThe data to be written. 需要写入的数据。
Returns
ErrorCode indicating success or failure. 返回操作结果的错误码。

Implements LibXR::Flash.

Definition at line 154 of file stm32_flash.hpp.

155 {
156 if (!data.addr_ || data.size_ == 0)
157 {
158 return ErrorCode::ARG_ERR;
159 }
160
161 uint32_t addr = base_address_ + offset;
162 if (!IsInRange(addr, data.size_))
163 {
164 return ErrorCode::OUT_OF_RANGE;
165 }
166
167 HAL_FLASH_Unlock();
168
169 const uint8_t* src = reinterpret_cast<const uint8_t*>(data.addr_);
170 size_t written = 0;
171
172#if defined(STM32H7) || defined(STM32H5)
173 alignas(32) uint32_t flash_word_buffer[8] = {0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu,
174 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu,
175 0xFFFFFFFFu, 0xFFFFFFFFu};
176 while (written < data.size_)
177 {
178 size_t chunk_size = std::min<size_t>(min_write_size_, data.size_ - written);
179
180 std::memcpy(flash_word_buffer, src + written, chunk_size);
181
182 if (memcmp(reinterpret_cast<const uint8_t*>(addr + written), src + written,
183 chunk_size) == 0)
184 {
185 written += chunk_size;
186 continue;
187 }
188
189 if (HAL_FLASH_Program(program_type_, addr + written,
190 reinterpret_cast<uint32_t>(flash_word_buffer)) != HAL_OK)
191 {
192 HAL_FLASH_Lock();
193 return ErrorCode::FAILED;
194 }
195
196 written += chunk_size;
197 }
198
199#else
200 while (written < data.size_)
201 {
202 size_t chunk_size = std::min<size_t>(min_write_size_, data.size_ - written);
203
204 if (memcmp(reinterpret_cast<const uint8_t*>(addr + written), src + written,
205 chunk_size) == 0)
206 {
207 written += chunk_size;
208 continue;
209 }
210
211 uint64_t word = 0xFFFFFFFFFFFFFFFF;
212 std::memcpy(&word, src + written, chunk_size);
213
214 if (HAL_FLASH_Program(program_type_, addr + written, word) != HAL_OK)
215 {
216 HAL_FLASH_Lock();
217 return ErrorCode::FAILED;
218 }
219
220 written += chunk_size;
221 }
222#endif
223
224 HAL_FLASH_Lock();
225 return ErrorCode::OK;
226 }
LibXR::Flash::min_write_size_
size_t min_write_size_
Minimum writable block size in bytes. 最小可写块大小（字节）。
Definition flash.hpp:36

Field Documentation

◆ base_address_

template<size_t SECTOR_COUNT, size_t START_SECTOR>
uint32_t LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >::base_address_
private

Definition at line 230 of file stm32_flash.hpp.

◆ program_type_

template<size_t SECTOR_COUNT, size_t START_SECTOR>
uint32_t LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >::program_type_
private

Definition at line 231 of file stm32_flash.hpp.

◆ sectors_

template<size_t SECTOR_COUNT, size_t START_SECTOR>
const FlashSector* LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >::sectors_
private

Definition at line 229 of file stm32_flash.hpp.

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