The data read from the STM32F767Zi flash are different from the data written to?

[qs202310]

Hello Sir/Madam，

My project is using Nucleo-F767Zi + X-NUCLEO-IKS4A1. The calibration data need to store in STM32F767ZI flash memory. I have coded writing and loading function for this purpose. However, the data read out from the flash memory are different from the data written into with forementioned functions. I do appreciate your help for debugging my codes and sorted out the issues. My codes are:

/**
******************************************************************************
* @file motion_ac_flash.c
* @author ChatGPT
* @brief 实现 MotionAC 加速度计校准参数的 Flash 存取功能
* - 使用 STM32F767ZI 的内部 Flash（Sector 11）
* - 支持写入后逐字校验
* - 保证读取与写入数据完全一致
* - 自动刷新 D-Cache，避免缓存导致读出旧数据
******************************************************************************
*/

#include "motion_ac_manager.h"
#include "motion_ac.h"
#include "stm32f7xx_hal.h"
#include <string.h>
#include <stdio.h>

/* --------------------------------------------------------------------------
* Flash 存储地址设置（根据 STM32F767ZI 的 Flash 空间布局）
* STM32F767ZI 总 Flash 容量为 2MB (0x08000000 ~ 0x081FFFFF)
* 每个扇区大小为 128KB
* 本程序使用最后一个扇区 (Sector 11, 起始地址 0x080E0000)
* -------------------------------------------------------------------------- */
#define MOTION_AC_FLASH_SECTOR_ADDR ((uint32_t)0x080E0000) // 扇区起始地址
#define MOTION_AC_FLASH_SECTOR FLASH_SECTOR_11 // 扇区编号
#define MOTION_AC_FLASH_BANK FLASH_BANK_1 // 所属 Bank

/**
* @brief 从 Flash 读取加速度计校准参数
*  data_size 数据大小（字节）
*  data 指向目标缓存区的指针 (MAC_output_t*)
* @retval 0: 成功读取到有效参数
* 1: 读取失败或数据无效
*/
char MotionAC_LoadCalFromNVM(unsigned short int data_size, unsigned int *data)
{
if (data == NULL || data_size == 0)
     return (char)1;

/* 清除DCache，防止读取到旧缓存数据 */
SCB_InvalidateDCache_by_Addr((uint32_t *)MOTION_AC_FLASH_SECTOR_ADDR, data_size);

/* 将 Flash 中的数据拷贝到 RAM 缓存 */
memcpy((void *)data, (void *)MOTION_AC_FLASH_SECTOR_ADDR, data_size);

/* 转换为 MotionAC 输出结构体指针，便于验证 */
MAC_output_t *p = (MAC_output_t *)data;

/* 校验数据是否为有效的校准参数（通过 CalQuality 判断） */
if (p->CalQuality == MAC_CALQSTATUSGOOD ||
        p->CalQuality == MAC_CALQSTATUSOK)
  {
   printf("[MotionAC] 成功加载校准参数，质量等级 = %d\r\n", p->CalQuality);
    return (char)0;
  }

printf("[MotionAC] 无有效校准参数，需要重新校准。\r\n");
return (char)1;
}

/**
* @brief 将加速度计校准参数保存到 Flash
*  data_size 数据大小（字节）
*  data 指向源数据的指针 (MAC_output_t*)
* @retval 0: 保存并校验成功
* 1: 写入失败或校验不通过
*/
char MotionAC_SaveCalInNVM(unsigned short int data_size, unsigned int *data)
{
if (data == NULL || data_size == 0)
return (char)1;

HAL_StatusTypeDef status;
uint32_t address = MOTION_AC_FLASH_SECTOR_ADDR;

/* 确保写入长度是4字节对齐（Flash按字写入） */
if (data_size % 4 != 0)
data_size = ((data_size + 3) / 4) * 4;

/* 解锁 Flash，允许擦写操作 */
HAL_FLASH_Unlock();

/* ----------------- 第1步：擦除指定扇区 ----------------- */
FLASH_EraseInitTypeDef eraseInitStruct;
uint32_t sectorError = 0;

eraseInitStruct.TypeErase = FLASH_TYPEERASE_SECTORS;
eraseInitStruct.VoltageRange = FLASH_VOLTAGE_RANGE_3; // 电压范围：2.7V-3.6V
eraseInitStruct.Sector = MOTION_AC_FLASH_SECTOR;
eraseInitStruct.Banks = MOTION_AC_FLASH_BANK;
eraseInitStruct.NbSectors = 1; // 擦除1个扇区

status = HAL_FLASHEx_Erase(&eraseInitStruct, &sectorError);
if (status != HAL_OK)
{
HAL_FLASH_Lock();
printf("[MotionAC] Flash 擦除失败！错误码=%lu\r\n", sectorError);
return (char)1;
}

/* ----------------- 第2步：逐字写入数据 ----------------- */
for (uint32_t i = 0; i < data_size / 4; i++)
{
status = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, address, data[i]);
if (status != HAL_OK)
{
HAL_FLASH_Lock();
printf("[MotionAC] Flash 写入失败！地址=0x%08lX\r\n", address);
return (char)1;
}
address += 4;
}

