Array mit vorzeichen im eeprom Speichern

[neuling (Gast)]

ich versuche grade mein array im eeprom des atmega128 zu speichern,beim 
lesen aus dem eeprom erhalte ich komische werte auch das vorzeichen wird 
nich richtig gelesen.
die Routinen sind hier aus dem Tutorial.

int i;
signed int Wert[19]; 
Wert[1] = -20; 

        for(i=0; i<19; i++)
         {
          EEPWriteByte( 10+i,Wert[i]);
          
         }

        for(i=0; i<19; i++)
         {
          Wert[i]=EEPReadByte(10+i);
          
         }

[holger (Gast)]

Dein signed int hat zwei Byte. Du speicherst
und liest nur ein Byte.

[neuling (Gast)]

Muss ich denn anstatt EEWritebyte  denn EEWriteWort benutzen
bitte um Nachsicht.
int i;
 signed int Wert[19];
 Wert[1] = -20;

         for(i=0; i<19; i++)
         {
           EEPWriteWort( 10+i,Wert[i]);

          }

         for(i=0; i<19; i++)
          {
           Wert[i]=EEPReadWort(10+i);

          }

[neuling (Gast)]

hallo,
kann mir von ihnen keiner weiterhelfen wie ich die werte speichern kan
mfg

[Tristan L (Gast)]

Ich würde sagen bleib bei dem byte. aber mach Typecasts

 uint8_t Wert[19];
int Wert2[19]; //Nur zum vergleichen
 Wert[1] = (uint8_t)-20;

         for(i=0; i<19; i++)
         {
           EEPWriteByte( 10+i,Wert[i]);

          }

         for(i=0; i<19; i++)
          {
           Wert2[i]=(int)EEPReadByte(10+i);

          }

Wichtig: nur Werte von -128 bis 127 sind möglich

[neuling (Gast)]

Leider Funktioniert das auch nicht,
Die -20 können zb. in Wert[2],Wert[10]
drin stehen.
mfg

[Johann L. (gjlayde)]

AVR-GCC-Tutorial: EEPROM

[neuling (Gast)]

ich hab das jetzt so aber so gehts auch nicht.
Denn beim Compilieren kommen 2 Warnings bei eeprom_write_word und 
eeprom_read_word.
vielleicht kann von ihnen noch einer weiterhelfen
mfg

int i;
signed int Wert[19]; 
Wert[1] = -20; 
Wert[8] = -18; 

        for(i=0; i<19; i++)
         {
          
          eeprom_write_word(&10+i,Wert[i]);
         }

        for(i=0; i<19; i++)
         {
          Wert[i]=eeprom_read_word(&10+i);
          
         }

[Vlad T. (vlad_tepesch)]

warum überhaupt so kompliziert?

#include <avr/eeprom.h>


#define SOMELARGEDATA_LENGTH 19
struct MyEepromData{
  int someData;
  int someOtherData;
  int someLargeData[SOMELARGEDATA_LENGTH];
};


// eeprom daten dem Compiler auch bekannt machen
// dann entfällt das merken und von Hand rumrechnen der eeprom adressen
// außerdem könnte man die Daten auch so gleich intialisieren
// (das gibt dann nach dem kompilieren einn .eep-File
struct MyEepromData EEMEM g_eepromData = // this reserves place in eeprom
{
  5, 7, {7,8,9,/* .. */},
}

// ...

void someFunction()
{
  struct MyEepromData workingCopy;
  // das ist alles was du brachst um Daten zu lesen:
  eeprom_read_block(&workingCopy, &g_eepromData, sizeof(g_eepromData));

  // oder wenn man dann wirklich nur das array braucht
  int array[SOMELARGEDATA_LENGTH];
  eeprom_read_block(&array, &(g_eepromData.someLargeData), sizeof(g_eepromData.someLargeData));

  //Analog dazu das schreiben:
  eeprom_write_block(&workingCopy, &g_eepromData, sizeof(g_eepromData));
  
  // bzw:
  eeprom_write_block(&array, &(g_eepromData.someLargeData), sizeof(g_eepromData.someLargeData));

}

[neuling (Gast)]

Erstmal vielen Dank für ihre Hilfe,
Die daten im array werden ja während das Programm im Atmega läuft
ja auch verändert ,mein Problem ist ja wie ich das vorzeichen zb.-20
im eeprom speichern und lesen kann.
mfg

[Johann L. (gjlayde)]

Verwende den richtigen Typ und fertig.

Ums Vorzeichen brauchst dich dann ebensowenig zu kümmern wie darum, ob 
die Zahl gerade ist oder ungerade oder ne Primzahl.

Was verstehst du am oben verlinkten Tutorial nicht?

[neuling (Gast)]

Wenn ich mein array als int wert[19] Deklariere und mit den Funktionen 
aus dem Tutorial
eepreadbyte und eepwritebyte kann ich das array an die gewünschte 
adresse speichern und lesen aber ohne Vorzeichen und so wie ichs jetzt 
habe gehts nicht das ist zurzeit mein problem.

