EEPROM Emulieren auf Atmel SAM4E APP Note

[Jannik (Gast)]

Ich versuche mich in der EEPROM Emulation bei einem Atmel SAM4E8C.
Zunächst einmal habe ich die Funktionen aus dem Atmel APP Note AT4066 
übernommen siehe Source unten.
Funktionieren tut es auch auf anhieb, zuerst wird die eep_init() 
aufgerufen, dann kann man ein paar Bytes aus einem Buffer über 
eep_write() in den Flash schreiben und über eep_read() auslesen.
eep_read() liest übrigens nicht immer aus dem flash - nach dem 
eep_init() ist der Flash Inhalt im RAM => eep_buffer Array.

Folgendes Problem:

eep_init();
eep_write(3Byte siehe Abbildung Nr. 1);
eep_write(3Byte siehe Abbildung Nr. 2);
eep_write(3Byte siehe Abbildung Nr. 3);

=> Im Flash sind nur die 3 Bytes vom letzten eep_write passend, die 
anderen Bytes wurden wieder auf 0xff gelöscht.
Das ist asynchron zum eep_buffer, bei dem der Inhalt aller 3 eep_write 
korrekt ist siehe Abbildung.

Frage: Soll das so? Gibt es hier einen Sinn warum nicht immer der ganze 
eep_buffer in den Flash geschrieben wird? Meine Erwartung war, dass der 
eep_buffer synchron zum Flash gehalten wird.

static int8_t get_eep_block(uint8_t * data)
{
  #if(EEPROM_SIZE == 511)
  if(data[0] & 0x01)
  return 0;
  #elif (EEPROM_SIZE == 255)
  if(data[0] & 0x01)
  return 0;
  else if(data[256] & 0x01)
  return 1;
  #elif((EEPROM_SIZE == 127))
  if(data[0] & 0x01)
  return 0;
  else if(data[128] & 0x01)
  return 1;
  else if(data[256] & 0x01)
  return 2;
  else if(data[384] & 0x01)
  return 3;
  #endif
  return -1;
  
  
}

uint8_t eep_init(void)
{
  
  uint8_t page_walker;
  uint8_t page_buffer[PAGE_SIZE];
  
  for(int i =0; i < EEPROM_SIZE ;i++)
  {
    eep_buffer[i] = 0xff;
  }
  
  //Find the page and block index for the valid writable page.
  for(page_walker = 0; page_walker < NUMBER_PAGES; page_walker++)
  {
    memcpy(page_buffer, (const void *)(FLASH_START + page_walker*PAGE_SIZE), sizeof(page_buffer));
    current_eep_index = get_eep_block(page_buffer);
    current_page = page_walker;
    if(current_eep_index >= 0)
    break;
  }
  
  
  //if no page found, then the last page was the valid one. select the last block and put the data into buffer
  if(page_walker == NUMBER_PAGES)
  {
    for(int i  = 0; i < EEPROM_SIZE; i++)
    #if(EEPROM_SIZE == 511)
    eep_buffer[i] = page_buffer[i + 1];
    #elif(EEPROM_SIZE == 255)
    eep_buffer[i] = page_buffer[i + 257];
    #elif(EEPROM_SIZE == 127)
    eep_buffer[i] = page_buffer[i + 385];
    #endif
    current_eep_index = 0;
    current_page = 0;
    
    //since all pages are dirty, erase before next write to page 0
    erase_flag = 1;
    
  }
  // if page was found, move one block back and copy the data
  else
  {
    //First block of a page, means data to be read in the last block of the previous page
    if(current_eep_index == 0)
    {
      memcpy(page_buffer, (const void *)(FLASH_START + ((current_page-1)*PAGE_SIZE)), sizeof(page_buffer));

      for(int i  = 0; i < EEPROM_SIZE; i++)
      #if(EEPROM_SIZE == 511)
      eep_buffer[i] = page_buffer[i + 1];
      #elif(EEPROM_SIZE == 255)
      eep_buffer[i] = page_buffer[i + 257];
      #elif(EEPROM_SIZE == 127)
      eep_buffer[i] = page_buffer[i + 385];
      #endif
    }
    //if it is within a page, go to previous block and fetch the data
    else
    {
      for(int i  = 0; i < EEPROM_SIZE; i++)
      eep_buffer[i] = page_buffer[((current_eep_index-1)*(EEPROM_SIZE+1))+1 + i];
    }
    
  }
  
  return 1;
  
}

uint8_t eep_write(uint8_t* data, uint16_t address, uint16_t size )
{
  uint32_t flash_start = FLASH_START;
  uint8_t page_buffer[PAGE_SIZE];
  
  for(int i = 0; i < PAGE_SIZE; i++){
//     if ()
//     page_buffer[i] = eep_buffer[i];
    page_buffer[i] = 0xff;
  }
  
  //
  
  if(size + address > EEPROM_SIZE)
  return 0;
  
  //If we have wrapped around the reserved 16 pages, delete everything
  if(current_page == 0 && (erase_flag) && (current_eep_index == 0))
  {
    //These commands could be different for different controllers.
    flash_erase_page(FLASH_START, IFLASH_ERASE_PAGES_8);
    flash_erase_page(FLASH_START + (PAGE_SIZE*8), IFLASH_ERASE_PAGES_8);
  }
  
  for(int i = 0; i < size; i++)
  {
    //clear valid flag
    page_buffer[(current_eep_index*(EEPROM_SIZE+1))] = 0x00;
    page_buffer[i + address + (current_eep_index*(EEPROM_SIZE+1)) + 1] = data[i];
    eep_buffer[i + address] = data[i];
  }
  flash_write(((FLASH_START + current_page*PAGE_SIZE)), (const void *)page_buffer, sizeof(page_buffer), 0);
  
  #if(EEPROM_SIZE == 511)
  current_page++;
  
  #elif(EEPROM_SIZE == 255)
  current_eep_index++;
  if(current_eep_index > 1)
  {
    current_page++;
    current_eep_index = 0;
  }
  #elif(EEPROM_SIZE == 127)
  current_eep_index++;
  if(current_eep_index > 3)
  {
    current_page++;
    current_eep_index = 0;
  }
  #endif
  if(current_page > 15)
  {
    current_page = 0;
    erase_flag = 1;
    current_eep_index = 0;
  }
  return 1;
}

