AVR-GCC-Tutorial: EEPROM

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));

}

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?

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));
}

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.

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 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

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 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.