Flash Programming in STM32 using HAL (Erase, Write & Read)

Working with flash memory is an essential part of STM32 development. Whether you are storing calibration values, configuration data, or implementing a bootloader, understanding how to erase, write, and read from the internal flash is crucial. In this tutorial, we will explore flash programming in STM32 microcontrollers using the HAL library. You will learn the difference between page-based and sector-based flash, see how the process varies across STM32 families like F1, F4, and H7, and walk through practical examples with complete code. By the end, you’ll have a clear step-by-step method to safely handle flash memory in your own STM32 projects.

This tutorial is divided into two sections for clarity and relevance.
The first section focuses on STM32 microcontrollers with page-based flash memory, such as those from the Cortex-M3 and Cortex-M0 series.
The second section covers microcontrollers with sector-based flash memory, commonly found in higher-end devices like the STM32F4 and H7 series.

H7 Series users can get the files from https://github.com/controllerstech/STM32/tree/master/FLASH_PROGRAM/H7%20SERIES

Hardware Required for STM32 Flash Tutorial

Before we begin with the project, let’s look at the hardware and software needed for this STM32 UART tutorial. Below are the affiliate links you can consider before purchasing the items.

• STM32F446 Dev Board
• ST-Link V2
• STM32H745 Dev Board
• STM32F103 Dev Board

Introduction to Flash Programming in STM32

When you work with STM32 microcontrollers, flash memory becomes very important. It not only stores your program code but can also keep data like settings, sensor calibration values, or logs. Since flash memory has limited write cycles and follows strict rules for erasing and writing, you need to understand how it works before you start using it. In this STM32 Flash Programming tutorial, we will first learn the basics of flash memory and then see how STM32 handles it with pages and sectors.

What is Flash Memory?

Flash memory is a type of non-volatile storage. This means it can hold data even when the power is off, unlike RAM which loses data after reset. In STM32 microcontrollers, your code runs directly from flash memory. You can also use free areas of flash to save important data that must remain safe after a restart or power loss.

However, flash memory works differently from normal RAM. You cannot just overwrite data directly. First, you must erase that memory block and then write new values. Also, flash erase operations happen in blocks instead of single bytes. That’s why STM32 uses either pages or sectors for organizing flash memory.

Page-Based vs Sector-Based Flash

STM32 devices use two common flash layouts, and knowing which one your MCU uses is very important.

• Page-Based Flash (STM32F1, STM32 M0 series):
  In these controllers, flash memory is divided into small pages, usually 1 KB or 2 KB in size. You can erase and write one page at a time. This makes the process simple. However, you must plan carefully, because erasing a page clears everything inside it. So, if you only want to change one variable, you still erase the whole page.
• Sector-Based Flash (STM32F4, STM32H7 series):
  Advanced controllers use sectors instead of pages. A sector is much larger and can range from a few KB to several tens of KB. The good part is that you can manage memory more flexibly. The challenge is that when you erase a sector, all the data inside it is lost. So you must design your data storage wisely to avoid losing important values.

Basically, page-based flash is smaller and easier to manage, while sector-based flash gives more flexibility but requires careful planning. Understanding this difference will help you use STM32 Flash Programming correctly in your projects.

The table below compare the Page-Based vs Sector-Based Flash memories in STM32.

STM32 Flash Programming with HAL

STM32 microcontrollers provide built-in flash memory that we can program using the HAL library. HAL functions make it easy to erase, write, and read data without handling low-level registers. In this section, we will cover the key steps involved in flash programming using HAL.

Unlocking and Locking the Flash

Before you can modify flash memory, you must unlock it. Flash is locked by default to prevent accidental writes or erases. Use the HAL function:

HAL_FLASH_Unlock();

HAL_FLASH_Unlock();

This allows write and erase operations. After finishing all flash operations, you should lock the flash again to protect it using:

HAL_FLASH_Lock();

HAL_FLASH_Lock();

Locking flash ensures your program and data remain safe from unintended modifications.

Erase Operation in Flash Memory

Flash memory cannot be overwritten directly. You must erase it before writing new data. HAL provides functions to erase pages or sectors depending on your STM32 series. For example, to erase a page in STM32F1:

