STM32 EEPROM Emulation Verständnisproblem

[technikus (Gast)]

Hallo Forum,

ich möchte ein paar Daten in dem Flash eines STM32 schreiben und habe 
hier absolute Verständnisprobleme.

Im Ref Manual / HAL Doku finde ich die Angabe der
a) Flash Page
b) die Adresse

Bei b) ist mir klar was das ist, allerdings weiß ich nicht wie ich die 
oberen Adressen ausfindig mache, damit ich „gefahrlos“ schreibe.
Bei a) fehlt es mir komplett.

Wie ihr seht, verstehe ich als Hobbyprogrammierer Grundlagen nicht und 
drehe mich beim Lesen im Kreis.
Bitte keine Antworten wie „lass die Finger davon und nutze Arduino“.
Ich möchte etwas lernen und habe keinen zum persönlichen Austausch in 
dem Bereich.

Kann mir jemand den Zusammenhang, bzw. die nötigen Daten erläutern?

Danke und Gruß
Ernst

[technikus (Gast)]

Siehe auch der Anhang aus dem Ref Manual.
Heißt das, ich „tobe“ mich in Page 31 aus und habe 2k Platz?

[Christian J. (Gast)]

technikus schrieb:
> Bei b) ist mir klar was das ist, allerdings weiß ich nicht wie ich die
> oberen Adressen ausfindig mache, damit ich „gefahrlos“ schreibe.

Ja, da fehlen ein paar Basics.... befasse dich mal mit dem Linker Script 
und wie man da Regions definiert, die zb frei bleiben sollen. Und ja, da 
geht noch mehr, Du kannst ein ganzes FS im Flash realisieren, wie ne 
Floppy-Disk :-)

RTFM:
https://www.st.com/content/ccc/resource/technical/document/user_manual/group1/09/b1/3b/15/39/41/44/08/UserManual_GNU_Linker/files/UserManual_GNUCC_Linker.pdf/jcr:content/translations/en.UserManual_GNUCC_Linker.pdf

zb so.....
unsigned short int FlashArray[8192] _attribute_ 
((section(''.flash_data_array'')));


MEMORY
{
name [(attr)] : ORIGIN = origin, LENGTH = len
...
}

auch das hier lesen und verstehen, also das Kapitel darüber:

SECTIONS
{
start_of_text = . ;
.text: { *(.text) }
end_of_text = . ;
start_of_data = . ;
.data: { *(.data) }
end_of_data = . ;
}

[A. B. (Gast)]

technikus schrieb:
> ich möchte ein paar Daten in dem Flash eines STM32 schreiben und habe

Das klingt ein wenig nach "auch mal überschreiben", sprich 
EEPROM-Simulation. Dazu siehe AN2594 und AN4061 bei www.st.com.

[technikus (Gast)]

Ich möchte lediglich ein EEPROM emulieren.
Im aktuellen Umfeld ein paar byte pder ein struct.

[A. F. (artur-f)]

technikus schrieb:
> Ich möchte lediglich ein EEPROM emulieren.
> Im aktuellen Umfeld ein paar byte pder ein struct

Für den STM32G031 steht: eine Page hat 2Kilobyte (2048 Byte). Zu der 
jeweiligen Page hast du auch einen angegebenen Adressbereich im 
Datenblatt. Wenn dir sagen wir Mal eine Page als Speicher reicht, hast 
du diese 2Kilobyte. Schreiben kannst du quasi nur uint32-weise, also 4 
Bytes. Fallst du die geschriebenen Daten ersetzen möchtest, musst du die 
Daten der kompletten Page retten (z.B.) ins RAM einlesen, die 
betroffenen Bytes manipulieren, die komplette Page löschen und die 
geänderten Daten vom RAm weder schreiben. Ganz einfach.

[technikus (Gast)]

Danke!
Langsam schließt sich der Kreis - langsam ;)
Sehe ich es richtig das beim STM32G031 nur uint64-weise schreiben kann?

[pegel (Gast)]

So viele Fragen.

Wo bleibt denn da der ganze Spaß? ;)

Für den G0 gibt es kein EEPROM Beispiel, aber für den F0.

Wenn Du das durch siehst, dürfte alles klar werden.

[Bauform B. (bauformb)]

technikus schrieb:
> Sehe ich es richtig das beim STM32G031 nur uint64-weise schreiben kann?

Im Prinzip ja, das ist die kleinste Einheit im Flash. Schreiben kann man 
nur 32 Bit auf einmal (weil die CPU nicht breiter ist), also muss man 
zweimal schreiben. Wichtig ist, dass das erste Wort auf eine durch 8 
teilbare Adresse geschrieben wird und das zweite Wort auf die folgende.

Das Flash ist 72 breit, also zweimal 32 Bit plus 8 Bit für die 
Fehlererkennung (ECC). Diese 8 Bit werden aus den 64 Daten-Bits 
berechnet, und zwar beim Schreiben und beim Lesen. Wenn man nicht alle 
auf einmal schreiben würde, gäbe es beim Lesen einen Fehler, weil die 
Prüfsumme nicht mehr passt.

