Structure Array ins EEPROM

[John S. (student)]

Hallo zusammen,

ich möchte ein zweidimensionales Array Feld für Feld (Indizees [Rx][Ry]) 
ins EEPROM Mega128 schreiben und wieder Feld für Feld lesen:
--------------------------------------------------------------------

#define PBMP_X (2*134+1)
#define PBMP_Y (2*179+1)

extern  int16_t Rx, Ry;

struct Railway
    {uint8_t GlbNr;
     uint8_t Valid;
    };

extern struct Railway RailPointer [PBMP_X/15+1][PBMP_Y/15+1];
struct Railway eeRailPointer [PBMP_X/15+1][PBMP_Y/15+1] EEMEM;

void EEPROM_RP_write (struct Railway RailPointer[Rx][Ry])
{
eeprom_write_block(&RailPointer[Rx][Ry],&eeRailPointer[Rx][Ry],sizeof(st 
ruct  Railway));
}

void EEPROM_RP_read (struct Railway RailPointer[Rx][Ry])
{
  eeprom_read_block(&RailPointer[Rx][Ry],&eeRailPointer[Rx][Ry],sizeof(str 
uct  Railway));
}

-------------------------------------------------------

Irgendwie funzt das aber nicht - liegt der Fehler vielleicht irgendwo 
hier im Code ?

Vielen Dank für Eure Hilfe

[holger (Gast)]

PBMP_X = 2*134+1 = 269

PBMP_X/15+1 = 18.93333

