Library for emulating writing to flash memory as in EEPROM

[brightproject]

I use the STM32F411 microcontroller on a BlackPill board

I needed to save several values ​​as flags in the microcontroller's memory in order to change the value from 1 to 2 and back with each reboot.

With eeprom it would look something like this:

bool Mode;

// Read value from EEPROM
int value = EEPROM.read(0); // Read value from address 0

// Set Mode flag depending on read value
if (value == 1) {
Mode = true; // true corresponds to 1
value += 1; // Increment value by 1 
} else {
Mode = false; // false corresponds to 0
value -= 1; // Decrement value by 1
}

// Write new value back to EEPROM
EEPROM.write(0, value); // Write new value to address 0

For such a purpose, it is clearly redundant to solder the EEPROM to the board, and I don't have the necessary microcircuit at hand, so I started looking for a solution and found one flash memory emulation library for STM32:

https://github.com/nimaltd/ee

Unfortunately, the library is written in HAL and the code for compilation must be run in cube IDE.
But I have no skills in working with this program, I compile the code in Arduino IDE and in .pio
In this regard, I see several ways to solve the problem:

1. Rewrite the code of the library ee.h for the Arduino_Core_STM32 core
2. The Arduino_Core_STM32 core seems to contain HAL files and they can be included here

Arduino_Core_STM32/cores/arduino/stm32/stm32yyxx_hal_conf.h

Line 135 in bb640bf

#if 0

3. Perhaps the Arduino_Core_STM32 core already has the ability to emulate flash memory like EEPROM
   I tried to figure out task 1

bool EE_Format(void)
{
  bool answer = false;
  uint32_t error;
  FLASH_EraseInitTypeDef flashErase;
  // FLASH_EraseInitTypeDef TypeErase;
  do
  {
    HAL_FLASH_Unlock();
#ifdef HAL_ICACHE_MODULE_ENABLED
    /* disabling ICACHE if enabled*/
    HAL_ICACHE_Disable();
#endif
#if EE_ERASE == EE_ERASE_PAGE_ADDRESS
    flashErase.TypeErase = FLASH_TYPEERASE_PAGES;
    flashErase.PageAddress = eeHandle.Address;
    flashErase.NbPages = 1;
#elif EE_ERASE == EE_ERASE_PAGE_NUMBER
    flashErase.TypeErase = FLASH_TYPEERASE_PAGES;
    flashErase.Page = eeHandle.PageSectorNumber;
    flashErase.NbPages = 1;
#else
    flashErase.TypeErase = FLASH_TYPEERASE_SECTORS;
    flashErase.Sector = eeHandle.PageSectorNumber;
    flashErase.NbSectors = 1;
    // TypeErase = FLASH_TYPEERASE_SECTORS;
    // Sector = eeHandle.PageSectorNumber;
    // NbSectors = 1;
#endif
#if (defined FLASH_BANK_1) || (defined FLASH_BANK_2)
    flashErase.Banks = eeHandle.BankNumber;
#endif
#ifdef FLASH_VOLTAGE_RANGE_3
    flashErase.VoltageRange = FLASH_VOLTAGE_RANGE_3;
#endif
    /* erasing page/sector */
    if (HAL_FLASHEx_Erase(&flashErase, &error) != HAL_OK)
    {
      break;
    }
    /* checking result */
    if (error != 0xFFFFFFFF)
    {
      break;
    }
    answer = true;

  } while (0);

  HAL_FLASH_Lock();
#ifdef HAL_ICACHE_MODULE_ENABLED
  HAL_ICACHE_Enable();
#endif
  return answer;
}

Somehow, I need to replace the HAL functions with those that the Arduino_Core_STM32 framework uses.
Although when working with the code in IDE, I can see the structures

typedef struct
{
uint32_t TypeErase; /*!< Mass erase or sector Erase.
This parameter can be a value of @ref FLASHEx_Type_Erase */

uint32_t Banks; /*!< Select banks to erase when Mass erase is enabled.
This parameter must be a value of @ref FLASHEx_Banks */

uint32_t Sector; /*!< Initial FLASH sector to erase when Mass erase is disabled
This parameter must be a value of @ref FLASHEx_Sectors */

uint32_t NbSectors; /*!< Number of sectors to be erased.
This parameter must be a value between 1 and (max number of sectors - value of Initial sector)*/

uint32_t VoltageRange;/*!< The device voltage range which defines the erase parallelism
This parameter must be a value of @ref FLASHEx_Voltage_Range */

} FLASH_EraseInitTypeDef;

And other HAL files.
This option is also difficult for me to understand.

I tried to implement task 2, but due to the lack of knowledge of HAL, I only get multiple compilation errors - this I won't be able to implement this option.

I hope that the task 3 is possible using the Arduino_Core_STM32 framework, but studying the wiki

https://github.com/stm32duino/Arduino_Core_STM32/wiki

I found there only work with HAL, but this option is difficult for me, it is easier for me to solder the EEPROM to the board😃

While figuring out the organization of the microcontroller's memory, I found this map:

Without touching on the problems described above, as far as I understand, in order to use flash memory as EEPROM, you first need to allocate a block of flash memory in the .ld file so that the firmware, which is usually placed in flash memory from the address 0x08000000, is not loaded into it, and only then can the allocated block of memory be used to emulate EEPROM?
I hope for help from the community.

[fpistm]

https://github.com/stm32duino/Arduino_Core_STM32/tree/main/libraries/EEPROM

[brightproject]

Thank you @fpistm
Below is an example of code for changing the operating mode when switching the device's power supply.
Initially, there was an idea to write a boolean flag to EEPROM, but it is more convenient to do this with a byte and you can save up to 256 program modes, if necessary.

#include <LEDBlinker.h>

#include <EEPROM.h>

// #define CLEAR_EEPROM

bool Mode;
int p[11];

LEDBlinker builtinLED(LED_INDICATOR, 200);

void setup() {

digitalWrite(LED_INDICATOR, HIGH);

Serial.begin(115200);

// If the CLEAR macro is active, then clear the EEPROM
#ifdef CLEAR_EEPROM

// Clear all EEPROM cells
for (int i = 0; i < EEPROM.length(); i++) {
EEPROM.write(i, 0);
}
Serial.println("EEPROM Cleared");
#else
// Read value from EEPROM
int value = EEPROM.read(0); // Read value at address 0

// Check if value in EEPROM is 255 (first power-on)
if (value == 255) {
value = 3; // Write 3 at first power-on
} else if (value == 3) {
value = 2; // If value is 3, write 2
} else {
value = 3; // If value is 2, write 3
}

// Write new value back to EEPROM
EEPROM.write(0, value); // Write new value at address 0

// Output value to serial
Serial.print("Value READ: ");
Serial.println(value); // Print the current value
 #endif

 if (value == 3) {
 int pattern[] = {0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0}; // array for value 3
 memcpy(p, temp, sizeof(pattern));
 } else if (value == 2) {
 int pattern[] = {0, 1, 0, 1, 0, 0, 0, 0, 0}; // array for value 2
 memcpy(p, pattern, sizeof(pattern));
 }
 builtinLED.set_pattern(p, sizeof(p)/sizeof(p[0]));
}

void loop()
{
 builtinLED.run_pattern();
}