pegel schrieb:
> Für den G0 gibt es kein EEPROM Beispiel, aber für den F0.
> Wenn Du das durch siehst, dürfte alles klar werden.

Das Beispiel taugt für das EEPROM-Prinzip (z.B., dass man möglichst 
mehrere Pages verwenden sollte), aber aufpassen, bei den Feinheiten 
unterscheiden sich F0 und G0.

[Seppel (Gast)]

Hallo,

leider ist das oben referenziert PDF nicht mehr online, wo finde ich 
das?

Ich hatte mir das : 
https://www.st.com/en/embedded-software/x-cube-eeprom.html angesehen, da 
ist nichts im Linker-Script, zumindest nichts beim STM32G474.

Das Beispiel verwendet in der eeprom_emul_conf.h eine Page recht weit 
vorne:

#define START_PAGE_ADDRESS 0x08010000U /*!< Start address of the 1st page in flash, for EEPROM emulation */

Hat jemand ein Beispiel für das Linker-Script und die ST-EEPROM 
emulation?

Vielen Dank, Grüße, Seppel

P.S. Ich verwende die STM32CubeIDE, welche aber bei der EEPROM Emulation 
leider keine Hilfe ist.

[Bauform B. (bauformb)]

Der kaputte Link sieht ja eher nach Linker als nach EEPROM aus, schau 
doch mal die Original-Doku zum Linker, GCC und dem ganzen Rest an:
https://directory.fsf.org/category/dev/

Die ziemlich aktuelle (auch für G4) Application Note AN4894:
https://www.st.com/resource/en/application_note/dm00311483-eeprom-emulation-techniques-and-software-for-stm32l4-and-stm32l4-series-microcontrollers-stmicroelectronics.pdf

Auf https://community.st.com/ gibt es jede Menge Fragen zum Thema, 
vielleicht ist auch eine Antwort dabei...

Seppel schrieb:
> Ich hatte mir das :
> https://www.st.com/en/embedded-software/x-cube-eeprom.html angesehen, da
> ist nichts im Linker-Script, zumindest nichts beim STM32G474.
> Ich verwende die STM32CubeIDE, welche aber bei der EEPROM Emulation
> leider keine Hilfe ist.

Ja, so kenne ich STM ;)

[Seppel (Gast)]

Hallo,

eventuell bin ich etwas weiter, hab das Linker-Script aus dem 
Code(https://www.st.com/en/embedded-software/x-cube-eeprom.html Version 
4.0.0) vom STM32G474 für den angepasst. Die Flash-EEPROM-Emulation habe 
ich vorne abgelegt weil man ja nicht weiß wie lang das Programm ist:

/* Flash- EEPROM-Emulation: 32 Pages * 2048Bytes = 65.536 Bytes = 0x1000 */
_Ld_FeeOrigin = 0x08000000;
_Ld_FeeLength = 64K;

_Ld_FlashLengthNominal = 512K;
_Ld_FlashLengthActual = _Ld_FlashLengthNominal -_Ld_FeeLength;
_Ld_FlashOrigin = _Ld_FeeLength + _Ld_FeeOrigin ;

MEMORY
{
  RAM    (xrw)    : ORIGIN = 0x20000000,   LENGTH = 128K
  FEE    (rx)    : ORIGIN = _Ld_FeeOrigin,   LENGTH = _Ld_FeeLength
  FLASH    (rx)    : ORIGIN = _Ld_FlashOrigin,   LENGTH = _Ld_FlashLengthActual
}

/* PROVIDE (FeeOrigin = _Ld_FeeOrigin); */

  /*Seppel's FEE Adresses */
  __m_fee_start = ORIGIN(FEE);
  __m_fee_end = ORIGIN(FEE) + LENGTH(FEE)-1;
  __m_fee_size = LENGTH(FEE);
  
  __m_flash_start = ORIGIN(FLASH);
  __m_flash_end = ORIGIN(FLASH) + LENGTH(FLASH) -1;
  __m_flash_size = LENGTH(FLASH);

Dann kann man die "Hardcoded Adresse" in eeprom_emul_conf.h los werden 
und aus dem Linkerscript bekommen:

extern uint32_t __m_fee_start[];
extern uint32_t __m_fee_end[];
extern uint32_t __m_fee_size[];

#define START_PAGE_ADDRESS      ((uint32_t)__m_fee_start) /*!< Start address of the 1st page in flash, for EEPROM emulation */

Der cast von uint32_t*(pointer) zu uint32_t ist natürlich übel, aber 
anders hab ich es aktuell nicht hin bekommen.

Man kann auch Headerfiles in den Linker rein ziehen, aber da mindestens 
Teile für den Aufruf des Linkers über die IDE konfiguriert werden weiß 
ich nicht ob das in dem Beispiel geht. Generell weiß ich auch noch nicht 
genau wie man das macht.

Für Ratschläge und Empfehlungen mit ausführlichen Erklärungen(die fehlen 
in vielen Foreneinträgen) bin ich, und bestimmt alle die professionelle, 
lehrreiche Beiträge lesen, sehr dankbar.

Grüße, Seppel