STM32F103ZET_JDASMBIC/Bluecell_Src/eeprom.c

/*
 * eeprom.c
 *
 *  Created on: 2020. 4. 22.
 *      Author: parkyj
 */
#include "main.h"
#include "eeprom.h"
#include "Bluecell_operate.h"
#include "stm32f1xx_hal.h"
#include "stm32f1xx_hal_gpio.h"

/* Includes ------------------------------------------------------------------*/   
HAL_StatusTypeDef EEPROM_M24C08_ByteRead(uint16_t devid,uint16_t Address,uint8_t* data,uint8_t size);



unsigned char E2promWriteByte( uint16_t addr, uint8_t data );

/////////////////////////////////////////////////////////////

unsigned char E2promReadByte( uint16_t addr );


bool		EEPROM24XX_Save(uint16_t Address,void *data,size_t size_of_data);
bool		EEPROM24XX_Load(uint16_t Address,void *data,size_t size_of_data);





void EEPROM_M24C08_Init(void){
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE,&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st) );
    
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_WINDOW_STATUS_ADDRESDS,&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL1_TABLE_ADDRESDS,&Att_DL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL2_TABLE_ADDRESDS,&Att_DL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL3_TABLE_ADDRESDS,&Att_DL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );

    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL4_TABLE_ADDRESDS,&Att_UL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL1_TABLE_ADDRESDS,&Att_UL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL2_TABLE_ADDRESDS,&Att_UL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL3_TABLE_ADDRESDS,&Att_UL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );

    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL4_TABLE_ADDRESDS,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_DL1_TABLE_ADDRESDS,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_DL2_TABLE_ADDRESDS,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_DL3_TABLE_ADDRESDS,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );


    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_DL4_TABLE_ADDRESDS,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL1_TABLE_ADDRESDS,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL2_TABLE_ADDRESDS,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL3_TABLE_ADDRESDS,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );


    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL4_TABLE_ADDRESDS,&Temp_DL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL1_TABLE_ADDRESDS,&Temp_DL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL2_TABLE_ADDRESDS,&Temp_DL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL3_TABLE_ADDRESDS,&Temp_DL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );


    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL4_TABLE_ADDRESDS,&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL1_TABLE_ADDRESDS,&Temp_UL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL2_TABLE_ADDRESDS,&Temp_UL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL3_TABLE_ADDRESDS,&Temp_UL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_USER_ATTEN_VALUE_ADDRESDS,&bluecell_UserData.bluecell_User_DL1_H,sizeof(USER_ATTEN_st) );



    
//    printf("bluecell_Currdatastatus.ATT_DL1_H : %x\r\n",bluecell_Currdatastatus.ATT_DL1_H);
//    printf("bluecell_Currdatastatus.ATT_DL1_L : %x\r\n",bluecell_Currdatastatus.ATT_DL1_L);        
//    
    printf("EEPROM INIT COMPLETE\r\n");

}










#if 0 // PYJ.2020.04.23_BEGIN -- 


void eepromtest(){
    memset(&eepdata[0],0x33,100);
    for(int i = 0; i < 100; i ++ ){
        printf("data[%d] : %x \r\n",i,eepdata[i]);
        EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID,EEPROM_ATT_BASE + i,&eepdata[i],1);
    }  
    for(int i = 0; i < 100; i ++ ){
        EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_ATT_BASE + i,&eepdata[i],1);
        printf("data[%d] : %x \r\n",i,eepdata[i]);
    }  
//    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE,&eepdata[0],100);
//    for(int i = 0; i < 100; i ++ ){
//        printf("data[%d] : %x \r\n",i,eepdata[i]);
//    }    

}
#endif // PYJ.2020.04.23_END -- 

#define MAXEEPROM_LENG 32

