//----------------------------------------------------------------------------

//Eeprom support module

//----------------------------------------------------------------------------

#include <Main.h>
#include <Eeprom.h>

//------------------------------ Constants: ----------------------------------

#define RBUFF 100 //EEPROM ring buffer size
#define RSIG 0xDA //record header signature

//------------------------------ Variables: ----------------------------------

typedef struct
{
char Sig; //record header signature
bool On; //On flag
int Val; //stored value
} EVal;

__no_init __eeprom int EData[EE_N]; //EEPROM data array
__no_init __eeprom EVal EVals[RBUFF]; //EEPROM ring buffer

static char EePnt = 0; //pointer to currently used record

//-------------------------- Read EEPROM data: -------------------------------

int Eeprom_Read(char a)
{
return(EData[a]); //read parameter
}

//-------------------------- Write EEPROM data: -------------------------------

void Eeprom_Write(char a, int d)
{
if(EData[a] != d) //if parameter changed
{
EData[a] = d; //write parameter
__watchdog_reset(); //watchdog reset
}
}

//-------------------------- Read V from EEPROM: -----------------------------

int Eeprom_ReadV(bool *on)
{
EePnt = RBUFF; //set incorrect pointer value
for(char i = 0; i < RBUFF; i++) //search signature in ring buffer
if(EVals[i].Sig == RSIG) //if signature found
{
EePnt = i; //initialize pointer
break;
}
if(EePnt == RBUFF) //if pointer incorrect (signature not found)
{
EePnt = 0; //set pointer to first array record
*on = 0; //supply off
return(0); //return V = 0
}
*on = EVals[EePnt].On; //read on flag
return(EVals[EePnt].Val); //read V
}

//--------------------------- Write V to EEPROM: -----------------------------

void Eeprom_WriteV(int v, bool on)
{
char NewPnt = EePnt; //save previous pointer value
if(NewPnt++ == RBUFF) //advance pointer
NewPnt = 0; //roll-up pointer
EVals[NewPnt].On = on; //save on flag
EVals[NewPnt].Val = v; //save V
EVals[NewPnt].Sig = RSIG; //save signature at new location
EVals[EePnt].Sig = 0xFF; //clear signature at old location
__watchdog_reset(); //watchdog reset
EePnt = NewPnt; //save new pointer value
}

//----------------------------------------------------------------------------

