STM32 Flash Programming: Erase, Write & Read (Page & Sector)

Internal flash in STM32 isn’t just for firmware, it’s also where you store calibration values, configuration parameters, device IDs, counters, and any data that must survive a power cycle. But flash works differently from RAM: you can’t overwrite it directly, erasing works on fixed blocks, and writing to the wrong address can corrupt your running firmware.

This tutorial covers STM32 flash programming using the HAL library for both major flash layouts. The first section covers page-based flash on STM32F1, M0, and M3 devices, where pages are small (1–2 KB) and easy to manage. The second section covers sector-based flash on STM32F4 and H7 devices, where sectors are larger and require more careful address planning. Both sections include complete write, read, and erase code for arrays, strings, integers, and floats — verified with a memory viewer.

STM32 Flash Memory: How It Works

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.

The single biggest mistake with sector-based flash: sectors are large (the STM32F446 has sectors ranging from 16 KB to 128 KB). Writing a 4-byte value to a sector that also contains other data you need will erase all of it. Always place your data storage in a dedicated sector that no other code occupies.

HAL Flash Operations: Unlock, Erase, Write, Read

All write and erase operations require unlocking flash first. Reading does not.

Unlock / Lock:

HAL_FLASH_Unlock();   // Enable write/erase access
// ... operations ...
HAL_FLASH_Lock();     // Re-protect after finishing

HAL_FLASH_Unlock();   // Enable write/erase access
// ... operations ...
HAL_FLASH_Lock();     // Re-protect after finishing

Erase (page or sector, via HAL_FLASHEx_Erase()):

HAL_FLASHEx_Erase(&EraseInitStruct, &PageOrSectorError);

HAL_FLASHEx_Erase(&EraseInitStruct, &PageOrSectorError);

Write word by word:

HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, address, data);
// Increment address by 4 per word (use 2 for half-word, 8 for double-word)

HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, address, data);
// Increment address by 4 per word (use 2 for half-word, 8 for double-word)

Read — direct pointer dereference, no unlock needed:

uint32_t value = *(__IO uint32_t*)address;

uint32_t value = *(__IO uint32_t*)address;

STM32 Page-Based Flash: F1, M0, M3 Series

This section uses the STM32F103 (BluePill). Its flash is organized into 128 pages of 1 KB each, totalling 128 KB starting at 0x08000000. 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 Function (Page-Based)

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 Function (Page-Based)

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.

Usage Example (Page-Based)

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 & Video walkthrough

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: F4 and H7 Series

This section covers the STM32F4 and STM32H7 families, where flash is organized into sectors of varying sizes. The STM32F446RE has 7 sectors; other F4 devices have 11, 15, or 23. The GetSector() helper function maps any address to its sector number — this is what makes the write function portable across the whole family.

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 Function (Sector-Based)

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 Function (Sector-Based)

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.

Usage Example (Sector-Based)

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 & Video Walkthrough

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 Flash Programming — Frequently Asked Questions

In this tutorial, you learned how STM32 flash memory works and how to safely erase, write, and read data using the HAL library — covering both page-based devices (F1, M0, M3) and sector-based devices (F4, H7). The helper functions Flash_Write_Data(), Flash_Read_Data(), Flash_Write_NUM(), and Flash_Read_NUM() give you a reusable foundation for storing any data type: arrays, strings, integers, and floats.

The most important things to keep in mind going forward: always write to addresses well clear of your firmware, never assume you can overwrite without erasing first, clear flash error flags between operations on newer STM32 families, and on sector-based devices, dedicate a full sector to data storage to avoid collateral erasure.

This foundation is what the STM32 custom bootloader series builds directly on — the next logical step if you want to use flash for in-application firmware updates (OTA), application validation, or jump-to-application logic.

W25Q Flash Series Part 1 – Connect and Read Device ID

W25Q Flash Series Part 2 – Read Data from Device

W25Q Flash Series Part 3 – How to Erase Sectors

W25Q Flash Series Part 4 – How to Program Pages

W25Q Flash Series Part 5 – how to update sectors

W25Q Flash Series Part 6 – Integers floats and 32bit Data

1 2 Next »

About the Author

Arun Rawat

Embedded Systems Engineer · Founder, ControllersTech

Arun is an embedded systems engineer with 10+ years of experience in STM32, ESP32, and AVR microcontrollers. He created ControllersTech to share practical tutorials on embedded software, HAL drivers, RTOS, and hardware design — grounded in real industrial automation experience.

About YouTube GitHub Facebook Instagram Shop