Wie Code auf 2 Flash bereiche aufteilen?

[Dirk (Gast)]

Hi ich habe ein Projekt mit einem STM32H743.
Der hat keinen durchgänigen Flash speicher und ich habe gerade die 512K 
vom ersten Bereich überschritten.
Was am schönsten wäre ist logischerweise das man die Berieche einfach 
dem Linker zur verfügung stellt und der die einfach nutzt, aber das geht 
wohl nicht.

So nun möchte ich einzelne Funktionen in den 2. Bereich rein legen, aber 
wie man anhand der Frage denken kann, klappt das nicht so richtig.


Was eigentlich gehen sollte ist das:

int __attribute__((section(".text2")))  MeineFunktion( int a)
{return a+1;}


Linker:
ROM_2  (rx) : ORIGIN = 0x80100000, LENGTH = 512K       /*  FLASH 2  */

.text2 : {
  . = ALIGN(4);
  *(.text2*)  /* Program code Teil 2 */
  . = ALIGN(4);
} > ROM_2


Variablen die ich so auf einen der 5 Ram Bereiche lege ist dann da wo er 
sein soll.

Aber der Code ist im Mapfile nicht da wo er hin gehört, der Bereich 
Text2 ist leer.

Was mache ich falsch?

[Daniel F. (foxi_the_daywalker)]

Hi,

wir verwenden auch den STM32H743/753 und ich hatte noch nie Probleme den 
Flash als durchgehenden Speicher zu verwenden, da der zweite Bereich 
direkt nach dem ersten kommt.
Ich habe schon eine Firmware gebaut, die 1,5MB groß war.

Oder möchtest du unbedingt gewisse Teile auftrennen um etwas nicht zu 
überschreiben?

Gruß
Daniel

[Dirk (Gast)]

Es gibt 2 Versionen vom dem Prozessor einmal mit 1MB und mit 2MB.

Die 2MB Variante ist durchgännig, der 1MB Variante fehlen mitten drin 
512K.

[Bauform B. (bauformb)]

Dirk schrieb:
> Linker:
> ROM_2  (rx) : ORIGIN = 0x80100000, LENGTH = 512K       /*  FLASH 2  */

sollte es nicht ORIGIN = 0x08100000 heissen?

[Dirk (Gast)]

Da hoffe ich doch mal das ich mich hier nur verschrieben habe.
Ansonsten wäre es auf jeden Fall falsch. Aber auch dann hätte der linker 
das in die section packen müssen.

Aber ich habe gerade mir im Debugger mal den Speicher angesehen und da 
war der Speicher durchgehend, also so wie es sauber wäre. Der Speicher 
im 2. Bereich war nicht lesbar. Im Datenblatt und in allen linkerfiles 
die ich gesehen habe war es immer mit Lücke. Also 2 Bereiche.

Wem soll man da noch trauen.
Ich muß das jetzt noch genauer testen.

[Klaus W. (mfgkw)]

Kommt halt auch drauf an, welchen STM32H743 genau du hast.

Dann sollte eigentlich das hier:
https://www.st.com/resource/en/reference_manual/rm0433-stm32h742-stm32h743753-and-stm32h750-value-line-advanced-armbased-32bit-mcus-stmicroelectronics.pdf
alle Bereiche und ihre Adressen liefern auf Seite 130.

Daraus die Fußnoten:
1. Flash memory bank 2 boundary is limited to 0x08100000 - 0x0817FFFF on 
STM32H742xG/STM32H743xG. It is reserved
on STM32H750xB.
2. Flash memory bank 1 boundary is limited to 0x08000000 - 0x0807FFFF 
and 0x08000000 - 0x0801FFFFon
STM32H742xG/STM32H743xG and STM32H750xB boundary, respectively.

Wenn du einen STM32H743xG hast, ist der Bereich tatsächlich nicht 
durchgehend.
Der zweite Teil beginnt jedenfalls bei 0x08100000.

[Dirk (Gast)]

Es ist ein xG!

Aber komischerweise zeigt der Debugger das anders an wie man erwarten 
würde.

Aber um auf meine Frage zurück zu kommen, wieso geht das verlegen einer 
Funktion nicht?

[Dirk (Gast)]

