Modified, refactored, and added tests for the EEPROM module.

Author: abdoaboganima

HAL/EEPROM/EEPROM_interface.h

@@ -1,16 +1,11 @@
  /**
  * @file EEPROM_interface.h
  * @author Abdulrahman Aboghanima ([email protected])
- * @brief 
- * @version 0.1
+ * @brief  Contains functions declaration for the EEPROM module
+ * @version 0.2
  * @copyright Copyright (c) 2022
  */
 
- /** @addtogroup HAL_drivers
-  * @{
-  * @addtogroup EEPROM_drivers
-  * @{
-  */
 
 #ifndef _EEPROM_INTERFACE_H_
 #define _EEPROM_INTERFACE_H_
@@ -21,15 +16,15 @@
  * @param data 
  * @param address 
  */
-void EEPROM_writeByte(const uint8_t data, const uint16_t address);
+extern void EEPROM_writeByte(const uint8_t data, const uint16_t address);
 
  /**
  * @brief Read a byte of data from the EEPROM, the byte will be stored 
  * in the memory location addressed by `var`.
  * @param var 
  * @param address 
  */
-void EEPROM_readByte(uint8_t * const var, const uint16_t address);
+extern void EEPROM_readByte(uint8_t * const var, const uint16_t address);
 
  /**
  * @brief Send sequence of data addressed by `sequence` to the EEPROM across the I^{2}C bus
@@ -39,24 +34,25 @@ void EEPROM_readByte(uint8_t * const var, const uint16_t address);
  * @param sequenceSize 
  * @note The data that will be stored is addressed by `sequence` and `fisrtAddress` is
  * the first address in the EEPROM of the data that will be stored
- * @code EEPROM_sendSequence("CoolStuff", 10, 9);
+ * @code EEPROM_writePage("CoolStuff", 10, 9);
  * @endcode 
  */
-void EEPROM_writeSequence(uint8_t * const sequence, const uint16_t firstAddress, const uint16_t sequenceSize);
+extern void EEPROM_writePage(const uint8_t * const sequence, const uint16_t firstAddress, const uint8_t pageSize);
 
  /**
  * @brief Read sequence of data from the EEPROM and store them in a memory location addressed by `sequence`
  * @param sequence 
  * @param firstAddress 
- * @param sequenceSize 
+ * @param pageSize
  * @note In the code bellow the data will be stored in the `buff` starting from the
  * address 20 in the EEPROM till address 1019 
  * @code 
  * uint8_t buff[1000];
  * EEPROM_readSequence(buff, 20, 1000);
  * @endcode 
+ * @note The maximum size of the page must be 16-byte
  */
-void EEPROM_readSequence(uint8_t * const sequence, const uint16_t firstAddress, const uint16_t sequenceSize);
+extern void EEPROM_readSequence(uint8_t * const sequence, const uint16_t firstAddress, const uint16_t sequenceSize);
+
 
 #endif /* _EEPROM_INTERFACE_H_ */
-/*@}@}*/

HAL/EEPROM/EEPROM_program.c

@@ -1,8 +1,8 @@
  /**
  * @file EEPROM_program.c
  * @author Abdulrahman Aboghanima ([email protected])
- * @brief 
- * @version 0.1
+ * @brief  Contains functions declaration for the EEPROM module 
+ * @version 0.2
  * @date 2022-02-03
  * @todo Fix or remove the delays. Include the in the I2C driver
  * @copyright Copyright (c) 2022
@@ -13,9 +13,10 @@
 #include "../../LIB/STD_TYPES.h"
 #include <util/delay.h>
 
-#define EEPROM_ADDRESS 0b1010000
+#define EEPROM_ADDRESS ( 0b1010000 | (A2_PIN<<2) )
+
 /*
-Suppos you would like to access memory which address is : X9X8X7X6X5X4X3X2X1X0
+Suppose you would like to access memory which address is : X9X8X7X6X5X4X3X2X1X0
 So in order to access that location you have to through the following address in the I^{2}C Bus
 |---+---+---+---+----+----+----|
 | 1 | 0 | 1 | 0 | A2 | X9 | X8 |
@@ -30,72 +31,51 @@ So in order to access that location you have to through the following address in
   */
 
 