FLASH_Erase_Sector(FLASH_SECTOR_2, VOLTAGE_RANGE_3);

FLASH_Erase_Sector(FLASH_SECTOR_2, VOLTAGE_RANGE_3);

Erasing sets all bits in the selected page or sector to 1. After erasing, you can safely write new data. Always choose the correct page or sector to avoid erasing important program code.

Writing Data to Flash

Once the flash is unlocked and erased, you can write data using HAL functions. Data can be integers, floats, arrays, or strings. For example:

HAL_FLASH_Program(TYPEPROGRAM_WORD, address, data);

HAL_FLASH_Program(TYPEPROGRAM_WORD, address, data);

• TYPEPROGRAM_WORD writes 32-bit data.
• address is the flash memory location.
• data is the value you want to store.

If you are writing multiple words or arrays, you can loop through the data and write each word sequentially.

Reading Data from Flash

Reading flash memory is simpler because you don’t need to unlock it. You can directly access flash addresses using pointers:

uint32_t value = *(__IO uint32_t*)address;

uint32_t value = *(__IO uint32_t*)address;

For arrays or strings, loop through memory addresses and copy the values into a buffer. This allows you to retrieve stored numbers, strings, or configuration data for your program.

Using these steps, you can unlock, erase, write, and read data safely in STM32 flash memory with HAL. This workflow applies to page-based or sector-based flash depending on your MCU series.

STM32 Page-Based Flash memory Programming (STM32F1/M0/M3)

For the first part of this tutorial, we are using the STM32F103 microcontroller. You can see its flash memory layout in the image below.

As shown above, the main flash memory in the STM32F103 is divided into 128 pages, with each page sized at 1 KB, giving a total of 128 KB of flash memory.

When programming flash, it’s important to start as low as possible in memory. The reason is that the beginning of the flash is already used by the program that is currently running on the microcontroller. I have explained this in detail in the video at the end of the post, so you can check that out for a visual explanation.

Since each page can store 1024 bytes and I don’t have much data to write, I will use the last page of flash memory, which ranges from 0x0801FC00 to 0x0801FFFF.

Write Data to STM32 FLASH

Below is the function to write the data into the Flash.

uint32_t Flash_Write_Data (uint32_t StartPageAddress, uint32_t *Data, uint16_t numberofwords)
{

	static FLASH_EraseInitTypeDef EraseInitStruct;
	uint32_t PAGEError;
	int sofar=0;

	  /* Unlock the Flash to enable the flash control register access *************/
	   HAL_FLASH_Unlock();

	   /* Erase the user Flash area*/

	  uint32_t StartPage = GetPage(StartPageAddress);
	  uint32_t EndPageAdress = StartPageAddress + numberofwords*4;
	  uint32_t EndPage = GetPage(EndPageAdress);

	   /* Fill EraseInit structure*/
	   EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
	   EraseInitStruct.PageAddress = StartPage;
	   EraseInitStruct.NbPages     = ((EndPage - StartPage)/FLASH_PAGE_SIZE) +1;

	   if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
	   {
	     /*Error occurred while page erase.*/
		  return HAL_FLASH_GetError ();
	   }

	   /* Program the user Flash area word by word*/

	   while (sofar<numberofwords)
	   {
	     if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, StartPageAddress, Data[sofar]) == HAL_OK)
	     {
	    	 StartPageAddress += 4;  // use StartPageAddress += 2 for half word and 8 for double word
	    	 sofar++;
	     }
	     else
	     {
	       /* Error occurred while writing data in Flash memory*/
	    	 return HAL_FLASH_GetError ();
	     }
	   }

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

	   return 0;
}