HAL_StatusTypeDef EEPROM_M24C08_Read(uint8_t devid,uint16_t Address,uint8_t* data,uint16_t size){
   HAL_StatusTypeDef ret = HAL_ERROR;
   uint16_t sizecnt = 0,sizeremain = 0; 
   uint16_t addrees_inc = 0;
//   ret = HAL_I2C_Mem_Read(&hi2c2, devid | ((Address & 0x0300) >> 7),((Address )),  I2C_MEMADD_SIZE_8BIT, &data[0], size, 1024);

   ret = HAL_I2C_Mem_Read(&hi2c2, devid ,((Address )),  I2C_MEMADD_SIZE_16BIT, &data[0], size, 1024);
//      EEPROM24XX_Load( Address,data, size);

      if(ret == HAL_ERROR)
            printf("Write ERR\r\n");
        else
        HAL_Delay(20);

    return ret;   
}
HAL_StatusTypeDef EEPROM_M24C08_write(uint8_t devid,uint16_t Address,uint8_t* data,uint16_t size){
    HAL_StatusTypeDef ret = HAL_ERROR;
    uint8_t sizecnt = 0,sizeremain = 0; 
    uint16_t addrees_inc = 0;
    sizecnt = size /MAXEEPROM_LENG;
    sizeremain = size % MAXEEPROM_LENG;
    addrees_inc = 0;
#if 0 // PYJ.2020.04.25_BEGIN -- 
       for(int i = 0 ; i <sizecnt; i++ ){
            addrees_inc = i * 16;
            ret = HAL_I2C_Mem_Write(&hi2c2, devid | (((Address  + addrees_inc) & 0x0300) >> 7),((Address + addrees_inc)) ,  I2C_MEMADD_SIZE_8BIT, &data[addrees_inc], 16, 1024);
            if(ret == HAL_ERROR)
                printf("Write ERR\r\n");
            else
                HAL_Delay(20);
       }
       addrees_inc += 16;
           ret = HAL_I2C_Mem_Write(&hi2c2, devid | (((Address  + addrees_inc) & 0x0300) >> 7),((Address + addrees_inc)) ,  I2C_MEMADD_SIZE_8BIT, &data[addrees_inc], sizeremain, 1024);
            //       EEPROM24XX_Save( Address,data, size);
            if(ret == HAL_ERROR)
                printf("Write ERR\r\n");
            else
                HAL_Delay(20);
#else
//    printf("size : %d sizecnt = %d sizeremain : %d\r\n",size,sizecnt,sizeremain);
    if(sizecnt > 0){
        for(int i = 0 ; i < sizecnt; i++ ){
             addrees_inc = i * MAXEEPROM_LENG;
             ret = HAL_I2C_Mem_Write(&hi2c2, devid  ,((Address + addrees_inc) & 0xFFFF) ,  I2C_MEMADD_SIZE_16BIT, &data[addrees_inc], MAXEEPROM_LENG, 1024);

             if(ret == HAL_ERROR)
                 printf("Write ERR\r\n");
             else
                 HAL_Delay(20);
        }
        addrees_inc += MAXEEPROM_LENG;
    }

//    printf("Remain Data Index : %d \r\n",sizeremain);
    
    if(sizeremain > 0){
         printf("Remain Data Write Start ");
        for(int i = 0; i < sizeremain; i++){
            ret = HAL_I2C_Mem_Write(&hi2c2, devid  ,((Address + addrees_inc + i)& 0xFFFF) ,  I2C_MEMADD_SIZE_16BIT, &data[addrees_inc + i], 1, 1024);
         //       EEPROM24XX_Save( Address,data, size);
         if(ret == HAL_ERROR)
             printf("Write ERR\r\n");
         else
             HAL_Delay(20);
        }
    }

#endif // PYJ.2020.04.25_END -- 
    return ret;
}





