STM32 Pointer auf FLASH Adresse zuweisen

[Sigurd W. (sig_w)]

Hallo,

zur Softwareentwicklung für einen STM32L4P5 nutze ich die STM32CubeIDE. 
Als c-Neuling scheitere ich an einer simplen Adresszuweisung. Ich habe 
ein Struktur-Array, das ich in den FLASH an eine bestimmte Adresse 
geschrieben habe. Ich möchte nun über ein Array auf diese Daten 
zugreifen.

struct calValue {
  unsigned freqMHz;
  float p22dBm;
  float p22V;
  float p20dBm;
};

/*Die Definition eines Pointers klappt noch ohne Compilerfehler*/
struct calValue *calPtr  =  ((struct calValue*)0x0804A000);

/*Diese Versuche zur Array-Definition schlagen kläglich fehl*/
__const struct calValue* cal[] = (struct calValue*) 0x0804A000;
__const struct calValue* cal[] __attribute__((_At(0x0804A000)));

Habe gelesen, dass man die LinkerScript Datei dafür ändern muss, was mir 
ja "sehr praktisch" erscheint. Muss ich wirklich die 
STM32L4P5CETX_FLASH.ld dafür ändern oder gibt es einen einfacheren Weg? 
Für ein Beispiel wäre ich sehr dankbar.

Dank im Voraus!
 Sigurd

[Kevin M. (arduinolover)]

Was versprichst du dir davon?

Sigurd W. schrieb:
> __const struct calValue* cal[] = (struct calValue*) 0x0804A000;
> __const struct calValue* cal[] __attribute__((_At(0x0804A000)));

du kannst doch mit der 1. Definition auf die Daten zugreifen:

    value = calPtr->freqMHz;

[Harry L. (mysth)]

Sigurd W. schrieb:
> struct calValue {
>   unsigned freqMHz;
>   float p22dBm;
>   float p22V;
>   float p20dBm;
> };

const struct calValue {
   unsigned freqMHz;
   float p22dBm;
   float p22V;
   float p20dBm;
};

freqMHz_ptr = &calValue.freqMHz;
p22V_ptr = &calValue.p22dbm;
// usw.

[FOp (Gast)]

const struct calValue cal[] __attribute__((_At(0x0804A000)))={{42U,22.0,22.2,20.0},{42U,22.0,22.2,20.0}};
const struct calValue* pcal=&cal[1];

wäre ein Versuch. Aber mein gcc meint Warnung "At" geht mir am .... 
vorbei. Also doch Linker Script anpassen.

[FOp (Gast)]

Oh, ich lese gerade, die Daten stehen schon dort. Dann geht folgender 
Ansatz :

struct calValue {
  unsigned freqMHz;
  float p22dBm;
  float p22V;
  float p20dBm;
};

const struct calValue *calPtr  =  ((struct calValue*)0x0804A000UL);
.
.
.
value = calPtr[42].freqMHz;

[FOp (Gast)]

noch besser :

const struct calValue * const calPtr  =  ((struct calValue*)0x0804A000UL);

weil die Adresse, wo der Gulasch steht ist ja auch konstant.

[Harry L. (mysth)]

FOp schrieb:
> Oh, ich lese gerade, die Daten stehen schon dort. Dann geht folgender
> Ansatz :
>

> struct calValue {
>   unsigned freqMHz;
>   float p22dBm;
>   float p22V;
>   float p20dBm;
> };
> 
> const struct calValue *calPtr  =  ((struct calValue*)0x0804A000UL);
> .
> .
> .
> value = calPtr[42].freqMHz;
>

So ein Quatsch!

 const struct calValue {
   unsigned freqMHz;
   float p22dBm;
   float p22V;
   float p20dBm;
 };

Jetzt liegt die struct bereits im Flash, und der Linker kümmert sich um 
die Adresse.

Darauf kann man dann direkt zugreifen:

  calValue_ptr = &calValue;        // Pointer auf die struct selbst
  freqMHz_ptr = &calValue.freqMHz; // Pouinter auf das Element freqMHz in der struct

[Harry L. (mysth)]

Schöner wirds dann mit einem typedef:

 typedef struct calValue_t {
   unsigned freqMHz;
   float p22dBm;
   float p22V;
   float p20dBm;
 };

 const calValue_t calValue;

 calValue_t* calValue_ptr;
 unsigned frequMHz* freqMHZ_ptr;

  calValue_ptr = &calValue;        // Pointer auf die struct selbst
  freqMHz_ptr = &calValue.freqMHz; // Pouinter auf das Element freqMHz in der struct

[Kevin M. (arduinolover)]

Harry L. schrieb:
> Schöner wirds dann mit einem typedef:

Er wird wohl mehr als ein Set an Werten haben.

Wie bereits geschrieben:
Kevin M. schrieb:
> Was versprichst du dir davon?
>
> Sigurd W. schrieb:
>> __const struct calValue* cal[] = (struct calValue*) 0x0804A000;
>> __const struct calValue* cal[] __attribute__((_At(0x0804A000)));
>
> du kannst doch mit der 1. Definition auf die Daten zugreifen:
>
>     value = calPtr->freqMHz;

Als Array kannst du das auch so machen:

/* Definition */
typedef struct {
  unsigned freqMHz;
  float p22dBm;
  float p22V;
  float p20dBm;
}calValue_t;

const calValue_t *calPtr  =  ((calValue_t*)0x0804A000);

/* Zugriff */

val1 = calPtr[0].freqMHz;
val2 = calPtr[0].p22dBm;

val3 = calPtr[1].freqMHz;
val4 = calPtr[1].p22dBm;

Ergebnis siehe Anhang (hier im RAM das spielt aber keine Rolle).

[FOp (Gast)]

Harry L. schrieb:
> So ein Quatsch!
> Jetzt liegt die struct bereits im Flash, und der Linker kümmert sich um
> die Adresse.

Laut erstem Beitrag liegt ein Array von diesen structs schon ohne den 
gesuchten Quellcode im Flash. Habe ich aber auch erstmal überlesen. Wie 
der dahin kommt : egal. Vielleicht hat er ja einen Generator, der eine 
.hex - Datei ausspuckt. Dein Code legt eine Struct selber an, und 
greift immer auf diese eine eigene zu.

[Harry L. (mysth)]

FOp schrieb:
> Dein Code legt eine Struct selber an, und
> greift immer auf diese eine eigene zu.

Du sprichst in Rätseln!

[J. S. (jojos)]

Sowas ohne sections im Linkerfile zu machen ist aber schmutzig, das 
kommt irgendwann als Boomerang zurück. Der hat mich auch gerade wieder 
getroffen, mal eben zum Test einen Puffer ins RAM packen, ist ja genug 
da...

[Sigurd W. (sig_w)]

Vielen Dank für die schnellen Antworten.

Die Antwort von FOp und Kevin M. trifft es am Besten, da ich auf die 
einzelnen Elemente per Index zugreifen möchte und nicht einen Pointer 
inc- /dercremetieren will. Das ich auch den Pointer indizieren kann, hab 
ich nicht geahnt.

value = calPtr[42].freqMHz;

[Émile (Gast)]

FOp schrieb:

 const struct calValue * const calPtr  =  ((struct  calValue*)0x0804A000UL);

Wobei helfen da die Klammern?

Schreibst Du auch

a = (b);