We use this type of storage for both the F series and the G series. Couple questions before you dig yourself in deep.
- How frequently do you need to write the data? ST micro flash can only be erased approximately 1000 times(this number is hard to find) as flash on these devices is really designed for holding code(older flash could be erased in the 100K range.) If the data is only configuration stuff that is updated infrequently you'll be fine. If your writing out error logs the code will have to be much more complex as you will need to track the number of sector erases(the G series refers to these as Pages.)
- If you decide that you will not burn the flash out by writing to many times, then find how big the Page(or Sector) sizes are and how large do the flash writes need to be. F series allowed you to write 4 bytes at a time where the G series that we use need to be 8 bytes at a time. Size your data structures accordingly so you keep everything aligned.
Some code below will give you an idea of storing configuration data that is NOT written to frequently.It's just basic stuff but should give you some idea of storing configuration information.
void __attribute__((optimize("O0"))) flash_config_init(void)
{
uint32_t seedValue, crcLength, crcTemp, pageNumber, *addr_p;
FLASH_Status status;
seedValue = CRC32_SEED_VALUE;
crcLength = (sizeof(flash_config_struct)-sizeof(uint32_t));
// Read out the Magic number...
addr_p = (uint32_t *)FLASH_CONFIG_START_ADDR;
data.magicNum = *(__IO uint32_t *)addr_p;
addr_p++;
data.softwareRev = *(__IO uint32_t *)addr_p;
if ((data.magicNum == EZTEMP_MAGIC_NUMBER) && (data.softwareRev == SOFTWARE_REV))
{
flash_read_x_uint32((uint32_t *)&flashData, (uint32_t *)FLASH_CONFIG_START_ADDR, sizeof(flash_config_struct));
}
else
{
// There is no flash data, or the software revision has changed. Set
// the flash data to default values.
memset(&data, 0, sizeof(flash_config_struct));
data.magicNum = EZTEMP_MAGIC_NUMBER;
data.xxx = 0xAA5500FF;
data.xxx2 = 0xFF00AA55;
data.softwareRev = SOFTWARE_REV;
// Calculate the CRC value going in...
//crcTemp = crc_check((uint8_t *)&data, (sizeof(flash_config_struct)-sizeof(uint32_t)));
CRC_SetInitRegister(CRC32_SEED_VALUE);
CRC_ResetDR();
crcTemp = flash_calculate_crc32((uint32_t *)&data, crcLength, (uint32_t *)&seedValue);
if(crcTemp)
{
data.crcValue = crcTemp;
// Erase/Clear the page/sector and program the default values...
HAL_FLASH_Unlock();
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_PROGERR | FLASH_FLAG_WRPERR);
// New HAL based driver code needs the page number, not address. It also starts
// a page erase and had used interrupts to finish the erase cycle. We don't use
// interrupts so we added a call to wait for the last operation to finish.
addr_p = (uint32_t *)FLASH_CONFIG_START_ADDR;
pageNumber = (FLASH_CONFIG_START_ADDR-FLASH_BANK2_START_ADDR)/FLASH_PAGE_SIZE;
status = FLASH_ErasePage(FLASH_BANK2, pageNumber);
if (status != FLASH_COMPLETE)
{
HAL_FLASH_Lock();
shut_down(ERROR_CRC_FAIL);
}
HAL_FLASH_Lock();
// Write out the configuration information.
flash_write_x_uint32( (uint32_t *)&data, (uint32_t *)(FLASH_CONFIG_START_ADDR), sizeof(flash_config_struct));
// Data has been written into flash, read it out.
// Valid data in flash. Read it out.
flash_read_x_uint32((uint32_t *)&flashData, (uint32_t *)FLASH_CONFIG_START_ADDR, sizeof(flash_config_struct));
}
}
// Verify the CRC value..
//crcTemp = crc_check((uint8_t *)&flashData, (sizeof(flash_config_struct)-sizeof(uint32_t)));
seedValue = CRC32_SEED_VALUE;
crcLength = (sizeof(flash_config_struct)-sizeof(uint32_t));
crcTemp = flash_calculate_crc32((uint32_t *)&flashData, crcLength, (uint32_t *)&seedValue);
if (crcTemp != flashData.crcValue)
{
// Default CRC is failing. Need to shut down...
shut_down(ERROR_CRC_FAIL);
}
crcTemp = verify_config(&flashData);
if (crcTemp != FUNCTION_SUCCESS)
{
// Flash configuration has failed the range check...
shut_down(crcTemp);
}
}
uint32_t flash_read_x_uint32(uint32_t *data_p, uint32_t *addr_p, uint32_t readSize)
{
uint32_t *tempAddr_p, *tempData_p, *end_p;
uint32_t rc = 0;
if ( (data_p != 0) && (readSize != 0) )
{
tempAddr_p = addr_p;
tempData_p = data_p;
end_p = (uint32_t *)(((uint8_t *)tempAddr_p)+readSize);
// We are reading 4 bytes at a time from flash
while (tempAddr_p < end_p)
{
*tempData_p = *(__IO uint32_t *)tempAddr_p;
tempAddr_p++;
tempData_p++;
}
}
else
{
rc = 1;
}
return(rc);
}
uint32_t flash_write_x_uint32(uint32_t *data_p, uint32_t *addr_p, uint32_t writeSize)
{
uint32_t *tempAddr_p, *end_p, rc = 0;
uint64_t *tempData_p;
if ( (data_p != 0) && (writeSize != 0) && (writeSize <= FLASH_PAGE_SIZE))
{
HAL_FLASH_Unlock();
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_PROGERR | FLASH_FLAG_WRPERR);
tempAddr_p = addr_p;
tempData_p = data_p;
end_p = (uint32_t *)(((uint8_t *)tempAddr_p)+writeSize);
// We are writing 8 bytes at a time to flash because the STM32G0B0RE can
// only write 8 bytes at a time.
while (tempAddr_p < end_p)
{
// We are writing 8 bytes at a time to flash because the STM32G0B0RE can
// only write 8 bytes at a time.
HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, (uint32_t)tempAddr_p, *tempData_p);
tempAddr_p += 2;
tempData_p ++;
}
// Both the image header and configuration have been written out, lock the flash.
HAL_FLASH_Lock();
}
else
{
rc = 1;
}
return(rc);
}
