STM32F103ZET_JDASMBIC/Bluecell_Src/eeprom.c

/*
 * eeprom.c
 *
 *  Created on: 2020. 4. 22.
 *      Author: parkyj
 */
#include <stdio.h>
#include <string.h>
#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);
#define MAXEEPROM_LENG 32


extern BLUESTATUS_st bluecell_Currdatastatus;






uint8_t testdata[120];

typedef enum{
    Test_DL1 = 0,
    Test_DL2 = 0,
    Test_DL3 = 0,
    Test_DL4 = 0,    
};
typedef enum{
    Test_UL1 = 0,
    Test_UL2 = 0,
    Test_UL3 = 0,
    Test_UL4 = 0,    
};
#define EEPROM_ADDRESS_M24C08_BLOCK0      0xA0
#define EEPROM_ADDRESS_M24C08_BLOCK1      0xA2
#define EEPROM_ADDRESS_M24C08_BLOCK2      0xA4
#define EEPROM_ADDRESS_M24C08_BLOCK3      0xA6
#define EEPROM_OK                       0
#define EEPROM_FAIL                     1   
#define EEPROM_TIMEOUT                  2   

#define AGC_Table_Ref_INDEX 95
#define ALC_Table_Ref_INDEX 159
__IO uint16_t  EEPROMAddress = 0;
__IO uint16_t  EEPROMPageSize = 0;
#define EEPROM_MAX_TRIALS               300
static HAL_StatusTypeDef I2Cx_IsDeviceReady(uint16_t DevAddress, uint32_t Trials)
{ 
  return (HAL_I2C_IsDeviceReady(&hi2c2, DevAddress, Trials, 3000));
}
HAL_StatusTypeDef EEPROM_I2C_IO_IsDeviceReady(uint16_t DevAddress, uint32_t Trials)
{ 
  return (I2Cx_IsDeviceReady(DevAddress, Trials));
}

static uint32_t EEPROM_I2C_Init(void)
{

  /*Select the EEPROM address for M24C32 or M24C64 and check if OK*/
  EEPROMAddress = EEPROM_M24C32_ID;
  EEPROMPageSize = MAXEEPROM_LENG;
  if (EEPROM_I2C_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK) 
  {
    EEPROMPageSize = 16;
    /*Select the EEPROM address for M24C08 (BLOCK0) and check if OK*/
    EEPROMAddress = EEPROM_ADDRESS_M24C08_BLOCK0;
    if (EEPROM_I2C_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK) 
    {
      /*Select the EEPROM address for M24C08 (BLOCK1) and check if OK*/
      EEPROMAddress = EEPROM_ADDRESS_M24C08_BLOCK1;
      if (EEPROM_I2C_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK) 
      {
        /*Select the EEPROM address for M24C08 (BLOCK2) and check if OK*/
        EEPROMAddress = EEPROM_ADDRESS_M24C08_BLOCK2;
        if (EEPROM_I2C_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK) 
        {
          /*Select the EEPROM address for M24C08 (BLOCK3) and check if OK*/
          EEPROMAddress = EEPROM_ADDRESS_M24C08_BLOCK3;
          if (EEPROM_I2C_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK) 
          {
            return EEPROM_FAIL;
          }
        }
      }
    }
  }

  return EEPROM_OK;
}

void EEPROM_M24C08_Init(void){
    uint8_t* data = 0;
    int16_t DL_Main_Atten[4] = {0,};
    int16_t DL_Offset_Atten[4] = {0,};

    int16_t UL_Main_Atten[4] = {0,};
    int16_t UL_Offset_Atten[4] = {0,};
    int16_t UL_ALC_Atten[4] = {0,};

    int16_t DL_High_ThreasHold = 0;
    int16_t DL_Low_ThreasHold = 0;

    int16_t UL_Hihh_ThreasHold = 0;

    bool DL_Path[4] = {0,};

    bool UL_Path[4] = {0,};    

    bool ALC_Path = 0;        
    bool AGC_Path = 0;            

    bool DL_shutdown_Path = 0;
    bool UL_shutdown_Path = 0;

    int16_t DL_Shutdown_ThreadHold = 0;        
    int16_t UL_Shutdown_ThreadHold = 0; 
    

//    DL_High_ThreasHold = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
//    ALC_TEMP[0] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
//    ALC_TEMP[1] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L;
//    ALC_TEMP[2] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L;
//    ALC_TEMP[3] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_WINDOW_STATUS_ADDRESDS,&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st) );

    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_ATT_BASE              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_ATT_DL1_TABLE_ADDRESDS,&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_ATT_DL2_TABLE_ADDRESDS,&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_ATT_DL3_TABLE_ADDRESDS,&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_ATT_DL4_TABLE_ADDRESDS,&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_ATT_UL1_TABLE_ADDRESDS,&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_ATT_UL2_TABLE_ADDRESDS,&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_ATT_UL3_TABLE_ADDRESDS,&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_ATT_UL4_TABLE_ADDRESDS,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_DET_DL1_TABLE_ADDRESDS,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_DET_DL2_TABLE_ADDRESDS,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_DET_DL3_TABLE_ADDRESDS,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );

    uint8_t* tmpdata;
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_DET_DL4_TABLE_ADDRESDS,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
    tmpdata = &Det_UL1.Table_Det_15_dBm_H;
