32BIT Variable in ATMEGA EEPROM direkt speichern

[Manuel K. (Gast)]

Hallo an alles AVR-FREUNDE:

32Bit im EEPROM speichern und auslesen.

hab die klassische EEPROM Routinen für AVR die hier überall im netz 
rumfliegen etwas erweitert.
Diese Routinen können Byte-Weise das interne EEPROM auslesen.
nur blöd dass die meisten daten die man so in einem prog hat, halt 
größer sind als 8Bit ..

nun kann man direkt eine integer variable im EEPROM speichern.
Es kann sowohl eine usigned int , als auch signed gespeichert werden.

viel Spass damit.

Verbesserungsvorschläge &  Fragen jederzeit willkommen.

Gruß, Manuel

[Karl H. (kbuchegg)]

Hast du dir schon mal die Funktionen angesehen, die mit
dem gcc mitgeliefert werden und in avr/eeprom.h vorhanden sind?

uint8_t eeprom_read_byte (const uint8_t *addr);
uint16_t eeprom_read_word (const uint16_t *addr);
void eeprom_read_block (void *pointer_ram,
                        const void *pointer_eeprom,
                        size_t size);
void eeprom_write_byte (uint8_t *addr,uint8_t value);
void eeprom_write_word (uint16_t *addr,uint16_t value);
void eeprom_write_block (const void *pointer_ram,
                         void *pointer_eeprom,
                         size_t size);

[Karl H. (kbuchegg)]

> void write_32bit_value_(signed int value, unsigned short start_address){
> // beispiel:
> // write_32bit_value_(messwert,0x00);
>
> unsigned char byte[4];
> int i;
> byte[0] = (char) value;
> byte[1] = (char) (value >>8);
> byte[2] = (char) ((value >>8)>>8);
> byte[3] = (char) (((value >>8)>>8)>>8);
>
> for (i=0;i<=4;i++)

Fehler. Du schreibst hier 5 Bytes, nicht 4!
Die Lesefunktion hat den gleichen Fehler. Nur ist er dort
ungleich folgenschwerer. Hier wird nur out-of-bounds gelesen,
in der Leseroutine wird aber out-of-bounds geschrieben.


>   eeprom_write (start_address+i,byte[i]);
>
> }

Das wär auch einfacher gegangen:

void write_32bit_value_( unsigned short start_address, signed int value )
{
  unsigned char i;
  unsigned char* tmp = (unsigned char*)&value;

  for( i = 0; i < sizeof( value ); ++i )
    eeprom_write( start_address++, *tmp++);
}

oder unter Benutzung der gcc Routinen (am Beispiel von float)

void write_float( unsigned short start_address, float value )
{
  eeprom_write_block( (void*)start_adress, &value, sizeof( value ) );
}

[Fab (Gast)]

Oder so:

eeprom_write_dword ((uint32_t *)eeprom_start_address, uint32_t_variable);

[Gast (Gast)]

Was ist denn ein "signed int"?

Wusste garnicht, dass die Kombination überhaupt zulässig ist ... wird 
aber wohl nichts anderes machen als "int", oder?

Grüße
Gast