- Added Documentation

Author: thijse

EEPROMex.cpp

@@ -45,6 +45,9 @@ EEPROMClassEx::EEPROMClassEx()
  * User API
  ******************************************************************************/
 
+ /**
+ * Set starting position and memory size that EEPROMEx may manage
+ */
 void EEPROMClassEx::setMemPool(int base, int memSize) {
 	//Base can only be adjusted if no addresses have already been issued
 	if (_nextAvailableaddress == _base) 
@@ -65,12 +68,18 @@ void EEPROMClassEx::setMemPool(int base, int memSize) {
 
 }
 
+/**
+ * Set global maximum of allowed writes
+ */
 void EEPROMClassEx::setMaxAllowedWrites(int allowedWrites) {
 #ifdef _EEPROMEX_DEBUG
 	_allowedWrites = allowedWrites;
 #endif			
 }
 
+/**
+ * Get a new starting address to write to. Adress is negative if not enough space is available
+ */
 int EEPROMClassEx::getAddress(int noOfBytes){
 	int availableaddress   = _nextAvailableaddress;
 	_nextAvailableaddress += noOfBytes;
@@ -86,16 +95,25 @@ int EEPROMClassEx::getAddress(int noOfBytes){
 	return availableaddress;		
 }
 
-
+/**
+ * Check if EEPROM memory is ready to be accessed
+ */
 bool EEPROMClassEx::isReady() {
 	return eeprom_is_ready();
 }
 
+/**
+ * Read a single byte
+ * This function performs as readByte and is added to be similar to the EEPROM library
+ */
 uint8_t EEPROMClassEx::read(int address)
 {
 	return readByte(address);
 }
 
+/**
+ * Read a single bit
+ */
 bool EEPROMClassEx::readBit(int address, byte bit) {
 	  if (bit> 7) return false; 
 	  if (!isReadOk(address+sizeof(uint8_t))) return false;
@@ -104,24 +122,36 @@ bool EEPROMClassEx::readBit(int address, byte bit) {
       return (byteVal & bytePos);
 }
 
+/**
+ * Read a single byte
+ */
 uint8_t EEPROMClassEx::readByte(int address)
 {	
 	if (!isReadOk(address+sizeof(uint8_t))) return 0;
 	return eeprom_read_byte((unsigned char *) address);
 }
 
+/**
+ * Read a single 16 bits integer
+ */
 uint16_t EEPROMClassEx::readInt(int address)
 {
 	if (!isReadOk(address+sizeof(uint16_t))) return 0;
 	return eeprom_read_word((uint16_t *) address);
 }
 
+/**
+ * Read a single 32 bits integer
+ */
 uint32_t EEPROMClassEx::readLong(int address)
 {
 	if (!isReadOk(address+sizeof(uint32_t))) return 0;
 	return eeprom_read_dword((unsigned long *) address);
 }
 
+/**
+ * Read a single float value
+ */
 float EEPROMClassEx::readFloat(int address)
 {
 	if (!isReadOk(address+sizeof(float))) return 0;
@@ -130,6 +160,9 @@ float EEPROMClassEx::readFloat(int address)
 	return _value;
 }
 
+/**
+ * Read a single double value (size will depend on board type)
+ */
 double EEPROMClassEx::readDouble(int address)
 {
 	if (!isReadOk(address+sizeof(double))) return 0;	
@@ -138,53 +171,83 @@ double EEPROMClassEx::readDouble(int address)
 	return _value;
 }
 
+/**
+ * Write a single byte
+ * This function performs as writeByte and is added to be similar to the EEPROM library
+ */
 bool EEPROMClassEx::write(int address, uint8_t value)
 {
 	return writeByte(address, value);
 }
 
+/**
+ * Write a single bit
+ */
 bool EEPROMClassEx::writeBit(int address, uint8_t bit, bool value) {
 	updateBit(address, bit, value);
 	return true;
 }
 
-
+/**
+ * Write a single byte
+ */
 bool EEPROMClassEx::writeByte(int address, uint8_t value)
 {
 	if (!isWriteOk(address+sizeof(uint8_t))) return false;
 	eeprom_write_byte((unsigned char *) address, value);
 	return true;
 }
 
+/**
+ * Write a single 16 bits integer
+ */
 bool EEPROMClassEx::writeInt(int address, uint16_t value)
 {
 	if (!isWriteOk(address+sizeof(uint16_t))) return false;
 	eeprom_write_word((uint16_t *) address, value);
 	return true;
 }
 
+/**
+ * Write a single 32 bits integer
+ */
 bool EEPROMClassEx::writeLong(int address, uint32_t value)
 {
 	if (!isWriteOk(address+sizeof(uint32_t))) return false;
 	eeprom_write_dword((unsigned long *) address, value);
 	return true;
 }
 
+/**
+ * Write a single float value
+ */
 bool EEPROMClassEx::writeFloat(int address, float value)
 {
 	return (writeBlock<float>(address, value)!=0);	
 }
 
+/**
+ * Write a single double value (size will depend on board type)
+ */
 bool EEPROMClassEx::writeDouble(int address, double value)
 {
 	return (writeBlock<float>(address, value)!=0);	
 }
 
+/**
+ * Update a single byte
+ * The EEPROM will only be overwritten if different. This will reduce wear.
+ * This function performs as updateByte and is added to be similar to the EEPROM library
+ */
 bool EEPROMClassEx::update(int address, uint8_t value)
 {
 	return (updateByte(address, value));
 }
 
+/**
+ * Update a single bit
+ * The EEPROM will only be overwritten if different. This will reduce wear.
+ */
 bool EEPROMClassEx::updateBit(int address, uint8_t bit, bool value) 
 {
 	  if (bit> 7) return false; 
@@ -204,31 +267,55 @@ bool EEPROMClassEx::updateBit(int address, uint8_t bit, bool value)
 	  return true;
 }
 
+
+/**
+ * Update a single byte
+ * The EEPROM will only be overwritten if different. This will reduce wear.
+ */
 bool EEPROMClassEx::updateByte(int address, uint8_t value)
 {
 	return (updateBlock<uint8_t>(address, value)!=0);
 }
 
+/**
+ * Update a single 16 bits integer 
+ * The EEPROM will only be overwritten if different. This will reduce wear.
+ */
 bool EEPROMClassEx::updateInt(int address, uint16_t value)
 {
 	return (updateBlock<uint16_t>(address, value)!=0);
 }
 
+/**
+ * Update a single 32 bits integer 
+ * The EEPROM will only be overwritten if different. This will reduce wear.
+ */
 bool EEPROMClassEx::updateLong(int address, uint32_t value)
 {
 	return (updateBlock<uint32_t>(address, value)!=0);
 }
 
+/**
+ * Update a single float value 
+ * The EEPROM will only be overwritten if different. This will reduce wear.
+ */
 bool EEPROMClassEx::updateFloat(int address, float value)
 {
 	return (updateBlock<float>(address, value)!=0);
 }
 
+/**
+ * Update a single double value (size will depend on board type)
+ * The EEPROM will only be overwritten if different. This will reduce wear.
+ */
 bool EEPROMClassEx::updateDouble(int address, double value)
 {
 	return (writeBlock<double>(address, value)!=0);
 }
 
+/**
+ * Performs check to see if writing to a memory address is allowed
+ */
 bool EEPROMClassEx::isWriteOk(int address)
 {
 #ifdef _EEPROMEX_DEBUG    
@@ -248,6 +335,9 @@ bool EEPROMClassEx::isWriteOk(int address)
 	return true;
 }
 
+/**
+ * Performs check to see if reading from a memory address is allowed
+ */
 bool EEPROMClassEx::isReadOk(int address)
 {
 #ifdef _EEPROMEX_DEBUG    

EEPROMex.h

@@ -91,21 +91,29 @@ class EEPROMClassEx
 
     // Use template for other data formats
 
-
+	/**
+	 * Template function to read  multiple items of any type of variable, such as structs
+	 */
 	template <class T> int readBlock(int address, const T value[], int items)
 	{
 		unsigned int i;
 		for (i = 0; i < (unsigned int)items; i++)
 			readBlock<T>(address+(i*sizeof(T)),value[i]);
 		return i;
 	}
-	
+
+	/**
+	 * Template function to read any type of variable, such as structs
+	 */	
 	template <class T> int readBlock(int address, const T& value)
 	{		
 		eeprom_read_block((void*)&value, (const void*)address, sizeof(value));
 		return sizeof(value);
 	}
 
+	/**
+	 * Template function to write multiple items of any type of variable, such as structs
+	 */	
 	template <class T> int writeBlock(int address, const T value[], int items)
 	{	
 		if (!isWriteOk(address+items*sizeof(T))) return 0;
@@ -114,14 +122,21 @@ class EEPROMClassEx
 			  writeBlock<T>(address+(i*sizeof(T)),value[i]);
 		return i;
 	}
-	
+
+	/**
+	 * Template function to write any type of variable, such as structs
+	 */		
 	template <class T> int writeBlock(int address, const T& value)
 	{
 		if (!isWriteOk(address+sizeof(value))) return 0;
 		eeprom_write_block((void*)&value, (void*)address, sizeof(value));			  			  
 		return sizeof(value);
 	}
-
+	 
+	/**
+	 * Template function to update multiple items of any type of variable, such as structs
+	 * The EEPROM will only be overwritten if different. This will reduce wear.
+	 */	 
 	template <class T> int updateBlock(int address, const T value[], int items)
 	{
 		int writeCount=0;
@@ -132,6 +147,10 @@ class EEPROMClassEx
 		return writeCount;
 	}
 
+	/**
+	 * Template function to update any type of variable, such as structs
+	 * The EEPROM will only be overwritten if different. This will reduce wear.
+	 */	 
 	template <class T> int updateBlock(int address, const T& value)
 	{
 		int writeCount=0;

extras/Documentation/Documentation.html

@@ -0,0 +1,2 @@
+<h1>EEPROMEx documentation</h1>
+<p><a href="html/class_e_e_p_r_o_m_class_ex.html">Browse the EEPROMEx documentation</a></p>