uint32_t Flash_Write_Data (uint32_t StartPageAddress, uint32_t *Data, uint16_t numberofwords)
{

	static FLASH_EraseInitTypeDef EraseInitStruct;
	uint32_t PAGEError;
	int sofar=0;

	  /* Unlock the Flash to enable the flash control register access *************/
	   HAL_FLASH_Unlock();

	   /* Erase the user Flash area*/

	  uint32_t StartPage = GetPage(StartPageAddress);
	  uint32_t EndPageAdress = StartPageAddress + numberofwords*4;
	  uint32_t EndPage = GetPage(EndPageAdress);

	   /* Fill EraseInit structure*/
	   EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
	   EraseInitStruct.PageAddress = StartPage;
	   EraseInitStruct.NbPages     = ((EndPage - StartPage)/FLASH_PAGE_SIZE) +1;

	   if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
	   {
	     /*Error occurred while page erase.*/
		  return HAL_FLASH_GetError ();
	   }

	   /* Program the user Flash area word by word*/

	   while (sofar<numberofwords)
	   {
	     if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, StartPageAddress, Data[sofar]) == HAL_OK)
	     {
	    	 StartPageAddress += 4;  // use StartPageAddress += 2 for half word and 8 for double word
	    	 sofar++;
	     }
	     else
	     {
	       /* Error occurred while writing data in Flash memory*/
	    	 return HAL_FLASH_GetError ();
	     }
	   }

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

	   return 0;
}

The function Flash_Write_Data takes the following parameters

• @ StartPageAddress is the address of the Start page, or memory in the page, from where you want to start writing the data.
• @ Data is the pointer to the 32 bit data array, that you want to write into the flash.
• @ numberofwords is the number of words, that you want to write in the memory.

The Flash_Write_Data function writes an array of 32-bit data (uint32_t) to STM32 Flash memory using page-level operations. It works as follows:

1. Unlock Flash: Enables access to the Flash control registers.
2. Determine pages: Calculates the start and end Flash pages based on the start address and number of words.
3. Erase pages: Clears the required pages before writing new data.
4. Program Flash: Writes data word by word to the Flash memory.
5. Error handling: Returns an error code if erasing or writing fails.
6. Lock Flash: Disables write access to protect memory after programming.

Read Data from STM32 FLASH

The function Flash_Read_Data provides a simple way to retrieve data from STM32 page-based flash memory.

void Flash_Read_Data (uint32_t StartPageAddress, uint32_t *RxBuf, uint16_t numberofwords)
{
	while (1)
	{
		*RxBuf = *(__IO uint32_t *)StartPageAddress;
		StartPageAddress += 4;
		RxBuf++;
		if (!(numberofwords--)) break;
	}
}

void Flash_Read_Data (uint32_t StartPageAddress, uint32_t *RxBuf, uint16_t numberofwords)
{
	while (1)
	{
		*RxBuf = *(__IO uint32_t *)StartPageAddress;
		StartPageAddress += 4;
		RxBuf++;
		if (!(numberofwords--)) break;
	}
}

The Flash_Read_Data function reads 32-bit data (uint32_t) from STM32 Flash memory. It works like this:

1. Read word by word: Accesses Flash memory starting from StartPageAddress and copies each 32-bit word into the provided buffer RxBuf.
2. Increment pointers: Moves the Flash address and buffer pointer forward by 4 bytes after each read.
3. Repeat: Continues until the specified numberofwords is read.

The Main() Function

To test the Flash operations, we will first write some data into the Flash and read it back.

char *data = "hello FLASH from ControllerTech\
	      This is a test to see how many words can we work with";

uint32_t data2[] = {0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9};
uint32_t Rx_Data[30];
char string[100];

int number = 123;
float val = 123.456;
float RxVal;

  Flash_Write_Data(0x08004410 , (uint32_t *)data2, 9);
  Flash_Read_Data(0x08004410 , Rx_Data, 10);


  int numofwords = (strlen(data)/4)+((strlen(data)%4)!=0);
  Flash_Write_Data(0x08004810 , (uint32_t *)data, numofwords);
  Flash_Read_Data(0x08004810 , Rx_Data, numofwords);
  Convert_To_Str(Rx_Data, string);


  Flash_Write_NUM(0x08005C10, number);
  RxVal = Flash_Read_NUM(0x08005C10);

  Flash_Write_NUM(0x08012000, val);
  RxVal = Flash_Read_NUM(0x08012000);

char *data = "hello FLASH from ControllerTech\
	      This is a test to see how many words can we work with";

uint32_t data2[] = {0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9};
uint32_t Rx_Data[30];
char string[100];

