Speicherort Variabeln

[Pascal E. (nimmzwei)]

Hallo Gemeinde,

ich initialisiere meine Variabeln wie folgt:

unsigned char    EE_actualSpeed          = 0;
unsigned short    EE_Test              = 0;
unsigned char    EE_minPWM            = 10;

Nun müsste man doch meinen, dass wenn ich mit einem Zeiger

&EE_actualSpeed

 die Adresse 9299 auslese. Die folgende Variabel

 &EE_Test

 an der Adresse 9300 befinden müsste.

Dies ist leider nicht so. Kann ich da meinem xMega irgendwie unter die 
Arme greiffen um dem Compiler zu sagen, dass die Adressen hier 
eingehalten werden müssen.

Besten Dank im Voraus

[Falk B. (falk)]

@ Pascal E. (nimmzwei)

>ich initialisiere meine Variabeln wie folgt:

>unsigned char    EE_actualSpeed          = 0;
>unsigned short    EE_Test              = 0;
>unsigned char    EE_minPWM            = 10;

Wo stehen die? In einer Funktion oder global?

>&EE_actualSpeed

> die Adresse 9299 auslese. Die folgende Variabel

> &EE_Test

> an der Adresse 9300 befinden müsste.

Nein. Die Reihenfolge und Lage von einzelnen Variablen ist NICHT 
garantiert. Das ist C, nicht ASM.

>Dies ist leider nicht so. Kann ich da meinem xMega irgendwie unter die
>Arme greiffen um dem Compiler zu sagen, dass die Adressen hier
>eingehalten werden müssen.

Ja, indem du diese Variablen in einem struc zusammenfasst. Dort MUSS der 
Compiler die Lage einhalten.

[Mark B. (markbrandis)]

Pascal E. schrieb:
> dass die Adressen hier eingehalten werden müssen.

Wozu?

[Falk B. (falk)]

@ Mark Brandis (markbrandis)

>> dass die Adressen hier eingehalten werden müssen.

>Wozu?

Berechtigte Frage. Denn normaleweise hat man in C mit absoluten Adressen 
nix zu tun, man greift immer über den Variablennamen auf Variablen zu.

[Ponter (Gast)]

Falk Brunner schrieb:
> man greift immer über den Variablennamen auf Variablen zu.
oder Pinter, welch Adresse jetzt aber genau im Pointer steht 
interessiert meistens niemanden.

[Pascal E. (nimmzwei)]

Danke für die rege Beteiligung

Um Missverständnisse zu beseitigen:

Ich brauche keine Fixe Adresse, wo das Zeug steht ist im Prinzip egal. 
Wichtig ist, dass die Reihenfolge innerhalb dieses Blocks "richtig" ist.

Geht darum einen Offsett für die Ablage ins EEprom zu berechnen und so 
automatisiert die Variabeln zu übertragen.

Interessant ist für mich nur, ob mein Wunsch vom Compiler erfüllt werden 
kann.

[PittyJ (Gast)]

Dann solltest du wirklich mit einem struct arbeiten, und die Variablen 
darin zusammen fassen.

[Pascal E. (nimmzwei)]

PittyJ schrieb:
> Dann solltest du wirklich mit einem struct arbeiten, und die Variablen
> darin zusammen fassen.

Bin mir nicht sicher, ob ich das soll.

Habe die Lösung auf einem anderen Controller bereits lauffähig gesehen.
Leider habe ich nicht ansatzweise eine Idee wie ich dem AVR-GCC meinen 
Wunsch aufdrücken kann.

[Peter II (Gast)]

Pascal E. schrieb:
> Bin mir nicht sicher, ob ich das soll.

warum nicht, welche bedenken gibt es?

> Habe die Lösung auf einem anderen Controller bereits lauffähig gesehen.
> Leider habe ich nicht ansatzweise eine Idee wie ich dem AVR-GCC meinen
> Wunsch aufdrücken kann.
weil C außer mit einer struct (packed!) dafür keine Möglichkeiten 
bieten.

[MaWin (Gast)]

Pascal E. schrieb:
> Nun müsste man doch meinen, dass wenn ich mit einem Zeiger
> Die folgende Variabel an der Adresse 9300 befinden müsste.

Nein.
Manche Compiler ordnen den Platz erst zu, wenn die Variabke benutzt 
wurde, und verwenden geeinsame Plätze für Variabken, die nicht gemeinsam 
verwendet werden können.

 void func(int i)
{
    int n=5*i;
    if(n>10)
    {
        int a=i-n;
        printf("a=\n",a);
    }
    else
    {
        int b=n-i;
        printf("b=\n",b);
    }
}

Da kann sich der Compiler entscheiden, n gar nicht zu speichern und a 
und b auf denselben Speicherort zu lege.

> Kann ich da meinem xMega irgendwie unter die
> Arme greiffen um dem Compiler zu sagen, dass die Adressen hier
> eingehalten werden müssen.