void js_LoadConfig(void)
{
    U8 *p = (U8 *)(CONFIG_START_FLASH_ADDRESS);
    U8 last_seq = *p;
    U8 *pLastConfig = p;
    U8 buf[sizeof(jsContext.Cfg)];
    PJS_CONFIG pCfg = (PJS_CONFIG)buf;
    int i;

    for (i = 0; i < CONFIG_MIRROR_PAGE_COUNT; i++)
    {
        p += FLASH_PAGE_SIZE_BYTES;
        if (((U8)(last_seq + 1)) == *p)
        {
            last_seq = *p;
            pLastConfig = p;
        }
        else
        {
            p = pLastConfig;
            break;
        }
    }
    // at this point p - points to the address with the most fresh config record
    memcpy( buf, p, sizeof(buf));
    jsContext.LastLocation = (U32)p;
    jsContext.Cfg.Sequence = *p;

    // check CRC of the record
    if ( CRC16( buf, sizeof(buf) != 0 )
    {
        printf("CRC error exp=%2x, cur=%2x, flash_addr=%x, seq=%d\n", hCRC, pCfg->CRC, (U32)p, *p);
        printf("The configuration has NOT been applied!\n" );
        printf("or there is no previously saved configuration.\n");
        // store defaults
        js_StoreConfig();
    }
    else
    {
        // CRC is ok, applying new settings
        memcpy( &jsContext.Cfg, pCfg, sizeof(jsContext.Cfg));
        printf("Configuration applied, seq_%x\n", *p);
    }
}


void js_StoreConfig(void)
{
    jsContext.Cfg.Sequence += 1;
    jsContext.LastLocation += FLASH_PAGE_SIZE_BYTES;
    if (jsContext.LastLocation > CONFIG_LAST_FLASH_CELL_ADDRESS)
        jsContext.LastLocation = CONFIG_START_FLASH_ADDRESS;

    jsContext.Cfg.CRC = CRC16( (U8 *)&jsContext.Cfg, sizeof(jsContext.Cfg) - 2);
    iap_PageWrite( jsContext.LastLocation, (U32 *)&jsContext.Cfg, sizeof(jsContext.Cfg) );

    printf("configuration stored, L(%x), Sq(%x), (%d)bytes\n", jsContext.LastLocation, jsContext.Cfg.Sequence, sizeof(jsContext.Cfg));
}

sn[i+1] - sn[ i ] != 1

#include <stdio.h>

static char str[100];

#define EEPROM_ADDRESS_TO_DESTROY 4094U

uint32_t cycles_;
uint16_t cycles_1000_;

void show_cycles(uint8_t is_failed)
{
if(is_failed)
{
sprintf(str, "\r\nFAILED ON: %ld", cycles_);
}
else
{
sprintf(str, "\r\nCURRENT: %ld", cycles_);
}

for(uint8_t i = 0; i < 100; i++)
{
if(str[i]) USB_TransmitByte(str[i]);
else break;
}
}

void eeprom_write_no_check(uint16_t address, uint8_t data)
{
while(EECR & _BV(EEWE));

EEAR = address;

EEDR = data;

ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
{
EECR |= _BV(EEMWE);
EECR |= _BV(EEWE);
}
}

uint8_t eeprom_read_no_check(uint16_t address)
{
while(EECR & _BV(EEWE));

EEAR = address;

EECR |= _BV(EERE);

return EEDR;
}


__attribute__((OS_main)) int main(void)
{
USB_Initialize();

sei();

for(;;)
{
eeprom_write_no_check(EEPROM_ADDRESS_TO_DESTROY, 0xFF);

++cycles_;
++cycles_1000_;

if(eeprom_read_no_check(EEPROM_ADDRESS_TO_DESTROY) != 0xFF)
{
show_cycles(TRUE);

for(;;);
}

if(cycles_1000_ == 1000)
{
cycles_1000_ = 0;

show_cycles(FALSE);

for(uint8_t data = 1; data; data <<= 1)
{
eeprom_write_no_check(EEPROM_ADDRESS_TO_DESTROY, data);

++cycles_;
++cycles_1000_;

if(eeprom_read_no_check(EEPROM_ADDRESS_TO_DESTROY) != data)
{
show_cycles(TRUE);

for(;;);
}
}
}

if(USB_IsDataReceived())
{
if(USB_ReceiveByte() == '?')
{
show_cycles(FALSE);
}
}
}

return 0;
}

// ...
CURRENT: 3236000
CURRENT: 3237000
CURRENT: 3238000
FAILED ON: 3238008

// Перезапуск по питанию

CURRENT: 1000
FAILED ON: 1008

// Перезапуск по питанию

CURRENT: 1000
CURRENT: 2000
CURRENT: 3000
CURRENT: 4000
CURRENT: 5000
WRITTEN: 36 // Проверка записи всё в тот же адрес
READ: 36 // Результат чтения
WRITTEN: 34
READ: 34
WRITTEN: 30
READ: 30
CURRENT: 6000
CURRENT: 7000
CURRENT: 8000
CURRENT: 9000
FAILED ON: 9008

// ...
CURRENT: 3326000
CURRENT: 3327000
FAILED ON: 3327762

// перезапуск

// ...
CURRENT: 99000
CURRENT: 100000
FAILED ON: 100889

// перезапуск

// ...
CURRENT: 101000
CURRENT: 102000
FAILED ON: 102918