int number = 123;
float val = 123.456;
float RxVal;

  Flash_Write_Data(0x08004410 , (uint32_t *)data2, 9);
  Flash_Read_Data(0x08004410 , Rx_Data, 10);


  int numofwords = (strlen(data)/4)+((strlen(data)%4)!=0);
  Flash_Write_Data(0x08004810 , (uint32_t *)data, numofwords);
  Flash_Read_Data(0x08004810 , Rx_Data, numofwords);
  Convert_To_Str(Rx_Data, string);


  Flash_Write_NUM(0x08005C10, number);
  RxVal = Flash_Read_NUM(0x08005C10);

  Flash_Write_NUM(0x08012000, val);
  RxVal = Flash_Read_NUM(0x08012000);

In this example, we are writing and reading different types of data to the STM32 flash.

• Character Strings:
  The data string contains multiple words. We calculate the number of 32-bit words needed using strlen(data)/4 and write it to flash with Flash_Write_Data(). Then we read it back using Flash_Read_Data() and convert it to a readable string with Convert_To_Str().
• Integer and Float Values:
  The integer number and float val are written and read using Flash_Write_NUM() and Flash_Read_NUM(). The values are stored in specific flash addresses and retrieved later for use.
• Array of 32-bit Data:
  The array data2 is also written to flash and then read back into Rx_Data for verification.

Result showing the Data stored in STM32 Flash

The image below shows the STM32 flash memory content after writing both an array of numbers and a string using HAL functions.

• In the first part (top table), you can see the 32-bit integer array data2 written to addresses 0x08004410 onward. Each cell represents a 32-bit word stored in flash. The array values 0x1, 0x2, … 0x9 are clearly visible.
• In the second part (bottom table), the string "hello FLASH from ControllerTech..." is stored starting at address 0x08004810. Each group of 4 bytes is displayed in hexadecimal, showing how the string is stored in 32-bit words. On the right, the text representation is also visible, confirming that the string is written correctly.

This demonstrates how HAL functions write arrays and strings to flash memory, and how you can verify the stored data using a memory viewer or debugger.

STM32 Sector-Based Flash memory Programming (STM32F4/H7)

STM32F4 and H7 MCUs have Flash memory divided into sectors, allowing selective erase and write operations. This makes updating firmware or storing data efficient and safe, without affecting the entire memory.

The image below shows the Sector-Based Flash Memory distribution in the STM32F4.

In the STM32F446RE, the Flash memory is divided into 7 sectors, each with a different size. Other STM32 microcontrollers may have 11, 15, or even 23 sectors. This STM32 sector-based Flash programming code works for all these controllers, no matter how many sectors they have, making it easy to erase, write, and manage Flash memory safely.

Write Data to STM32 FLASH

The function Flash_Write_Data writes the data to the Flash memory.

uint32_t Flash_Write_Data (uint32_t StartSectorAddress, uint32_t *Data, uint16_t numberofwords)
{

	static FLASH_EraseInitTypeDef EraseInitStruct;
	uint32_t SECTORError;
	int sofar=0;


	 /* Unlock the Flash to enable the flash control register access *************/
	  HAL_FLASH_Unlock();

	  /* Erase the user Flash area */

	  /* Get the number of sector to erase from 1st sector */

	  uint32_t StartSector = GetSector(StartSectorAddress);
	  uint32_t EndSectorAddress = StartSectorAddress + numberofwords*4;
	  uint32_t EndSector = GetSector(EndSectorAddress);

	  /* Fill EraseInit structure*/
	  EraseInitStruct.TypeErase     = FLASH_TYPEERASE_SECTORS;
	  EraseInitStruct.VoltageRange  = FLASH_VOLTAGE_RANGE_3;
	  EraseInitStruct.Sector        = StartSector;
	  EraseInitStruct.NbSectors     = (EndSector - StartSector) + 1;

	  /* Note: If an erase operation in Flash memory also concerns data in the data or instruction cache,
	     you have to make sure that these data are rewritten before they are accessed during code
	     execution. If this cannot be done safely, it is recommended to flush the caches by setting the
	     DCRST and ICRST bits in the FLASH_CR register. */
	  if (HAL_FLASHEx_Erase(&EraseInitStruct, &SECTORError) != HAL_OK)
	  {
		  return HAL_FLASH_GetError ();
	  }

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

	   while (sofar<numberofwords)
	   {
	     if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, StartSectorAddress, Data[sofar]) == HAL_OK)
	     {
	    	 StartSectorAddress += 4;  // use StartPageAddress += 2 for half word and 8 for double word
	    	 sofar++;
	     }
	     else
	     {
	       /* Error occurred while writing data in Flash memory*/
	    	 return HAL_FLASH_GetError ();
	     }
	   }

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

	   return 0;
}