struct
{
    unsigned char    EE_actualSpeed;
    unsigned short    EE_Test;
    unsigned char    EE_minPWM;
}
EE_struct={0,0,10};

Achtung, Alignment wird gegebenenfalls EE_test nicht auf 
EE_actualSpeed+1 legen, aber eventuell EE_minPW in den Platz zwischen 
EE_actusalSpeed und EE_Test schieben, also achte auf das eingestellte 
Alignment;

[Max H. (hartl192)]

Wenn du die Struktur mit __attribute__((packed)) erstellst, dann kannst 
du dem Compiler auch verbieten irgendwelche Padding-Bytes einzufügen.

[Falk B. (falk)]

@Pascal E. (nimmzwei)

>Wichtig ist, dass die Reihenfolge innerhalb dieses Blocks "richtig" ist.

>Geht darum einen Offsett für die Ablage ins EEprom zu berechnen und so
>automatisiert die Variabeln zu übertragen.

Auch dafür braucht man keine feste Reihenfolge, denn auch EEPROM 
Variablen werden über den NAMEN angesprochen, nicht die reale Adresse. 
Um die realen

uint16_t varRAM;
uint16_t varEE EEPROM;

eeprom_write_word(&varEE, varRAM);
varRAM = eeprom_read_word(&varEE);

>Habe die Lösung auf einem anderen Controller bereits lauffähig gesehen.

Na dann zeig sie doch mal hier.

>Leider habe ich nicht ansatzweise eine Idee wie ich dem AVR-GCC meinen
>Wunsch aufdrücken kann.

Lese- und Schreibzugriffe laufen beim avr gcc über Funktionen. Siehe 
Doku der libc.

https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#EEPROM

[Klausy (Gast)]

Im AVR Codevision gibt es die möglichkeit über @ die Adresse 
festzulegen.
also: unsigned char  EE_actualSpeed@0x5000;
Ansonsten gibts evtl. sowas wie
#pragma DATA_SECTION(...);

[Thomas (Gast)]

Hallo Pascal,

eigentlich gibt es nur drei Möglichkeiten, die sinnvoll sind:

a) Du vertraust dem C-Compiler (und glaub mir, der weiß was er tut!) und 
nutzt normale C-Syntax um auf Variablen zuzugreifen (Pointer, sowie 
Pointer-Arithmetik),

b) Du nutzt eine Struktur, am besten gepackt, und kannst mit 
einigermaßen Gewissheit sagen wie der Compiler diese Sturktur füllt und 
könntest nun von einer vorherigen Variable in der Struktur die Adresse 
der nächsten Ableiten - macht aber ja nicht so richtig Sinn weil du 
gleich den Variablennamen der Variable in der Struktur nehmen kannst,

c) Du weißt es besser als der C-Compiler und programmierst entweder die 
Funktion, oder gleich das komplette Programm selber in Assembler.

Sinnvollerweise wirds also wohl a) oder c) sein.

Thomas

[Axel S. (a-za-z0-9)]

Thomas schrieb:
> eigentlich gibt es nur drei Möglichkeiten, die sinnvoll sind:

Es gibt mindestens noch eine 4. Möglichkeit:

d) du definierst eine eigene Sektion im EEPROM der du dann im Linker- 
skript einen Adreßbereich zuweisen kannst und weist den Compiler an, 
deine Variablen (oder die struct) in diese Sektion zu legen.

Im Prinzip macht die EEMEM Deklaration nichts anderes, nur daß die halt 
den gesamten EEPROM als eine Sektion behandelt.

[Karl H. (kbuchegg)]

Thomas schrieb:

> b) Du nutzt eine Struktur, am besten gepackt, und kannst mit
> einigermaßen Gewissheit sagen wie der Compiler diese Sturktur füllt und
> könntest nun von einer vorherigen Variable in der Struktur die Adresse
> der nächsten Ableiten - macht aber ja nicht so richtig Sinn weil du
> gleich den Variablennamen der Variable in der Struktur nehmen kannst,

Oder aber. Man kopiert ganz einfach das komplette Strukturobjekt so wie 
es ist, ohne sich weiter um seine inneren Aufbau kümmern zu müssen.
Das macht dann am allermeisten Sinn, weil man ein Ding weniger hat, um 
das man sich kümmern muss.

struct MotorData
{
  unsigned char   actualSpeed;
  unsigned short  Test;
  unsigned char   minPWM;
};

struct MotorData Motor1 = { 0, 0, 10 };   // Das Objekt im Speicher

struct MotorData EE_Motor EEMEM;          // Die Variante davon im EEPROM

.....
   // Vom EEProm in den Speicher
   eeprom_read_block( &Motor1, &EE_Motor, sizeof( Motor1 ) );
...
  // Vom Speicher ins EEPROM
   eeprom_write_block( &Motor1, &EE_Motor, sizeof( Motor1 ) );

Pascal schrieb
> Bin mir nicht sicher, ob ich das soll.

Doch. Genau das sollst du. Und wenn du schon dabei bist, sollst du auch 
noch ein C-Buch kaufen und durcharbeiten.