HAL_StatusTypeDef EEPROM_M24C08_ByteRead(uint16_t devid,uint16_t Address,uint8_t* data,uint8_t size){
   HAL_StatusTypeDef ret = HAL_ERROR;
#if 0 // PYJ.2020.04.24_BEGIN -- 
   for(int i = 0; i < size; i++){
     ret = HAL_I2C_Mem_Read(&hi2c2, devid, Address + i, I2C_MEMADD_SIZE_8BIT, &data[i], 1, 1024);
//     ret = HAL_I2C_Mem_Read(&hi2c2, devid|(((Address + i)&0x0700>>7)),((Address + i)&0xff),  I2C_MEMADD_SIZE_16BIT, &data[i], 1, 1024);     
       if(ret == HAL_ERROR)
        printf("Write ERR\r\n");
//     ret = HAL_I2C_Mem_Read_IT(&hi2c2, devid, Address + i, I2C_MEMADD_SIZE_8BIT, &data[i], 1);
     HAL_Delay(10);
   }
#endif // PYJ.2020.04.24_END -- 
    return ret;   
}
uint8_t I2CWrite[1024];
HAL_StatusTypeDef EEPROM_M24C08_Bytewrite(uint16_t devid,uint16_t Address,uint8_t* data,uint8_t size){
    HAL_StatusTypeDef ret = HAL_ERROR;
#if 0 // PYJ.2020.04.24_BEGIN -- 

    for(int i = 0; i < size; i++){
        ret = HAL_I2C_Mem_Write(&hi2c2, devid, Address + i,  I2C_MEMADD_SIZE_8BIT, &data[i], 1, 1024);
//        ret = HAL_I2C_Mem_Write(&hi2c2, devid|(((Address + i)&0x0700>>7)),((Address + i)&0xff),  I2C_MEMADD_SIZE_16BIT, &data[i], 1, 1024);

        if(ret == HAL_ERROR)
            printf("Write ERR\r\n");
        else
            HAL_Delay(7);
//        ret = HAL_I2C_Mem_Write_IT(&hi2c2, devid, Address + i, I2C_MEMADD_SIZE_8BIT, &data[i], 1);
    }
#endif // PYJ.2020.04.24_END -- 
    return ret;
}




#define _EEPROM_SIZE_KBIT 8