uint32_t Flash_Write_Data (uint32_t StartSectorAddress, uint32_t *Data, uint16_t numberofwords)
{

	static FLASH_EraseInitTypeDef EraseInitStruct;
	uint32_t SECTORError;
	int sofar=0;


	 /* Unlock the Flash to enable the flash control register access *************/
	  HAL_FLASH_Unlock();

	  /* Erase the user Flash area */

	  /* Get the number of sector to erase from 1st sector */

	  uint32_t StartSector = GetSector(StartSectorAddress);
	  uint32_t EndSectorAddress = StartSectorAddress + numberofwords*4;
	  uint32_t EndSector = GetSector(EndSectorAddress);

	  /* Fill EraseInit structure*/
	  EraseInitStruct.TypeErase     = FLASH_TYPEERASE_SECTORS;
	  EraseInitStruct.VoltageRange  = FLASH_VOLTAGE_RANGE_3;
	  EraseInitStruct.Sector        = StartSector;
	  EraseInitStruct.NbSectors     = (EndSector - StartSector) + 1;

	  /* Note: If an erase operation in Flash memory also concerns data in the data or instruction cache,
	     you have to make sure that these data are rewritten before they are accessed during code
	     execution. If this cannot be done safely, it is recommended to flush the caches by setting the
	     DCRST and ICRST bits in the FLASH_CR register. */
	  if (HAL_FLASHEx_Erase(&EraseInitStruct, &SECTORError) != HAL_OK)
	  {
		  return HAL_FLASH_GetError ();
	  }

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

	   while (sofar<numberofwords)
	   {
	     if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, StartSectorAddress, Data[sofar]) == HAL_OK)
	     {
	    	 StartSectorAddress += 4;  // use StartPageAddress += 2 for half word and 8 for double word
	    	 sofar++;
	     }
	     else
	     {
	       /* Error occurred while writing data in Flash memory*/
	    	 return HAL_FLASH_GetError ();
	     }
	   }

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

	   return 0;
}

The Flash_Write_Data function writes an array of 32-bit data (uint32_t) to STM32 Flash memory starting from a given address. It works in these steps:

1. Unlock Flash: Enables access to Flash control registers.
2. Calculate sectors: Determines which Flash sectors need erasing based on the start address and number of words.
3. Erase sectors: Clears the necessary sectors before writing.
4. Program Flash: Writes data word by word (uint32_t) to the Flash memory.
5. Error handling: Returns an error code if erasing or writing fails.
6. Lock Flash: Disables Flash write access to protect memory after programming.

Read Data from FLASH

The function Flash_Read_Data provides a simple way to retrieve data from STM32 sector-based Flash memory.

void Flash_Read_Data (uint32_t StartSectorAddress, uint32_t *RxBuf, uint16_t numberofwords)
{
	while (1)
	{
		*RxBuf = *(__IO uint32_t *)StartSectorAddress;
		StartSectorAddress += 4;
		RxBuf++;
		if (!(numberofwords--)) break;
	}
}

void Flash_Read_Data (uint32_t StartSectorAddress, uint32_t *RxBuf, uint16_t numberofwords)
{
	while (1)
	{
		*RxBuf = *(__IO uint32_t *)StartSectorAddress;
		StartSectorAddress += 4;
		RxBuf++;
		if (!(numberofwords--)) break;
	}
}

The Flash_Read_Data function reads 32-bit data (uint32_t) from STM32 Flash memory. It works like this:

1. Read word by word: Accesses Flash memory starting from StartPageAddress and copies each 32-bit word into the provided buffer RxBuf.
2. Increment pointers: Moves the Flash address and buffer pointer forward by 4 bytes after each read.
3. Repeat: Continues until the specified numberofwords is read.

The Main Function

To test the Flash operations, we will first write some data into the Flash and read it back.