//    for(int i =0; i < sizeof(DET_TABLEUL_st) ; i++){
//        printf("[%d]%f \r\n",i,(tmpdata[i * 2] << 8 | tmpdata[i*2+1])*0.001);
//    }
//    printf("");
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_DET_UL1_TABLE_ADDRESDS,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
//    data = &Det_UL2.Table_Det_15_dBm_H;
//    for(int i = 0; i < sizeof(DET_TABLEUL_st) ; i ++ ){
//        printf("[%d] %x \r\n",i,data[i]);       
//    }    
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_DET_UL2_TABLE_ADDRESDS,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
//    data = &Det_UL3.Table_Det_15_dBm_H;
//    for(int i = 0; i < sizeof(DET_TABLEUL_st) ; i ++ ){
//        printf("[%d] %x \r\n",i,data[i]);       
//    }    
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_DET_UL3_TABLE_ADDRESDS,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );


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


    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_TEMP_DL4_TABLE_ADDRESDS,&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_TEMP_UL1_TABLE_ADDRESDS,&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_TEMP_UL2_TABLE_ADDRESDS,&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C32_ID,EEPROM_TEMP_UL3_TABLE_ADDRESDS,&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );
    Table_Init();
#if 0 // PYJ.2020.06.28_BEGIN -- 
    DL_Main_Atten[Test_DL1] = (bluecell_Currdatastatus.ATT_DL1_H << 8) | bluecell_Currdatastatus.ATT_DL1_L;
    DL_Main_Atten[Test_DL2] = bluecell_Currdatastatus.ATT_DL2_H << 8 | bluecell_Currdatastatus.ATT_DL2_L;
    DL_Main_Atten[Test_DL3] = bluecell_Currdatastatus.ATT_DL3_H << 8 | bluecell_Currdatastatus.ATT_DL3_L;
    DL_Main_Atten[Test_DL4] = bluecell_Currdatastatus.ATT_DL4_H << 8 | bluecell_Currdatastatus.ATT_DL4_L;

    DL_Offset_Atten[Test_DL1] = bluecell_Currdatastatus.bluecell_User_DL1_H << 8 | bluecell_Currdatastatus.bluecell_User_DL1_L;
    DL_Offset_Atten[Test_DL2] = bluecell_Currdatastatus.bluecell_User_DL2_H << 8 | bluecell_Currdatastatus.bluecell_User_DL2_L;
    DL_Offset_Atten[Test_DL3] = bluecell_Currdatastatus.bluecell_User_DL3_H << 8 | bluecell_Currdatastatus.bluecell_User_DL3_L;
    DL_Offset_Atten[Test_DL4] = bluecell_Currdatastatus.bluecell_User_DL4_H << 8 | bluecell_Currdatastatus.bluecell_User_DL4_L;
    

    UL_Main_Atten[Test_UL1] = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
    UL_Main_Atten[Test_UL2] = bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L;
    UL_Main_Atten[Test_UL3] = bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L;
    UL_Main_Atten[Test_UL4] = bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L;

    UL_Offset_Atten[Test_UL1] = bluecell_Currdatastatus.bluecell_User_UL1_H << 8 | bluecell_Currdatastatus.bluecell_User_UL1_L;
    UL_Offset_Atten[Test_UL2] = bluecell_Currdatastatus.bluecell_User_UL2_H << 8 | bluecell_Currdatastatus.bluecell_User_UL2_L;
    UL_Offset_Atten[Test_UL3] = bluecell_Currdatastatus.bluecell_User_UL3_H << 8 | bluecell_Currdatastatus.bluecell_User_UL3_L;
    UL_Offset_Atten[Test_UL4] = bluecell_Currdatastatus.bluecell_User_UL4_H << 8 | bluecell_Currdatastatus.bluecell_User_UL4_L;

    UL_ALC_Atten[Test_UL1] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
    UL_ALC_Atten[Test_UL2] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L;
    UL_ALC_Atten[Test_UL3] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L;
    UL_ALC_Atten[Test_UL4] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
