EEPROM auslesen - "lvalue required as unary '&' operand" Fehler

[Philipp W. (phiwa)]

Moin Moin,

ich möchte einen AT90CAN128 MUC mit dem AVR Studeio 4 programmieren und 
dabei in einem Bootloader eine Variable im EEPROM speichern.

Teil der Bootloader.c

#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/boot.h>


#define EEPROM_SECTION  __attribute__ ((section (".eeprom")))
unsigned int  CAN_CONTROLLER_MASK_ID  EEPROM_SECTION  =  0x00000100;

Im eigentlichen Programm was ich aufflashe (beginnend nach der 
geschützten Bootsection) soll diese  Variable aus dem EEPROM gelesen 
werden und eine Variable mit dem Wert versehen werden.

Teil der Steuerung.c

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <avr/eeprom.h>
#include <avr/boot.h>


int main(void)
{
// Maske aus EEPROM laden
unsigned int CAN_CONTROLLER_MASK_ID_FW  =  eeprom_read_byte((unsigned int*)&(CAN_CONTROLLER_MASK_ID));
CAN_CONTROLLER_MASK_ID = CAN_CONTROLLER_MASK_ID_FW; // unsigned int  CAN_CONTROLLER_MASK_ID  = 0x00000100; in Steuerung.h
}

in der Steuerung.h sollen weitere Defines mit der aus dem EEPROM 
geladenen Maske "zusammengebaut" werden
Folgendermaßen:

#define CONTROLLER_SWITCH_1_ON       (CAN_CONTROLLER_MASK_ID|0x00000001)

Dabei gibt der Compiler die Fehler aus:

../Steuerung.c:504:76: error: lvalue required as unary '&' operand
../Steuerung.c:505:25: error: lvalue required as left operand of assignment

Der Syntax der  eeprom_read_byte() ider doch so richtig oder?

[NurEinGast (Gast)]

Verstehe ich nicht

Du schreibst ->

#define CAN_CONTROLLER_MASK_ID  0x00000100   in Steuerung.h

Und nun willst du dieser festen Zahl eine neue zuweisen ?

CAN_CONTROLLER_MASK_ID = CAN_CONTROLLER_MASK_ID_FW
ist ja
0x00000100 = CAN_CONTROLLER_MASK_ID_FW

hmmmm.


Und weiter oben willst Du die Adresse eine Zahl haben ?

&(CAN_CONTROLLER_MASK_ID)
ist ja
&(0x00000100 )

[Karl H. (kbuchegg)]

Philipp Wagner schrieb:

> Im eigentlichen Programm was ich aufflashe

....


> #define  CAN_CONTROLLER_MASK_ID  0x00000100

das ist aber etwas vollkommen anderes!
Du solltest mal ein C-Buch lesen. ernsthaft!

Das hier legt keine Variable an bzw. definiert oder deklariert auch 
keine, sondern sorgt einfach nur dafür, dass der Präprozessor im Code 
den Text CAN_CONTROLLER_MASK_ID  duirch den Text 0x00000100 ersetzt.

Nach dem Präprozessor lauf, steht also in deinem Programm

  ... eeprom_read_byte((unsigned int*)&(0x00000100));

...
  0x00000100 = CAN_CONTROLLER_MASK_ID_FW;
...

und das das QUatsch ist, brauch ich wohl nicht extra zu betonen.
Genau das meint 'l-value'. Das 'l' steht für 'left' und gemeint ist 
damit der linke Teil in einer Zuweisung

   a = ausdruck;

a muss logischerweise etwas sein, was etwas speichern kann. Eine 
Variable zum Beispiel. 0x00000100 ist aber ganz sicher keine Variable. 
0x00000100  ist einfach nur eine Zahlenkonstante. Und der kann man 
nichts neues zuweisen. Genausowenig wie eine Zahlenkonstante keine 
Adresse im Speicher hat, die man mit & feststellen könnte. Eine 
Zahlenkonstante ist daher kein l-Value.


PS: Ich denke auch, dass du hier

unsigned int  CAN_CONTROLLER_MASK_ID  EEPROM_SECTION  =  0x00000100;

etwas machst, was du gar nicht beabsichtigt hast. Die Angabe 0x00000100 
ist der Initialiwert, den diese EEPROM Zelle haben soll. Sie ist NICHT 
die Adresse im EEPROM, an der diese Variable lokalisiert sein soll.
D.h. selbst wenn du deine syntaktischen Probleme ausräumst, wird nicht 
das passieren, was du dir vorstellst.

[Philipp W. (phiwa)]

Ich hatte mich geirrt beim Tippen, in der Headerdatei  ist die

unsigned int  CAN_CONTROLLER_MASK_ID  = 0x00000100;

angelegt worden, nicht definiert.
Mir ist durchaus bewusst wozu die #define's da sind und das an dieser 
Stelle keine Sinn gemacht hätte.

In der EEPROM Sektion soll diese Variable genau diesen Wert haben

unsigned int  CAN_CONTROLLER_MASK_ID  EEPROM_SECTION  =  0x00000100;

Wie kann ich die Adresse der Variablen bestimmen, damit ich in der 
Steuerung.c den Inhalt der CAN_CONTROLLER_MASK_ID aus dem EEPROM 
(0x00000100) abrufen kann?

[NurEinGast (Gast)]

Die Zeile

CAN_CONTROLLER_MASK_ID = CAN_CONTROLLER_MASK_ID_FW;

will direkt in das EEprom schreiben.
(unsigned int  CAN_CONTROLLER_MASK_ID  EEPROM_SECTION)

Das geht aber nicht direkt sondern mit eeprom_update_byte(..) und 
Konosorten.