char *data = "hello FLASH from ControllerTech\
			  This is a test to see how many words can we work with";

uint32_t data2[] = {0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9};

uint32_t Rx_Data[30];

char string[100];

int number = 123;

float val = 123.456;

float RxVal;

  Flash_Write_Data(0x08004100 , (uint32_t *)data2, 9);
  Flash_Read_Data(0x08004100 , Rx_Data, 10);


  int numofwords = (strlen(data)/4)+((strlen(data)%4)!=0);
  Flash_Write_Data(0x08008100 , (uint32_t *)data, numofwords);
  Flash_Read_Data(0x08008100 , Rx_Data, numofwords);
  Convert_To_Str(Rx_Data, string);


  Flash_Write_NUM(0x0800C100, number);
  RxVal = Flash_Read_NUM(0x0800C100);

  Flash_Write_NUM(0x0800D100, val);
  RxVal = Flash_Read_NUM(0x0800D100);

char *data = "hello FLASH from ControllerTech\
			  This is a test to see how many words can we work with";

uint32_t data2[] = {0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9};

uint32_t Rx_Data[30];

char string[100];

int number = 123;

float val = 123.456;

float RxVal;

  Flash_Write_Data(0x08004100 , (uint32_t *)data2, 9);
  Flash_Read_Data(0x08004100 , Rx_Data, 10);


  int numofwords = (strlen(data)/4)+((strlen(data)%4)!=0);
  Flash_Write_Data(0x08008100 , (uint32_t *)data, numofwords);
  Flash_Read_Data(0x08008100 , Rx_Data, numofwords);
  Convert_To_Str(Rx_Data, string);


  Flash_Write_NUM(0x0800C100, number);
  RxVal = Flash_Read_NUM(0x0800C100);

  Flash_Write_NUM(0x0800D100, val);
  RxVal = Flash_Read_NUM(0x0800D100);

This example shows how to store and retrieve arrays, strings, integers, and floats in STM32 Flash memory using page/sector-based programming.

Define data and buffers:

• data is a string to store in Flash.
• data2 is an array of 32-bit integers.
• Rx_Data is a buffer to read Flash data back.
• string, number, and val are variables to demonstrate storing and reading different data types.

Write and read integer array:

• Flash_Write_Data(0x08004100, data2, 9); writes 9 words from data2 to Flash.
• Flash_Read_Data(0x08004100, Rx_Data, 10); reads back 10 words into Rx_Data.

Read and write string:

• Calculates numofwords needed to store the string (rounded up to 32-bit words).
• Flash_Write_Data(0x08008100, data, numofwords); writes the string to Flash.
• Flash_Read_Data(0x08008100, Rx_Data, numofwords); reads it back.
• Convert_To_Str(Rx_Data, string); converts the read words back to a string.

Write and read numbers:

• Flash_Write_NUM and Flash_Read_NUM store and retrieve integer (number) and float (val) values from Flash.

Result showing the Data stored in STM32 Flash

The image below shows the STM32 flash memory content after writing both an array of numbers and a string using HAL functions.

• In the first part (top table), you can see the 32-bit integer array data2 written to addresses 0x08004410 onward. Each cell represents a 32-bit word stored in flash. The array values 0x1, 0x2, … 0x9 are clearly visible.
• In the second part (bottom table), the string "hello FLASH from ControllerTech..." is stored starting at address 0x08004810. Each group of 4 bytes is displayed in hexadecimal, showing how the string is stored in 32-bit words. On the right, the text representation is also visible, confirming that the string is written correctly.

This demonstrates how HAL functions write arrays and strings to flash memory, and how you can verify the stored data using a memory viewer or debugger.

Conclusion

In this tutorial, we explored STM32 sector- and page-based Flash programming using the F4/H7 series. We demonstrated how to safely write and read arrays, strings, integers, and float values in Flash memory. By using functions like Flash_Write_Data, Flash_Read_Data, and Flash_Write_NUM/Flash_Read_NUM, developers can efficiently store non-volatile data in STM32 microcontrollers. Understanding these techniques is essential for applications like firmware updates, configuration storage, and data logging, making your STM32 projects more robust and versatile.

PROJECT DOWNLOAD

STM32 Flash Programming FAQs