Problem mit Strukturen

[Pal .. (pal)]

Hallo,

ich habe mir eine Struktur mit eeprom-Speicherstellen angelegt. Leider 
nervt mich der Compiler mit einem Fehler - ich sehe nur nicht was er von 
mir will.

Kann mir jemand sagen wo mein Problem ist?

/* EEPROM Speicher */
uint16_t eeBetr_h       EEMEM = 2;                      // Aktuelle Betriebsstunden aus EEPROM
uint8_t  eeBetr_min_1600  EEMEM = 3;                      // Aktuelle Betriebsminuten bis 1600h aus EEPROM
uint8_t  eeBetr_min_3200  EEMEM = 4;                      // Aktuelle Betriebsminuten bis 3200h aus EEPROM
uint8_t  eeBetr_min_4800  EEMEM = 5;                      // Aktuelle Betriebsminuten bis 4800h aus EEPROM
uint8_t  eeBetr_min_6400  EEMEM = 6;                      // Aktuelle Betriebsminuten bis 6400h aus EEPROM
uint8_t  eeBetr_min_8000  EEMEM = 7;                      // Aktuelle Betriebsminuten bis 8000h aus EEPROM
uint8_t  eeBetr_min_9600  EEMEM = 8;                      // Aktuelle Betriebsminuten bis 9600h aus EEPROM
uint8_t  eeBetr_min_11200 EEMEM = 9;                      // Aktuelle Betriebsminuten bis 11200h aus EEPROM
uint8_t  eeBetr_min_12800 EEMEM = 10;                      // Aktuelle Betriebsminuten bis 12800h aus EEPROM

/* Übersetzungstabelle für EEPROM Speicherstellen */
struct numSel
{
  uint16_t memcycl;                                // Speicherzyklen
  uint8_t  memory;                                // Speicherplatz
};

struct numSel numMemSel[] =
{
  { 1600,  eeBetr_min_1600  },
  { 3200,  eeBetr_min_3200  },
  { 4800,  eeBetr_min_4800  },
  { 6400,  eeBetr_min_6400  },
  { 8000,  eeBetr_min_8000  },
  { 9600,  eeBetr_min_9600  },
  { 11200, eeBetr_min_11200 },
  { 12800, eeBetr_min_12800 },
};

#define ARRAY_SIZE(x)  (sizeof(x)/sizeof(*x))

Die Fehlermeldung lautet:

../betrStd.c:41: error: initializer element is not constant
../betrStd.c:41: error: (near initialization for 'numMemSel[0].memory')
../betrStd.c:42: error: initializer element is not constant
../betrStd.c:42: error: (near initialization for 'numMemSel[1].memory')
../betrStd.c:43: error: initializer element is not constant
../betrStd.c:43: error: (near initialization for 'numMemSel[2].memory')
../betrStd.c:44: error: initializer element is not constant
../betrStd.c:44: error: (near initialization for 'numMemSel[3].memory')
../betrStd.c:45: error: initializer element is not constant
../betrStd.c:45: error: (near initialization for 'numMemSel[4].memory')
../betrStd.c:46: error: initializer element is not constant
../betrStd.c:46: error: (near initialization for 'numMemSel[5].memory')
../betrStd.c:47: error: initializer element is not constant
../betrStd.c:47: error: (near initialization for 'numMemSel[6].memory')
../betrStd.c:48: error: initializer element is not constant
../betrStd.c:48: error: (near initialization for 'numMemSel[7].memory')

[Karl H. (kbuchegg)]

pal ... schrieb:

> ../betrStd.c:41: error: initializer element is not constant

Na ja. So schwer ist das dann auch wieder nicht.
Da wird etwas initialisiert. Und das, womit es initialisiert wird, muss 
eine Konstante sein. Also

   int i = 5;

ist eine korrekte Initialisierung, weil 5 eine Konstante ist.


   int j = sqrt( k );

ist nicht korrekt, weil sqrt(k) keine Konstante ist.

Was soll