/* ----------------- 第3步：关闭Flash写保护 ----------------- */
HAL_FLASH_Lock();

/* ----------------- 第4步：刷新Cache ----------------- */
SCB_CleanDCache_by_Addr((uint32_t *)MOTION_AC_FLASH_SECTOR_ADDR, data_size);
SCB_InvalidateDCache_by_Addr((uint32_t *)MOTION_AC_FLASH_SECTOR_ADDR, data_size);

/* ----------------- 第5步：逐字校验Flash内容 ----------------- */
uint32_t *src=(uint32_t *)data; // 源数据（RAM）
uint32_t *dst = (uint32_t *)MOTION_AC_FLASH_SECTOR_ADDR; // 写入后Flash数据

for (uint32_t i = 0; i < data_size / 4; i++)
{
if (src[i] != dst[i]) // 校验不一致
{
printf("[MotionAC] 校验失败 @0x%08lX: 写=0x%08lX, 读=0x%08lX\r\n",
(unsigned long)&dst[i],
(unsigned long)src[i],
(unsigned long)dst[i]);
return (char)1;
}
}

printf("[MotionAC] 校准参数保存成功并校验通过。\r\n");
return (char)0;
}

Post edited by ST moderator to be inline with the community rules especially with the code sharing. In next time please use </> button to paste your code. Please read this post: How to insert source code

[EXUE.2]

what is the level about the difference between read and write data? totally different or only a few words? please care about the sysclk configuration and the FLASH_LATENCY configuration, they will affect the flash read/write. below is the successful example for STM32F767ZI-Nucleo board:

/* Private define ------------------------------------------------------------*/
#define FLASH_USER_START_ADDR  ADDR_FLASH_SECTOR_2 /* Start @ of user Flash area */
#define FLASH_USER_END_ADDR   (ADDR_FLASH_SECTOR_6-1) /* End @ of user Flash area */

#define DATA_32 ((uint32_t)0x12345678)

/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
uint32_t FirstSector = 0, NbOfSectors = 0;
uint32_t Address = 0, SECTORError = 0;
__IO uint32_t data32 = 0 , MemoryProgramStatus = 0;
FLASH_OBProgramInitTypeDef OBInit;
/*Variable used for Erase procedure*/
static FLASH_EraseInitTypeDef EraseInitStruct;

/* Private function prototypes -----------------------------------------------*/
static void MPU_Config(void);
void SystemClock_Config(void);
static uint32_t GetSector(uint32_t Address);
static void CPU_CACHE_Enable(void);

/* Private functions ---------------------------------------------------------*/

/**
* @brief Main program
* @PAram None
* @retval None
*/
int main(void)
{
/* Configure the MPU attributes */
MPU_Config();

/* Enable the CPU Cache */
CPU_CACHE_Enable();
HAL_Init();

/* Configure the system clock to 216 MHz */
SystemClock_Config();

/* Unlock the Flash to enable the flash control register access *************/
HAL_FLASH_Unlock();
/* Allow Access to option bytes sector */
HAL_FLASH_OB_Unlock();

/* Get the Dual bank configuration status */
HAL_FLASHEx_OBGetConfig(&OBInit);

if((OBInit.USERConfig & OB_NDBANK_SINGLE_BANK) == OB_NDBANK_DUAL_BANK)
{
  ;//error
}

/* Erase the user Flash area
(area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR) ***********/

/* Get the 1st sector to erase */
FirstSector = GetSector(FLASH_USER_START_ADDR);
/* Get the number of sector to erase from 1st sector*/
NbOfSectors = GetSector(FLASH_USER_END_ADDR) - FirstSector + 1;
/* Fill EraseInit structure*/
EraseInitStruct.TypeErase = FLASH_TYPEERASE_SECTORS;
EraseInitStruct.VoltageRange = FLASH_VOLTAGE_RANGE_3;
EraseInitStruct.Sector = FirstSector;
EraseInitStruct.NbSectors = NbOfSectors;

if (HAL_FLASHEx_Erase(&EraseInitStruct, &SECTORError) != HAL_OK)
{
/* Infinite loop */
while (1)

{

   ;//error
 }

}

/* Program the user Flash area word by word
(area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR) ***********/

Address = FLASH_USER_START_ADDR;

while (Address < FLASH_USER_END_ADDR)
{
if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, DATA_32) == HAL_OK)
{
Address = Address + 4;
}
else
{
/* Error occurred while writing data in Flash memory.
User can add here some code to deal with this error */
while (1)
{
;//error
}
}
}