wie muss ich den richtigen Type verwenden?
mfg

[Johann L. (gjlayde)]

Funktionen zum Lesen eines Bytes passen nicht gut, wenn man zwei davon 
lesen will.

Was spricht gegen sowas?

#include <avr/eeprom.h>

int a_ram[19];
int a_ee[19] EEMEM;

void read (void)
{
    eeprom_read_block (a_ram, a_ee, sizeof (a_ee));
}

[Karl H. (kbuchegg)]

neuling schrieb:
> Wenn ich mein array als int wert[19] Deklariere und mit den Funktionen
> aus dem Tutorial
> eepreadbyte und eepwritebyte

vergiss ee_read_byte bzw. ee_write_byte
Du hast nun mal keine einzelnen Bytes!

Du kannst dein Array im weitesten Sinne als einen Block von Bytes 
auffassen und damit ee_read_block bzw. ee_write_block benutzen, so wie 
Vlad das da oben gezeigt hat.

Klar bricht sich diese Funktion das dann auch wieder in Bytes runter. 
Aber danmn macht es die Funktion und du brauchst es nicht machen.

Ist doch ganz einfach.

[Karl H. (kbuchegg)]

neuling schrieb:
> Wenn ich mein array als int wert[19] Deklariere und mit den Funktionen
> aus dem Tutorial
> eepreadbyte und eepwritebyte kann ich das array an die gewünschte
> adresse speichern und lesen aber ohne Vorzeichen

Dein Problem war nicht das Vorzeichen an sich, sondern dass du ganz am 
Anfang nur die Hälfte gespeichert bzw. gelesen hast.

Du musst zwischen 'Problem' und 'Symptom' unterscheiden lernen. Was du 
gesehen hast war das Symptom. Dein Problem war aber ein ganz anderes.

[neuling (Gast)]

hallo,
Mit Stucts habe ich bisher noch nicht gearbeitet,
ich hab 2 Drehencoder einen für die array-nummer 1-19 ist gleichzeitig 
auch die eep-adresse, der andere stellt den wert ein im array.
Die eep-werte weiss ich vorher nicht wird über den Drehencoder 
eingestellt daher weiss ich auch nicht wie ich die eep-adresse mit dem 
struct einstellen kann.

ich habs jetzt so meine werte werden auch gespeichert, nun kommen 
allerdings 2 warnings:
passing argument 2 of 'eeprom_write_block' makes pointer from integer
without a cast
passing argument 2 of 'eeprom_read_word' makes pointer from integer 
without a cast


mfg

signed int Wert[19]; 
int b = 0x20;           //eep-adresse
Wert[1] = -20; 
Wert[8] = -18; 

        
          
          eeprom_write_word(Wert, b, sizeof(Wert));
         


          Wert[i]=eeprom_read_word(Wert, b, sizeof(Wert));

[Karl H. (kbuchegg)]

neuling schrieb:
> hallo,
> Mit Stucts habe ich bisher noch nicht gearbeitet,

dann lass sie weg.


> ich habs jetzt so meine werte werden auch gespeichert, nun kommen
> allerdings 2 warnings:
> passing argument 2 of 'eeprom_write_block' makes pointer from integer
> without a cast
> passing argument 2 of 'eeprom_read_word' makes pointer from integer
> without a cast
>
>
> mfg
>
>

> signed int Wert[19];
> int b = 0x20;           //eep-adresse
> Wert[1] = -20;
> Wert[8] = -18;
> 
> 
> 
>           eeprom_write_word(Wert, b, sizeof(Wert));
> 
> 
> 
>           Wert[i]=eeprom_read_word(Wert, b, sizeof(Wert));
> 
> 
>

wie passt diese 'Code' zu einer Fehlermeldung die über eine Funktion 
eeprom_write_block spricht? Richtig. Gar nicht.

* Möglichkeit 1

int Wert[0];
int Wert_Eeprom[19] EEMEM;

// nur einen einzelnen Wert aus dem Array im EEPROM transferieren
int readWert(uint8_t index)
{
  return (int)eeprom_read_word((uint16_t*)&Wert_Eeprom[index]);
}

void writeWert( uint8_t index, int Wert )
{
  eeprom_write_word( (uint16_t*)&Wert_Eeprom[index], (uint16_t)Wert );
}

int main()
{
  ....

  Wert[0] = readWert( 0 );
  Wert[1] = readWert( 1 );

  ...

  for( i = 5; i < 15; i++ )
    Wert[i] = readWert( i );

  ...

  writeWert( 0, Wert[0] );
  writeWert( 1, Wert[1] );

  ...

  for( i = 8; i < 19; i++ )
    writeWert( i, Wert[i] );

  ...
}

* Möglichkeit 2

int Werte[19];
int Wert_Eeprom[19] EEMEM;