So ich habe eine kleine Tabelle genau auf 0x0807ffe4 liegen und die 
nächst auf 0x8080060.
Beide Tabellen sind ohne Fehler im Flash.
Also stimmen die Daten nicht so ganz. Ich prüfe jetzt nicht alles nach, 
aber ich vermute das in der Beschreibung die Bereiche vertauscht sind, 
oder der Kommentar dazu einfach nicht eindeutige ist.

Es soll ja noch einen 128k Bereich geben der dem bootloader zugeordnet 
ist und an den man nur dran kommt wenn man den gestartet hat. Das wird 
Bank 2 sein.
Bank 1 wird dann wohl der normale Flash sein, nur die Adresse wäre 
falsch oder die wird intern umgestellt.
Wie auch immer der Speicher ist doch nicht geteilt und ich mache weiter.

[Klaus W. (mfgkw)]

Was auch sein kann:
ST garantiert ja nicht, daß ein Speicher NICHT da ist.
Nur je nach Typ muß ein bestimmter Flash- und RAM-Speicher da sein.

Es kommt durchaus vor, daß ein konkretes Exemplar mehr hat als 
eigentlich im DS steht.

Ein anderer vom selben Typ kann dann wieder weniger haben.

[Daniel F. (foxi_the_daywalker)]

Dirk schrieb:
> Es gibt 2 Versionen vom dem Prozessor einmal mit 1MB und mit 2MB.
>
> Die 2MB Variante ist durchgännig, der 1MB Variante fehlen mitten drin
> 512K.

Da muss ich mich entschuldigen. Da habe ich noch nie drauf geachtet.
Ich habe bei dem STM32H743XI immer gedacht, dass das "I" einfach für den 
Temperaturbereich steht.

Gruß
Daniel

[Jim M. (turboj)]

Dirk schrieb:
> Aber der Code ist im Mapfile nicht da wo er hin gehört, der Bereich
> Text2 ist leer.
>
> Was mache ich falsch?

Eventuell wird die Funktion einfach nur wegoptimiert.
Versuche mal:

int __attribute__((noinline,section(".text2")))  MeineFunktion( int a)
{
return a+1;
}

[Dirk (Gast)]

Da hätte der gcc aber eine Menge wegoptimieren müssen, ich habe ca. 20 
Funktionen gut 10k im Flash versucht da hin zu legen.

Das das Programm am Ende nicht gelaufen wäre ist ja eine andere Sache.

Aber vielleicht ist das inline ja auch der Schlüssel.
Jedenfalls will ich noch einige Funktionen in den ictm RAM einbauen, 
weil ich hoffe das die noch was bringen. Aber wie das dann geht weiß ich 
noch nicht.

[Dirk (Gast)]

So jetzt fragt nicht wieso, aber jetzt geht es plötzlich.

Ich habe eigentlich nur.Text2 in.myrom umbenannt und vielleicht noch ein 
space ein- oder ausgebaut.
Jedenfalls die Unterschiede kann ich jetzt nicht mehr nachvollziehen.
Das Ergebnis ist aber das ich nun den Code schön verteilen kann, wenn 
auch nur Funktion für Funktion.

[E(SATA) (Gast)]

> das ich nun den Code schön verteilen kann

Hmm, zumindest bei der ARM-Version der IAR-Compiler reicht es,
im Linkerscript 2 Bereiche anzulegen. Um das Verteilen kuemmert
sich der Linker dann von alleine.
Bei "gleichwertigen" Bereichen hat man nicht viel gekonnt
wenn man das selbst dem Linker vorkauen muss.

[pegel (Gast)]

Steht irgendwo in der ld Datei:
.text*

Damit erklärt sich dann das Problem mit:
.text2*

[Dirk (Gast)]

Ja das steht so drin und ich vermute mal das * ein Platzhalter ist und 
die 2 dann schluckt. Hätte aber vorher da was anderes stehen und das 
wollte auch nicht funktionieren, was da aber falsch war kann ich nicht 
sagen.
Jedenfalls jetzt geht es.

Wie iar das macht würde mich mal interessieren. Weil das natürlich die 
beste Methode wäre.
Kannst ja mal die linker Daten hier zeigen, vielleicht geht das ja auch 
beim gcc.