-void EEPROM_writeByte(const uint8_t data, const uint16_t address)
+extern void EEPROM_writeByte(const uint8_t data, const uint16_t address)
 {
   TWI_sendStartCondition();
-  _delay_ms(50);
-  TWI_sendSlaveAddressWithWrite( EEPROM_ADDRESS | (A2_PIN<<2) |(address>>8) );
-  _delay_ms(50);
+  /*Send slave address (which consists also of the number of block)*/
+  TWI_sendSlaveAddressWithWrite( EEPROM_ADDRESS | (address>>8) );
+  /*Send the address of the byte in the block(block consists of 256 bytes)*/
   TWI_masterWrite( (uint8_t) address);
-  _delay_ms(50);
   TWI_masterWrite(data);
-  _delay_ms(50);
   TWI_sendStopCondition();
-  _delay_ms(50);
 }
 
-void EEPROM_readByte(uint8_t * const var, const uint16_t address)
+extern void EEPROM_readByte(uint8_t * const var, const uint16_t address)
 {
   TWI_sendStartCondition();
-  _delay_ms(50);
-  TWI_sendSlaveAddressWithWrite(EEPROM_ADDRESS | (A2_PIN<<2) | (address>>8));
-  _delay_ms(50);
+  TWI_sendSlaveAddressWithWrite(EEPROM_ADDRESS | (address>>8));
   TWI_masterWrite((uint8_t) address);
-  _delay_ms(50);
   TWI_sendRepeatedStartCondition();
-  _delay_ms(50);
-  TWI_sendSlaveAddressWithRead(EEPROM_ADDRESS | (A2_PIN<<2) | (address>>8));
-  _delay_ms(50);
+  TWI_sendSlaveAddressWithRead(EEPROM_ADDRESS | (address>>8));
   TWI_masterRead(var, 1);
-  _delay_ms(50);
   TWI_sendStopCondition();
-  _delay_ms(100);
-
 }
 
