Czy istnieje ogólny algorytm wyrównywania zużycia mikrokontrolera EEPROM?

Pracuję nad biblioteką Arduino, która zmaksymalizuje żywotność EEPROM AVR. Pobiera liczbę zmiennych, które chcesz przechowywać, i wykonuje resztę. To jest moja próba, która nie działa we wszystkich przypadkach.

Informacje ogólne

Przez przemienne zapisuje między dwoma adresami pamięci, możemy zwiększyć wymazywanie / zapis do 200 000 cykli. Trzy adresy pamięci dają 300 000 cykli kasowania/zapisu i tak dalej. Aby zautomatyzować ten proces, bufor stanu jest używany do śledzenia miejsca następnego zapisu. Bufor stanu musi również mieć taką samą długość jak bufor parametru, ponieważ również na nim musi być wykonywane wyrównywanie zużycia. Ponieważ nie możemy zapisać indeksu następnego zapisu, zwiększamy odpowiedni indeks w stanie bufor.

   <------------------- EEPROM -------------------->  
   0                                               N
   -------------------------------------------------
       Parameter Buffer    |     Status Buffer     |
   -------------------------------------------------

   Initial state.
   [ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]

   First write is a 7. The corresponding position
   in the status buffer is changed to previous value + 1.
   Both buffers are circular.
   [ 7 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 ]

   A second value, 4, is written to the parameter buffer 
   and the second element in the status buffer becomes
   the previous element, 1 in this case, plus 1.
   [ 7 | 4 | 0 | 0 | 0 | 0 | 1 | 2 | 0 | 0 | 0 | 0 ]

   And so on
   [ 7 | 4 | 9 | 0 | 0 | 0 | 1 | 2 | 3 | 0 | 0 | 0 ]

Aby określić, gdzie powinien nastąpić następny zapis, przyjrzymy się różnicy między elementami. Jeśli poprzedni element + 1 nie jest równy kolejnemu elementowi, to tam powinien nastąpić następny zapis. Na przykład:

   Compute the differences by starting at the first
   element in the status buffer and wrapping around. 
   General algo: previous element + 1 = current element
   1st element:  0 + 1 = 1 = 1st element (move on)
   2nd element:  1 + 1 = 2 = 2nd element (move on)
   3rd element:  2 + 1 = 3 = 3rd element (move on)
   4th element:  3 + 1 = 4 != 4th element (next write occurs here)

   [ 7 | 4 | 9 | 0 | 0 | 0 | 1 | 2 | 3 | 0 | 0 | 0 ]
                 ^                       ^
                 |                       |

   Another edge case to consider is when the incrementing values
   wrap around at 256 because we are writing bytes. With the
   following buffer we know the next write is at the 3rd element 
   because 255 + 1 = 0 != 250 assuming we are using byte arithmetic.

   [ x | x | x | x | x | x | 254 | 255 | 250 | 251 | 252 | 253 ]
                                          ^
                                          | 

   After we write at element 3 the status buffer is incremented 
   to the next value using byte arithmetic and looks like this.
   255 + 1 = 0 (wrap around)
   0 + 1 != 251 (next write is here)

   [ x | x | x | x | x | x | 254 | 255 |  0  | 251 | 252 | 253 ]
                                                ^
                                                | 

Powyższe przykłady pokazują jak przedłużyć żywotność pamięci EEPROM dla jednej zmiennej. Dla wielu zmiennych wyobraź sobie segmentację pamięci EEPROM na wiele segmentów o tej samej strukturze danych, ale mniejszych bufory.

Problem

Mam działający kod do tego, co opisałem powyżej. Mój problem polega na tym, że algorytm nie działa, gdy długość bufora >= 256. Oto co się dzieje

   Buffer length of 256. The last zero is from
   the initial state of the buffer. At every index
   previous element + 1 == next element. No way to
   know where the next write should be.

   <-------------- Status Buffer ------------>
   [  1  |  2  | ... | 253 | 254 | 255 |  0  ]


   A similar problem occurs when the buffer length
   is greater than 256. A lookup for a read will think
   the next element is at the first 0 when it should be at 
   255.
   <-------------------- Status Buffer ------------------>
   [  1  |  2  | ... | 253 | 254 | 255 |  0  |  0  |  0  ]

Pytanie

Jak mogę rozwiązać powyższy problem? Czy istnieje lepszy sposób, aby śledzić, gdzie następny element powinien być napisany?