struct numSel numMemSel[] =
{
  { 1600,  eeBetr_min_1600  },

in diesem Zusammenhang "eeBetr_min_1600" sein?
Es müsste eigentlich eien Konstante sein, deren Wert der COmpiler zur 
Compilierzeit ermitteln kann. Und weil er das nicht kann, darum setzt es 
ein:
error: initializer element is not constant

Das Problem an dieser Stelle ist aber nicht, dass das irgendein 
Schreiweisen-Problem wäre, sondern es ist ein prinzipielles Problem: Du 
hast hier nichts verwendet was konstant wäre. Daher die Meldung.

[Oliver (Gast)]

pal ... schrieb:
> Die Fehlermeldung lautet:../betrStd.c:41: error: initializer element is >not 
constant
> ../betrStd.c:41: error: (near initialization for 'numMemSel[0].memory')

Steht doch alles da.

pal ... schrieb:
> struct numSel numMemSel[] =
> {
>   { 1600,  eeBetr_min_1600  },

Zur Initialisierung von structs sind in C nur echte Konstanten erlaubt, 
keine Variablen (selbst, wenn sie const wären, nicht).

Allerdings ist mir sowieso nicht ganz klar, was du da genau machen 
willst. eeBetr_min_1600 liegt schließlich im eeprom...

Oliver

[Karl H. (kbuchegg)]

Ich kann nur raten, was du da eigentlich vor hattest. Du wolltest dir in 
dieser STruktur die Speicheradressen der Teile im EEPROM ablegen. Hast 
es aber nicht getan.

Die ganze Idee ist aber "flawed". Das machst du ganz anders. Und das 
beginnt damit, dass du den Compiler das EEPROM verwalten lässt.

Du legst dir eine Struktur an

struct ConfigValues
{
  uint16_t eeBetr_h;              // Aktuelle Betriebsstunden
  uint8_t  eeBetr_min_1600;       // Aktuelle Betriebsminuten
  uint8_t  eeBetr_min_3200;       // Aktuelle Betriebsminuten bis 3200h
  ...
};

und von dieser Struktur, gibt es 2 Instanzen.
Die eine existiert im EEPROM

struct ConfigValues eepromValue EEMEM;

und die andere im SRAM

struct ConfigValues Values;

und beim Hochfahren des Programms kopierst du die komplette Struktur aus 
dem EEPROM ins SRAM, bzw. bei Veränderung aus dem SRAM wieder zurück ins 
EEPROM

AVR-GCC-Tutorial: Block lesen/schreiben

[Pal .. (pal)]

danke für die Antworten...

Der Gedanke dabei ist, je nachdem welche betr_std ich erhalte schreibe 
ich auf einen anderen eeprom-speicherplatz

Die zugehörige Funktion lautet:

/*
 * Regelt das Lesen / Schreiben der Betriebsminuten
 * aus / in das EEPORM
 *
 * rw = 0  (read)
 * rw = 1  (write)
 */
void eeManagerMin(uint8_t rw) {

  for(uint8_t i = 0; i < ARRAY_SIZE(numMemSel); i++) {

    if(betr_h < numMemSel[i].memcycl) {

      if(rw == 0) {                            // read
        betr_min = eeprom_read_byte(&numMemSel[i].memory);
        if(betr_min == 255) {
          betr_min = 0;
          eeprom_write_byte(&numMemSel[i].memory, betr_min);      // Defaultwert setzen
        }
      } else if(rw == 1) {                        // write
        if(betr_min >= 60) {
          eeprom_write_byte(&numMemSel[i].memory, 0);
        } else {
          eeprom_write_byte(&numMemSel[i].memory, betr_min);
        }
      }
    }
  }

}

@Karl Heinz: Ich versuche einen Betriebsstundenzähler zu progr und 
möchte jede Minute ins eeprom schreiben.
Aus diesem Grund möchte ich nur einzelne Speicher beschreiben, wenn 
diese ca 100000mal beschrieben sind gehe ich zur nächsten Stelle.

[Karl H. (kbuchegg)]

pal ... schrieb:

> Der Gedanke dabei ist, je nachdem welche betr_std ich erhalte schreibe
> ich auf einen anderen eeprom-speicherplatz

Dazu brauchst du aber die Adresse unter der der Wert im EEPROM abgelegt 
wurde. Also musst du dir auch die entsprechende Adresse in deiner 
Struktur aufheben. Und diese Adresse ist dann auch eine Compiletime 
Konstante.

struct numSel
{
  uint16_t memcycl;                                // Speicherzyklen
  uint8_t* memory;                                // Speicherplatz
};

struct numSel numMemSel[] =
{
  { 1600,  &eeBetr_min_1600  },

....


         betr_min = eeprom_read_byte( numMemSel[i].memory );

[Pal .. (pal)]

Danke Karl Heinz das ist mir nicht aufgefallen.

Nur zur Vollständigkeit:
Das Schreiben erfolgt ebenfalls nach dem gleichen Schema

eeprom_write_byte(numMemSel[i].memory, betr_min);

Danke!!!