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

#include <stm32_flash.hpp>

Inheritance diagram for LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >:

Collaboration diagram for LibXR::STM32Flash< SECTOR_COUNT, START_SECTOR >:

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 87 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 95 of file stm32_flash.hpp.

      : Flash(sectors[START_SECTOR - 1].size, DetermineMinWriteSize(),
              {reinterpret_cast<void*>(sectors[START_SECTOR - 1].address),
               sectors[SECTOR_COUNT - 1].address - sectors[START_SECTOR - 1].address +
                   sectors[SECTOR_COUNT - 1].size}),
        sectors_(sectors),
        base_address_(sectors[START_SECTOR - 1].address),
        program_type_(DetermineProgramType())
  {
  }

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 254 of file stm32_flash.hpp.

  {
#ifdef FLASH_TYPEPROGRAM_BYTE
    return 1;
#elif defined(FLASH_TYPEPROGRAM_HALFWORD)
    return 2;
#elif defined(FLASH_TYPEPROGRAM_WORD)
    return 4;
#elif defined(FLASH_TYPEPROGRAM_DOUBLEWORD)
    return 8;
#elif defined(FLASH_TYPEPROGRAM_FLASHWORD)
    return FLASH_NB_32BITWORD_IN_FLASHWORD * 4;
#else
#error "No supported FLASH_TYPEPROGRAM_xxx defined"
#endif
  }

◆ 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 237 of file stm32_flash.hpp.

  {
#ifdef FLASH_TYPEPROGRAM_BYTE
    return FLASH_TYPEPROGRAM_BYTE;
#elif defined(FLASH_TYPEPROGRAM_HALFWORD)
    return FLASH_TYPEPROGRAM_HALFWORD;
#elif defined(FLASH_TYPEPROGRAM_WORD)
    return FLASH_TYPEPROGRAM_WORD;
#elif defined(FLASH_TYPEPROGRAM_DOUBLEWORD)
    return FLASH_TYPEPROGRAM_DOUBLEWORD;
#elif defined(FLASH_TYPEPROGRAM_FLASHWORD)
    return FLASH_TYPEPROGRAM_FLASHWORD;
#else
#error "No supported FLASH_TYPEPROGRAM_xxx defined"
#endif
  }

◆ 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

offset	The starting offset of the section to erase. 要擦除的起始偏移地址。
size	The size of the section to erase. 要擦除的区域大小。

Returns: ErrorCode indicating success or failure. 返回操作结果的错误码。

Implements LibXR::Flash.

Definition at line 106 of file stm32_flash.hpp.

  {
    if (size == 0)
    {
      return ErrorCode::ARG_ERR;
    }
 
    uint32_t start_addr = base_address_ + offset;
    uint32_t end_addr = start_addr + size;
 
    HAL_FLASH_Unlock();
 
    for (size_t i = 0; i < SECTOR_COUNT; ++i)
    {
      const auto& sector = sectors_[i];
      if (sector.address + sector.size <= start_addr)
      {
        continue;
      }
      if (sector.address >= end_addr)
      {
        break;
      }
      FLASH_EraseInitTypeDef erase_init = {};
 
#if defined(FLASH_TYPEERASE_PAGES) && defined(FLASH_PAGE_SIZE)  // STM32F1/G4... series
      erase_init.TypeErase = FLASH_TYPEERASE_PAGES;
      SetNbPages(erase_init, sector.address, i);
      erase_init.NbPages = 1;
      SetBanks(erase_init);
#elif defined(FLASH_TYPEERASE_SECTORS)  // STM32F4/F7/H7... series
      erase_init.TypeErase = FLASH_TYPEERASE_SECTORS;
      erase_init.Sector = static_cast<uint32_t>(i);
      erase_init.NbSectors = 1;
      erase_init.Banks = FLASH_BANK_1;
#else
      return ErrorCode::NOT_SUPPORT;
#endif
 
      uint32_t error = 0;
      HAL_StatusTypeDef status = HAL_FLASHEx_Erase(&erase_init, &error);
      if (status != HAL_OK || error != 0xFFFFFFFFU)
      {
        HAL_FLASH_Lock();
        return ErrorCode::FAILED;
      }
    }
 
    HAL_FLASH_Lock();
    return ErrorCode::OK;
  }

◆ 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 271 of file stm32_flash.hpp.

  {
    uint32_t end = addr + size;
    for (size_t i = 0; i < SECTOR_COUNT; ++i)
    {
      const auto& s = sectors_[i];
      if (addr >= s.address && end <= s.address + s.size)
      {
        return true;
      }
    }
    return false;
  }

◆ 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

offset	The starting offset to write data. 数据写入的起始偏移地址。
data	The data to be written. 需要写入的数据。

Returns: ErrorCode indicating success or failure. 返回操作结果的错误码。

Implements LibXR::Flash.

Definition at line 158 of file stm32_flash.hpp.

  {
    if (!data.addr_ || data.size_ == 0)
    {
      return ErrorCode::ARG_ERR;
    }
 
    uint32_t addr = base_address_ + offset;
    if (!IsInRange(addr, data.size_))
    {
      return ErrorCode::OUT_OF_RANGE;
    }
 
    HAL_FLASH_Unlock();
 
    const uint8_t* src = reinterpret_cast<const uint8_t*>(data.addr_);
    size_t written = 0;
 
#if defined(STM32H7) || defined(STM32H5)
    alignas(32) uint32_t flash_word_buffer[8] = {0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu,
                                                 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu,
                                                 0xFFFFFFFFu, 0xFFFFFFFFu};
    while (written < data.size_)
    {
      size_t chunk_size = LibXR::min<size_t>(min_write_size_, data.size_ - written);
 
      std::memcpy(flash_word_buffer, src + written, chunk_size);
 
      if (memcmp(reinterpret_cast<const uint8_t*>(addr + written), src + written,
                 chunk_size) == 0)
      {
        written += chunk_size;
        continue;
      }
 
      if (HAL_FLASH_Program(program_type_, addr + written,
                            reinterpret_cast<uint32_t>(flash_word_buffer)) != HAL_OK)
      {
        HAL_FLASH_Lock();
        return ErrorCode::FAILED;
      }
 
      written += chunk_size;
    }
 
#else
    while (written < data.size_)
    {
      size_t chunk_size = LibXR::min<size_t>(min_write_size_, data.size_ - written);
 
      if (memcmp(reinterpret_cast<const uint8_t*>(addr + written), src + written,
                 chunk_size) == 0)
      {
        written += chunk_size;
        continue;
      }
 
      uint64_t word = 0xFFFFFFFFFFFFFFFF;
      std::memcpy(&word, src + written, chunk_size);
 
      if (HAL_FLASH_Program(program_type_, addr + written, word) != HAL_OK)
      {
        HAL_FLASH_Lock();
        return ErrorCode::FAILED;
      }
 
      written += chunk_size;
    }
#endif
 
    HAL_FLASH_Lock();
    return ErrorCode::OK;
  }

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 234 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 235 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 233 of file stm32_flash.hpp.

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

driver/st/stm32_flash.hpp

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ STM32Flash()

Member Function Documentation

◆ DetermineMinWriteSize()

◆ DetermineProgramType()

◆ Erase()

◆ IsInRange()

◆ Write()

Field Documentation

◆ base_address_

◆ program_type_

◆ sectors_