Skip to content Skip to sidebar Skip to footer

STM32 Arduino How to Save Float To EEPROM

Save Float Value To STM32 EEPROM

STM32 EEPROM is one of the important things that must be learned. STM32 does not have EEPROM by default, so we can use flash memory for EEPROM allocation. 
STM32 EEPROM Emulation Arduino Library
Save Float to EEPROM STM32


This method is called STM32 EEPROM Emulation.

In the other article, I wrote a tutorial How to Access Read and Write EEPROM on STM32F103 Using Arduino IDE, which can store String data.

Well, complex programs often use float values because they can hold very detailed data.
For example, coordinate data to show an accurate location, requires data behind the comma of the float data.

The more numbers behind the comma, the more detailed the results of the object's position at these coordinates.

I tried to find out on the internet how to save float to EEPROM and reread the data stored on STM32 Blue Pill. But I did not find the right program. 

For that reason, I made a program that can write float data and save to the STM32 EEPROM (in this case I am testing using STM32F103 Blue Pill) and read it again

EEPROMwrite command to write data. The data used must be a string, so Float Data must be Converted to String. The program below is a modification program from the stm32projects website.

The EEPROM STM32 Float Read and Write Program on Arduino IDE

The program below I wrote using Indonesian. You can replace it with your language.
#include <EEPROM.h>

const int addressEEPROM_min = 0;              //Tentukan batasan alamat yang ingin digunakan.
const int addressEEPROM_max = 4095;           //Sebagai contoh maksimum adalah 4095, artinya kita alokasikan memori 4KB (4096 bytes) untuk EEPROM Virtual.

float latitude =   4.158919;                  //Ini adalah contoh data yang ingin disimpan ke EEPROM.
float longitude = 96.124843;                  //Data Koordinat yang terdiri dari Latitude dan Longitude.

int addressLat = 0;                           //Jumlah karakter dari nilai latitude adalah 8, jadi alamat dimulai dari 0 hingga 8.
int addressLon = 9;                           //Jumlah karakter dari nilai longitude adalah 9, jadi alamat dimulai dari 9 hingga 17.

void setup()
{
  Serial.begin(9600);
  delay(100);

  String lat = String (latitude, 6);         //Data yang akan disimpan ke EEPROM adalah String. Baris ini digunakan untuk konversi float ke String.
  String lon = String (longitude, 6);        //Nilai 6 menunjukkan berapa banyak angka dibelakang koma yang akan di konversi.

  //------------------- Perintah Tulis Data -------------------
  Serial.println(" -----------------------------------------");
  Serial.println("| Menulis Latitude  ke EEPROM | Tersimpan |");
  EEPROMwrite(addressLat, lat);
  Serial.println("| Menulis Longitude ke EEPROM | Tersimpan |");
  EEPROMwrite(addressLon, lon);
  Serial.println(" -----------------------------------------");
  Serial.println("\n");
  delay(1000);
  //----------------------------------------------------------

  //------------------- Perintah Baca Data -------------------
  Serial.println("Baca data dari EEPROM.....");
  Serial.print("Latitude  : ");
  Serial.println(EEPROMread(addressLat, 8));  //Ambil data dari alamat 0 dengan jumlah karakter sebanyak 8.
  Serial.print("Longitude : ");
  Serial.println(EEPROMread(addressLon, 9));  //Ambil data dari alamat 9 dengan jumlah karakter sebanyak 9.
  Serial.println("\n");
  delay(1000);
  //----------------------------------------------------------

  Serial.println("Sekarang, silahkan COMMENT *Perintah Tulis Data* untuk menonaktifkan perintah tulis data ke EEPROM.");
  delay(5000);
  Serial.println("Kemudian, silahkan tekan tombol reset atau cabut STM32 dari komputer, untuk melihat apakah data dari EEPROM tetap tersimpan atau tidak.");
} 

void loop()
{

}

String EEPROMread(int StartAddr, int StringLength)
{
  char buf[StringLength + 1];
  eeprom_read_string(StartAddr, buf, StringLength + 1);
  String dataStr = buf;
  return dataStr;
}

void EEPROMwrite(int StartAddr, String DataString)
{
  int val = DataString.length() + 1;
  char StringChar[val];
  char buff[val];

  DataString.toCharArray(StringChar, val);
  strcpy(buff, StringChar);
  eeprom_write_string(StartAddr, buff);
}

boolean eeprom_is_addr_ok(int addr)
{
  return ((addr >= addressEEPROM_min) && (addr <= addressEEPROM_max));
}

boolean eeprom_write_bytes(int startAddr, const byte* array, int numBytes)
{
  int i;

  if (!eeprom_is_addr_ok(startAddr) || !eeprom_is_addr_ok(startAddr + numBytes))
  {
    return false;
  }

  for (i = 0; i < numBytes; i++)
  {
    EEPROM.write(startAddr + i, array[i]);
  }
  return true;
}

boolean eeprom_write_string(int addr, const char* string)
{
  int numBytes;                                                    // jumlah byte aktual yang akan ditulis

  numBytes = strlen(string) + 1;                                   // Tulis konten string ditambah byte terminator string (0x00)
  return eeprom_write_bytes(addr, (const byte*)string, numBytes);
}

boolean eeprom_read_string(int addr, char* buffer, int bufSize)
{
  byte ch;                                                         // byte baca dari eeprom
  int bytesRead;                                                   // jumlah byte yang dibaca sejauh ini

  if (!eeprom_is_addr_ok(addr))                                    // periksa alamat mulai
  {
    return false;
  }

  if (bufSize == 0)                                                // bagaimana kita bisa menyimpan byte dalam buffer kosong?
  {
    return false;
  }

  if (bufSize == 1)                                                // apakah ada ruang untuk terminator string saja, tidak ada alasan untuk melangkah lebih jauh
  {
    buffer[0] = 0;
    return true;
  }

  bytesRead = 0;                                                   // inisialisasi penghitung byte
  ch = EEPROM.read(addr + bytesRead);                              // baca byte berikutnya dari eeprom
  buffer[bytesRead] = ch;                                          // simpan ke dalam buffer pengguna
  bytesRead++;

  // jika tidak ada kondisi berhenti terpenuhi, baca byte berikutnya dari eeprom
  while ( (ch != 0x00) && (bytesRead < bufSize) && ((addr + bytesRead) <= addressEEPROM_max) )
  {
    ch = EEPROM.read(addr + bytesRead);
    buffer[bytesRead] = ch;                                        // simpan ke dalam buffer pengguna
    bytesRead++;
  }

  if ((ch != 0x00) && (bytesRead >= 1))                            // pastikan buffer pengguna memiliki terminator string, (0x00) sebagai byte terakhirnya
  {
    buffer[bytesRead - 1] = 0;
  }
  return true;
}

Result:
How to Save Float To STM32 EEPROM Arduino
Float Data Read


This program still has shortcomings. As you can see of Latitude, the initial value written is 96.124843, when it reads it again becomes 96.124840. I don't know the code for storing data with the amount of data above 8 characters correctly.


if you can resolve this, please comment below to help me improve this STM32 EEPROM article.

May be useful. That's all

2 comments for "STM32 Arduino How to Save Float To EEPROM "

  1. Hi, I try your example at
    https://www.chippiko.eu.org/2020/06/stm32-eeprom-arduino.html
    but not work, i receive ⸮⸮⸮⸮⸮⸮⸮⸮
    I do not know if write error or read error.
    What to do?
    Reguards

    ReplyDelete