-void EEPROM_writeSequence(uint8_t * const sequence, const uint16_t firstAddress, const uint16_t sequenceSize)
+extern void EEPROM_writePage(const uint8_t * const sequence, const uint16_t firstAddress, const uint8_t pageSize)
 {
   TWI_sendStartCondition();
-  _delay_ms(20);
-  TWI_sendSlaveAddressWithWrite(EEPROM_ADDRESS|(A2_PIN<<2)|(firstAddress>>8));
-  _delay_ms(20);
+  /*Send slave address (which consists also of the number of block)*/
+  TWI_sendSlaveAddressWithWrite(EEPROM_ADDRESS | (firstAddress>>8));
+  /*Send the address of the byte in the block (block consists of 256 bytes)*/
   TWI_masterWrite((uint8_t)firstAddress);
-  _delay_ms(20);
-  for(uint8_t i=0; i<sequenceSize; i++){
+  for(uint8_t i=0; i<pageSize; i++){
     TWI_masterWrite(sequence[i]);
-    _delay_ms(20);
   }
   TWI_sendStopCondition();
-  _delay_ms(100);
 }
 
-void EEPROM_readSequence(uint8_t * const sequence, const uint16_t firstAddress, const uint16_t sequenceSize)
+extern void EEPROM_readSequence(uint8_t * const sequence, const uint16_t firstAddress, const uint16_t sequenceSize)
 {
   TWI_sendStartCondition();
-  _delay_ms(20);
-  TWI_sendSlaveAddressWithWrite(( EEPROM_ADDRESS | (A2_PIN<<2) | (firstAddress>>8) ));
-  _delay_ms(20);
+  TWI_sendSlaveAddressWithWrite(( EEPROM_ADDRESS  | (firstAddress>>8) ));
   TWI_masterWrite( (uint8_t) firstAddress);
-  _delay_ms(20);
   TWI_sendRepeatedStartCondition();
-  _delay_ms(20);
-  TWI_sendSlaveAddressWithRead( EEPROM_ADDRESS | (A2_PIN<<2) | (firstAddress>>8) );
-  _delay_ms(20);
+  TWI_sendSlaveAddressWithRead( EEPROM_ADDRESS | (firstAddress>>8) );
   for(uint16_t i=0; i<sequenceSize; i++){
     TWI_masterRead(sequence+i, sequenceSize-i);
-    _delay_ms(100);
   }
 
   TWI_sendStopCondition();
-  _delay_ms(100);
 }

tests/EEPROM_output.gif

@@ -0,0 +1,66 @@
+/**
+ *
+ * @file       EEPROM_test.c
+ * @brief      Contains some tests for the EEPROM module
+ * @author     Abdulrahman Aboghanima
+ * @date       Oct 15 20:48:29 2021
+ * @copyright  Copyright (c) 2022
+ * @version    0.2
+ * 
+ */
+
+#include "../LIB/STD_TYPES.h"
+#include "../MCAL/DIO/DIO_interface.h"
+#include "../MCAL/USART/USART_interface.h"
+#include "../MCAL/TWI/TWI_interface.h"
+#include "../HAL/EEPROM/EEPROM_interface.h"
+#include <util/delay.h>
+
+
+char *data="My name is Abdulrahman.\nIlove Embedded Systems So much. :) ;)\n";
+char buffer[1024];
+
+int main(void)
+{
+  DIO_SetPinDirection(DIO_PORTD, DIO_PIN0, DIO_PIN_INPUT);
+  DIO_SetPinDirection(DIO_PORTD, DIO_PIN1, DIO_PIN_OUTPUT);
+  
+  DIO_SetPortDirection(DIO_PORTC, DIO_PORT_OUTPUT);
+
+  TWI_initMaster();
+  USART_init();
+  USART_sendStream("Testing EEPROM\n\n");
+
+
+  USART_sendStream("Reading the Entire EEPROM:\n");
+  /*Reading the entire contents of the EEPROM and saving it into `buffer`*/
+  EEPROM_readSequence((uint8_t*)buffer, 0, 1024);
+
+  for(uint16_t i=0; i<1024; i++){
+    USART_send(buffer[i]);
+    if(i%64==0)
+      USART_send('\n');
+  }
+
+  
+  EEPROM_writePage((uint8_t*)data, 0, 16);
+  EEPROM_writePage((uint8_t*)&data[16], 16, 16);
+  EEPROM_writePage((uint8_t*)&data[32], 32, 16);
+
+  EEPROM_readSequence((uint8_t*)buffer, 0, 48);
+
+  
+  while(1){
+    
+    _delay_ms(6000);
+    USART_sendStream("\n\nRead from EEPROM:\n\n");
+
+    for(uint8_t i=0; i<48; i++)
+      USART_send(buffer[i]);
+    
+    USART_sendStream("\n\n");
+
+  }
+
+  return 0;
+}

tests/EEPROM_test.c

@@ -120,4 +120,19 @@ So the period time of the signal = 256 * 8 uS = 2.048 mS as shown in the figure.
 In this program, I used an ADC resolution of 10 bits, and used a potentiometer as
 an analog signal source. After the conversion, the 10 bits are displayed using 10 bits;
 8 from `PORTC` and 2 from `PORTD`.
+
 ![Simulation of the ADC](./ADC_output.gif)
+
+## I2C (Inter Integrated Circuit) or TWI (Two Wire Interface)
+
+### Interfacing With EEPROM (`AT24C08`)
+
+In this test, I used `At24C08` with which them micro controller communicates using I2C bus.
+
+I read the entire contents of the EEPROM, saved it into `buffer[1024]`, 
+and sent it into the terminal using the USART.
+
+The content of the EEPROM is written by me before.
+
+
+![Simulation of the EEPROM](./EEPROM_output.gif)