Das als Index für ein Array. Na ich weiss nicht :(

[Martin L. (melvin_the_moose)]

> PBMP_X = 2*134+1 = 269
>
> PBMP_X/15+1 = 18.93333

Das ist Integerarithmetik, das Ergebnis läßt sich sehr wohl als Index 
für ein Array verwenden. Die Nachkommastellen gehen dann verloren.

[holger (Gast)]

@ Martin

extern struct Railway RailPointer [18.93333][24.93333];

Ach komm das sieht doch scheisse aus.
Möglicherweise wollte er [19][25], aber das kommt da
bei den Berechnungen halt nicht raus.

[Martin L. (melvin_the_moose)]

holger wrote:

> Ach komm das sieht doch scheisse aus.
> Möglicherweise wollte er [19][25], aber das kommt da
> bei den Berechnungen halt nicht raus.

Eigentlich hast Du recht. Aber andererseits: vielleicht hat Charly 
deshalb "+1" bei der Definition der Arraygröße angegeben?
Ohne weitere Info ist es jedenfalls ein Blick in die Glaskugel.
-Was "funzt" nicht?
-Was sollen diese Variablen abbilden (wie kommt man auf die Definition 
dieser Arraygröße)?

[John S. (student)]

Hallo,

erst mal Danke für die ersten Inputs. Die Indizees (deinitiv Integer) 
sind o.k. - das ist es nicht.

Mir kommt es mehr auf das Verständnis an, ob ich die EEPROM Strukturen 
richtig deklariert habe. Geht das so mit der Structure und dem Array 
bzw. seiner Felder ?

Kann ich also ein Array Feld für Feld ansprechen ? Stimmt dann die 
sizeof Abfrage ? Sind die EEPROM function calls richtig ?

[Martin L. (melvin_the_moose)]

> Kann ich also ein Array Feld für Feld ansprechen ?
Ja, denn das ist der Zweck eines Arrays.

> Stimmt dann die sizeof Abfrage ?
Ein "sizeof(Typname)" gibt die Größe des Typs zurück. Wenn die Funktion 
das an dieser Stelle erwartet: ja.

> Sind die EEPROM function calls richtig ?
Keine Ahnung. Kommt auf die Signatur der Funktionen und den Zweck an. 
Wenn die Funktionen Zeiger auf Elemente des Typs struct Railway erwarten 
und Rx, Ry vorhanden und initialisiert sind: ja.

Wie ist denn das genaue Fehlverhalten (Compilerfehler, 
LAufzeitfehler...)?

Außerdem habe ich ein Verständnisproblem mit der Definition von
> struct Railway eeRailPointer [PBMP_X/15+1][PBMP_Y/15+1] EEMEM;

Wofür steht das EEMEM: ohne das EEMEM wäre dies einfach ein 2-dim. Array 
namens eeRailPointer mit Elementen des Typs struct Railway. (Liegt 
vielleicht daran, daß ich selber selten mit Arrays of struct arbeite...)

[John S. (student)]

Also der Compiler zeigt 0 warnings und 0 errors. Programm läuft. Aber 
das, was ich speichere kann ich nicht wieder lesen (scheint verloren). 
Entweder habe ich fehlerhaft gespeichert, oder der Lesevorgang funzt 
nicht oder beides.

Muss man was an den Fuses verändenr ?

[John S. (student)]

Hallo zusammen,

vielleicht liest noch mal jemand mein Problem:

Witzigerweise klappt das Programm in der Simulation Studio einwandfrei 
(in den EEPROM Strukturen wird gespeichert) - nur der Mega128 tut nicht 
das was ich will.

Definitiv hat das EEPROM noch keine 100.000 Speicherzyklen hinter sich - 
mit dem EEPROM arbeite ich zum ersten Mal.

Was könnte das sein ? Soweit ich weiss werden die Interrupts doch in der 
AVR Library während der Schreib und Lesezyklen ausgeschaltet - oder ?

Bin echt ratlos - hatte schon jemand dieses Problem ?

Grüsse

[John S. (student)]

Also,

das Problem ist definitiv ein Problem des function Aufrufs - Übergabe 
Parameter !
Wenn ich ein einzelnes Byte ins EEPROM abspeichere und wieder lese, dann 
funzts.

Also, was ist bei der Structure Übergabe bei den function calls falsch ?

Leider bin ich mit structures wenig geübt. Ist die size-of Abfage o.k. - 
ich frage ja lediglich die Breite des Records ab - nicht die gesamte 
Array - Grösse - ist das o.k. so oder muss ich die gesamte Arraygrösse 
in size-of übergeben ?

Grüsse

[John S. (student)]

Charly Grosse wrote:
> Hallo zusammen,
>
> ich möchte ein zweidimensionales Array Feld für Feld (Indizees [Rx][Ry])
> ins EEPROM Mega128 schreiben und wieder Feld für Feld lesen:
> --------------------------------------------------------------------
>
> #define PBMP_X (2*134+1)
> #define PBMP_Y (2*179+1)
>
> extern  int16_t Rx, Ry;
>
> struct Railway
>     {uint8_t GlbNr;
>      uint8_t Valid;
>     };
>
> extern struct Railway RailPointer [PBMP_X/15+1][PBMP_Y/15+1];
> struct Railway eeRailPointer [PBMP_X/15+1][PBMP_Y/15+1] EEMEM;
>
> void EEPROM_RP_write (struct Railway RailPointer[Rx][Ry]) //<= Fehler !!
> {
> eeprom_write_block(&RailPointer[Rx][Ry],&eeRailPointer[Rx][Ry],sizeof(st ruct
> Railway));
> }
>
> void EEPROM_RP_read (struct Railway RailPointer[Rx][Ry]) //<= Fehler
> {
>   eeprom_read_block(&RailPointer[Rx][Ry],&eeRailPointer[Rx][Ry],sizeof(str uct
> Railway));
> }
>
> -------------------------------------------------------
>
> Irgendwie funzt das aber nicht - liegt der Fehler vielleicht irgendwo
> hier im Code ?
>
> Vielen Dank für Eure Hilfe

Fehler gefunden: (siehe Markierung <= Fehler (oben))

Offensichtlich wird hier ein neuer Speicherbereich im Funktionsaufruf 
vereinbart(der natürlich leer ist).
Wenn ich nämlich Pointer auf den externen Speicherbereich übergebe, 
funzt es.

Andere Möglichkeit (ungetestet) würde wahrscheinlich so lauten:
   void EEPROM_RP_read (extern struct Railway RailPointer[Rx][Ry])

Danke für Eure Mithilfe & Grüsse