bool EEPROM24XX_IsConnected(void)
{
	#if	(_EEPROM_USE_WP_PIN==1)
	#endif
	if(HAL_I2C_IsDeviceReady(&hi2c2,0xa0,1,100)==HAL_OK)
		return true;
	else
		return false;	
}
//##########################################################################
bool		EEPROM24XX_Save(uint16_t Address,void *data,size_t size_of_data)
{
	#if ((_EEPROM_SIZE_KBIT==1) || (_EEPROM_SIZE_KBIT==2))
	if(size_of_data > 8)
		return false;
	#elif ((_EEPROM_SIZE_KBIT==4) || (_EEPROM_SIZE_KBIT==8) || (_EEPROM_SIZE_KBIT==16))
	if(size_of_data > 16)
		return false;
	#else 
	if(size_of_data > 32)
		return false;
	#endif
	
	#if	(_EEPROM_USE_WP_PIN==1)
	HAL_GPIO_WritePin(_EEPROM_WP_GPIO,_EEPROM_WP_PIN,GPIO_PIN_RESET);
	#endif
	
	#if ((_EEPROM_SIZE_KBIT==1) || (_EEPROM_SIZE_KBIT==2))
	if(HAL_I2C_Mem_Write(&hi2c2,0xa0,Address,I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
	#elif	(_EEPROM_SIZE_KBIT==4)
	if(HAL_I2C_Mem_Write(&hi2c2,0xa0|((Address&0x0100>>7)),(Address&0xff),I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
	#elif	(_EEPROM_SIZE_KBIT==8)
	if(HAL_I2C_Mem_Write(&hi2c2,0xa0|((Address&0x0300>>7)),(Address&0xff),I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
	#elif	(_EEPROM_SIZE_KBIT==16)
	if(HAL_I2C_Mem_Write(&hi2c2,0xa0|((Address&0x0700>>7)),(Address&0xff),I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)		
	#else
	if(HAL_I2C_Mem_Write(&hi2c2,0xa0,Address,I2C_MEMADD_SIZE_16BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
	#endif
	{
		HAL_Delay(7);
	}
	else
	{
	}
}
//##########################################################################
bool		EEPROM24XX_Load(uint16_t Address,void *data,size_t size_of_data)
{
	#if	(_EEPROM_USE_WP_PIN==1)
	HAL_GPIO_WritePin(_EEPROM_WP_GPIO,_EEPROM_WP_PIN,GPIO_PIN_SET);
	#endif
	#if ((_EEPROM_SIZE_KBIT==1) || (_EEPROM_SIZE_KBIT==2))
	if(HAL_I2C_Mem_Read(&hi2c2,0xa0,Address,I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
	#elif (_EEPROM_SIZE_KBIT==4)
	if(HAL_I2C_Mem_Read(&hi2c2,0xa0|((Address&0x0100>>7)),(Address&0xff),I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
	#elif (_EEPROM_SIZE_KBIT==8)
	if(HAL_I2C_Mem_Read(&hi2c2,0xa0|((Address&0x0300>>7)),(Address&0xff),I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
	#elif (_EEPROM_SIZE_KBIT==16)
	if(HAL_I2C_Mem_Read(&hi2c2,0xa0|((Address&0x0700>>7)),(Address&0xff),I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
	#else
	if(HAL_I2C_Mem_Read(&hi2c2,0xa0,Address,I2C_MEMADD_SIZE_16BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
	#endif
		return true;
	else
		return false;		
}








// EEPROM 24lcXXX 
/// ST에서 제공하는 I2C 소스는 뭘 해도 안된다.. 내가 잘못한건지 뭔지 참..
/// while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)); ??????????
/// 중국애들?이 제공하는 소스로 하니 바로 되버리는 이 현상은 뭘까...
///////////////////////// 
///// i2c gpio 직접 제어 코드..

#define E2PROM_SDA EEPROM_SCL_Pin
#define E2PROM_SCL EEPROM_SDA_Pin

#define E2PROM_CMD_WRITE 0xA0
#define E2PROM_CMD_READ 0xA1
#define I2C_PageSize     16

void I2CStart( void )
{
  HAL_GPIO_WritePin( GPIOB, E2PROM_SDA ,GPIO_PIN_SET );
  HAL_Delay(10);
  HAL_GPIO_WritePin( GPIOB, E2PROM_SCL,GPIO_PIN_SET );
  HAL_Delay(10);
  HAL_GPIO_WritePin( GPIOB, E2PROM_SDA,GPIO_PIN_RESET );
  HAL_Delay(10);

  HAL_GPIO_WritePin( GPIOB, E2PROM_SCL ,GPIO_PIN_RESET);
}


void I2CStop( void )
{
  HAL_GPIO_WritePin( GPIOB, E2PROM_SDA,GPIO_PIN_RESET );
  HAL_Delay(10);
  HAL_GPIO_WritePin( GPIOB, E2PROM_SCL ,GPIO_PIN_SET);
  HAL_Delay(10);
  HAL_GPIO_WritePin( GPIOB, E2PROM_SDA ,GPIO_PIN_SET);
  HAL_Delay(10);

  HAL_GPIO_WritePin( GPIOB, E2PROM_SCL,GPIO_PIN_RESET );
}


unsigned char I2CSlaveAck( void )
{
  GPIO_InitTypeDef GPIO_InitStruct;
  unsigned int TimeOut;
  unsigned char RetValue;

  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;  /*?里一定要?成?入上拉，否?不能?出?据*/
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.Pin = E2PROM_SDA;


  
  HAL_GPIO_Init( GPIOB, &GPIO_InitStruct );

  HAL_GPIO_WritePin( GPIOB, E2PROM_SCL,GPIO_PIN_SET );
  TimeOut = 10000;
  while( TimeOut-- > 0 )
  {
    if( SET == HAL_GPIO_ReadPin( GPIOB, E2PROM_SDA ) )
    {
      RetValue = RESET;
      break;
    }
    else
    {
      RetValue = SET;
    }
  }
  HAL_GPIO_WritePin( GPIOB, E2PROM_SCL,GPIO_PIN_RESET );
  
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  HAL_GPIO_Init( GPIOB, &GPIO_InitStruct );
  return RetValue;
}

void I2CWriteByte( unsigned char byte )
{
  unsigned char i;

  for( i=0; i<8; i++ )
  {
    if( 0X80 & byte )
      HAL_GPIO_WritePin( GPIOB, E2PROM_SDA ,GPIO_PIN_SET);
    else
      HAL_GPIO_WritePin( GPIOB, E2PROM_SDA,GPIO_PIN_RESET );
    byte <<= 1;
    HAL_Delay(10);

    HAL_GPIO_WritePin( GPIOB, E2PROM_SCL ,GPIO_PIN_SET);
    HAL_Delay(10);
    HAL_GPIO_WritePin( GPIOB, E2PROM_SCL,GPIO_PIN_RESET );
    HAL_Delay(10);
  }
}


unsigned char I2CReadByte( void )
{
  unsigned char i;
  unsigned char ReadValue = 0;
  GPIO_InitTypeDef GPIO_InitStruct;
  unsigned char bit;

  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;  
  GPIO_InitStruct.Pin = E2PROM_SDA;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init( GPIOB, &GPIO_InitStruct );
  for( i=0; i<8; i++ )
  {
    HAL_GPIO_WritePin( GPIOB, E2PROM_SCL ,GPIO_PIN_SET);
    HAL_Delay(10);
    if( SET == HAL_GPIO_ReadPin( GPIOB, E2PROM_SDA ) )
      bit = 0X01;
    else
      bit = 0x00;
      
    ReadValue = (ReadValue<<1)|bit;
    HAL_GPIO_WritePin( GPIOB, E2PROM_SCL,GPIO_PIN_RESET );
    HAL_Delay(10);
  }

  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  HAL_GPIO_Init( GPIOB, &GPIO_InitStruct );
  return ReadValue;
}


unsigned char E2promWriteByte( uint16_t addr, uint8_t data )
{

  I2CStart();

  I2CWriteByte( E2PROM_CMD_WRITE );
  if( RESET == I2CSlaveAck() )
  {
    return RESET;
  }

  I2CWriteByte((unsigned char)(addr>>8));
  if( RESET == I2CSlaveAck() )
  {
    return RESET;
  }
  I2CWriteByte((uint8_t)(addr));
  if( RESET == I2CSlaveAck() )
  {
    return RESET;
  }

  I2CWriteByte( data );
  if( RESET == I2CSlaveAck() )
  {
    return RESET;
  }
  I2CStop();
  //asm("CPSIE I");  //?中?

  return SET;
}

/////////////////////////////////////////////////////////////

unsigned char E2promReadByte( uint16_t addr )
{
  unsigned char ReadValue;

  I2CStart();

  I2CWriteByte( E2PROM_CMD_WRITE );
  if( RESET == I2CSlaveAck() )
  {
    return RESET;
  }

  I2CWriteByte((unsigned char)(addr>>8));
  if( RESET == I2CSlaveAck() )
  {
    return RESET;
  }
  I2CWriteByte((uint8_t)(addr));
  if( RESET == I2CSlaveAck() )
  {
    return RESET;
  }

  I2CStart();
  I2CWriteByte( E2PROM_CMD_READ );
  if( RESET == I2CSlaveAck() )
  {
    return RESET;
  }
  ReadValue = I2CReadByte();
  I2CStop();

  return ReadValue;  
}