STM32 Pointer auf FLASH Adresse zuweisen

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;

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

1

const struct calValue {

2

   unsigned freqMHz;

3

   float p22dBm;

4

   float p22V;

5

   float p20dBm;

6

};

7

8

freqMHz_ptr = &calValue.freqMHz;

9

p22V_ptr = &calValue.p22dbm;

10

// usw.

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

1

> struct calValue {

2

>   unsigned freqMHz;

3

>   float p22dBm;

4

>   float p22V;

5

>   float p20dBm;

6

> };

7

> 

8

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

9

> .

10

> .

11

> .

12

> value = calPtr[42].freqMHz;

13

>

So ein Quatsch!

1

 const struct calValue {

2

   unsigned freqMHz;

3

   float p22dBm;

4

   float p22V;

5

   float p20dBm;

6

 };

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

Darauf kann man dann direkt zugreifen:

1

  calValue_ptr = &calValue;        // Pointer auf die struct selbst

2

  freqMHz_ptr = &calValue.freqMHz; // Pouinter auf das Element freqMHz in der struct

Schöner wirds dann mit einem typedef:

1

 typedef struct calValue_t {

2

   unsigned freqMHz;

3

   float p22dBm;

4

   float p22V;

5

   float p20dBm;

6

 };

7

8

 const calValue_t calValue;

9

10

 calValue_t* calValue_ptr;

11

 unsigned frequMHz* freqMHZ_ptr;

12

13

  calValue_ptr = &calValue;        // Pointer auf die struct selbst

14

  freqMHz_ptr = &calValue.freqMHz; // Pouinter auf das Element freqMHz in der struct

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:

1

/* Definition */

2

typedef struct {

3

  unsigned freqMHz;

4

  float p22dBm;

5

  float p22V;

6

  float p20dBm;

7

}calValue_t;

8

9

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

10

11

/* Zugriff */

12

13

val1 = calPtr[0].freqMHz;

14

val2 = calPtr[0].p22dBm;

15

16

val3 = calPtr[1].freqMHz;

17

val4 = calPtr[1].p22dBm;

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

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

Du sprichst in Rätseln!

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...

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;