// alle Werte auf einmal von SRAM ins EEPROM und umgekehrt

void transferWerteToSRAM()
{
  eeprom_read_block( Werte,  Wert_Eeprom, sizeof(Werte) );
}

void transferWerteToEEprom()
{
  eeprom_write_block( Werte,  Wert_Eeprom, sizeof(Werte) );
}

int main()
{
  ...
  transferWerteToSRAM();

  ...

  Wert[0] = 876;
  Wert[12] = -67;

  ...

  transferWerteToEEprom();

  ...
}

* Möglichkeit 3
  Mischen von Mögl. 2 und Mögl. 1
  Am Anfang des Programm werden alle Werte auf einmal ins SRAM
  übertragen. Wird ein Wert verändert, dann wird dieser eine Wert
  und nur dieser eine Wert wieder ins EEprom zurückgeschrieben

[Vlad T. (vlad_tepesch)]

neuling schrieb:
> ich habs jetzt so meine werte werden auch gespeichert, nun kommen
> allerdings 2 warnings:
> passing argument 2 of 'eeprom_write_block' makes pointer from integer
> without a cast
> passing argument 2 of 'eeprom_read_word' makes pointer from integer
> without a cast

das wird auch nicht funktionieren
du hast ein array mit intwerten (2 byte breit)
und du indizierst einen Byte-Addressierten Speicher mit den in deimem 
Wert enthaltenen fortlaufenden Adressen
das eeprom-Layout sieht also folgender maßen aus:

Byte   1 2 3 4 5 6 7 8 9 ...
Daten  [ 0][ 1][ 2][ 3]  ...

Du beschreibst aber so:
Byte   1 2 3 4 5 6 7 8 9 ...
Daten  [ 0]
         [ 1]
           [ 2]
             [ 3]  ...

Deine geschriebene Werte überlappen sich.

MAch es vernünftig.
Leg eine eeprom-Variable ab und beschreib diese, so wie ich es oben 
geschrieben habe.

int EEMEM g_eepromWert[19]; // this reserves place in eeprom
int       g_Wert[19]; // this holds the working copy 


// am Prgrammbegin einlesen:
eeprom_read_block (g_Wert, g_eepromWert, sizeof (g_eepromWert));


// arbeiten ganz normal auf dem ram array (g_Wert)



// und irgendwann zurückschreiben
eeprom_write_block (g_Wert, g_eepromWert, sizeof (g_eepromWert));


sollen wirklich einzelne WErte geschrieben werden, kann man das genauso machen
int indxex;
int wert;
eeprom_read_block ( &wert, &(g_eepromWert[index]), sizeof (wert));
eeprom_write_block ( &wert, &(g_eepromWert[index]), sizeof (wert));

[neuling (Gast)]

erstmal vielen Dank an ihnen,
ich habe jetzt noch eine Frage,ich möchte gerne die eeprom schreib und 
lese routine in eine Funktion legen, doch leider kommt ein error und 2 
warnings beim block lesen und schreiben.
vielleicht kann mir von ihnen noch ein tipp geben.
mfg

// Block aus dem EEPROM lesen
int EEPReadBlock(uint16_t adress,int array)
{
  return (int)eeprom_read_block(array,(uint16_t *)&adress, array);
}

// Block in das EEPROM schreiben
void EEPWriteBlock(uint16_t adress, int array)
{
  eeprom_write_block(array,(uint16_t *)&adress, sizeof (array));
}

Aufruf zum lesen
EEPReadBlock(0x20,int Wert);

Aufruf zum schreiben
EEPWriteBlock(0x20,int Wert);

[Patrick (Gast)]

neuling schrieb:
> Aufruf zum lesen
> EEPReadBlock(0x20,int Wert);

Naja, DAS kann ja nicht gehen... Mehr verrat' ich nicht, da Du uns ja 
auch nicht die Fehlermeldungen verraten willst :-P

[neuling (Gast)]

die Fehlermeldung lautet:

EEPReadBlock:
passing argument 2 of 'eeprom_write_block' makes pointer from integer
without a cast
invalid use of void expression

EEPWriteBlock:
passing argument 2 of 'eeprom_write_block' makes pointer from integer
without a cast

mfg

[Karl H. (kbuchegg)]

neuling schrieb:

> vielleicht kann mir von ihnen noch ein tipp geben.

Ja.
Warum versuchst du schon wieder dein eigenes Süppchen zu kochen, wenn du 
nichts davon verstehst?
Kauf dir ein C-Buch und arbeite es durch. Irgendwann wird dir der 
Unterschied zwischen Adressen und 'Wert an einer Adresse' unterkommen 
und dann arbeitest du die im Buch angegebenen Übungen besonders 
sorgfältig durch. So jedenfalls macht das momentan überhaupt keinen 
Sinn. Du schreibst einfach irgendwas hin und hoffst, das das richtige 
schon dabei sein wird.