/* Lock the Flash to disable the flash control register access (recommended
to protect the FLASH memory against possible unwanted operation) *********/
HAL_FLASH_Lock();

/* Check if the programmed data is OK
MemoryProgramStatus = 0: data programmed correctly
MemoryProgramStatus != 0: number of words not programmed correctly ******/
Address = FLASH_USER_START_ADDR;
MemoryProgramStatus = 0x0;

while (Address < FLASH_USER_END_ADDR)
{
data32 = *(__IO uint32_t *)Address;

if (data32 != DATA_32)
{
MemoryProgramStatus++;
}
Address = Address + 4;
}

/*Check if there is an issue to program data*/
if (MemoryProgramStatus == 0)
{
/* No error detected. Switch on LED1*/
BSP_LED_On(LED1);
}
else
{
/* Error detected. Switch on LED2*/
BSP_LED_On(LED2);
}

/* Infinite loop */
while (1)
{
}
}

/**
* @brief Gets the sector of a given address
* @PAram None
* @retval The sector of a given address
*/
static uint32_t GetSector(uint32_t Address)
{
uint32_t sector = 0;

if((Address < ADDR_FLASH_SECTOR_1) && (Address >= ADDR_FLASH_SECTOR_0))
{
sector = FLASH_SECTOR_0;
}
else if((Address < ADDR_FLASH_SECTOR_2) && (Address >= ADDR_FLASH_SECTOR_1))
{
sector = FLASH_SECTOR_1;
}
else if((Address < ADDR_FLASH_SECTOR_3) && (Address >= ADDR_FLASH_SECTOR_2))
{
sector = FLASH_SECTOR_2;
}
else if((Address < ADDR_FLASH_SECTOR_4) && (Address >= ADDR_FLASH_SECTOR_3))
{
sector = FLASH_SECTOR_3;
}
else if((Address < ADDR_FLASH_SECTOR_5) && (Address >= ADDR_FLASH_SECTOR_4))
{
sector = FLASH_SECTOR_4;
}
else if((Address < ADDR_FLASH_SECTOR_6) && (Address >= ADDR_FLASH_SECTOR_5))
{
sector = FLASH_SECTOR_5;
}
else if((Address < ADDR_FLASH_SECTOR_7) && (Address >= ADDR_FLASH_SECTOR_6))
{
sector = FLASH_SECTOR_6;
}
else if((Address < ADDR_FLASH_SECTOR_8) && (Address >= ADDR_FLASH_SECTOR_7))
{
sector = FLASH_SECTOR_7;
}
else if((Address < ADDR_FLASH_SECTOR_9) && (Address >= ADDR_FLASH_SECTOR_8))
{
sector = FLASH_SECTOR_8;
}
else if((Address < ADDR_FLASH_SECTOR_10) && (Address >= ADDR_FLASH_SECTOR_9))
{
sector = FLASH_SECTOR_9;
}
else if((Address < ADDR_FLASH_SECTOR_11) && (Address >= ADDR_FLASH_SECTOR_10))
{
sector = FLASH_SECTOR_10;
}
#if defined(DUAL_BANK)
else if((Address < ADDR_FLASH_SECTOR_12) && (Address >= ADDR_FLASH_SECTOR_11))
{
sector = FLASH_SECTOR_11;
}
else if((Address < ADDR_FLASH_SECTOR_13) && (Address >= ADDR_FLASH_SECTOR_12))
{
sector = FLASH_SECTOR_12;
}
else if((Address < ADDR_FLASH_SECTOR_14) && (Address >= ADDR_FLASH_SECTOR_13))
{
sector = FLASH_SECTOR_13;
}
else if((Address < ADDR_FLASH_SECTOR_15) && (Address >= ADDR_FLASH_SECTOR_14))
{
sector = FLASH_SECTOR_14;
}
else if((Address < ADDR_FLASH_SECTOR_16) && (Address >= ADDR_FLASH_SECTOR_15))
{
sector = FLASH_SECTOR_15;
}
else if((Address < ADDR_FLASH_SECTOR_17) && (Address >= ADDR_FLASH_SECTOR_16))
{
sector = FLASH_SECTOR_16;
}
else if((Address < ADDR_FLASH_SECTOR_18) && (Address >= ADDR_FLASH_SECTOR_17))
{
sector = FLASH_SECTOR_17;
}
else if((Address < ADDR_FLASH_SECTOR_19) && (Address >= ADDR_FLASH_SECTOR_18))
{
sector = FLASH_SECTOR_18;
}
else if((Address < ADDR_FLASH_SECTOR_20) && (Address >= ADDR_FLASH_SECTOR_19))
{
sector = FLASH_SECTOR_19;
}
else if((Address < ADDR_FLASH_SECTOR_21) && (Address >= ADDR_FLASH_SECTOR_20))
{
sector = FLASH_SECTOR_20;
}
else if((Address < ADDR_FLASH_SECTOR_22) && (Address >= ADDR_FLASH_SECTOR_21))
{
sector = FLASH_SECTOR_21;
}
else if((Address < ADDR_FLASH_SECTOR_23) && (Address >= ADDR_FLASH_SECTOR_22))
{
sector = FLASH_SECTOR_22;
}
else /* (Address < FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_23) */
{
sector = FLASH_SECTOR_23;
}
#else
else /* (Address < FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_11) */
{
sector = FLASH_SECTOR_11;
}
#endif /* DUAL_BANK */
return sector;
}

