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);
extern void Table_Init();

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,    
};*/
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_M24C08_ID,EEPROM_WINDOW_STATUS_ADDRESDS,&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st) );

    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );

    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL1_TABLE_ADDRESDS,&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL2_TABLE_ADDRESDS,&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL3_TABLE_ADDRESDS,&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );

    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL4_TABLE_ADDRESDS,&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL1_TABLE_ADDRESDS,&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL2_TABLE_ADDRESDS,&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL3_TABLE_ADDRESDS,&Att_UL4.Table_0_0_dBm,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) );

//    uint8_t* tmpdata;
    EEPROM_M24C08_Read(EEPROM_M24C08_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_M24C08_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_M24C08_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_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_1_Temp,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL1_TABLE_ADDRESDS,&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL2_TABLE_ADDRESDS,&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL3_TABLE_ADDRESDS,&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );


    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL4_TABLE_ADDRESDS,&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL1_TABLE_ADDRESDS,&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL2_TABLE_ADDRESDS,&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL3_TABLE_ADDRESDS,&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );
    Table_Init();
    printf("ATT TableDL 1_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_DL1.Table_Length,Att_DL1.Table_Ref);
    printf("ATT TableDL 2_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_DL2.Table_Length,Att_DL2.Table_Ref);
    printf("ATT TableDL 3_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_DL3.Table_Length,Att_DL3.Table_Ref);    
    printf("ATT TableDL 4_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_DL4.Table_Length,Att_DL4.Table_Ref);
    printf("ATT TableUL 1_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_UL1.Table_Length,Att_UL1.Table_Ref);
    printf("ATT TableUL 2_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_UL2.Table_Length,Att_UL2.Table_Ref);
    printf("ATT TableUL 3_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_UL3.Table_Length,Att_UL3.Table_Ref);    
    printf("ATT TableUL 4_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_UL4.Table_Length,Att_UL4.Table_Ref);    

    printf("DET TableDL 1_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL1.Table_Length,Det_DL1.Table_Ref);
    printf("DET TableDL 2_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL2.Table_Length,Det_DL2.Table_Ref);
    printf("DET TableDL 3_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL3.Table_Length,Det_DL3.Table_Ref);    
    printf("DET TableDL 4_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL4.Table_Length,Det_DL4.Table_Ref);
    printf("DET TableUL 1_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_UL1.Table_Length,Det_UL1.Table_Ref);
    printf("DET TableUL 2_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_UL2.Table_Length,Det_UL2.Table_Ref);
    printf("DET TableUL 3_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_UL3.Table_Length,Det_UL3.Table_Ref);    
    printf("DET TableUL 4_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_UL4.Table_Length,Det_UL4.Table_Ref);    
//    printf("DL1\r\n");    Table_DET_DataSetting(&DL_Table_ref[AGC_Table_DL1_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_DL1.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_DL1.Table_Length);
//    printf("DL2\r\n");    Table_DET_DataSetting(&DL_Table_ref[AGC_Table_DL2_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_DL2.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_DL2.Table_Length);
//    printf("DL3\r\n");    Table_DET_DataSetting(&DL_Table_ref[AGC_Table_DL3_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_DL3.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_DL3.Table_Length);
//    printf("DL4\r\n");    Table_DET_DataSetting(&DL_Table_ref[AGC_Table_DL4_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_DL4.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_DL4.Table_Length);
//    printf("UL1\r\n");    Table_DET_DataSetting(&UL_Table_ref[ALC_Table_UL1_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_UL1.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_UL1.Table_Length);
//    printf("UL2\r\n");    Table_DET_DataSetting(&UL_Table_ref[ALC_Table_UL2_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_UL2.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_UL2.Table_Length);
//    printf("UL3\r\n");    Table_DET_DataSetting(&UL_Table_ref[ALC_Table_UL3_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_UL3.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_UL3.Table_Length);
//    printf("UL4\r\n");    Table_DET_DataSetting(&UL_Table_ref[ALC_Table_UL4_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_UL4.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_UL4.Table_Length);

#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.DLI_FRBT_Atten1_H = 0;
    bluecell_Currdatastatus.DLI_FRBT_Atten2_H = 0;
    bluecell_Currdatastatus.DLI_FRBT_Atten3_H = 0;
    bluecell_Currdatastatus.DLI_FRBT_Atten4_H = 0;
    bluecell_Currdatastatus.DLI_FRBT_Atten1_L = 0;    
    bluecell_Currdatastatus.DLI_FRBT_Atten2_L = 0;    
    bluecell_Currdatastatus.DLI_FRBT_Atten3_L = 0;    
    bluecell_Currdatastatus.DLI_FRBT_Atten4_L = 0;
    bluecell_Currdatastatus.DLI_FRBT_D_Day = 0;
    bluecell_Currdatastatus.Selftest1 = false;
    bluecell_Currdatastatus.Selftest2 = false;
    bluecell_Currdatastatus.Selftest3 = false;
    bluecell_Currdatastatus.Selftest4 = false;    
//    bluecell_Currdatastatus.DLI_FRBT_Status = 7;
    bluecell_Currdatastatus.ALARM_TESTMODE = 0;
    bluecell_Currdatastatus.Type = 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_M24C08_ID,EEPROM_ATT_BASE              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_DL1_TABLE_ADDRESDS,&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_DL2_TABLE_ADDRESDS,&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_DL3_TABLE_ADDRESDS,&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_DL4_TABLE_ADDRESDS,&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_UL1_TABLE_ADDRESDS,&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_UL2_TABLE_ADDRESDS,&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_UL3_TABLE_ADDRESDS,&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
    
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_UL4_TABLE_ADDRESDS,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL1_TABLE_ADDRESDS,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL2_TABLE_ADDRESDS,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL3_TABLE_ADDRESDS,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
    
    
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL4_TABLE_ADDRESDS,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL1_TABLE_ADDRESDS,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL2_TABLE_ADDRESDS,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL3_TABLE_ADDRESDS,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
    
    
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL4_TABLE_ADDRESDS,&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_DL1_TABLE_ADDRESDS,&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_DL2_TABLE_ADDRESDS,&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_DL3_TABLE_ADDRESDS,&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );
    
    
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_DL4_TABLE_ADDRESDS,&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_UL1_TABLE_ADDRESDS,&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_UL2_TABLE_ADDRESDS,&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_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_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;
   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);


#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;
#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");
             
             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, 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;
}