[NurEinGast (Gast)]

... ausserdem hast Du jetzt anscheinend Dein ursprüngliches Posting 
geändert.
Plötzlich steht da :

unsigned int  CAN_CONTROLLER_MASK_ID  = 0x00000100; in Steuerung.h

statt

#define CAN_CONTROLLER_MASK_ID  0x00000100   in Steuerung.h

vorher

Ist die CAN_CONTROLLER_MASK_ID jetzt plötzlich doch nicht mehr im EEPROM 
?
Ich geb's auf. Wenn sich die Vorgaben der alten Postings plötzlich 
ändern, dann wird der ganze Thread vollkommen unduchschaubar.

[Karl H. (kbuchegg)]

NurEinGast schrieb:

>

unsigned int  CAN_CONTROLLER_MASK_ID  = 0x00000100; in 
> Steuerung.h

> statt
>

#define CAN_CONTROLLER_MASK_ID  0x00000100   in Steuerung.h 
>

> vorher

?
Den #define hab ich aus dem Kommentar herausisoliert.

Im Original war es immer schon eine Variable im Bootloader-Programm und 
(anscheinend) ein #define im eigentlichen Programm.

[Philipp W. (phiwa)]

Karl Heinz schrieb:
> NurEinGast schrieb:
>
>>

unsigned int  CAN_CONTROLLER_MASK_ID  = 0x00000100; in
>> Steuerung.h

>> statt
>>

#define CAN_CONTROLLER_MASK_ID  0x00000100   in Steuerung.h
>>

>> vorher
>
> ?
> Den #define hab ich aus dem Kommentar herausisoliert.
>
> Im Original war es immer schon eine Variable im Bootloader-Programm und
> (anscheinend) ein #define im eigentlichen Programm.

Genau, weil ich mich vertippt habe, hab ich es geändert.

Im Bootloader-Programm ist eine Variable angelegt worden.
Im Steuerungsprgramm möchte ich diese Variable nur auslesen und damit 
neue Variablen zusammenstellen, in etwar so:

unsigned int CONTROLLER_SWITCH_1_ON   = (CAN_CONTROLLER_MASK_ID|0x00000001);

Mir ist aufgefallen, dass ich im Steuerungsprgramm dafür keine defines 
mehr nutzen kann, da die Werte auch nach dem compilieren geändert werden 
müssen.

Der Sinn hinter diesem Aufwand ist, dass ich die Bootloader in der 
CAN_CONTROLLER_MASK_ID  angepasst, nur einmal auf je einen 
Mikrocontroller aufflashe und später die Steuersoftware mittels bereits 
implementieretem Flashprogramm per CAN Bus flasche ohne jeweils im 
Steuerungsprogramm die IDs des jeweiligen Mikrocontrollers zu ändern.

[NurEinGast (Gast)]

unsigned int  CAN_CONTROLLER_MASK_ID  EEPROM_SECTION  =  0x00000100; 
unsigned int  CAN_CONTROLLER_MASK_ID_FW;
unsigned int  CONTROLLER_SWITCH_1_ON;

CAN_CONTROLLER_MASK_ID_FW  =  eeprom_read_word(&CAN_CONTROLLER_MASK_ID);
CONTROLLER_SWITCH_1_ON     =  CAN_CONTROLLER_MASK_ID_FW | 0x0001;

geht nicht ?

Dabei muss die CAN_CONTROLLER_MASK_ID Variable im Hauptprogramm und im 
Bootloader halt auf der gleiche EeProm Speicherzelle liegen.



Noch ein paar Dinge :


- Du hast CAN_CONTROLLER_MASK_ID als unsigned int definiert ( 16 Bit )
- Dann willst Du sie mit 0x00000100 vorbelgen (32 Bit)
- Und Du willst die CAN_CONTROLLER_MASK_ID mit eeprom_read_byte() lesen 
( 8 Bit )

[Karl H. (kbuchegg)]

Philipp Wagner schrieb:

> Im Bootloader-Programm ist eine Variable angelegt worden.

Davon wirst du Abstand nehmen müssen.
Denn oberste Priorität hat, dass in beiden Programmen immer dieselbe 
Speicherzelle benutzt wird. Die Adresse kennst du aber so nicht, bzw. 
kannst sie nicht einfach von einem Programm zum anderen übertragen.


In diesem Fall wirst du die Kontrolle über die Adresse komplett selber 
übernehmen müssen. Zumindest würde ich das so machen

D.h. die Variable wird als Variable aus dem Bootloader ausgebaut und 
durch eine ansonsten unbenutzte EEPROM Adresse ersetzt. Vorzugsweise am 
Ende des EEPROM, da der Linker (andere) Variablen von vorne beginnend im 
EEPROM allokiert und du nicht mit diesen kollidieren willst

// Adresse im EEPROM an der die Daten gespeichert sind
// der dort gespeicherte Wert ist als
// unsigned int aufzufassen

#define  CAN_CONTROLLER_MASK_ADDR ((unsigned int*)0xFE)  
                                                         
                                                         


...


  unsigned int CanControllerMask;

  CanControllerMask = eeprom_read_word( CAN_CONTROLLER_MASK_ADDR );


  ....

  eeprom_write_word( CAN_CONTROLLER_MASK_ADDR, CanControllerMask );

und das dann gleichermassen im Bootloader bzw. im Anwendungsprogramm zu 
benutzen.


Eine andere Möglickeit wäre es, eine eigene Linker-Section für diese 
Variable anzulegen und dann in beiden Programmen den Linker jeweils die 
Variable in genau diese Section vom EEPROM legen zu lassen.