uint8_t eep_read(uint8_t* data, uint16_t address, uint16_t size )
{
  if(size + address > EEPROM_SIZE)
  return 0;
  for(int i = 0; i < size; i++)
  {
    data[i] = eep_buffer[address + i];
  }
  return 1;
}

[Jannik (Gast)]

Ich habs jetzt einfach geändert sodass der alte Inhalt immer wieder 
mitgeschrieben wird. Aber wenn einem was einfällt, warum man soetwas wie 
unten steht gebrauchen kann oder es ggf. mehr Sinn macht lasst es mich 
bitte wissen. Ist für mich Neuland. Vielleicht gibt es hier Vorteile die 
ich nicht sehe.

in der eep_write() habe ich folgendes angepasst:

//   for(int i = 0; i < PAGE_SIZE; i++){
//     page_buffer[i] = 0xff;
//   }
  
  //Modifiziert, sodass alte Werte, welche bereits über eep_write beschrieben wurden erhalten bleiben
  page_buffer[0] = 0xff;
  
  for(int i = 0; i < PAGE_SIZE; i++){
    page_buffer[i+1] = eep_buffer[i];
  }
  //Modi Ende

Gruß

[Marco H. (damarco)]

Das Problem besteht darin das du nicht verstanden hast wie der memory 
Controller funktioniert. Dieser ließt bzw. schreibt (ich habe nicht 
nachgeschaut) in einen Cache der z.bsp 64byte groß ist. Nicht nur das, 
du musst deine EEROM Simulation korrekt Initialisieren. So das sich auch 
richtig funktioniert. Der Controller schützt dann diese Bereiche. Man 
kann nicht wild irgend wo in den Flash schreiben, bzw. man sollte es 
nicht.

Hier wird wohl die Page gelöscht und neu geschrieben, hierzu mal in das 
Register schauen mit welchen Mode geschrieben wird. Meist wird die Page 
erst gelöscht und neu beschrieben. Das macht aber keine Routine sondern 
der Controller! Dieser löscht die Page und schreibt den Inhalt vom Cache 
dort hinein.

Damit sind alte Daten weg und das kann man verhindern wenn man den EEROM 
bzw. Flash entsprechend organisiert. So das Inhalte die Unabhängig von 
einander sind erhalten bleiben.

[Adam P. (adamap)]

Hey Jannik,

ich arbeite auch mit einem SAM4E und habe die Funktionen
- flash_write(...)
- flash_read(...)
- flash_erase_page(...)

für ein Bootloader verwendet, womit ich kaum glauben konnte das es in 
dem Bsp. solche Probleme gibt...

Was mich jedoch überhaupt wundert: Bei dir dürften die Werte NIEMALS 
wirklich im Flash gespeichert werden (habe das Atmel Bsp. mal getestet)
-> es fehlt der flash_init(...) Aufruf!

Klar ist: der Flash Controller lässt es nicht zu einzelne Bytes (weniger 
wie 32 Bit) zu speichern, bzw. ist der Zustand der drumherum liegenden 
dann nicht definiert (siehe Datenblatt).

Auszug aus der flash_efc.c:

/* Write page.
* Writing 8-bit and 16-bit data is not allowed and may lead to
* unpredictable data corruption.
*/

Ich würde an deiner Stelle die Idee so aufnehmen, jedoch mir die EEPROM 
Funktionen selbst schreiben:
- Bei init() wird die aktive Page im Flash gesucht und in den globalen 
eeprom_buf kopiert.
- Bei write() kopierst die übergebenen Daten in eeprom_buf und schreibst 
ihn auf die nächste Flash Page.
- Bei read() kannst dann direkt aus eeprom_buf lesen, da dieser dann 
wirklich die Kopie der aktiven Flash Page ist.

Dann ist die Funktion die gleiche wie im Bsp., warum das Bsp. jedoch so 
programmiert wurde und dann noch fehlerhaft ...? Naja, ist nicht das 
erste mal, dass ich Fehler in Bsp. oder ASF von Atmel finde. Da muss 
wohl jeder durch ;-)

Gruß

[Marco H. (damarco)]

Nunja es geht ja anscheint darum den Inhalt getrennte zu verändern. Ob 
wirklich so sinnvoll ist muss man schauen.. Man könnte zuerst auslesen, 
ändern und wieder rein schreiben.

Oder man ließt nur zum Start aus und arbeitet mit einen copy im Speicher 
weiter. Zu gegeben Anlass, Spannung bricht ein oder Zeit schreibt man 
die Kopie zurück in den Flash.

Das schont den Flash und das schreiben ist wenn man blockierende 
Funktionen benutzt nicht gerade schnell. Es ist ewt. nicht unerheblich 
an welcher Stelle des Programms man in den Flash schreibt. Es lohnt sich 
auch in die Ref. zu schauen um zu verstehen was die Funktionen des ASFs 
eigentlich machen.