Hi everybody,

As a Micro/PIC newbie (and EEPROM useage in particular) I would be grateful
if someone could point me in the right direction.

My current project will eventually use a 16F874 @ 16MHz (if and when
available!).  I am using the EEPROM to retain user settings after power down
(universal AC supply powered equipment).  Currently this only requires 6
bytes, of which 2 are used for status and 4 are absolute values, but this
may well increase.  All user inputs are by button presses with auto-repeat
on some.  Retaining the settings is more a user convenience rather than a
vital requirement but once implemented it really needs to be reliable.
Typical useage of the equipment is to power up two to ten times per day but
it could be a lot more.

The code I am using on the prototype is fairly simplistic in that during
initialisation a check is made to see if each of the absolute values is
within a valid working range.  If all are OK then the EEPROM copy is assumed
to be correct and so is copied over to the working registers.  If not OK
then 'safe' default values are used instead.  No other checks are used at
the moment.

A routine is called once per main program loop (8-10mS) to check if each of
the working registers matches the appropriate EEPROM location and if not
they are written back to EEPROM once per loop (if a previous write has
finished).

Precautions have been taken to prevent too many writes to the EEPROM such as
waiting for key repeats to end etc.  I have also implemented a system to
even out the 'useage' on the EEPROM whereby the location of the 6 bytes is
incremented after each power up. (the location of the first byte in the
block is stored in a fixed location).

This system seems to work OK but I am not convinced that it is secure
enough, particularly during noisy power ups and power downs.  There is also
a finite time between the user changing the settings and the EEPROM being
updated, as well as the additional time required for a previous write to
finish.  This is particularly the case when the user input affects more than
one byte.

Does such a simple system sound reasonable?  Since my requirement would seem
to be a fairly common one, are there any 'standard' ways of implementing
such a scheme reliably without requiring extensive code and cycles?  Call it
a challenge if you like!

Sorry for the length of this post.

TIA

David