E²PROM Ring Puffer

[hacker]

Hallo zusammen,

ich muss eine 4 Byte große Zahl nichtflüchtig ablegen. Jedoch reichen die 100 000 Schreibzyklen des internen E²PROMs nicht aus. Jetzt hab ich mit Anlehnung an die Application Note AVR101 von Atmel versucht, eine Ring Puffer Strukture zu implementieren:

#include <avr/eeprom.h>

#include <circularBuffer.h>

// 1k EEPROM
// 0 - 799 Datenspeicher
// 800 - 999 Pointerspeicher
#define BEGINNING_DATA 0x0000
#define STOP_DATA 0x031F
#define BEGINNING_POINTER 0x0320
#define STOP_POINTER 0x03E7

unsigned char ring_counter = 0;
unsigned short ring_addr = 0;

void init_circularBuffer(void)
{
    
    circularBuffer_findPointerPosition();    

}



void circularBuffer_WriteEEPROM(unsigned long value)
{

    ring_counter++;

    if (ring_addr != STOP_POINTER)
    {
        ring_addr++;
    }else
    {
        ring_addr = BEGINNING_POINTER;
    }

    eeprom_write_dword((unsigned long*)((ring_addr-BEGINNING_POINTER)*4), value);

    eeprom_write_byte((unsigned char*)ring_addr, ring_counter);

}



unsigned long circularBuffer_ReadEEPROM(void)
{

    return eeprom_read_dword((unsigned long*)((ring_addr-BEGINNING_POINTER)*4));

}



void circularBuffer_findPointerPosition(void)
{

    unsigned short i = BEGINNING_POINTER;
    unsigned short j = BEGINNING_POINTER +1;

    while(eeprom_read_byte((unsigned char*)(i))+1 == eeprom_read_byte((unsigned char*)(j)))
    {

        if (i != STOP_POINTER)
        {
            i++;
        }else
        {
            i = BEGINNING_POINTER;    
        }

        if (j != STOP_POINTER)
        {
            j++;
        }else
        {
            j = BEGINNING_POINTER;    
        }

    }
    
    // absolute Addresse im Ring Puffer?
    ring_addr = i;

    ring_counter = eeprom_read_byte((unsigned char*)i);

}

Leider komme ich erst nächste Woche dazu, den Code auf dem Mega32 selber zu testen.

Daher hab ich die Bitte, ob ihr mal vorab drüber schauen könnt.


Eine Frage vorweg noch von mir: Der E²PROM hat ja einen eigenen Speicher/Adressbereich; d.h die Hardware Adressen gehen schon von 0 bis 1023 (im Falle des Mega32 mit 1k internem E²PROM)?

Den Code kann man sicherlich noch schöner mit Pointern schreiben. Mir gehts in erster Linie aber draum, ob das Ding so funktioniert.

Der Datenpuffer kann 200 Werte vom Typ "long" beinhalten, daher müsste ja die Lebensdauer 100 000 * 200 = 20000000 Zyklen betragen, was bei einer geschätzen Häufigkeit von 1000mal Abspeichern pro Tag ca. 55 Jahre Lebensdauer bedeutet.



Viele Grüße,
hacker

[Slein]

Auf die Schnelle seh ich nichts, woran es scheitern sollte.
Aber statt ((ring_addr-BEGINNING_POINTER)*4) könnte ((ring_addr-BEGINNING_POINTER)<<2) schneller sein.

Ich tät lieber ein SRAM mit Lithiumzelle nehmen.
Ein DS1307 z.B. hat 64 byte, schicke Anschlüsse für ne Knopfzelle und ne RTC kann man öfter mal gebrauchen