#endif // PYJ.2020.06.28_END -- 
#if 0 // PYJ.2020.06.28_BEGIN -- 

    for(int i = 0; i < 4; i++)
        printf("DL       : %d \r\n",DL_Main_Atten[Test_DL1+i]);
    for(int i = 0; i < 4; i++)
        printf("DL Offset: %d \r\n",DL_Offset_Atten[Test_DL1+i]);
    for(int i = 0; i < 4; i++)
        printf("UL       : %d \r\n",UL_Main_Atten[Test_DL1+i]);
    for(int i = 0; i < 4; i++)
        printf("UL Offset: %d \r\n",UL_Offset_Atten[Test_DL1+i]);
    for(int i = 0; i < 4; i++)
        printf("UL ALC: %d \r\n",UL_ALC_Atten[Test_DL1+i]);    
#endif // PYJ.2020.06.28_END -- 
    /*Table Initial Length Setting */
#if 0 // PYJ.2020.06.23_BEGIN -- 
        printf("Init Temp_UL3 Length : %d \r\n",Temp_UL3.Table_Length);
        Bluecell_DataCopy(testdata, &Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
        for(int i = 0; i < sizeof(TEMP_TABLE_st); i++){
            printf("\r\n testdata[%d] : %x ",i,testdata[i]);
        }
#endif // PYJ.2020.06.23_END -- 
    bluecell_Currdatastatus.ALARM_TEMP_HIGH = 0; //bit
    bluecell_Currdatastatus.ALARM_DLI_Level = 0;
    bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN = 0;
    bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm = 0;
    bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm = 0;    
    bluecell_Currdatastatus.ALARM_ULO_Level = 0;
    bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN = 0;
    bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 = 0;    
    bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 = 0;    
    bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = 0;    
    bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 = 0;    
    bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1 = 0;        
    bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2 = 0;        
    bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3 = 0;            
    bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 = 0;        
//    bluecell_Currdatastatus.CPUVERSION1 =  0;
//    bluecell_Currdatastatus.CPUVERSION2 = 0;
//    bluecell_Currdatastatus.CPUVERSION3 = 8;
#if 0 // PYJ.2020.06.28_BEGIN -- 

    Att_DL1.Table_Ref = ATTENTABLEDL_REF;
    Att_DL2.Table_Ref = ATTENTABLEDL_REF;
    Att_DL3.Table_Ref = ATTENTABLEDL_REF;
    Att_DL4.Table_Ref = ATTENTABLEDL_REF;
    Att_UL1.Table_Ref = ATTENTABLEUL_REF;
    Att_UL2.Table_Ref = ATTENTABLEUL_REF;
    Att_UL3.Table_Ref = ATTENTABLEUL_REF;
    Att_UL4.Table_Ref = ATTENTABLEUL_REF;
    Det_DL1.Table_Ref = ATTENTABLEDET_DL_REF;
    Det_DL2.Table_Ref = ATTENTABLEDET_DL_REF;
    Det_DL3.Table_Ref = ATTENTABLEDET_DL_REF;
    Det_DL4.Table_Ref = ATTENTABLEDET_DL_REF;
    Det_UL1.Table_Ref = ATTENTABLEDET_UL_REF;
    Det_UL2.Table_Ref = ATTENTABLEDET_UL_REF;
    Det_UL3.Table_Ref = ATTENTABLEDET_UL_REF;
    Det_UL4.Table_Ref = ATTENTABLEDET_UL_REF;
    Temp_DL1.Table_Ref= ATTENTABLE_TEMP_REF;
    Temp_DL2.Table_Ref= ATTENTABLE_TEMP_REF;
    Temp_DL3.Table_Ref= ATTENTABLE_TEMP_REF;
    Temp_DL4.Table_Ref= ATTENTABLE_TEMP_REF;
    Temp_UL1.Table_Ref= ATTENTABLE_TEMP_REF;
    Temp_UL2.Table_Ref= ATTENTABLE_TEMP_REF;
    Temp_UL3.Table_Ref= ATTENTABLE_TEMP_REF;
    Temp_UL4.Table_Ref= ATTENTABLE_TEMP_REF;        
      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_ATT_BASE              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_ATT_DL1_TABLE_ADDRESDS,&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_ATT_DL2_TABLE_ADDRESDS,&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_ATT_DL3_TABLE_ADDRESDS,&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );

      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_ATT_DL4_TABLE_ADDRESDS,&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_ATT_UL1_TABLE_ADDRESDS,&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_ATT_UL2_TABLE_ADDRESDS,&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_ATT_UL3_TABLE_ADDRESDS,&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );

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


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


      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_DET_UL4_TABLE_ADDRESDS,&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st) );
      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_TEMP_DL1_TABLE_ADDRESDS,&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st) );
      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_TEMP_DL2_TABLE_ADDRESDS,&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_TEMP_DL3_TABLE_ADDRESDS,&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );


      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_TEMP_DL4_TABLE_ADDRESDS,&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st) );
      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_TEMP_UL1_TABLE_ADDRESDS,&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st) );
      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_TEMP_UL2_TABLE_ADDRESDS,&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
      EEPROM_M24C08_write(EEPROM_M24C32_ID,EEPROM_TEMP_UL3_TABLE_ADDRESDS,&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );

#endif // PYJ.2020.06.28_END -- 

    bluecell_Currdatastatus.ALARM_TEMP_HIGH          = 0;
    bluecell_Currdatastatus.ALARM_DLI_Level          = 0;
    bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN  = 0;
    bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm      = 0;
    bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm      = 0;
    bluecell_Currdatastatus.ALARM_ULO_Level          = 0;
    bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN  = 0;

//    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_M24C32_ID,EEPROM_ATT_BASE + i,&eepdata[i],1);
    }  
    for(int i = 0; i < 100; i ++ ){
        EEPROM_M24C08_ByteRead(EEPROM_M24C32_ID,EEPROM_ATT_BASE + i,&eepdata[i],1);
        printf("data[%d] : %x \r\n",i,eepdata[i]);
    }  
//    EEPROM_M24C08_Read(EEPROM_M24C32_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 -- 



HAL_StatusTypeDef EEPROM_M24C08_Read(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;

 //  uint16_t sizecnt = 0,
   //uint16_t 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);

   EEPROM_I2C_Init();

#if 1 // PYJ.2020.06.28_BEGIN -- 
   ret = HAL_I2C_Mem_Read(&hi2c2, devid ,((Address )),  I2C_MEMADD_SIZE_16BIT, &data[0], size, 0xFFFF);
//      EEPROM24XX_Load( Address,data, size);

      if(ret == HAL_ERROR)
            printf("Write ERR\r\n");
#else
    if(sizecnt > 0){
        for(int i = 0 ; i < sizecnt; i++ ){
             addrees_inc = i * MAXEEPROM_LENG;
             ret = HAL_I2C_Mem_Read(&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");
             
             HAL_Delay(20);
        }
        addrees_inc += MAXEEPROM_LENG;
    }

#endif // PYJ.2020.06.28_END -- 


    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;
    EEPROM_I2C_Init();    
#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;


            EEPROM_I2C_Init();
             ret = HAL_I2C_Mem_Write(&hi2c2, devid  ,((Address + addrees_inc) & 0xFFFF) ,  I2C_MEMADD_SIZE_16BIT, &data[addrees_inc], MAXEEPROM_LENG, 0xFFFF);
             HAL_Delay(20);

             if(ret == HAL_ERROR)
                 printf("Write ERR\r\n");
             
        }
        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, 0xFFFF);
         //       EEPROM24XX_Save( Address,data, size);
         if(ret == HAL_ERROR)
             printf("Write ERR\r\n");
         
          HAL_Delay(20);
        }
    }
//    printf("EEPROM WRITE\r\n");

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

HAL_StatusTypeDef EEPROM_M24C08_Zerowrite(uint8_t devid,uint16_t Address){
    HAL_StatusTypeDef ret = HAL_ERROR;
   // uint8_t sizeremain = 0;
    uint16_t addrees_inc = 0;
    addrees_inc = 0;
    uint8_t data[4096] = {0,};
    printf("EEPROM ALL ERASE \r\n");

    for(int i = 0 ; i < 128; i++ ){
         addrees_inc = i * MAXEEPROM_LENG;
         ret = HAL_I2C_Mem_Write(&hi2c2, devid  ,((Address + addrees_inc) & 0xFFFF) ,  I2C_MEMADD_SIZE_16BIT, &data[0], MAXEEPROM_LENG, 0xFFFF);
         if(ret == HAL_ERROR)
             printf("Write ERR\r\n");
         else
             HAL_Delay(20);
    }


    return ret;
}