Skip to main content
Graduate
October 13, 2025
Question

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

  • October 13, 2025
  • 1 reply
  • 437 views

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

 

    This topic has been closed for replies.

    1 reply

    ST Employee
    October 23, 2025

    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();
    }