/**
* @brief System Clock Configuration
* The system Clock is configured as follow :
* System Clock source = PLL (HSE)
* SYSCLK(Hz) = 216000000
* HCLK(Hz) = 216000000
* AHB Prescaler = 1
* APB1 Prescaler = 4
* APB2 Prescaler = 2
* HSE Frequency(Hz) = 8000000
* PLL_M = 8
* PLL_N = 432
* PLL_P = 2
* PLL_Q = 9
* PLL_R = 7
* VDD(V) = 3.3
* Main regulator output voltage = Scale1 mode
* Flash Latency(WS) = 7
* @PAram None
* @retval None
*/
void SystemClock_Config(void)
{
RCC_ClkInitTypeDef RCC_ClkInitStruct;
RCC_OscInitTypeDef RCC_OscInitStruct;

/* Enable HSE Oscillator and activate PLL with HSE as source */
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_BYPASS;
RCC_OscInitStruct.HSIState = RCC_HSI_OFF;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 8;
RCC_OscInitStruct.PLL.PLLN = 432;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 9;
RCC_OscInitStruct.PLL.PLLR = 7;
if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
while(1) {};
}

/* Activate the OverDrive to reach the 216 Mhz Frequency */
if(HAL_PWREx_EnableOverDrive() != HAL_OK)
{
while(1) {};
}


/* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2
clocks dividers */
RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_7) != HAL_OK)
{
while(1) {};
}
}

/**
* @brief Configure the MPU attributes
* @PAram None
* @retval None
*/
static void MPU_Config(void)
{
MPU_Region_InitTypeDef MPU_InitStruct;

/* Disable the MPU */
HAL_MPU_Disable();

/* Configure the MPU as Strongly ordered for not defined regions */
MPU_InitStruct.Enable = MPU_REGION_ENABLE;
MPU_InitStruct.BaseAddress = 0x00;
MPU_InitStruct.Size = MPU_REGION_SIZE_4GB;
MPU_InitStruct.AccessPermission = MPU_REGION_NO_ACCESS;
MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
MPU_InitStruct.IsShareable = MPU_ACCESS_SHAREABLE;
MPU_InitStruct.Number = MPU_REGION_NUMBER0;
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
MPU_InitStruct.SubRegionDisable = 0x87;
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_DISABLE;

HAL_MPU_ConfigRegion(&MPU_InitStruct);

/* Enable the MPU */
HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
}

/**
* @brief CPU L1-Cache enable.
* @PAram None
* @retval None
*/
static void CPU_CACHE_Enable(void)
{
/* Enable I-Cache */
SCB_EnableICache();

/* Enable D-Cache */
SCB_EnableDCache();
}