STM32F103ZET_JDASMBIC/Bluecell_Src/Bluecell_operate.c

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "main.h"
#include "Bluecell_operate.h"
#include "PE43711.h"
#include "eeprom.h"

extern volatile uint32_t LedTimerCnt;
extern volatile uint32_t AdcTimerCnt;
extern void PE43711_atten_ctrl(PE43711_st ATT ,uint8_t data);
extern void Uart1_Data_Send(uint8_t* data,uint8_t size);
double AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size);
void Bluecell_StructCpy(uint8_t* dst,uint8_t* src,uint16_t size);
void DataStatusSet(void);
void Alarm_Check();

uint8_t Alarm_Status[MAX_ALARM_Len] = {0,};
//uint8_t data123[10000];
uint8_t ResultData[1024] = {0,};
uint8_t DataWrite[512] = {0,};
uint8_t DataRead[512] = {0,};


typedef enum{
BLUECELL_HEADER,
BLUECELL_TYPE,
BLUECELL_LENGTH,
BLUECELL_CRCINDEX,
BLUECELL_DATA,
}BLUECELLProt_st;


typedef enum{
    Bluecell_Table_ATT_DL1 = 0,
    Bluecell_Table_ATT_UL1,
    Bluecell_Table_ATT_DL2,
    Bluecell_Table_ATT_UL2,
    Bluecell_Table_ATT_DL3,
    Bluecell_Table_ATT_UL3,
    Bluecell_Table_ATT_DL4,
    Bluecell_Table_ATT_UL4,
    Bluecell_Table_DET_DL1,
    Bluecell_Table_DET_UL1,
    Bluecell_Table_DET_DL2,
    Bluecell_Table_DET_UL2,
    Bluecell_Table_DET_DL3,
    Bluecell_Table_DET_UL3,
    Bluecell_Table_DET_DL4,
    Bluecell_Table_DET_UL4,
    Bluecell_Table_TEMP_DL1,
    Bluecell_Table_TEMP_UL1,
    Bluecell_Table_TEMP_DL2,
    Bluecell_Table_TEMP_UL2,
    Bluecell_Table_TEMP_DL3,
    Bluecell_Table_TEMP_UL3,
    Bluecell_Table_TEMP_DL4,
    Bluecell_Table_TEMP_UL4,
}Bluecell_tableIndex;
typedef enum{
    MBIC_PROT_PREAMBLE0_INDEX,
    MBIC_PROT_PREAMBLE1_INDEX,
    MBIC_PROT_PREAMBLE2_INDEX,
    MBIC_PROT_PREAMBLE3_INDEX,    
    MBIC_PROT_SUB_UID0_INDEX,        
    MBIC_PROT_SUB_UID1_INDEX,            
    MBIC_PROT_R_CODE_INDEX,                
    MBIC_PROT_TR_ID0_INDEX,                    
    MBIC_PROT_TR_ID1_INDEX,                        
    MBIC_PROT_SEQ_NUM_INDEX,                            
    MBIC_PROT_TTL_INDEX,                                
    MBIC_PROT_TIME0_INDEX,                                    
    MBIC_PROT_TIME1_INDEX,                                    
    MBIC_PROT_TIME2_INDEX,                                    
    MBIC_PROT_TIME3_INDEX,                                    
    MBIC_PROT_TIME4_INDEX,                                    
    MBIC_PROT_TIME5_INDEX,  
    MBIC_PROT_ERR_RESP_INDEX,      
    MBIC_PROT_CMD_INDEX,          
    MBIC_PROT_LENGTH_INDEX,              
    MBIC_PROT_HEADERCHECKSUM_INDEX,  
    MBIC_PROT_SUB_DATA_INDEX,      

    MBIC_PROT_INDEX_MAX,

};
    
ATT_TABLE_st Att_DL1;
ATT_TABLE_st Att_DL2;
ATT_TABLE_st Att_DL3;
ATT_TABLE_st Att_DL4;
ATT_TABLE_st Att_UL1;
ATT_TABLE_st Att_UL2;
ATT_TABLE_st Att_UL3;
ATT_TABLE_st Att_UL4;

DET_TABLEDL_st Det_DL1;
DET_TABLEDL_st Det_DL2;
DET_TABLEDL_st Det_DL3;
DET_TABLEDL_st Det_DL4;

DET_TABLEUL_st Det_UL1;
DET_TABLEUL_st Det_UL2;
DET_TABLEUL_st Det_UL3;
DET_TABLEUL_st Det_UL4;

TEMP_TABLE_st Temp_DL1;
TEMP_TABLE_st Temp_DL2;
TEMP_TABLE_st Temp_DL3;
TEMP_TABLE_st Temp_DL4;

TEMP_TABLE_st Temp_UL1;
TEMP_TABLE_st Temp_UL2;
TEMP_TABLE_st Temp_UL3;
TEMP_TABLE_st Temp_UL4;
extern ALL_PE43711_st ALL_ATT;
BLUESTATUS_st bluecell_Currdatastatus;
BLUESTATUS_st bluecell_Prevdatastatus;
typedef struct{
    bool AGC1_En;
    bool AGC2_En;
    bool AGC3_En;
    bool AGC4_En;
    bool ALC1_En;
    bool ALC2_En;
    bool ALC3_En;
    bool ALC4_En;
}AutoCtrl_st;

//5~ - 25 
typedef struct{
    int8_t DET_DL_0;
    int8_t DET_DL_1;
    int8_t DET_DL_2;
    int8_t DET_DL_3;
    int8_t DET_DL_4;
    int8_t DET_DL_5;
    int8_t DET_DL_6;
    int8_t DET_DL_7;
    int8_t DET_DL_8;
    int8_t DET_DL_9;
    int8_t DET_DL_10;
    int8_t DET_DL_11;
    int8_t DET_DL_12;
    int8_t DET_DL_13;
    int8_t DET_DL_14;
    int8_t DET_DL_15;
    int8_t DET_DL_16;
    int8_t DET_DL_17;
    int8_t DET_DL_18;
    int8_t DET_DL_19;
    int8_t DET_DL_20;
    int8_t DET_DL_21;
    int8_t DET_DL_22;
    int8_t DET_DL_23;
    int8_t DET_DL_24;
    int8_t DET_DL_25;
    int8_t DET_DL_26;
    int8_t DET_DL_27;
    int8_t DET_DL_28;
    int8_t DET_DL_29;
    int8_t DET_DL_30;
}AGC_dBm_t;
typedef struct{
    int8_t DET_UL_0;
    int8_t DET_UL_1;
    int8_t DET_UL_2;
    int8_t DET_UL_3;
    int8_t DET_UL_4;
    int8_t DET_UL_5;
    int8_t DET_UL_6;
    int8_t DET_UL_7;
    int8_t DET_UL_8;
    int8_t DET_UL_9;
    int8_t DET_UL_10;
    int8_t DET_UL_11;
    int8_t DET_UL_12;
    int8_t DET_UL_13;
    int8_t DET_UL_14;
    int8_t DET_UL_15;
    int8_t DET_UL_16;
    int8_t DET_UL_17;
    int8_t DET_UL_18;
    int8_t DET_UL_19;
    int8_t DET_UL_20;
    int8_t DET_UL_21;
    int8_t DET_UL_22;
    int8_t DET_UL_23;
    int8_t DET_UL_24;
    int8_t DET_UL_25;
    int8_t DET_UL_26;
    int8_t DET_UL_27;
    int8_t DET_UL_28;
    int8_t DET_UL_29;
    int8_t DET_UL_30;
    int8_t DET_UL_31;
    int8_t DET_UL_32;
    int8_t DET_UL_33;
    int8_t DET_UL_34;
    int8_t DET_UL_35;
    int8_t DET_UL_36;
    int8_t DET_UL_37;
    int8_t DET_UL_38;
    int8_t DET_UL_39;
    int8_t DET_UL_40;
    int8_t DET_UL_41;
    int8_t DET_UL_42;
    int8_t DET_UL_43;
    int8_t DET_UL_44;
    int8_t DET_UL_45;
}ALC_dBm_t;
int8_t AGC_Table_ref[sizeof(AGC_dBm_t)] = {
     5   ,    4   ,    3   ,    2   ,
     1   ,    0   ,    -1  ,    -2  ,
    -3  ,    -4  ,    -5  ,    -6  ,
    -7  ,    -8  ,    -9  ,    -10 ,
    -11 ,    -12 ,    -13 ,    -14 ,
    -15 ,    -16 ,    -17 ,    -18 ,
    -19 ,    -20 ,    -21 ,    -22 ,
    -23 ,    -24 ,    -25 ,  

};
int8_t AGC_ATTEN_ref[16] = {
    15  ,
    14  ,
    13  ,
    12  ,
    11  ,
    10  ,
    9   ,
    8   ,
    7   ,
    6   ,
    5   ,
    4   ,
    3   ,
    2   ,
    1   ,
    0   ,
};

ALC_dBm_t ALC_Table_ref = {
    -15 ,    -16 ,    -17 ,    -18 ,  -19 ,
    -20 ,    -21 ,    -22 ,    -23 ,  -24 ,    -25 ,    -26 ,    -27 ,
    -28 ,    -29 ,    -30 ,    -31 ,  -32 ,    -33 ,    -34 ,    -35 ,
    -36 ,    -37 ,    -38 ,    -39 ,  -40 ,    -41 ,    -42 ,    -43 ,
    -44 ,    -45 ,    -46 ,    -47 ,  -48 ,    -49 ,    -50 ,    -51 ,
    -52 ,    -53 ,    -54 ,    -55 ,  -56 ,    -57 ,    -58 ,    -59 ,
    -60 ,

};




double TableAtteGuarantee(uint8_t* Table,double AttenValue);
uint8_t PE43711_Calc(uint8_t* Table,uint8_t high_bit,uint8_t low_bit,uint8_t offset_h,uint8_t offset_l);
uint8_t PE43711_Calc_NoTable(uint8_t high_bit,uint8_t low_bit);
double PE43711_Double(uint8_t high_bit,uint8_t low_bit);
int8_t AutoControl_Save[sizeof(ALC_dBm_t)];

uint8_t MBIC_TxDataArray[256] = {0,};


void Boot_LED_Toggle(void){
  if(LedTimerCnt > 500){
    HAL_GPIO_TogglePin(BOOT_LED_GPIO_Port,BOOT_LED_Pin);
    HAL_GPIO_TogglePin(LED_ACT_GPIO_Port,LED_ACT_Pin);
    HAL_GPIO_TogglePin(LED_FAIL_GPIO_Port,LED_FAIL_Pin);  
    LedTimerCnt = 0;
//    printf("LED OF OFF\r\n");
  }
}





uint8_t PE43711_Calc(uint8_t* Table,uint8_t high_bit,uint8_t low_bit,uint8_t offset_h,uint8_t offset_l){

    double ret = 0;
    uint8_t Result = 0;
    ret = PE43711_Double(high_bit,low_bit);
    ret += PE43711_Double(offset_h,offset_l);
    ret += PE43711_Double(0,HIDDENATTEN);
//    printf("ret1 : %f \r\n",ret); // 2
    ret = TableAtteGuarantee(Table,ret);//Table Guarantee
//    printf("ret2 : %f \r\n",ret);
    Result = PE43711_DataToHexConvert(ret);
    return Result;
}
uint8_t PE43711_Calc_NoTable(uint8_t high_bit,uint8_t low_bit){

    double ret = 0;

    ret = PE43711_Double(high_bit,low_bit);

    PE43711_DataToHexConvert(ret);
    return 0;
}
/*2 byte Data Double Convert Function*/
double PE43711_Double(uint8_t high_bit,uint8_t low_bit){
    uint16_t tmp_h = 0,tmp_l = 0;
    double ret = 0;

    tmp_h = high_bit;
    tmp_l = low_bit;
    ret = ((tmp_h << 8) & 0xFF00);
    ret += (tmp_l & 0x00FF);
    /*Minus Convert*/
    if((((tmp_h << 8) & 0xFF00) & 0xF000) == 0xF000){
//        printf("minus Calc Start\r\n");
        ret = 0xFFFF - ret;
//        printf("0xFFFF - %x\r\n",ret);
        ret += 0x01;
        ret = ret - (2*ret);
//        printf("ret :  %x\r\n",ret);        
    }
//    printf("%s 1: ret : %x\r\n",__func__,ret);
    ret /= 10;
//    printf("%s 2: ret : %f\r\n",__func__,ret);
    return ret;

}
double TableAtteGuarantee(uint8_t* Table,double AttenValue){
    int8_t GuaranteeData[256];
    double ret = 0;
    //double ref = 0;
    uint8_t cnt = 0;
    for(double ref = 0; ref < AttenValue; ref += 0.5){
        cnt++;       
    }
    
    Bluecell_StructCpy(&GuaranteeData[0],&Table[0],sizeof(ATT_TABLE_st));
    
//    printf("H  : %x   L : %x \r\n",GuaranteeData[cnt * 2],GuaranteeData[cnt * 2 + 1]);
    ret =  GuaranteeData[cnt] / 2;
//= PE43711_Double(GuaranteeData[cnt * 2],GuaranteeData[cnt * 2 + 1]);
//    printf("ret3 : %f \r\n",ret); //1
    ret += AttenValue;
//    printf("ret4 : %f \r\n",ret);
    return ret;

}


void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
     uint8_t val = 0;


    if((Curr.ATT_DL1_H != Prev.ATT_DL1_H
     ||Curr.ATT_DL1_L != Prev.ATT_DL1_L)
     ||(Curr.bluecell_User_DL1_H != Prev.bluecell_User_DL1_H
     ||Curr.bluecell_User_DL1_L != Prev.bluecell_User_DL1_L)){
//         printf("%s : %d \r\n",__func__,__LINE__);   
            bluecell_Prevdatastatus.ATT_DL1_H = bluecell_Currdatastatus.ATT_DL1_H;
            bluecell_Prevdatastatus.ATT_DL1_L = bluecell_Currdatastatus.ATT_DL1_L;
            bluecell_Prevdatastatus.bluecell_User_DL1_H = bluecell_Currdatastatus.bluecell_User_DL1_H;
            bluecell_Prevdatastatus.bluecell_User_DL1_L = bluecell_Currdatastatus.bluecell_User_DL1_L;
            val = PE43711_Calc(&Att_DL1.Table_0_0_dBm,
                                Curr.ATT_DL1_H,
                                Curr.ATT_DL1_L,
                               bluecell_Currdatastatus.bluecell_User_DL1_H,
                               bluecell_Currdatastatus.bluecell_User_DL1_L);
//            printf("%s : %d \r\n",__func__,__LINE__);   
//            printf("%d val = %x \r\n",__LINE__,val);
            PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);
     
    }
    if((Curr.ATT_DL2_H != Prev.ATT_DL2_H)
     ||(Curr.ATT_DL2_L != Prev.ATT_DL2_L)
     ||(Curr.bluecell_User_DL2_H != Prev.bluecell_User_DL2_H
     ||Curr.bluecell_User_DL2_L != Prev.bluecell_User_DL2_L)){
            bluecell_Prevdatastatus.ATT_DL2_H = bluecell_Currdatastatus.ATT_DL2_H;
            bluecell_Prevdatastatus.ATT_DL2_L = bluecell_Currdatastatus.ATT_DL2_L;
            bluecell_Prevdatastatus.bluecell_User_DL2_H = bluecell_Currdatastatus.bluecell_User_DL2_H;
            bluecell_Prevdatastatus.bluecell_User_DL2_L = bluecell_Currdatastatus.bluecell_User_DL2_L;
            val = PE43711_Calc(&Att_DL2.Table_0_0_dBm,
                                Curr.ATT_DL2_H,
                                Curr.ATT_DL2_L,
                               bluecell_Currdatastatus.bluecell_User_DL2_H,
                               bluecell_Currdatastatus.bluecell_User_DL2_L);
    //        printf("%d val = %x \r\n",__LINE__,val);
            PE43711_atten_ctrl(ALL_ATT.ATT_DL2,val);
    }
     
    if((Curr.ATT_DL3_H != Prev.ATT_DL3_H
     ||Curr.ATT_DL3_L != Prev.ATT_DL3_L)
     ||(Curr.bluecell_User_DL3_H != Prev.bluecell_User_DL3_H
     ||Curr.bluecell_User_DL3_L != Prev.bluecell_User_DL3_L)){

        bluecell_Prevdatastatus.ATT_DL3_H = bluecell_Currdatastatus.ATT_DL3_H;
        bluecell_Prevdatastatus.ATT_DL3_L = bluecell_Currdatastatus.ATT_DL3_L;
        bluecell_Prevdatastatus.bluecell_User_DL3_H = bluecell_Currdatastatus.bluecell_User_DL3_H;
        bluecell_Prevdatastatus.bluecell_User_DL3_L = bluecell_Currdatastatus.bluecell_User_DL3_L;
        val = PE43711_Calc(&Att_DL3.Table_0_0_dBm,
                            Curr.ATT_DL3_H,
                            Curr.ATT_DL3_L,
                           bluecell_Currdatastatus.bluecell_User_DL3_H,
                           bluecell_Currdatastatus.bluecell_User_DL3_L);
//        printf("%d val = %x \r\n",__LINE__,val);
        PE43711_atten_ctrl(ALL_ATT.ATT_DL3,val);
    }
//    printf("\r\nCurr.ATT_DL3_H : %x \r\nPrev.ATT_DL3_H : %x \r\n",Curr.ATT_DL3_H,Prev.ATT_DL3_H);
//     printf("\r\nCurr.ATT_DL3_L : %x \r\nPrev.ATT_DL3_L : %x \r\n",Curr.ATT_DL3_L,Prev.ATT_DL3_L);
     
    if((Curr.ATT_DL4_H != Prev.ATT_DL4_H
     ||Curr.ATT_DL4_L != Prev.ATT_DL4_L)
     ||(Curr.bluecell_User_DL4_H != Prev.bluecell_User_DL4_H
     ||Curr.bluecell_User_DL4_L != Prev.bluecell_User_DL4_L)){
     
            bluecell_Prevdatastatus.ATT_DL4_H = bluecell_Currdatastatus.ATT_DL4_H;
            bluecell_Prevdatastatus.ATT_DL4_L = bluecell_Currdatastatus.ATT_DL4_L;
            bluecell_Prevdatastatus.bluecell_User_DL4_H = bluecell_Currdatastatus.bluecell_User_DL4_H;
            bluecell_Prevdatastatus.bluecell_User_DL4_L = bluecell_Currdatastatus.bluecell_User_DL4_L;
            val = PE43711_Calc(&Att_DL4.Table_0_0_dBm,
                                Curr.ATT_DL4_H,
                                Curr.ATT_DL4_L,
                               bluecell_Currdatastatus.bluecell_User_DL4_H,
                               bluecell_Currdatastatus.bluecell_User_DL4_L);
    //        printf("%d val = %x \r\n",__LINE__,val);
            PE43711_atten_ctrl(ALL_ATT.ATT_DL4,val);
    }

    
    if((Curr.ATT_UL1_H != Prev.ATT_UL1_H
     ||Curr.ATT_UL1_L != Prev.ATT_UL1_L)
     ||(Curr.bluecell_User_UL1_H != Prev.bluecell_User_UL1_H
     ||Curr.bluecell_User_UL1_L != Prev.bluecell_User_UL1_L)){
     
            bluecell_Prevdatastatus.ATT_UL1_H = bluecell_Currdatastatus.ATT_UL1_H;
            bluecell_Prevdatastatus.ATT_UL1_L = bluecell_Currdatastatus.ATT_UL1_L;
            bluecell_Prevdatastatus.bluecell_User_UL1_H = bluecell_Currdatastatus.bluecell_User_UL1_H;
            bluecell_Prevdatastatus.bluecell_User_UL1_L = bluecell_Currdatastatus.bluecell_User_UL1_L;
            val = PE43711_Calc(&Att_UL1.Table_0_0_dBm,
                                Curr.ATT_UL1_H,
                                Curr.ATT_UL1_L,
                               bluecell_Currdatastatus.bluecell_User_UL1_H,
                               bluecell_Currdatastatus.bluecell_User_UL1_L);
    //        printf("%d val = %x \r\n",__LINE__,val);
            PE43711_atten_ctrl(ALL_ATT.ATT_UL1,val);
    }
    if((Curr.ATT_UL2_H != Prev.ATT_UL2_H
     ||Curr.ATT_UL2_L != Prev.ATT_UL2_L)
     ||(Curr.bluecell_User_UL2_H != Prev.bluecell_User_UL2_H
     ||Curr.bluecell_User_UL2_L != Prev.bluecell_User_UL2_L)){
            bluecell_Prevdatastatus.ATT_UL2_H = bluecell_Currdatastatus.ATT_UL2_H;
            bluecell_Prevdatastatus.ATT_UL2_L = bluecell_Currdatastatus.ATT_UL2_L;
            bluecell_Prevdatastatus.bluecell_User_UL2_H = bluecell_Currdatastatus.bluecell_User_UL2_H;
            bluecell_Prevdatastatus.bluecell_User_UL2_L = bluecell_Currdatastatus.bluecell_User_UL2_L;
            val = PE43711_Calc(&Att_UL2.Table_0_0_dBm,
                                Curr.ATT_UL2_H,
                                Curr.ATT_UL2_L,
                               bluecell_Currdatastatus.bluecell_User_UL2_H,
                               bluecell_Currdatastatus.bluecell_User_UL2_L);
    //        printf("%d val = %x \r\n",__LINE__,val);
            PE43711_atten_ctrl(ALL_ATT.ATT_UL2,val);
    }
     
    if((Curr.ATT_UL3_H != Prev.ATT_UL3_H
     ||Curr.ATT_UL3_L != Prev.ATT_UL3_L)
     ||(Curr.bluecell_User_UL3_H != Prev.bluecell_User_UL3_H
     ||Curr.bluecell_User_UL3_L != Prev.bluecell_User_UL3_L))
     {
            bluecell_Prevdatastatus.ATT_UL3_H = bluecell_Currdatastatus.ATT_UL3_H;
            bluecell_Prevdatastatus.ATT_UL3_L = bluecell_Currdatastatus.ATT_UL3_L;
            bluecell_Prevdatastatus.bluecell_User_UL3_H = bluecell_Currdatastatus.bluecell_User_UL3_H;
            bluecell_Prevdatastatus.bluecell_User_UL3_L = bluecell_Currdatastatus.bluecell_User_UL3_L;
            
            val = PE43711_Calc(&Att_UL3.Table_0_0_dBm,
                                Curr.ATT_UL3_H,
                                Curr.ATT_UL3_L,
                               bluecell_Currdatastatus.bluecell_User_UL3_H,
                               bluecell_Currdatastatus.bluecell_User_UL3_L);
    //        printf("%d val = %x \r\n",__LINE__,val);
            PE43711_atten_ctrl(ALL_ATT.ATT_UL3,val);
    }
    if((Curr.ATT_UL4_H != Prev.ATT_UL4_H
     ||Curr.ATT_UL4_L != Prev.ATT_UL4_L)
     ||(Curr.bluecell_User_UL4_H != Prev.bluecell_User_UL4_H
     ||Curr.bluecell_User_UL4_L != Prev.bluecell_User_UL4_L)){
            bluecell_Prevdatastatus.ATT_UL4_H = bluecell_Currdatastatus.ATT_UL4_H;
            bluecell_Prevdatastatus.ATT_UL4_L = bluecell_Currdatastatus.ATT_UL4_L;
            bluecell_Prevdatastatus.bluecell_User_UL4_H = bluecell_Currdatastatus.bluecell_User_UL4_H;
            bluecell_Prevdatastatus.bluecell_User_UL4_L = bluecell_Currdatastatus.bluecell_User_UL4_L;
            
            val = PE43711_Calc(&Att_UL4.Table_0_0_dBm,
                                Curr.ATT_UL4_H,
                                Curr.ATT_UL4_L,
                               bluecell_Currdatastatus.bluecell_User_UL4_H,
                               bluecell_Currdatastatus.bluecell_User_UL4_L);
    //        printf("%d val = %x \r\n",__LINE__,val);
            PE43711_atten_ctrl(ALL_ATT.ATT_UL4,val);
    }
//    memcpy(&bluecell_Prevdatastatus.ATT_DL1_H,&bluecell_Currdatastatus.ATT_DL1_H,32);
#if 1 // PYJ.2020.04.21_BEGIN -- 
    
    if((Curr.ATT_ALC1_MAX_H != Prev.ATT_ALC1_MAX_H
     ||Curr.ATT_ALC1_MAX_L != Prev.ATT_ALC1_MAX_L)
     ||(Curr.bluecell_User_UL1_H != Prev.bluecell_User_UL1_H
     ||Curr.bluecell_User_UL1_L != Prev.bluecell_User_UL1_L)){
        bluecell_Prevdatastatus.ATT_ALC1_MAX_H = bluecell_Currdatastatus.ATT_ALC1_MAX_H;
        bluecell_Prevdatastatus.ATT_ALC1_MAX_L = bluecell_Currdatastatus.ATT_ALC1_MAX_L;
        bluecell_Prevdatastatus.bluecell_User_UL1_H = bluecell_Currdatastatus.bluecell_User_UL1_H;
        bluecell_Prevdatastatus.bluecell_User_UL1_L = bluecell_Currdatastatus.bluecell_User_UL1_L;
        val = PE43711_Calc(&Att_UL1.Table_0_0_dBm,
                            Curr.ATT_ALC1_MAX_H,
                            Curr.ATT_ALC1_MAX_L,
                           bluecell_Currdatastatus.bluecell_User_DL1_H,
                           bluecell_Currdatastatus.bluecell_User_DL1_L);
//        val = PE43711_DataToHexConvert(ret);
//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
    if((Curr.ATT_ALC2_MAX_H != Prev.ATT_ALC2_MAX_H
     ||Curr.ATT_ALC2_MAX_L != Prev.ATT_ALC2_MAX_L)
     ||(Curr.bluecell_User_UL2_H != Prev.bluecell_User_UL2_H
     ||Curr.bluecell_User_UL2_L != Prev.bluecell_User_UL2_L)){
        bluecell_Prevdatastatus.ATT_ALC2_MAX_H = bluecell_Currdatastatus.ATT_ALC2_MAX_H;
        bluecell_Prevdatastatus.ATT_ALC2_MAX_L = bluecell_Currdatastatus.ATT_ALC2_MAX_L;
        bluecell_Prevdatastatus.bluecell_User_UL2_H = bluecell_Currdatastatus.bluecell_User_UL2_H;
        bluecell_Prevdatastatus.bluecell_User_UL2_L = bluecell_Currdatastatus.bluecell_User_UL2_L;
        val = PE43711_Calc(&Att_UL2.Table_0_0_dBm,
                            Curr.ATT_ALC2_MAX_H,
                            Curr.ATT_ALC2_MAX_L,
                           bluecell_Currdatastatus.bluecell_User_DL2_H,
                           bluecell_Currdatastatus.bluecell_User_DL2_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
    if((Curr.ATT_ALC3_MAX_H != Prev.ATT_ALC3_MAX_H
     ||Curr.ATT_ALC3_MAX_L != Prev.ATT_ALC3_MAX_L)
     ||(Curr.bluecell_User_UL3_H != Prev.bluecell_User_UL3_H
     ||Curr.bluecell_User_UL3_L != Prev.bluecell_User_UL3_L)){
        bluecell_Prevdatastatus.ATT_ALC3_MAX_H = bluecell_Currdatastatus.ATT_ALC3_MAX_H;
        bluecell_Prevdatastatus.ATT_ALC3_MAX_L = bluecell_Currdatastatus.ATT_ALC3_MAX_L;
        bluecell_Prevdatastatus.bluecell_User_UL3_H = bluecell_Currdatastatus.bluecell_User_UL3_H;
        bluecell_Prevdatastatus.bluecell_User_UL3_L = bluecell_Currdatastatus.bluecell_User_UL3_L;
        val = PE43711_Calc(&Att_UL3.Table_0_0_dBm,
            Curr.ATT_ALC3_MAX_H,
            Curr.ATT_ALC3_MAX_L,
                           bluecell_Currdatastatus.bluecell_User_DL3_H,
                           bluecell_Currdatastatus.bluecell_User_DL3_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
    if((Curr.ATT_ALC4_MAX_H != Prev.ATT_ALC4_MAX_H
     ||Curr.ATT_ALC4_MAX_L != Prev.ATT_ALC4_MAX_L)
     ||(Curr.bluecell_User_UL4_H != Prev.bluecell_User_UL4_H
     ||Curr.bluecell_User_UL4_L != Prev.bluecell_User_UL4_L)){
//        printf("Curr.ATT_ALC4_MAX_H : %x Curr.ATT_ALC4_MAX_L : %x\r\n",Curr.ATT_ALC4_MAX_H,Curr.ATT_ALC4_MAX_L);
        bluecell_Prevdatastatus.ATT_ALC4_MAX_H = bluecell_Currdatastatus.ATT_ALC4_MAX_H;
        bluecell_Prevdatastatus.ATT_ALC4_MAX_L = bluecell_Currdatastatus.ATT_ALC4_MAX_L;
        bluecell_Prevdatastatus.bluecell_User_UL4_H = bluecell_Currdatastatus.bluecell_User_UL4_H;
        bluecell_Prevdatastatus.bluecell_User_UL4_L = bluecell_Currdatastatus.bluecell_User_UL4_L;
        val = PE43711_Calc(&Att_UL4.Table_0_0_dBm,
            Curr.ATT_ALC4_MAX_H,
            Curr.ATT_ALC4_MAX_L,
                           bluecell_Currdatastatus.bluecell_User_DL4_H,
                           bluecell_Currdatastatus.bluecell_User_DL4_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }

    
    if((Curr.ATT_ALC_Threshold_H != Prev.ATT_ALC_Threshold_H
     ||Curr.ATT_ALC_Threshold_L != Prev.ATT_ALC_Threshold_L)
     ||(Curr.bluecell_User_UL1_H != Prev.bluecell_User_UL1_H
     ||Curr.bluecell_User_UL1_L != Prev.bluecell_User_UL1_L)){
        bluecell_Prevdatastatus.ATT_ALC_Threshold_H = bluecell_Currdatastatus.ATT_ALC_Threshold_H;
        bluecell_Prevdatastatus.ATT_ALC_Threshold_L = bluecell_Currdatastatus.ATT_ALC_Threshold_L;
        bluecell_Prevdatastatus.bluecell_User_UL1_H = bluecell_Currdatastatus.bluecell_User_UL1_H;
        bluecell_Prevdatastatus.bluecell_User_UL1_L = bluecell_Currdatastatus.bluecell_User_UL1_L;
        val = PE43711_Calc(&Att_DL1.Table_0_0_dBm,
            Curr.ATT_ALC_Threshold_H,
            Curr.ATT_ALC_Threshold_L,
                           bluecell_Currdatastatus.bluecell_User_UL1_H,
                           bluecell_Currdatastatus.bluecell_User_UL1_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
    if((Curr.ATT_ALC2_MIN_H != Prev.ATT_ALC2_MIN_H
     ||Curr.ATT_ALC2_MIN_L != Prev.ATT_ALC2_MIN_L)
     ||(Curr.bluecell_User_UL2_H != Prev.bluecell_User_UL2_H
     ||Curr.bluecell_User_UL2_L != Prev.bluecell_User_UL2_L)){
        bluecell_Prevdatastatus.ATT_ALC2_MIN_H = bluecell_Currdatastatus.ATT_ALC2_MIN_H;
        bluecell_Prevdatastatus.ATT_ALC2_MIN_L = bluecell_Currdatastatus.ATT_ALC2_MIN_L;
        bluecell_Prevdatastatus.bluecell_User_UL2_H = bluecell_Currdatastatus.bluecell_User_UL2_H;
        bluecell_Prevdatastatus.bluecell_User_UL2_L = bluecell_Currdatastatus.bluecell_User_UL2_L;
        val = PE43711_Calc(&Att_DL2.Table_0_0_dBm,
            Curr.ATT_ALC2_MIN_H,
            Curr.ATT_ALC2_MIN_L,
                           bluecell_Currdatastatus.bluecell_User_UL2_H,
                           bluecell_Currdatastatus.bluecell_User_UL2_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
    if((Curr.ATT_ALC3_MIN_H != Prev.ATT_ALC3_MIN_H
     ||Curr.ATT_ALC3_MIN_L != Prev.ATT_ALC3_MIN_L)
     ||(Curr.bluecell_User_UL3_H != Prev.bluecell_User_UL3_H
     ||Curr.bluecell_User_UL3_L != Prev.bluecell_User_UL3_L)){
        bluecell_Prevdatastatus.ATT_ALC3_MIN_H = bluecell_Currdatastatus.ATT_ALC3_MIN_H;
        bluecell_Prevdatastatus.ATT_ALC3_MIN_L = bluecell_Currdatastatus.ATT_ALC3_MIN_L;
        bluecell_Prevdatastatus.bluecell_User_UL3_H = bluecell_Currdatastatus.bluecell_User_UL3_H;
        bluecell_Prevdatastatus.bluecell_User_UL3_L = bluecell_Currdatastatus.bluecell_User_UL3_L;
        val = PE43711_Calc(&Att_DL3.Table_0_0_dBm,
            Curr.ATT_ALC3_MIN_H,
            Curr.ATT_ALC3_MIN_L,
                           bluecell_Currdatastatus.bluecell_User_UL3_H,
                           bluecell_Currdatastatus.bluecell_User_UL3_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
    if((Curr.ATT_ALC4_MIN_H != Prev.ATT_ALC4_MIN_H
     ||Curr.ATT_ALC4_MIN_L != Prev.ATT_ALC4_MIN_L)
     ||(Curr.bluecell_User_UL4_H != Prev.bluecell_User_UL4_H
     ||Curr.bluecell_User_UL4_L != Prev.bluecell_User_UL4_L)){
        bluecell_Prevdatastatus.ATT_ALC4_MIN_H = bluecell_Currdatastatus.ATT_ALC4_MIN_H;
        bluecell_Prevdatastatus.ATT_ALC4_MIN_L = bluecell_Currdatastatus.ATT_ALC4_MIN_L;
        bluecell_Prevdatastatus.bluecell_User_UL4_H = bluecell_Currdatastatus.bluecell_User_UL4_H;
        bluecell_Prevdatastatus.bluecell_User_UL4_L = bluecell_Currdatastatus.bluecell_User_UL4_L;
        val = PE43711_Calc(&Att_DL4.Table_0_0_dBm,
            Curr.ATT_ALC4_MIN_H,
            Curr.ATT_ALC4_MIN_L,
                           bluecell_Currdatastatus.bluecell_User_UL4_H,
                           bluecell_Currdatastatus.bluecell_User_UL4_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
#endif // PYJ.2020.04.21_END -- 
     
}


void Bluecell_StructCopyFunction(uint16_t* dst,uint8_t* src,uint16_t size){
  for(int i = 0; i < size / 2; i++){
    dst[i]  = ((src[i * 2] << 8) & 0xFF00);
    dst[i]  += src[i * 2 + 1] & 0x00FF;
  }
}

void Bluecell_StructCpy(uint8_t* dst,uint8_t* src,uint16_t size){
  for(int i = 0; i < size; i++){
    dst[i]  = src[i];
  }
}


uint16_t ConvertTo2byte(uint8_t highbit, uint8_t lowbit){
    uint16_t ret = 0;
    ret += ((highbit << 8) & 0xFF00);
    ret += (lowbit & 0x00FF);

    return ret;
}
typedef struct{
    uint8_t High_bit;
    uint8_t Low_bit;
}OneByteToTwoByte;
OneByteToTwoByte ConvertTo1Byte(uint16_t data){
    OneByteToTwoByte ret;
    
    ret.High_bit = ((data & 0xFF00) >> 8);
    ret.Low_bit = ((data & 0x00FF));
    
    return ret;
}

void Bluecell_Struct2byteCopyFunction(uint8_t* dst,uint16_t* src,uint8_t size){
  OneByteToTwoByte convert;
  for(int i = 0; i < (size / 2); i++){
    convert = ConvertTo1Byte(src[i]);
    dst[i * 2]      = convert.High_bit;
    dst[i * 2 + 1]  = convert.Low_bit;
  }
}
void Bluecell_structprintf(uint8_t* dst,uint8_t size){
  for(int i = 0; i < size; i++){
    printf("Index[%d]%x \r\n",i,dst[i]);
  }
}



void Bluecell_DataCopy(uint8_t* dst,uint8_t* src,uint16_t size){
    for(int i = 0; i < size; i++){
      dst[i] = src[i];
    }

}

void Bluecell_TableLoad(uint8_t* data,uint8_t type){
    uint8_t tabletype = type;
//    OneByteToTwoByte data;
//    printf("%s : %x \r\n",__func__,tabletype);
//INDEX :5 COpy Start
    switch(tabletype){
        case DLI_P1_ATT_Accuracy_Table_Number: 
            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_WINDOW_STATUS_ADDRESDS              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
//            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
          break;
        case DLI_P2_ATT_Accuracy_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL1_TABLE_ADDRESDS),&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
            break;
        case DLI_P3_ATT_Accuracy_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL2_TABLE_ADDRESDS),&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );               
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
            break;
        case DLI_P4_ATT_Accuracy_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL3_TABLE_ADDRESDS),&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );               
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
            break;
        case ULO_P1_ATT_Accuracy_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL4_TABLE_ADDRESDS),&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
        break;
        case ULO_P2_ATT_Accuracy_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL1_TABLE_ADDRESDS),&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
            break;
        case ULO_P3_ATT_Accuracy_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL2_TABLE_ADDRESDS),&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
            break;
        case ULO_P4_ATT_Accuracy_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL3_TABLE_ADDRESDS),&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
            break;
        case DLI_P1_Level_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL4_TABLE_ADDRESDS),&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
            break;
        case DLI_P2_Level_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL1_TABLE_ADDRESDS),&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
            break;
        case DLI_P3_Level_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL2_TABLE_ADDRESDS),&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
            break;
        case DLI_P4_Level_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL3_TABLE_ADDRESDS),&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
            break;
        case ULO_P1_Level_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL4_TABLE_ADDRESDS),&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
            break;
        case ULO_P2_Level_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL1_TABLE_ADDRESDS),&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
        
            break;
        case ULO_P3_Level_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL2_TABLE_ADDRESDS),&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
            break;
        case ULO_P4_Level_Table_Number: 
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL3_TABLE_ADDRESDS),&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;

            break;
        case DLI_P1_ATT_Temp_guarantee_Table_Number:
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;

            break;
        case DLI_P2_ATT_Temp_guarantee_Table_Number:
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL1_TABLE_ADDRESDS),&Temp_DL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;

            break;
        case DLI_P3_ATT_Temp_guarantee_Table_Number:
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&Temp_DL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;

            break;
        case DLI_P4_ATT_Temp_guarantee_Table_Number:
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL3_TABLE_ADDRESDS),&Temp_DL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
        data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;

        break;
        case ULO_P1_ATT_Temp_guarantee_Table_Number:
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
        
            break;
        case ULO_P2_ATT_Temp_guarantee_Table_Number:
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
        
            break;
        case ULO_P3_ATT_Temp_guarantee_Table_Number:
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL2_TABLE_ADDRESDS),&Temp_UL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
        
            break;
        case ULO_P4_ATT_Temp_guarantee_Table_Number:
            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL3_TABLE_ADDRESDS),&Temp_UL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;

            break;
    }
        
    
}


void Bluecell_TableSave(uint8_t* data,uint8_t type){
    uint8_t tabletype = type;
    
    //printf("%s : %x \r\n",__func__,tabletype);
    switch(tabletype){
        case DLI_P1_ATT_Accuracy_Table_Number: 
            Bluecell_DataCopy(&Att_DL1.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_BASE)              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
//            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
//            printf("ADDRESS : %d \r\n",EEPROM_WINDOW_STATUS_ADDRESDS );
//            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            break;
        case DLI_P2_ATT_Accuracy_Table_Number: 
            Bluecell_DataCopy(&Att_DL2.Table_0_0_dBm,&data[BLUECELL_DATA + 1],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) );
//            printf("ADDRESS : %d \r\n",EEPROM_ATT_DL1_TABLE_ADDRESDS );
            break;
        case DLI_P3_ATT_Accuracy_Table_Number: 
            Bluecell_DataCopy(&Att_DL3.Table_0_0_dBm,&data[BLUECELL_DATA + 1],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));
            break;
        case DLI_P4_ATT_Accuracy_Table_Number: 
            Bluecell_DataCopy(&Att_DL4.Table_0_0_dBm,&data[BLUECELL_DATA + 1],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));
            break;
        case ULO_P1_ATT_Accuracy_Table_Number: 
            Bluecell_DataCopy(&Att_UL1.Table_0_0_dBm,&data[BLUECELL_DATA + 1],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));
            break;
        case ULO_P2_ATT_Accuracy_Table_Number: 
            Bluecell_DataCopy(&Att_UL2.Table_0_0_dBm,&data[BLUECELL_DATA + 1],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));
            break;
        case ULO_P3_ATT_Accuracy_Table_Number: 
            Bluecell_DataCopy(&Att_UL3.Table_0_0_dBm,&data[BLUECELL_DATA + 1],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));
            break;
        case ULO_P4_ATT_Accuracy_Table_Number: 
            Bluecell_DataCopy(&Att_UL4.Table_0_0_dBm,&data[BLUECELL_DATA + 1],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));
            break;
        case DLI_P1_Level_Table_Number: 
            Bluecell_DataCopy(&Det_DL1.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st));
            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL4_TABLE_ADDRESDS),&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
            break;
        case DLI_P2_Level_Table_Number: 
            Bluecell_DataCopy(&Det_DL2.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],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));
            break;
        case DLI_P3_Level_Table_Number: 
            Bluecell_DataCopy(&Det_DL3.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],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));
        case DLI_P4_Level_Table_Number: 
            Bluecell_DataCopy(&Det_DL4.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],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));
            break;
        case ULO_P1_Level_Table_Number: 
            Bluecell_DataCopy(&Det_UL1.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st));
            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL4_TABLE_ADDRESDS),&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));            
            break;
        case ULO_P2_Level_Table_Number: 
            Bluecell_DataCopy(&Det_UL2.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],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));            
        break;
        case ULO_P3_Level_Table_Number: 
            Bluecell_DataCopy(&Det_UL3.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],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));            
            break;
        case ULO_P4_Level_Table_Number: 
            Bluecell_DataCopy(&Det_UL4.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],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));            
            break;
        case DLI_P1_ATT_Temp_guarantee_Table_Number:
            Bluecell_DataCopy(&Temp_DL1.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                    
            break;
        case DLI_P2_ATT_Temp_guarantee_Table_Number:
            Bluecell_DataCopy(&Temp_DL2.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL1_TABLE_ADDRESDS),&Temp_DL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                    
            break;
        case DLI_P3_ATT_Temp_guarantee_Table_Number:
            Bluecell_DataCopy(&Temp_DL3.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&Temp_DL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                    
            
            break;
        case DLI_P4_ATT_Temp_guarantee_Table_Number:
            Bluecell_DataCopy(&Temp_DL4.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL3_TABLE_ADDRESDS),&Temp_DL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                    
            break;
        case ULO_P1_ATT_Temp_guarantee_Table_Number:
            Bluecell_DataCopy(&Temp_UL1.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
            EEPROM_M24C08_write(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_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                                    
            Bluecell_structprintf(&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st));        
            break;
        case ULO_P2_ATT_Temp_guarantee_Table_Number:
            Bluecell_DataCopy(&Temp_UL2.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                            
            break;
        case ULO_P3_ATT_Temp_guarantee_Table_Number:
            Bluecell_DataCopy(&Temp_UL3.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL2_TABLE_ADDRESDS),&Temp_UL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                            
            break;
        case ULO_P4_ATT_Temp_guarantee_Table_Number:
            Bluecell_DataCopy(&Temp_UL4.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL3_TABLE_ADDRESDS),&Temp_UL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                                
            break;
    }
    
}
uint8_t Txdata[512];
extern HAL_StatusTypeDef EEPROM_M24C08_Zerowrite(uint8_t devid,uint16_t Address);







bool Bluecell_Operate(uint8_t* data){
  uint8_t datatype = data[BLUECELL_TYPE];


  //double ret = 0 ,tmp = 0.1;
  int16_t tempdata = 0;

  uint8_t i = 0;
  switch(datatype){
    case BLUECELL_SOFTWARERESET:
        NVIC_SystemReset();
        break;
	case ATTSET 				 :
//		printf("Function : %s Line %d \r\n",__func__,__LINE__);
        bluecell_Currdatastatus.ATT_DL1_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_DL1_L = data[BLUECELL_DATA + i++];
//        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);        
        bluecell_Currdatastatus.ATT_DL2_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_DL2_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_DL3_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_DL3_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_DL4_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_DL4_L = data[BLUECELL_DATA + i++];

        bluecell_Currdatastatus.ATT_UL1_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_UL1_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_UL2_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_UL2_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_UL3_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_UL3_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_UL4_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_UL4_L = data[BLUECELL_DATA + i++];

        bluecell_Currdatastatus.ATT_ALC1_MAX_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC1_MAX_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC2_MAX_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC2_MAX_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC3_MAX_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC3_MAX_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC4_MAX_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC4_MAX_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC_Threshold_H = data[BLUECELL_DATA + i++]; // 20
        bluecell_Currdatastatus.ATT_ALC_Threshold_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC2_MIN_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC2_MIN_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC3_MIN_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC3_MIN_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC4_MIN_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC4_MIN_L = data[BLUECELL_DATA + i++];
//        printf("ALC 1 H: %x \r\n",        bluecell_Currdatastatus.ATT_ALC1_MAX_H);
//        printf("ALC 1 L: %x \r\n",        bluecell_Currdatastatus.ATT_ALC1_MAX_L);
//        printf("bluecell_Currdatastatus.ATT_ALC4_MAX_H : %x \r\nbluecell_Currdatastatus.ATT_ALC4_MAX_L : %x\r\n",
            //bluecell_Currdatastatus.ATT_ALC4_MAX_H,bluecell_Currdatastatus.ATT_ALC4_MAX_L);
     //   memcpy(&bluecell_Currdatastatus.ATT_DL1_H,&data[BLUECELL_DATA],32);
//		bluecell_Currdatastatus.ATT_DL1_H =  data[BLUECELL_DATA + i++];
//		bluecell_Currdatastatus.ATT_DL1_L =  data[BLUECELL_DATA + 1];
        /*
            Atten Ctrl Function
        */
		CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
//		printf("ret : %f ,tmp %f \r\n",ret,tmp );
		break;
	case ATT_DL1_PATH 		 :
        if(data[BLUECELL_DATA]==0){
            HAL_GPIO_WritePin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin,GPIO_PIN_RESET);//CLOCK        
//            printf("ATT_DL1_PATH OFF\r\n");
        }
        else{
            HAL_GPIO_WritePin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin,GPIO_PIN_SET);//CLOCK
            bluecell_Prevdatastatus.ATT_DL1_H = ~bluecell_Prevdatastatus.ATT_DL1_H;
            bluecell_Prevdatastatus.ATT_DL1_L = ~bluecell_Prevdatastatus.ATT_DL1_L;
            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
//            printf("ATT_DL1_PATH ON\r\n");
        }
        bluecell_Currdatastatus.ATT_DL1_PATH = data[BLUECELL_DATA];
	

		break;
	case ATT_UL1_PATH        :
        if(data[BLUECELL_DATA]==0){
            HAL_GPIO_WritePin(PATH_EN_UL1_GPIO_Port,PATH_EN_UL1_Pin,GPIO_PIN_RESET);//CLOCK
        }
        else{
            HAL_GPIO_WritePin(PATH_EN_UL1_GPIO_Port,PATH_EN_UL1_Pin,GPIO_PIN_SET);//CLOCK
            bluecell_Prevdatastatus.ATT_UL1_H = ~bluecell_Prevdatastatus.ATT_UL1_H;
            bluecell_Prevdatastatus.ATT_UL1_L = ~bluecell_Prevdatastatus.ATT_UL1_L;
            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

        }
        bluecell_Currdatastatus.ATT_UL1_PATH = data[BLUECELL_DATA];
//        printf("Function : %s Line %d \r\n",__func__,__LINE__);
		break;
	case ATT_SelfTest1		 :
        if(data[BLUECELL_DATA]==0){
            HAL_GPIO_WritePin(_PATH_SW1_GPIO_Port,_PATH_SW1_Pin,GPIO_PIN_RESET);//CLOCK
            HAL_GPIO_WritePin(PATH_SW1_GPIO_Port,PATH_SW1_Pin,GPIO_PIN_SET);//CLOCK
        }
        else{
            HAL_GPIO_WritePin(_PATH_SW1_GPIO_Port,_PATH_SW1_Pin,GPIO_PIN_SET);//CLOCK
            HAL_GPIO_WritePin(PATH_SW1_GPIO_Port,PATH_SW1_Pin,GPIO_PIN_RESET);//CLOCK
        }
        bluecell_Currdatastatus.Selftest1 = data[BLUECELL_DATA];
//		printf("Function : %s Line %d \r\n",__func__,__LINE__);
		break;
	case ATT_DL2_PATH		 :
        if(data[BLUECELL_DATA]==0){
            HAL_GPIO_WritePin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin,GPIO_PIN_RESET);//CLOCK
        }
        else{
            HAL_GPIO_WritePin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin,GPIO_PIN_SET);//CLOCK
            bluecell_Prevdatastatus.ATT_DL2_H = ~bluecell_Prevdatastatus.ATT_DL2_H;
            bluecell_Prevdatastatus.ATT_DL2_L = ~bluecell_Prevdatastatus.ATT_DL2_L;
            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
        }
        bluecell_Currdatastatus.ATT_DL2_PATH = data[BLUECELL_DATA];
//		printf("Function : %s Line %d \r\n",__func__,__LINE__);
		break;

		break;
	case ATT_UL2_PATH 		 :
        if(data[BLUECELL_DATA]==0){
            HAL_GPIO_WritePin(PATH_EN_UL2_GPIO_Port,PATH_EN_UL2_Pin,GPIO_PIN_RESET);//CLOCK
        }
        else{
            HAL_GPIO_WritePin(PATH_EN_UL2_GPIO_Port,PATH_EN_UL2_Pin,GPIO_PIN_SET);//CLOCK
            bluecell_Prevdatastatus.ATT_UL2_H = ~bluecell_Prevdatastatus.ATT_UL2_H;
            bluecell_Prevdatastatus.ATT_UL2_L = ~bluecell_Prevdatastatus.ATT_UL2_L;
            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
        }
        bluecell_Currdatastatus.ATT_UL2_PATH = data[BLUECELL_DATA];
		break;
	case ATT_SelfTest2		 :
        if(data[BLUECELL_DATA]==0){
            HAL_GPIO_WritePin(_PATH_SW2_GPIO_Port,_PATH_SW2_Pin,GPIO_PIN_RESET);//CLOCK
            HAL_GPIO_WritePin(PATH_SW2_GPIO_Port,PATH_SW2_Pin,GPIO_PIN_SET);//CLOCK
        }else{
            HAL_GPIO_WritePin(PATH_SW2_GPIO_Port,PATH_SW2_Pin,GPIO_PIN_RESET);//CLOCK
            HAL_GPIO_WritePin(_PATH_SW2_GPIO_Port,_PATH_SW2_Pin,GPIO_PIN_SET);//CLOCK
        }
        bluecell_Currdatastatus.Selftest2 = data[BLUECELL_DATA];
//		printf("Function : %s Line %d \r\n",__func__,__LINE__);
		break;
	case ATT_DL3_PATH :
        if(data[BLUECELL_DATA]==0){
            HAL_GPIO_WritePin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin,GPIO_PIN_RESET);//CLOCK
        }
        else{
            HAL_GPIO_WritePin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin,GPIO_PIN_SET);//CLOCK
            bluecell_Prevdatastatus.ATT_DL3_H = ~bluecell_Prevdatastatus.ATT_DL3_H;
            bluecell_Prevdatastatus.ATT_DL3_L = ~bluecell_Prevdatastatus.ATT_DL3_L;
            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
        }
        bluecell_Currdatastatus.ATT_DL3_PATH = data[BLUECELL_DATA];
//		printf("Function : %s Line %d \r\n",__func__,__LINE__);
		break;
	case ATT_UL3_PATH :
        if(data[BLUECELL_DATA]==0){
            HAL_GPIO_WritePin(PATH_EN_UL3_GPIO_Port,PATH_EN_UL3_Pin,GPIO_PIN_RESET);//CLOCK
        }
        else{
            HAL_GPIO_WritePin(PATH_EN_UL3_GPIO_Port,PATH_EN_UL3_Pin,GPIO_PIN_SET);//CLOCK
            bluecell_Prevdatastatus.ATT_UL3_H = ~bluecell_Prevdatastatus.ATT_UL3_H;
            bluecell_Prevdatastatus.ATT_UL3_L = ~bluecell_Prevdatastatus.ATT_UL3_L;
            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
        }
        bluecell_Currdatastatus.ATT_UL3_PATH = data[BLUECELL_DATA];
//		printf("Function : %s Line %d \r\n",__func__,__LINE__);
		break;
	case ATT_SelfTest3 :
        if(data[BLUECELL_DATA]==0){
            HAL_GPIO_WritePin(_PATH_SW3_GPIO_Port,_PATH_SW3_Pin,GPIO_PIN_RESET);//CLOCK
            HAL_GPIO_WritePin(PATH_SW3_GPIO_Port,PATH_SW3_Pin,GPIO_PIN_SET);//CLOCK
        }
        else{
            HAL_GPIO_WritePin(PATH_SW3_GPIO_Port,PATH_SW3_Pin,GPIO_PIN_RESET);//CLOCK
            HAL_GPIO_WritePin(_PATH_SW3_GPIO_Port,_PATH_SW3_Pin,GPIO_PIN_SET);//CLOCK
        }
        bluecell_Currdatastatus.Selftest3 = data[BLUECELL_DATA];
//		printf("Function : %s Line %d \r\n",__func__,__LINE__);
		break;
	case ATT_DL4_PATH :
        if(data[BLUECELL_DATA]==0){
            HAL_GPIO_WritePin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin,GPIO_PIN_RESET);//CLOCK
        }else{
            HAL_GPIO_WritePin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin,GPIO_PIN_SET);//CLOCK    
            bluecell_Prevdatastatus.ATT_DL4_H = ~bluecell_Prevdatastatus.ATT_DL4_H;
            bluecell_Prevdatastatus.ATT_DL4_L = ~bluecell_Prevdatastatus.ATT_DL4_L;
            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

        }
        bluecell_Currdatastatus.ATT_DL4_PATH = data[BLUECELL_DATA];
//		printf("Function : %s Line %d \r\n",__func__,__LINE__);
		break;
	case ATT_UL4_PATH:
        if(data[BLUECELL_DATA]==0){
            HAL_GPIO_WritePin(PATH_EN_UL4_GPIO_Port,PATH_EN_UL4_Pin,GPIO_PIN_RESET);//CLOCK
        }
        else{
            HAL_GPIO_WritePin(PATH_EN_UL4_GPIO_Port,PATH_EN_UL4_Pin,GPIO_PIN_SET);//CLOCK
            bluecell_Prevdatastatus.ATT_UL4_H = ~bluecell_Prevdatastatus.ATT_UL4_H;
            bluecell_Prevdatastatus.ATT_UL4_L = ~bluecell_Prevdatastatus.ATT_UL4_L;
            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
        }
        bluecell_Currdatastatus.ATT_UL4_PATH = data[BLUECELL_DATA];
//		printf("Function : %s Line %d \r\n",__func__,__LINE__);
		break;
	case ATT_SelfTest4 :
	  if(data[BLUECELL_DATA]==0){
	    HAL_GPIO_WritePin(_PATH_SW4_GPIO_Port,_PATH_SW4_Pin,GPIO_PIN_RESET);//CLOCK
	    HAL_GPIO_WritePin(PATH_SW4_GPIO_Port,PATH_SW4_Pin,GPIO_PIN_SET);//CLOCK
	  }else{
	    HAL_GPIO_WritePin(_PATH_SW4_GPIO_Port,_PATH_SW4_Pin,GPIO_PIN_SET);//CLOCK
	    HAL_GPIO_WritePin(PATH_SW4_GPIO_Port,PATH_SW4_Pin,GPIO_PIN_RESET);//CLOCK
	  }
      bluecell_Currdatastatus.Selftest4 = data[BLUECELL_DATA];
//		printf("Function : %s Line %d \r\n",__func__,__LINE__);
		break;
    case ALC1_EN :
        if(data[BLUECELL_DATA]==0){
            bluecell_Currdatastatus.ATT_ALC1_ONOFF = false;
        }
        else{
            bluecell_Currdatastatus.ATT_ALC1_ONOFF = true;
        }
    break;
    case ALC2_EN :
        if(data[BLUECELL_DATA]==0){
            bluecell_Currdatastatus.ATT_ALC2_ONOFF = false;
        }
        else{
            bluecell_Currdatastatus.ATT_ALC2_ONOFF = true;
        }
    break;
    case ALC3_EN :
        if(data[BLUECELL_DATA]==0){
            bluecell_Currdatastatus.ATT_ALC3_ONOFF = false;
        }
        else{
            bluecell_Currdatastatus.ATT_ALC3_ONOFF = true;
        }
    break;
    case ALC4_EN :
        if(data[BLUECELL_DATA]==0){
            bluecell_Currdatastatus.ATT_ALC4_ONOFF = false;
        }
        else{
            bluecell_Currdatastatus.ATT_ALC4_ONOFF = true;
        }
    break;
    case AGC1_EN :
        if(data[BLUECELL_DATA]==0){
            bluecell_Currdatastatus.DLI_AGC_ON_OFF = false;
        }
        else{
            bluecell_Currdatastatus.DLI_AGC_ON_OFF = true;
        }
//        printf("bluecell_Currdatastatus.ATT_AGC1_ONOFF : %d \r\n",bluecell_Currdatastatus.ATT_AGC1_ONOFF);
    break;
    case AGC2_EN :
        if(data[BLUECELL_DATA]==0){
            bluecell_Currdatastatus.ATT_AGC2_ONOFF = false;
        }
        else{
            bluecell_Currdatastatus.ATT_AGC2_ONOFF = true;
        }

    break;
    case AGC3_EN :
        if(data[BLUECELL_DATA]==0){
            bluecell_Currdatastatus.ATT_AGC3_ONOFF = false;
        }
        else{
            bluecell_Currdatastatus.ATT_AGC3_ONOFF = true;
        }

    break;
    case AGC4_EN :
        if(data[BLUECELL_DATA]==0){
            bluecell_Currdatastatus.ATT_AGC4_ONOFF = false;
        }
        else{
            bluecell_Currdatastatus.ATT_AGC4_ONOFF = true;
        }

      break;
    case ATT_TableSet:
        Bluecell_TableSave(data, data[BLUECELL_DATA]);
    case ATT_TableGet:
        Bluecell_TableLoad(data, data[BLUECELL_DATA]);
        data[BLUECELL_TYPE] = ATT_TableGet;
        data[data[BLUECELL_LENGTH] + 1] = STH30_CreateCrc(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH]);
        Bluecell_StructCpy(&Txdata[0],&data[0],data[BLUECELL_LENGTH] + 3);
        Uart1_Data_Send(&Txdata[0], Txdata[BLUECELL_LENGTH] + 3);
#if 0 // PYJ.2020.04.22_BEGIN -- 
        for(int i = 0 ; i < data[BLUECELL_LENGTH] + 3; i++ ){
//            printf("%x ",data[i]);
        Txdata[0] = data[0];        }
        printf("\r\n");
#endif // PYJ.2020.04.22_END -- 
//        printf("\r\nuint8_t data : %x  data[BLUECELL_LENGTH] + 6 : %d\r\n",data[0],data[BLUECELL_LENGTH] + 6);
        break;
    case Bluecell_StatusReq:
        DataStatusSet();
        Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
        Txdata[BLUECELL_LENGTH] = 94 - 3;//sizeof(BLUESTATUS_st) - 3;
        Txdata[94 - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]);
#if 0 // PYJ.2020.04.22_BEGIN -- 
        for(int i = 0 ; i < sizeof(BLUESTATUS_st); i++ ){
            printf("%x ",Txdata[i]);
        }
        printf("\r\n");
#endif // PYJ.2020.04.22_END --    
        Uart1_Data_Send(&Txdata[0], 94);
        break;
    case Bluecell_StatusSave:
//        printf("Copy Complete");
//        Bluecell_StructCpy(&DataWrite[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
//        EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_BASE),&DataWrite[0],sizeof(BLUESTATUS_st));
//        Bluecell_StructCpy(&Txdata[0],&DataWrite[0],sizeof(BLUESTATUS_st));
//        Txdata[sizeof(BLUESTATUS_st) - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], sizeof(BLUESTATUS_st) - 3);
//        Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st));        
        EEPROM_M24C08_Zerowrite(EEPROM_M24C08_ID ,(EEPROM_ATT_BASE));
//        printf("ZERO WRITE COMPLETE");
         NVIC_SystemReset();

        break;

    case Bluecell_DL1_USER: 
        bluecell_Currdatastatus.bluecell_User_DL1_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.bluecell_User_DL1_L = data[BLUECELL_DATA + i++];
        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
        break;
    case Bluecell_DL2_USER:
        bluecell_Currdatastatus.bluecell_User_DL2_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.bluecell_User_DL2_L = data[BLUECELL_DATA + i++];
        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
        break;
    case Bluecell_DL3_USER:
        bluecell_Currdatastatus.bluecell_User_DL3_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.bluecell_User_DL3_L = data[BLUECELL_DATA + i++];
        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
        break;
    case Bluecell_DL4_USER:     
        bluecell_Currdatastatus.bluecell_User_DL4_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.bluecell_User_DL4_L = data[BLUECELL_DATA + i++];
        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
        break;

    case Bluecell_UL1_USER: 
        bluecell_Currdatastatus.bluecell_User_UL1_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.bluecell_User_UL1_L = data[BLUECELL_DATA + i++];
        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
        break;
    case Bluecell_UL2_USER:
        bluecell_Currdatastatus.bluecell_User_UL2_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.bluecell_User_UL2_L = data[BLUECELL_DATA + i++];
        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

        break;
    case Bluecell_UL3_USER:
        bluecell_Currdatastatus.bluecell_User_UL3_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.bluecell_User_UL3_L = data[BLUECELL_DATA + i++];
        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

        break;
    case Bluecell_UL4_USER:
        bluecell_Currdatastatus.bluecell_User_UL4_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.bluecell_User_UL4_L = data[BLUECELL_DATA + i++];
        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
        break;

        /*******/
#if 0 // PYJ.2020.05.13_BEGIN -- 
    수정 및 추가 
#endif // PYJ.2020.05.13_END -- 
        /*******/
    case Bluecell_TEMP_USER                               :
        bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET = data[BLUECELL_DATA + i++];
//        bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET_L = data[BLUECELL_DATA + i++];

        break;
    case Bluecell_DLI_AGC_ON_OFF:                             
        bluecell_Currdatastatus.DLI_AGC_ON_OFF = data[BLUECELL_DATA + i];

        break;
    case Bluecell_ULO_ALC_ON_OFF:                             
        bluecell_Currdatastatus.ATT_ALC1_ONOFF = data[BLUECELL_DATA + i];
        break;
    case Bluecell_DLI_AGC_Threshold:                          
        bluecell_Currdatastatus.DLI_AGC_Threshold_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.DLI_AGC_Threshold_L = data[BLUECELL_DATA + i++];
//        tempdata = (( bluecell_Currdatastatus.DLI_AGC_Threshold_H << 8) & 0xFF00) ;
//        tempdata +=  bluecell_Currdatastatus.DLI_AGC_Threshold_L ;
//        tempdata /= 10;
//        printf("tempdata : %d\r\n",tempdata);
//        bluecell_Currdatastatus.DLI_AGC_Threshold_H = ((tempdata & 0xFF00) >> 8);
//        bluecell_Currdatastatus.DLI_AGC_Threshold_L = (tempdata & 0x00FF); 

        break;
    case Bluecell_DLI_AGC_Threshold_Default:                  
        bluecell_Currdatastatus.DLI_AGC_Threshold_default = data[BLUECELL_DATA + i++];
        if(bluecell_Currdatastatus.DLI_AGC_Threshold_default == true){
            bluecell_Currdatastatus.DLI_AGC_Threshold_H = MBIC_DLI_AGC_Threshold_Default_H;
            bluecell_Currdatastatus.DLI_AGC_Threshold_L = MBIC_DLI_AGC_Threshold_Default_L;
            bluecell_Currdatastatus.DLI_AGC_Threshold_default = false;
            printf("%s : %d \r\n",__func__,__LINE__);
        }
        break;
    case Bluecell_DLI_Shutdown_ON_OFF:                        
        bluecell_Currdatastatus.DLI_Shutdown_ON_OFF = data[BLUECELL_DATA + i++];
        printf("%s : %d \r\n",__func__,__LINE__);
        
        break;
    case Bluecell_DLI_Shutdown_Threshold:                     
        bluecell_Currdatastatus.DLI_Shutdown_Threshold_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.DLI_Shutdown_Threshold_L = data[BLUECELL_DATA + i++];
        tempdata = (( bluecell_Currdatastatus.DLI_Shutdown_Threshold_H << 8) & 0xFF00) ;
        tempdata +=  bluecell_Currdatastatus.DLI_Shutdown_Threshold_L ;
//        tempdata /= 10;
//        printf("tempdata : %d\r\n",tempdata);
//        bluecell_Currdatastatus.DLI_Shutdown_Threshold_H = ((tempdata & 0xFF00) >> 8);
//        bluecell_Currdatastatus.DLI_Shutdown_Threshold_L = (tempdata & 0x00FF);
//        printf("tempdata %d \r\n",tempdata);

        break;
    case Bluecell_DLI_Shutdown_Threshold_Default:             
        bluecell_Currdatastatus.DLI_Shutdown_Threshold_Default = data[BLUECELL_DATA + i++];
        if(bluecell_Currdatastatus.DLI_Shutdown_Threshold_Default == true){
            bluecell_Currdatastatus.DLI_Shutdown_Threshold_H = MBIC_DLI_Shutdown_Threshold_Default_H;
            bluecell_Currdatastatus.DLI_Shutdown_Threshold_L = MBIC_DLI_Shutdown_Threshold_Default_L;
        }
        printf("%s : %d \r\n",__func__,__LINE__);
//      printf("bluecell_Currdatastatus.DLI_Shutdown_Threshold_Default : %d \r\n",bluecell_Currdatastatus.DLI_Shutdown_Threshold_Default);
        break;
    case Bluecell_DLI_Shutdown_Count:                         
        /*NOP*/
        break;
    case Bluecell_DLI_Level_High_Threshold                :   
        bluecell_Currdatastatus.DLI_Level_High_Threshold_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.DLI_Level_High_Threshold_L = data[BLUECELL_DATA + i++];
        tempdata = (( bluecell_Currdatastatus.DLI_Level_High_Threshold_H << 8) & 0xFF00) ;
        tempdata +=  bluecell_Currdatastatus.DLI_Level_High_Threshold_L ;
//        tempdata /= 10;
//        printf("tempdata : %d\r\n",tempdata);
//        bluecell_Currdatastatus.DLI_Level_High_Threshold_H = ((tempdata & 0xFF00) >> 8);
//        bluecell_Currdatastatus.DLI_Level_High_Threshold_L = (tempdata & 0x00FF);
        break;
    case Bluecell_DLI_Level_Low_Threshold                 :   
        bluecell_Currdatastatus.DLI_Level_Low_Threshold_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.DLI_Level_Low_Threshold_L = data[BLUECELL_DATA + i++];
        tempdata = (( bluecell_Currdatastatus.DLI_Level_Low_Threshold_H << 8) & 0xFF00) ;
        tempdata +=  bluecell_Currdatastatus.DLI_Level_Low_Threshold_L ;
//        tempdata /= 10;
//         printf("tempdata : %d\r\n",tempdata);
//        bluecell_Currdatastatus.DLI_Level_Low_Threshold_H = ((tempdata & 0xFF00) >> 8);
//        bluecell_Currdatastatus.DLI_Level_Low_Threshold_L = (tempdata & 0x00FF);    

        break;
    case Bluecell_DLI_Level_High_Low_Threshold_default    :   
        bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default = data[BLUECELL_DATA + i++];
        if(bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default == true){
            bluecell_Currdatastatus.DLI_Level_High_Threshold_H = MBIC_DLI_Level_High_Threshold_default_H;
            bluecell_Currdatastatus.DLI_Level_High_Threshold_L = MBIC_DLI_Level_High_Threshold_default_L;
            bluecell_Currdatastatus.DLI_Level_Low_Threshold_H = MBIC_DLI_Level_Low_Threshold_default_H;
            bluecell_Currdatastatus.DLI_Level_Low_Threshold_L = MBIC_DLI_Level_Low_Threshold_default_L;
        }
        break;
    case Bluecell_LED_TEST  :                                 
        bluecell_Currdatastatus.LED_TEST = data[BLUECELL_DATA + i++];
        printf("%s : %d \r\n",__func__,__LINE__);
        break;
    case Bluecell_Temperature_Offset                      :   
        bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET = data[BLUECELL_DATA + i++];
        printf("%s : %d \r\n",__func__,__LINE__);

        break;
    case Bluecell_Temp_High_Threshold                     :   
        bluecell_Currdatastatus.Temp_High_Threshold = data[BLUECELL_DATA + i++];
        printf("%s : %d \r\n",__func__,__LINE__);
        break;
    case Bluecell_Temp_High_Threshold_Default             :   
        bluecell_Currdatastatus.Temp_High_Threshold_Default = data[BLUECELL_DATA + i++];
        if(bluecell_Currdatastatus.Temp_High_Threshold_Default == true){
            bluecell_Currdatastatus.Temp_High_Threshold_Default = MBIC_Temp_High_Threshold_Default;
        }
        printf("%s : %d \r\n",__func__,__LINE__);
        break;
    case Bluecell_ULO_Level_High_Threshold                :   
        bluecell_Currdatastatus.ULO_Level_High_Threshold_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ULO_Level_High_Threshold_L = data[BLUECELL_DATA + i++];
        tempdata = (( bluecell_Currdatastatus.ULO_Level_High_Threshold_H << 8) & 0xFF00) ;
        tempdata +=  bluecell_Currdatastatus.ULO_Level_High_Threshold_L ;
//        tempdata /= 10;
//         printf("tempdata : %d\r\n",tempdata);
//        bluecell_Currdatastatus.ULO_Level_High_Threshold_H = ((tempdata & 0xFF00) >> 8);
//        bluecell_Currdatastatus.ULO_Level_High_Threshold_L = (tempdata & 0x00FF);   

       

        break;
    case Bluecell_ULO_Level_High_Threshold_default        :   
        bluecell_Currdatastatus.ULO_Level_High_Threshold_default = data[BLUECELL_DATA + i++];
        if(bluecell_Currdatastatus.ULO_Level_High_Threshold_default == true){
            bluecell_Currdatastatus.ULO_Level_High_Threshold_H = MBIC_ULO_Level_High_Threshold_Default_H;
            bluecell_Currdatastatus.ULO_Level_High_Threshold_L = MBIC_ULO_Level_High_Threshold_Default_L;
        }
        break;
    case Bluecell_ULO_ALC_Threshold                       :   
        bluecell_Currdatastatus.ATT_ALC_Threshold_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC_Threshold_L = data[BLUECELL_DATA + i++];
        tempdata = (( bluecell_Currdatastatus.ATT_ALC_Threshold_H << 8) & 0xFF00) ;
        tempdata +=  bluecell_Currdatastatus.ATT_ALC_Threshold_L ;
//        tempdata /= 10;
//        printf("tempdata : %d\r\n",tempdata);
//        bluecell_Currdatastatus.ATT_ALC_Threshold_H = ((tempdata & 0xFF00) >> 8);
//        bluecell_Currdatastatus.ATT_ALC_Threshold_L = (tempdata & 0x00FF);

        break;
    case Bluecell_ULO_ALC_Threshold_Default               :   
        bluecell_Currdatastatus.ULO_ALC_Threshold_Default = data[BLUECELL_DATA + i++];
        if(bluecell_Currdatastatus.ULO_Level_High_Threshold_default == true){
            bluecell_Currdatastatus.ATT_ALC_Threshold_H = MBIC_ULO_ALC_Threshold_Default_H;
            bluecell_Currdatastatus.ATT_ALC_Threshold_L = MBIC_ULO_ALC_Threshold_Default_L;
        }
        printf("%s : %d \r\n",__func__,__LINE__);

        break;
    case Bluecell_ULO_Shutdown_ON_OFF                     :   
        bluecell_Currdatastatus.ULO_Shutdown_ON_OFF = data[BLUECELL_DATA + i++];
         printf("%s : %d \r\n",__func__,__LINE__);

        break;
    case Bluecell_ULO_Shutdown_Threshold                  :   
        bluecell_Currdatastatus.ULO_Shutdown_Threshold_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ULO_Shutdown_Threshold_L = data[BLUECELL_DATA + i++];
        tempdata = (( bluecell_Currdatastatus.ULO_Shutdown_Threshold_H << 8) & 0xFF00) ;
        tempdata +=  bluecell_Currdatastatus.ULO_Shutdown_Threshold_L ;
//        tempdata /= 10;
//        printf("tempdata : %d\r\n",tempdata);
//        bluecell_Currdatastatus.ULO_Shutdown_Threshold_H = ((tempdata & 0xFF00) >> 8);
//        bluecell_Currdatastatus.ULO_Shutdown_Threshold_L = (tempdata & 0x00FF);     

        break;
    case Bluecell_ULO_Shutdown_Threshold_Default          :   
        bluecell_Currdatastatus.ULO_Shutdown_Threshold_Default = data[BLUECELL_DATA + i++];
        if(bluecell_Currdatastatus.ULO_Level_High_Threshold_default == true){
            bluecell_Currdatastatus.ULO_Shutdown_Threshold_H = MBIC_ULO_Shutdown_Threshold_Default_H;
            bluecell_Currdatastatus.ULO_Shutdown_Threshold_L = MBIC_ULO_Shutdown_Threshold_Default_L;
        }
         printf("%s : %d \r\n",__func__,__LINE__);
        break;
    case Bluecell_ULO_Shutdown_Retry_Count                :   
        break;
  }
  if(datatype != Bluecell_StatusReq){
      Bluecell_StructCpy(&DataWrite[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
      EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS),&DataWrite[0],sizeof(BLUESTATUS_st));
//      Bluecell_StructCpy(&Txdata[0],&DataWrite[0],sizeof(BLUESTATUS_st));
//      Txdata[sizeof(BLUESTATUS_st) - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], sizeof(BLUESTATUS_st) - 3);
//      Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st));        
  }
  return true;
}
void DataStatusSet(void){
        bluecell_Currdatastatus.bluecell_header = 0xbe;
        bluecell_Currdatastatus.bluecell_type = Bluecell_StatusReq;
        bluecell_Currdatastatus.bluecell_length = 94 - 3;
        bluecell_Currdatastatus.bluecell_crcindex = 94 - 2 + 1;
        bluecell_Currdatastatus.ATT_DL2_PATH = HAL_GPIO_ReadPin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin);//CLOCK;
        bluecell_Currdatastatus.ATT_DL3_PATH = HAL_GPIO_ReadPin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin);//CLOCK;
        bluecell_Currdatastatus.ATT_DL4_PATH = HAL_GPIO_ReadPin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin);//CLOCK;
        bluecell_Currdatastatus.ATT_UL1_PATH = HAL_GPIO_ReadPin(PATH_EN_UL1_GPIO_Port,PATH_EN_UL1_Pin);//CLOCK;
        bluecell_Currdatastatus.ATT_UL2_PATH = HAL_GPIO_ReadPin(PATH_EN_UL2_GPIO_Port,PATH_EN_UL2_Pin);//CLOCK;
        bluecell_Currdatastatus.ATT_UL3_PATH = HAL_GPIO_ReadPin(PATH_EN_UL3_GPIO_Port,PATH_EN_UL3_Pin);//CLOCK;
        bluecell_Currdatastatus.ATT_UL4_PATH = HAL_GPIO_ReadPin(PATH_EN_UL4_GPIO_Port,PATH_EN_UL4_Pin);//CLOCK;
        bluecell_Currdatastatus.bluecell_etx = 0xeb;
             
        
     
}
 void Bluecell_DataInit(){

    
    HAL_GPIO_WritePin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin,bluecell_Currdatastatus.ATT_DL1_PATH);   
    HAL_GPIO_WritePin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin,bluecell_Currdatastatus.ATT_DL2_PATH);   
    HAL_GPIO_WritePin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin,bluecell_Currdatastatus.ATT_DL3_PATH);   
    HAL_GPIO_WritePin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin,bluecell_Currdatastatus.ATT_DL4_PATH);   

    
    HAL_GPIO_WritePin(PATH_EN_UL1_GPIO_Port,PATH_EN_UL1_Pin,bluecell_Currdatastatus.ATT_UL1_PATH);   
    HAL_GPIO_WritePin(PATH_EN_UL2_GPIO_Port,PATH_EN_UL2_Pin,bluecell_Currdatastatus.ATT_UL2_PATH);   
    HAL_GPIO_WritePin(PATH_EN_UL3_GPIO_Port,PATH_EN_UL3_Pin,bluecell_Currdatastatus.ATT_UL3_PATH);   
    HAL_GPIO_WritePin(PATH_EN_UL4_GPIO_Port,PATH_EN_UL4_Pin,bluecell_Currdatastatus.ATT_UL4_PATH);   


    CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
    if(bluecell_Currdatastatus.Selftest1==0){
//        printf("Selftest1 : 0 \r\n");
        HAL_GPIO_WritePin(_PATH_SW1_GPIO_Port,_PATH_SW1_Pin,GPIO_PIN_RESET);//CLOCK
        HAL_GPIO_WritePin(PATH_SW1_GPIO_Port,PATH_SW1_Pin,GPIO_PIN_SET);//CLOCK
    }else{
//        printf("Selftest1 : 1 \r\n");
        HAL_GPIO_WritePin(_PATH_SW1_GPIO_Port,_PATH_SW1_Pin,GPIO_PIN_SET);//CLOCK
        HAL_GPIO_WritePin(PATH_SW1_GPIO_Port,PATH_SW1_Pin,GPIO_PIN_RESET);//CLOCK
    }
    if(bluecell_Currdatastatus.Selftest2==0){
//                printf("Selftest1 : 0 \r\n");
        HAL_GPIO_WritePin(_PATH_SW2_GPIO_Port,_PATH_SW2_Pin,GPIO_PIN_RESET);//CLOCK
        HAL_GPIO_WritePin(PATH_SW2_GPIO_Port,PATH_SW2_Pin,GPIO_PIN_SET);//CLOCK
    }else{
//        printf("Selftest2 : 1 \r\n");
        HAL_GPIO_WritePin(_PATH_SW2_GPIO_Port,_PATH_SW2_Pin,GPIO_PIN_SET);//CLOCK
        HAL_GPIO_WritePin(PATH_SW2_GPIO_Port,PATH_SW2_Pin,GPIO_PIN_RESET);//CLOCK
    }
    if(bluecell_Currdatastatus.Selftest3==0){
//                printf("Selftest1 : 0 \r\n");
        HAL_GPIO_WritePin(_PATH_SW3_GPIO_Port,_PATH_SW3_Pin,GPIO_PIN_RESET);//CLOCK
        HAL_GPIO_WritePin(PATH_SW3_GPIO_Port,PATH_SW3_Pin,GPIO_PIN_SET);//CLOCK
    }else{
//                printf("Selftest3 : 1 \r\n");
        HAL_GPIO_WritePin(_PATH_SW3_GPIO_Port,_PATH_SW3_Pin,GPIO_PIN_SET);//CLOCK
        HAL_GPIO_WritePin(PATH_SW3_GPIO_Port,PATH_SW3_Pin,GPIO_PIN_RESET);//CLOCK
    }
    if(bluecell_Currdatastatus.Selftest4==0){
//                printf("Selftest4 : 0 \r\n");
        HAL_GPIO_WritePin(_PATH_SW4_GPIO_Port,_PATH_SW4_Pin,GPIO_PIN_RESET);//CLOCK
        HAL_GPIO_WritePin(PATH_SW4_GPIO_Port,PATH_SW4_Pin,GPIO_PIN_SET);//CLOCK
    }else{
//                printf("Selftest4 : 1 \r\n");
        HAL_GPIO_WritePin(_PATH_SW4_GPIO_Port,_PATH_SW4_Pin,GPIO_PIN_SET);//CLOCK
        HAL_GPIO_WritePin(PATH_SW4_GPIO_Port,PATH_SW4_Pin,GPIO_PIN_RESET);//CLOCK
    }


    DataStatusSet();
}
uint8_t* MBIC_HeaderDataSetting(uint8_t* data){
	ResultData[MBIC_PREAMBLE_0] = MBIC_PREAMBLE0;
	ResultData[MBIC_PREAMBLE_1] = MBIC_PREAMBLE1;
	ResultData[MBIC_PREAMBLE_2] = MBIC_PREAMBLE2;
	ResultData[MBIC_PREAMBLE_3] = MBIC_PREAMBLE3;

	ResultData[MBIC_SUBUID_0] = MBIC_SUBUID0;
	ResultData[MBIC_SUBUID_1] = MBIC_SUBUID1;

	ResultData[MBIC_RCODE_0] = data[MBIC_RCODE_0];

	ResultData[MBIC_TRID_0] = data[MBIC_TRID_0];
	ResultData[MBIC_TRID_1] = data[MBIC_TRID_1];

	ResultData[MBIC_SEQSUM_0] = data[MBIC_SEQSUM_0];

	ResultData[MBIC_TTL_0] = data[MBIC_TTL_0];

    data[MBIC_PAYLOADSTART + 10] = bluecell_Currdatastatus.CPUVERSION3;        	ResultData[MBIC_TIME_0] = data[MBIC_TIME_0];
	ResultData[MBIC_TIME_1] = data[MBIC_TIME_1];
	ResultData[MBIC_TIME_2] = data[MBIC_TIME_2];
	ResultData[MBIC_TIME_3] = data[MBIC_TIME_3];
	ResultData[MBIC_TIME_4] = data[MBIC_TIME_4];
	ResultData[MBIC_TIME_5] = data[MBIC_TIME_5];

    ResultData[MBIC_ERRRESPONSE_0] = MBIC_ERRRESPONSE;

    ResultData[MBIC_CMD_0] = MBIC_ERRRESPONSE;

    ResultData[MBIC_LENGTH_0] = MBIC_ERRRESPONSE;    
    ResultData[MBIC_LENGTH_1] = MBIC_ERRRESPONSE;        

    ResultData[MBIC_HEADERCHECKSUM_0] = Chksum_Create(ResultData,MBIC_HEADER_SIZE - 1);    

	return ResultData;
}
void ALARM_Value_Get(uint8_t datatype,uint8_t* ret){
    switch(datatype){

    }

}

typedef enum{
    MBIC_GET = 0,
    MBIC_SET,        
    MBIC_Table_Get = 0x40,
    MBIC_Table_Set = 0x41,
}BMBM_CMD;

bool MBIC_Operate(uint8_t* data){
	uint16_t datatype = (((data[MBIC_PROT_SUB_DATA_INDEX] << 8) & 0xFF00)  // 2byte Data
              |((data[MBIC_PROT_SUB_DATA_INDEX + 1] << 8) & 0x00FF) );
    uint8_t Length = (data[MBIC_PROT_SUB_DATA_INDEX + 2]);
    uint8_t cmd = 0;

    uint16_t Temp_ADC = 0;
    uint16_t i = 0;
    double temp = 0;
    int16_t Level = 0;
    /*AID*/
  /* for(int i = 0; i < Length; i++){
        SubData[i] = (data[MBIC_PROT_SUB_DATA_INDEX + 3 + i]);
    }*/
    //    SubData     임시 데이터 변수 선언 Subdata로 데이터 전송 
    if(cmd == MBIC_GET){
        /*ALARM FLAG*/
#if 0    
        data[MBIC_PAYLOADSTART + 0] = bluecell_Currdatastatus.ALARM_MASK1;
        
        /*ALARM BIT LIST*/
        data[MBIC_PAYLOADSTART + 5] = bluecell_Currdatastatus.ALARM_TEMP_HIGH;
        data[MBIC_PAYLOADSTART + 6] = bluecell_Currdatastatus.ALARM_DLI_Level;
        data[MBIC_PAYLOADSTART + 7] = bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN;
        data[MBIC_PAYLOADSTART + 8] = bluecell_Currdatastatus.ALARM_ULO_Level;
        data[MBIC_PAYLOADSTART + 9] = bluecell_Currdatastatus.ALARM_ULO_AGC_SHTUTDOWN;
        /*ALARM BIT LIST*/
#else
        /*ALARM BIT LIST*/
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_TEMP_HIGH;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_DLI_Level;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_ULO_Level;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN;
        /*ALARM BIT LIST*/

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK1;
        

#endif
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_TESTMODE;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_Test_Dummy1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_Test_Dummy2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_Test_Dummy3;


        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPUVERSION1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPUVERSION2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPUVERSION3;

        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Current_Bank;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank_Select;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank1_Image_Version1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank1_Image_Version2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank1_Image_Version3;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime3;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime4;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime5;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime6;

        for(int a = 0; a < 32; a++){
            data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank1_Image_Name[a];
        }

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank2_Image_Version1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank2_Image_Version2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank2_Image_Version3;
        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime3;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime4;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime5;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime6;

       for(int a = 0; a < 32; a++){
            data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank2_Image_Name[a];
       }

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.S_W_Reset;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Factory_Set_Initialization;

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_TEMP;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET;

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Temp_High_Threshold;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Temp_High_Threshold_Default;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Temp_High_Alarm;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.LED_TEST;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.NODE;

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Type;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.PCB_Version[0];
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.PCB_Version[1];
        for(int a = 0; a < 20; a++){
            data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Serial_Number[a];
        }

        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Manufacture;

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Manufacture_Date[0];
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Manufacture_Date[1];
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Manufacture_Date[2];
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Freq_ID;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Carrier_ID;
        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Carrier_ON_OFF;

        Temp_ADC = ((bluecell_Currdatastatus.DET_DL1_IN_H << 8) & 0xFF00 
                   |(bluecell_Currdatastatus.DET_DL1_IN_L));
        data[MBIC_PAYLOADSTART + i++] = ((Temp_ADC & 0xFF00) >> 8);
        data[MBIC_PAYLOADSTART + i++] = (Temp_ADC & 0x00FF);
        
        Temp_ADC = ((bluecell_Currdatastatus.DET_DL2_IN_H << 8) & 0xFF00 
                   |(bluecell_Currdatastatus.DET_DL2_IN_L));
        data[MBIC_PAYLOADSTART + i++] = ((Temp_ADC & 0xFF00) >> 8);
        data[MBIC_PAYLOADSTART + i++] = (Temp_ADC & 0x00FF);


        Temp_ADC = ((bluecell_Currdatastatus.DET_DL3_IN_H << 8) & 0xFF00 
                   |(bluecell_Currdatastatus.DET_DL3_IN_L));

        data[MBIC_PAYLOADSTART + i++] = ((Temp_ADC & 0xFF00) >> 8);
        data[MBIC_PAYLOADSTART + i++] = (Temp_ADC & 0x00FF);

        Temp_ADC = ((bluecell_Currdatastatus.DET_DL4_IN_H << 8) & 0xFF00 
                   |(bluecell_Currdatastatus.DET_DL4_IN_L));
        data[MBIC_PAYLOADSTART + i++] = ((Temp_ADC & 0xFF00) >> 8);
        data[MBIC_PAYLOADSTART + i++] = (Temp_ADC & 0x00FF);


        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_DL1_PATH;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_DL2_PATH;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_DL3_PATH;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_DL4_PATH;

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL1_IN_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL1_IN_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL2_IN_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL2_IN_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL3_IN_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL3_IN_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL4_IN_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL4_IN_L;
        /*USER == OFFSET */
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_DL1_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_DL1_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_DL2_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_DL2_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_DL3_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_DL3_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_DL4_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_DL4_L;
        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Threshold_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Threshold_L;

        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_Low_Threshold_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_Low_Threshold_L;

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;

        /*DLI LEVEL QUESTION START ???? */

        temp  = (bluecell_Currdatastatus.DET_DL1_IN_H << 8 
              | bluecell_Currdatastatus.DET_DL1_IN_L) * 3.3/4095; 
        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
        Level *= 10;
        bluecell_Currdatastatus.DLI_Level1_H = ((Level & 0xFF00) >> 8);
        bluecell_Currdatastatus.DLI_Level1_L = ((Level & 0xFF00) >> 8);
        temp  = (bluecell_Currdatastatus.DET_DL2_IN_H << 8 
              | bluecell_Currdatastatus.DET_DL2_IN_L) * 3.3/4095; 
        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
        Level *= 10;
        bluecell_Currdatastatus.DLI_Level1_H = ((Level & 0xFF00) >> 8);
        bluecell_Currdatastatus.DLI_Level1_L = ((Level & 0xFF00) >> 8);
        
        temp  = (bluecell_Currdatastatus.DET_DL3_IN_H << 8 
              | bluecell_Currdatastatus.DET_DL3_IN_L) * 3.3/4095; 
        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
        Level *= 10;
        bluecell_Currdatastatus.DLI_Level1_H = ((Level & 0xFF00) >> 8);
        bluecell_Currdatastatus.DLI_Level1_L = ((Level & 0xFF00) >> 8);
        
        temp  = (bluecell_Currdatastatus.DET_DL4_IN_H << 8 
              | bluecell_Currdatastatus.DET_DL4_IN_L) * 3.3/4095; 
        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
        Level *= 10;
        bluecell_Currdatastatus.DLI_Level1_H = ((Level & 0xFF00) >> 8);
        bluecell_Currdatastatus.DLI_Level1_L = ((Level & 0xFF00) >> 8);

        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level1_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level1_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level2_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level2_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level3_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level3_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level4_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level4_L;
        /*DLI LEVEL QUESTION END ???? */

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Alarm1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Alarm2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Alarm3;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Alarm4;
        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_Low_Alarm1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_Low_Alarm2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_Low_Alarm3;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_Low_Alarm4;


        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_FRBT_Atten1_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_FRBT_Atten1_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_FRBT_Atten2_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_FRBT_Atten2_L;
        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_FRBT_Atten3_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_FRBT_Atten3_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_FRBT_Atten4_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_FRBT_Atten4_L;
        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_FRBT_D_Day;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_FRBT_Status;


        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_AGC_ON_OFF;

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_AGC_Threshold_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_AGC_Threshold_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_AGC_Threshold_default;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_ON_OFF;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_Threshold_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_Threshold_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_Threshold_Default;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_AGC_Alarm1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_AGC_Alarm2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_AGC_Alarm3;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_AGC_Alarm4;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_Alarm1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_Alarm2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_Alarm3;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_Alarm4;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL1_PATH;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL2_PATH;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL3_PATH;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL4_PATH;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL1_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL1_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL2_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL2_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL3_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL3_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL4_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL4_L;
        
        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_UL1_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_UL1_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_UL2_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_UL2_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_UL3_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_UL3_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_UL4_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_UL4_L;

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level_High_Threshold_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level_High_Threshold_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level_High_Threshold_default;
        /*ULO LEVEL QUESTION START ???? */


        temp  = (bluecell_Currdatastatus.DET_UL1_IN_H << 8 
              | bluecell_Currdatastatus.DET_UL1_IN_L) * 3.3/4095; 
        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
        Level *= 10;
        bluecell_Currdatastatus.ULO_Level1_H = ((Level & 0xFF00) >> 8);
        bluecell_Currdatastatus.ULO_Level1_L = ((Level & 0xFF00) >> 8);
        temp  = (bluecell_Currdatastatus.DET_UL2_IN_H << 8 
              | bluecell_Currdatastatus.DET_UL2_IN_L) * 3.3/4095; 
        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
        Level *= 10;
        bluecell_Currdatastatus.ULO_Level2_H = ((Level & 0xFF00) >> 8);
        bluecell_Currdatastatus.ULO_Level2_L = ((Level & 0xFF00) >> 8);
        
        temp  = (bluecell_Currdatastatus.DET_UL3_IN_H << 8 
              | bluecell_Currdatastatus.DET_UL3_IN_L) * 3.3/4095; 
        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
        Level *= 10;
        bluecell_Currdatastatus.ULO_Level3_H = ((Level & 0xFF00) >> 8);
        bluecell_Currdatastatus.ULO_Level3_L = ((Level & 0xFF00) >> 8);
        
        temp  = (bluecell_Currdatastatus.DET_UL4_IN_H << 8 
              | bluecell_Currdatastatus.DET_UL4_IN_L) * 3.3/4095; 
        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
        Level *= 10;
        bluecell_Currdatastatus.ULO_Level4_H = ((Level & 0xFF00) >> 8);
        bluecell_Currdatastatus.ULO_Level4_L = ((Level & 0xFF00) >> 8);

        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level1_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level1_L;        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level2_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level2_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level3_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level3_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level4_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level4_L;
        /*ULO LEVEL QUESTION END ???? */
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level_High_Alarm1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level_High_Alarm2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level_High_Alarm3;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level_High_Alarm4;

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_ALC_ON_OFF;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_ALC_Threshold_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_ALC_Threshold_L;
        
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_ALC_Threshold_Default;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_ON_OFF;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_Threshold_H;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_Threshold_L;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_Threshold_Default;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4;

        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_ALC_Alarm1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_ALC_Alarm2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_ALC_Alarm3;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_ALC_Alarm4;


        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_Alarm1;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_Alarm2;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_Alarm3;
        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_Alarm4;

        //Uart1_Data_Send(data, uint8_t size)
    
    }
    else if(cmd == MBIC_SET){
        switch(datatype){
            case  Alarm_Bit_List                          :
                /*NOP*/
                break;
            case  Alarm_Mask                              :
                bluecell_Currdatastatus.ALARM_MASK1 = data[MBIC_PAYLOADSTART + 0]; 
                break;
            case  Alarm_Test_Mode                         :
                bluecell_Currdatastatus.ALARM_TESTMODE = data[MBIC_PAYLOADSTART + 0]; 
                break;
            case  Alarm_Test_Dummy                        :
                bluecell_Currdatastatus.ALARM_Test_Dummy1 = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ALARM_Test_Dummy2 = data[MBIC_PAYLOADSTART + 1];
                bluecell_Currdatastatus.ALARM_Test_Dummy3 = data[MBIC_PAYLOADSTART + 2];
                break;
            case  CPU_Version                             :
                bluecell_Currdatastatus.CPUVERSION1 = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.CPUVERSION1 = data[MBIC_PAYLOADSTART + 1];
                bluecell_Currdatastatus.CPUVERSION1 = data[MBIC_PAYLOADSTART + 2];
                break;
            case  ModuleINFORMATION_null1                 :
                /*NOP*/
                break;
            case  CPU_Current_Bank                        :
                bluecell_Currdatastatus.CPU_Current_Bank = data[MBIC_PAYLOADSTART + 0]; 

                break;
            case  CPU_Bank_Select_Reboot_by               :
                bluecell_Currdatastatus.CPU_Bank_Select = data[MBIC_PAYLOADSTART + 0]; 

                break;
            case  CPU_Bank1_Image_Version                 :
                bluecell_Currdatastatus.CPU_Bank1_Image_Version1 = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.CPU_Bank1_Image_Version2 = data[MBIC_PAYLOADSTART + 1]; 
                bluecell_Currdatastatus.CPU_Bank1_Image_Version3 = data[MBIC_PAYLOADSTART + 2]; 
                break;
            case  CPU_Bank1_Image_BuildTime               :
                bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime1 = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime2 = data[MBIC_PAYLOADSTART + 1]; 
                bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime3 = data[MBIC_PAYLOADSTART + 2]; 
                bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime4 = data[MBIC_PAYLOADSTART + 3]; 
                bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime5 = data[MBIC_PAYLOADSTART + 4]; 
                bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime6 = data[MBIC_PAYLOADSTART + 5]; 
                break;
            case  CPU_Bank1_Image_Name                    :
                for(int a = 0; a < 32; a++)
                    bluecell_Currdatastatus.CPU_Bank1_Image_Name[a] = data[MBIC_PAYLOADSTART + a]; 
                break;
            case  CPU_Bank2_Image_Version                 :
                bluecell_Currdatastatus.CPU_Bank2_Image_Version1 = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.CPU_Bank2_Image_Version2 = data[MBIC_PAYLOADSTART + 1]; 
                bluecell_Currdatastatus.CPU_Bank2_Image_Version3 = data[MBIC_PAYLOADSTART + 2]; 
                break;
            case  CPU_Bank2_Image_BuildTime               :
                bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime1 = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime2 = data[MBIC_PAYLOADSTART + 1]; 
                bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime3 = data[MBIC_PAYLOADSTART + 2]; 
                bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime4 = data[MBIC_PAYLOADSTART + 3]; 
                bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime5 = data[MBIC_PAYLOADSTART + 4]; 
                bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime6 = data[MBIC_PAYLOADSTART + 5]; 
                break;
            case  CPU_Bank2_Image_Name                    :
                for(int a = 0; a < 32; a++)
                    bluecell_Currdatastatus.CPU_Bank2_Image_Name[a] = data[MBIC_PAYLOADSTART + a]; 
                break;
            case  SW_Reset                                :
                bluecell_Currdatastatus.S_W_Reset = data[MBIC_PAYLOADSTART + 0]; 
                break;
            case  Factory_Set_Initialization              :
                bluecell_Currdatastatus.Factory_Set_Initialization = data[MBIC_PAYLOADSTART + 0]; 
                break;
            case  Temperature                     :
                /*I WILL MODIFY*/
                bluecell_Currdatastatus.DET_TEMP = data[MBIC_PAYLOADSTART + 0]; 
                break;
            case  Temperature_Offset                      :
                bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET = data[MBIC_PAYLOADSTART + 0]; 
                break;
            case  Temp_High_Threshold                     :
                bluecell_Currdatastatus.Temp_High_Threshold = data[MBIC_PAYLOADSTART + 0]; 

                break;
            case  Temp_High_Threshold_Default             :
                bluecell_Currdatastatus.Temp_High_Threshold_Default = data[MBIC_PAYLOADSTART + 0]; 

                break;
            case  Temp_High_Alarm                         :
                bluecell_Currdatastatus.Temp_High_Alarm = data[MBIC_PAYLOADSTART + 0]; 

                break;
            case  LED_TEST                                :
                bluecell_Currdatastatus.LED_TEST = data[MBIC_PAYLOADSTART + 0]; 

                break;
#if 0
            case  Node                                    :
//                bluecell_Currdatastatus.LED_TEST = data[MBIC_PAYLOADSTART + 0]; 

                break;
            case  Type                                    :
//                bluecell_Currdatastatus.LED_TEST = data[MBIC_PAYLOADSTART + 0]; 

                break;
            case  PCB_Version                             :

                break;
            case  Serial_Number                           :

                break;
            case  Manufacture                             :

                break;
            case  Manufacture_Date                        :

                break;
            case  ENVIRONMENT_INVENTORY_NULL0             :

                break;
            case  Freq_ID                                 :

                break;
            case  Carrier_ID                              :

                break;
            case  Carrier_ON_OFF                          :

                break;
            case  DLI_P1_Level                    :

                break;
            case  DLI_P2_Level                            :

                break;
            case  DLI_P3_Level                            :

                break;
            case  DLI_P4_Level                            :

                break;
            case  ULO_P1_Level                            :break;
            case  ULO_P2_Level                            :break;
            case  ULO_P3_Level                            :break;
            case  ULO_P4_Level                            :break;
#endif
            case  DLI_RF_Path1_ON_OFF             :
                bluecell_Currdatastatus.ATT_DL1_PATH = data[MBIC_PAYLOADSTART + 0]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
                break;
            case  DLI_RF_Path2_ON_OFF                     :
                bluecell_Currdatastatus.ATT_DL2_PATH = data[MBIC_PAYLOADSTART + 0]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
                break;
            case  DLI_RF_Path3_ON_OFF                     :
                bluecell_Currdatastatus.ATT_DL3_PATH = data[MBIC_PAYLOADSTART + 0]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
                break;
            case  DLI_RF_Path4_ON_OFF                     :
                bluecell_Currdatastatus.ATT_DL4_PATH = data[MBIC_PAYLOADSTART + 0]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
                break;
            case  DLI_Gain_Atten1                         :
                bluecell_Currdatastatus.ATT_DL1_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ATT_DL1_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
                break;
            case  DLI_Gain_Atten2                         :
                bluecell_Currdatastatus.ATT_DL2_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ATT_DL2_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  DLI_Gain_Atten3                         :
                bluecell_Currdatastatus.ATT_DL3_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ATT_DL3_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  DLI_Gain_Atten4                         :
                bluecell_Currdatastatus.ATT_DL4_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ATT_DL4_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  DLI_Gain_Atten_Offset1                  :
                bluecell_Currdatastatus.bluecell_User_DL1_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.bluecell_User_DL1_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  DLI_Gain_Atten_Offset2                  :
                bluecell_Currdatastatus.bluecell_User_DL2_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.bluecell_User_DL2_L = data[MBIC_PAYLOADSTART + 1];
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  DLI_Gain_Atten_Offset3                  :
                bluecell_Currdatastatus.bluecell_User_DL3_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.bluecell_User_DL3_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  DLI_Gain_Atten_Offset4                  :
                bluecell_Currdatastatus.bluecell_User_DL4_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.bluecell_User_DL4_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  DLI_Level_High_Threshold                :
                bluecell_Currdatastatus.DLI_Level_High_Threshold_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.DLI_Level_High_Threshold_L = data[MBIC_PAYLOADSTART + 1]; 

                break;
            case  DLI_Level_Low_Threshold                 :
                bluecell_Currdatastatus.DLI_Level_Low_Threshold_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.DLI_Level_Low_Threshold_L = data[MBIC_PAYLOADSTART + 1]; 

                break;
            case  DLI_Level_High_Low_Threshold_default    :
                bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default = data[MBIC_PAYLOADSTART + 0]; 

                break;
#if 0 // PYJ.2020.05.12_BEGIN -- 
            case  DLI_Level                               :
                bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default = data[MBIC_PAYLOADSTART + 0]; 
                break;
            case  DLI_Level_High_Alarm1            :

                break;
            case  DLI_Level_High_Alarm2                   :

                break;
            case  DLI_Level_High_Alarm3                   :

                break;
            case  DLI_Level_High_Alarm4                   :

                break;
            case  DLI_Level_Low_Alarm1                    :

                break;
            case  DLI_Level_Low_Alarm2                    :

                break;
            case  DLI_Level_Low_Alarm3                    :break;
            case  DLI_Level_Low_Alarm4                    :break;
#endif // PYJ.2020.05.12_END -- 
            case DLI_FRBT_Atten: 
                bluecell_Currdatastatus.DLI_FRBT_Atten1_H = data[MBIC_PAYLOADSTART + 0];
                bluecell_Currdatastatus.DLI_FRBT_Atten1_L = data[MBIC_PAYLOADSTART + 1];

                bluecell_Currdatastatus.DLI_FRBT_Atten2_H = data[MBIC_PAYLOADSTART + 2];
                bluecell_Currdatastatus.DLI_FRBT_Atten2_L = data[MBIC_PAYLOADSTART + 3];

                bluecell_Currdatastatus.DLI_FRBT_Atten3_H = data[MBIC_PAYLOADSTART + 4];
                bluecell_Currdatastatus.DLI_FRBT_Atten3_L = data[MBIC_PAYLOADSTART + 5];

                bluecell_Currdatastatus.DLI_FRBT_Atten4_H = data[MBIC_PAYLOADSTART + 6];
                bluecell_Currdatastatus.DLI_FRBT_Atten4_L = data[MBIC_PAYLOADSTART + 7];
            
                break;
            case DLI_FRBT_D_Day: 
                bluecell_Currdatastatus.DLI_FRBT_D_Day = data[MBIC_PAYLOADSTART + 0];
                break;
            case DLI_FRBT_Status: 
                bluecell_Currdatastatus.DLI_FRBT_Status = data[MBIC_PAYLOADSTART + 0];
                break;

            case  DLI_AGC_ON_OFF                   :
                /*AGC multi apply*/
                bluecell_Currdatastatus.DLI_AGC_ON_OFF = data[MBIC_PAYLOADSTART + 0];
                break;
            case  DLI_AGC_Threshold                       :
                bluecell_Currdatastatus.DLI_AGC_Threshold_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.DLI_AGC_Threshold_L = data[MBIC_PAYLOADSTART + 1]; 

                break;
            case  DLI_AGC_Threshold_Default               :
                bluecell_Currdatastatus.DLI_AGC_Threshold_default = data[MBIC_PAYLOADSTART + 0]; 
                break;
            case  DLI_Shutdown_ON_OFF                     :
                bluecell_Currdatastatus.DLI_Shutdown_ON_OFF = data[MBIC_PAYLOADSTART + 0]; 

                break;
            case  DLI_Shutdown_Threshold                  :
                bluecell_Currdatastatus.DLI_Shutdown_Threshold_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.DLI_Shutdown_Threshold_L = data[MBIC_PAYLOADSTART + 1]; 

                break;
            case  DLI_Shutdown_Threshold_Default          :
                bluecell_Currdatastatus.DLI_Shutdown_Threshold_Default = data[MBIC_PAYLOADSTART + 0]; 

                break;
            case  DLI_Shutdown_Count                      :
                bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 = data[MBIC_PAYLOADSTART + 1]; 
                bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = data[MBIC_PAYLOADSTART + 2]; 
                bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 = data[MBIC_PAYLOADSTART + 3]; 

                break;
#if 0 // PYJ.2020.05.12_BEGIN -- 
            case  DLI_AGC_Alarm1                          :

                break;
            case  DLI_AGC_Alarm2                          :

                break;
            case  DLI_AGC_Alarm3                          :

                break;
            case  DLI_AGC_Alarm4                          :

                break;
            case  DLI_Shutdown_Alarm1                     :break;
            case  DLI_Shutdown_Alarm2                     :break;
            case  DLI_Shutdown_Alarm3                     :break;
            case  DLI_Shutdown_Alarm4                     :break;
#endif // PYJ.2020.05.12_END -- 
            case  ULO_RF_Path1_ON_OFF1            :
                bluecell_Currdatastatus.ATT_UL1_PATH = data[MBIC_PAYLOADSTART + 0]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
                break;
            case  ULO_RF_Path2_ON_OFF2                    :
                bluecell_Currdatastatus.ATT_UL2_PATH = data[MBIC_PAYLOADSTART + 0]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  ULO_RF_Path3_ON_OFF3                    :
                bluecell_Currdatastatus.ATT_UL3_PATH = data[MBIC_PAYLOADSTART + 0]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  ULO_RF_Path4_ON_OFF4                    :
                bluecell_Currdatastatus.ATT_UL4_PATH = data[MBIC_PAYLOADSTART + 0]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  ULO_Gain_Atten1                         :
                bluecell_Currdatastatus.ATT_UL1_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ATT_UL1_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  ULO_Gain_Atten2                         :
                bluecell_Currdatastatus.ATT_UL2_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ATT_UL2_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  ULO_Gain_Atten3                         :
                bluecell_Currdatastatus.ATT_UL3_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ATT_UL3_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  ULO_Gain_Atten4                         :
                bluecell_Currdatastatus.ATT_UL4_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ATT_UL4_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  ULO_Gain_Atten_Offset1                  :
                bluecell_Currdatastatus.bluecell_User_UL1_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.bluecell_User_UL1_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  ULO_Gain_Atten_Offset2                  :
                bluecell_Currdatastatus.bluecell_User_UL2_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.bluecell_User_UL2_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  ULO_Gain_Atten_Offset3                  :
                bluecell_Currdatastatus.bluecell_User_UL3_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.bluecell_User_UL3_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  ULO_Gain_Atten_Offset4                  :
                bluecell_Currdatastatus.bluecell_User_UL4_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.bluecell_User_UL4_L = data[MBIC_PAYLOADSTART + 1]; 
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);

                break;
            case  ULO_Level_High_Threshold                :
                bluecell_Currdatastatus.ULO_Level_High_Threshold_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ULO_Level_High_Threshold_L = data[MBIC_PAYLOADSTART + 1]; 
                break;
            case  ULO_Level_High_Threshold_default        :
                bluecell_Currdatastatus.ULO_Level_High_Threshold_default = data[MBIC_PAYLOADSTART + 0]; 
                break;
#if 0 // PYJ.2020.05.12_BEGIN -- 
            case  ULO_Level                               :
                break;
            case  ULO_Level_High_Alarm1                  :break;
            case  ULO_Level_High_Alarm2                  :break;
            case  ULO_Level_High_Alarm3                  :break;
            case  ULO_Level_High_Alarm4                  :break;
            case  SERIAL_UL_NULL1                        :break;
#endif // PYJ.2020.05.12_END -- 
            case  ULO_ALC_ON_OFF                   :
                bluecell_Currdatastatus.ULO_ALC_ON_OFF = data[MBIC_PAYLOADSTART + 0]; 

                break;
            case  ULO_ALC_Threshold                       :
                bluecell_Currdatastatus.ATT_ALC_Threshold_H = data[MBIC_PAYLOADSTART + 0];
                bluecell_Currdatastatus.ATT_ALC_Threshold_L = data[MBIC_PAYLOADSTART + 1];

                break;
            case  ULO_ALC_Threshold_Default               :
                bluecell_Currdatastatus.ULO_ALC_Threshold_Default = data[MBIC_PAYLOADSTART + 0]; 

                break;
            case  ULO_Shutdown_ON_OFF                     :
                bluecell_Currdatastatus.ULO_Shutdown_ON_OFF = data[MBIC_PAYLOADSTART + 0]; 

                break;
            case  ULO_Shutdown_Threshold                  :
                bluecell_Currdatastatus.ULO_Shutdown_Threshold_H = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ULO_Shutdown_Threshold_L = data[MBIC_PAYLOADSTART + 1]; 

                break;
            case  ULO_Shutdown_Threshold_Default          :
                bluecell_Currdatastatus.ULO_Shutdown_Threshold_Default = data[MBIC_PAYLOADSTART + 0]; 


                break;
            case  ULO_Shutdown_Retry_Count                :
                bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1 = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2 = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3 = data[MBIC_PAYLOADSTART + 0]; 
                bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 = data[MBIC_PAYLOADSTART + 0]; 
                break;
#if 0 // PYJ.2020.05.13_BEGIN -- 
            case  ULO_ALC_Alarm1                          :

                break;
            case  ULO_ALC_Alarm2                          :

                break;
            case  ULO_ALC_Alarm3                          :

                break;
            case  ULO_ALC_Alarm4                          :

                break;
            case  ULO_Shutdown_Alarm1                     :

                break;
            case  ULO_Shutdown_Alarm2                     :

                break;
            case  ULO_Shutdown_Alarm3                     :

                break;
            case  ULO_Shutdown_Alarm4                     :
#endif // PYJ.2020.05.13_END -- 

                break;
        }
        
              Bluecell_StructCpy(&DataWrite[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
              EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS),&DataWrite[0],sizeof(BLUESTATUS_st));
    }
    else if(cmd == MBIC_Table_Get){
        /*Table Get */

        
        if(data[MBIC_PAYLOADSTART + 0] == UNIT_TYPE_MBIC){
//            data[MBIC_PAYLOADSTART + 1] //Reserve Data
            switch(data[MBIC_PAYLOADSTART + 2]){
            	case DLI_P1_Level_Table_Number                 :
            	case DLI_P2_Level_Table_Number                 :
            	case DLI_P3_Level_Table_Number                 :
            	case DLI_P4_Level_Table_Number                 :
            	case ULO_P1_Level_Table_Number                 :
            	case ULO_P2_Level_Table_Number                 :
            	case ULO_P3_Level_Table_Number                 :
            	case ULO_P4_Level_Table_Number                 :
            	case DLI_P1_ATT_Temp_guarantee_Table_Number    :
            	case DLI_P2_ATT_Temp_guarantee_Table_Number    :
            	case DLI_P3_ATT_Temp_guarantee_Table_Number    :
            	case DLI_P4_ATT_Temp_guarantee_Table_Number    :
            	case ULO_P1_ATT_Temp_guarantee_Table_Number    :
            	case ULO_P2_ATT_Temp_guarantee_Table_Number    :
            	case ULO_P3_ATT_Temp_guarantee_Table_Number    :
            	case ULO_P4_ATT_Temp_guarantee_Table_Number    :
            	case DLI_P1_ATT_Accuracy_Table_Number          :
            	case DLI_P2_ATT_Accuracy_Table_Number          :
            	case DLI_P3_ATT_Accuracy_Table_Number          :
            	case DLI_P4_ATT_Accuracy_Table_Number          :
            	case ULO_P1_ATT_Accuracy_Table_Number          :
            	case ULO_P2_ATT_Accuracy_Table_Number          :
            	case ULO_P3_ATT_Accuracy_Table_Number          :
            	case ULO_P4_ATT_Accuracy_Table_Number          :
              //Header 문장 + sizeof(ATT_TABLE_st) + EXT 문장 Length 추가 
                Bluecell_TableLoad(&data[MBIC_PAYLOADSTART],data[MBIC_PAYLOADSTART + 2]);
            }

        }
        data[MBIC_PAYLOADSTART + i++] = 0x00;
        data[MBIC_PAYLOADSTART + i++] = 0x00;    
            
    }
    else if(cmd == MBIC_Table_Set){

    }
    else{
        /*NOP*/
        printf("DATA ERR\r\n");
    }
//    Uart1_Data_Send(&data[0], data[BLUECELL_LENGTH] + 3);
	return true;
}

uint16_t Ascendingcompare(const void *a, const void *b)    // 오름차순 비교 함수 구현
{
    uint16_t num1 = *(int *)a;    // void 포인터를 int 포인터로 변환한 뒤 역참조하여 값을 가져옴
    uint16_t num2 = *(int *)b;    // void 포인터를 int 포인터로 변환한 뒤 역참조하여 값을 가져옴

    if (num1 < num2)    // a가 b보다 작을 때는
        return -1;      // -1 반환
    
    if (num1 > num2)    // a가 b보다 클 때는
        return 1;       // 1 반환
    
    return 0;    // a와 b가 같을 때는 0 반환
}
uint16_t Descendingcompare(const void *a, const void *b)    // 내림차순 비교 함수 구현
{
    uint16_t num1 = *(uint16_t *)a;    // void 포인터를 uint16_t 포인터로 변환한 뒤 역참조하여 값을 가져옴
    uint16_t num2 = *(uint16_t *)b;    // void 포인터를 uint16_t 포인터로 변환한 뒤 역참조하여 값을 가져옴

    if (num1 > num2)    // a가 b보다 클 때는
        return -1;      // -1 반환
    
    if (num1 < num2)    // a가 b보다 작을 때는
        return 1;       // 1 반환
    
    return 0;           // a와 b가 같을 때는 0 반환
}
void DascendigFunc(uint16_t* data,uint32_t size ){

  int temp;
  for(int i = 0 ; i < size - 1 ; i ++) {
      for(int j = i+1 ; j < size ; j ++) {
          if(data[i] < data[j]) {
              temp = data[j];
              data[j] = data[i];
              data[i] = temp;
        }
      }
  }
}

uint32_t SumFunc(uint16_t* data,uint16_t size){
    uint32_t ret = 0;
    for (uint16_t i = 0; i < size; i++)    // 배열의 요소 개수만큼 반복
    {
        ret += data[i];    // sum과 배열의 요소를 더해서 다시 sum에 저장
    }
    return ret;
}

extern volatile uint32_t ADC1_Average_value[4];
extern volatile uint32_t ADC3_Average_value[5];
extern volatile uint16_t ADC1valuearray[4][ADC_AVERAGECNT];
extern volatile uint16_t ADC3valuearray[5][ADC_AVERAGECNT];

uint16_t ADC1Ret[4];
uint16_t ADC3Ret[5];

void ADC_Check(void){
    //static uint8_t Cnt = 0;

   // double ret = 0;
    uint16_t MIN_ADC[ADC3_CNT] = {0,};
    uint16_t cnt[ADC3_CNT] = {0,};
    double temp;
//    if(AdcTimerCnt > 10){
    // 정렬할 배열, 요소 개수, 요소 크기, 비교 함수를 넣어줌



    if(adc3cnt >= 500){
  for(int i = 0; i < ADC3_CNT; i++){
            DascendigFunc(&ADC3valuearray[i][0],ADC_AVERAGECNT);
            MIN_ADC[i] = ADC3valuearray[i][0] - 12;
            for(int a = 0; a < ADC_AVERAGECNT; a++){
//                 printf("ADC3valuearray[%d][%d] : %d \r\n",i,a,ADC3valuearray[i][a]);
                if(ADC3valuearray[i][a] < MIN_ADC[i]){
                    cnt[i] = a;
//                    printf("cnt[i] %d \r\n",cnt[i]);
                    break;
                }else{
                    cnt[i] = ADC_AVERAGECNT;
                }
            }
            ADC3_Average_value[i] = SumFunc(&ADC3valuearray[i][0],cnt[i]);
//            printf("ADC3_Average_value[%d] : %d / %f \r\n",i,ADC3_Average_value[i],ADC3_Average_value[i]/cnt[i] * Volt_Calc_val);
        }

        for(int i = 0; i < 5; i++){
            ADC3Ret[i] = ADC3_Average_value[i] / cnt[i];
            ADC3_Average_value[i] = 0;
        }
        adc3cnt = 0;
        bluecell_Currdatastatus.DET_DL1_IN_H 
            = ((ADC3Ret[1] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_DL1_IN_L 
            = ((ADC3Ret[1] & 0x00FF));
        

        bluecell_Currdatastatus.DET_DL2_IN_H 
            = ((ADC3Ret[2] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_DL2_IN_L 
            = ((ADC3Ret[2] & 0x00FF) );

            
        bluecell_Currdatastatus.DET_DL3_IN_H 
            = ((ADC3Ret[3] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_DL3_IN_L 
            = ((ADC3Ret[3] & 0x00FF) );

            
        bluecell_Currdatastatus.DET_DL4_IN_H 
            = ((ADC3Ret[4] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_DL4_IN_L 
            = ((ADC3Ret[4] & 0x00FF) );

            
        bluecell_Currdatastatus.DET_UL4_IN_H 
            = ((ADC3Ret[0] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_UL4_IN_L 
            = ((ADC3Ret[0] & 0x00FF) );

#if 0 // PYJ.2020.04.26_BEGIN -- 
        ret = (ADC3Ret[0]) * Volt_Calc_val;
        printf("ADC3Ret[0] : %d        UL4 : %f\r\n",ADC3Ret[0],ret);
        ret = (ADC3Ret[1]) * Volt_Calc_val;
        printf("ADC3Ret[1] : %d        DL1 : %f\r\n",ADC3Ret[1],ret);
        ret = (ADC3Ret[2]) * Volt_Calc_val;
        printf("ADC3Ret[2] : %d        DL2 : %f\r\n",ADC3Ret[2],ret);
        ret = (ADC3Ret[3]) * Volt_Calc_val;
        printf("ADC3Ret[3] : %d        DL3 : %f\r\n",ADC3Ret[3],ret);

        ret = (ADC3Ret[4]) * Volt_Calc_val;
        printf("ADC3Ret[4] : %d        DL4 : %f\r\n",ADC3Ret[4],ret);
#endif // PYJ.2020.04.26_END -- 
    }

    if(adc1cnt >= 500){ 
        for(int i = 0; i < ADC1_CNT; i++){
            DascendigFunc(&ADC1valuearray[i][0],ADC_AVERAGECNT);
            MIN_ADC[i] = ADC1valuearray[i][0] - 12;
            for(int a = 0; a < ADC_AVERAGECNT; a++){
//                 printf("ADC1valuearray[%d][%d] : %d \r\n",i,a,ADC1valuearray[i][a]);
                if(ADC1valuearray[i][a] < MIN_ADC[i]){
                    cnt[i] = a;
//                    printf("cnt[i] %d \r\n",cnt[i]);
                    break;
                }else{
                    cnt[i] = ADC_AVERAGECNT;
                }
            }
            ADC1_Average_value[i] = SumFunc(&ADC1valuearray[i][0],cnt[i]);
//            printf("ADC1_Average_value[%d] : %d / %f \r\n",i,ADC1_Average_value[i],ADC1_Average_value[i]/cnt[i] * Volt_Calc_val);
        }

        for(int i = 0; i < 4; i++){
            ADC1Ret[i] = ADC1_Average_value[i] / cnt[i];
            ADC1_Average_value[i] = 0;
        }
        adc1cnt = 0;
        bluecell_Currdatastatus.DET_UL1_IN_H 
            = ((ADC1Ret[0] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_UL1_IN_L 
            = ((ADC1Ret[0] & 0x00FF) );

            
        bluecell_Currdatastatus.DET_UL2_IN_H 
            = ((ADC1Ret[1] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_UL2_IN_L 
            = ((ADC1Ret[1] & 0x00FF) );

            
        bluecell_Currdatastatus.DET_UL3_IN_H 
            = ((ADC1Ret[2] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_UL3_IN_L 
            = ((ADC1Ret[2] & 0x00FF) );

            
#if 0 // PYJ.2020.05.14_BEGIN -- 
        bluecell_Currdatastatus.DET_TEMP_H  
            =((ADC1Ret[3] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_TEMP_L  
            =((ADC1Ret[3] & 0x00FF) );
#else    
/* *
온도 소수점 제거  
*/
    temp = (ADC1Ret[3] * 3.3 / 4095);
//    printf("temp %f \r\n",temp  );
    bluecell_Currdatastatus.DET_TEMP = (uint8_t)( (temp - 0.5) * 100);
//    printf("DET_TEMP %d \r\n",bluecell_Currdatastatus.DET_TEMP  );
    bluecell_Currdatastatus.DET_TEMP  += bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET;
//    printf("2 DET_TEMP %d \r\n",bluecell_Currdatastatus.DET_TEMP  );
//     temp= ((( - 0.5 ) * 100)  + );

#endif // PYJ.2020.05.14_END -- 


//        ret = ((ADC1Ret[0]) * Volt_Calc_val);
//        printf("UL1 : %f\r\n",ret);

//        ret = ((ADC1Ret[1]) * Volt_Calc_val);
//        printf("UL2 : %f\r\n",ret);

//        ret = ((ADC1Ret[2]) * Volt_Calc_val);
////        printf("UL3 : %f\r\n",ret);
//        bluecell_Currdatastatus.DET_TEMP_H  
//            =((ADC1Ret[3] & 0xFF00) >> 8);
//        bluecell_Currdatastatus.DET_TEMP_L  
//            =((ADC1Ret[3] & 0x00FF) );
//    printf("bluecell_Currdatastatus.DET_TEMP  %d \r\n",bluecell_Currdatastatus.DET_TEMP  );
//    printf(" ADC1Ret[3]    %x \r\n",  ADC1Ret[3]   );


//        ret = ((ADC1Ret[3]) * Volt_Calc_val);
//        printf("Temp : %f\r\n",ret);

    }

}



#if 1 // PYJ.2020.05.12_BEGIN -- 

/*One Point  round*/
double Bluecell_round( double value )
{
    unsigned short data = value * 1000;
    unsigned short temp = 0;
    double ret = 0;
//    printf("1: %d\r\n",data);
    temp = data % 10;
    if(temp >= 5){
        data = data - temp + 10;
    }else{
        data = data - temp;
    }
//    printf("2: %d\r\n",data);
    temp = (data % 100) / 10;
//    printf("3: %d\r\n",temp);
    if(temp >= 5){
        data = data - (temp * 10)+ 100;
    }else{
        data = data - (temp * 10);
    }
//     printf("4: %d\r\n",data);
     ret = data;
//        printf("ret : %f\r\n",ret / 1000);

     return ret / 1000;
}


#endif // PYJ.2020.05.12_END -- 

#if 0 // PYJ.2020.05.12_BEGIN -- 
double AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size){
    double ret = 0xFF,CurrRet = 0,TableAdc,TableAdcret; 
    uint8_t LastIndex = 0;
    double Max_ADC = 0,Min_ADC = 0;
    double step = 0;
    double dot = 0,tempret = 0xFF;
    for(int i =0; i < size / 2; i++){
        TableAdc = CompareAdc[i * 2] << 8;
        TableAdc += CompareAdc[i * 2 + 1];
        TableAdc /= 1000;
//        printf("TableAdc[%d] : %f \r\n",i,TableAdc);
        CurrRet = TableAdc - CurrentAdc;
        
        if(CurrRet < 0){ // plus 공식 
            CurrRet = (CurrRet * -2) + CurrRet;
        }
        if(ret > CurrRet){
            ret = CurrRet;
            TableAdcret = TableAdc;
            LastIndex = i;
        }
    }
    
    /*MIN*/
    TableAdc = CompareAdc[LastIndex * 2] << 8;
    TableAdc += CompareAdc[LastIndex * 2 + 1];
    TableAdc /= 1000;
    Min_ADC = TableAdc;
    /*MAX*/
    TableAdc = CompareAdc[LastIndex * 2 - 2 ] << 8;
    TableAdc += CompareAdc[LastIndex * 2 - 1];
    TableAdc /= 1000;
    Max_ADC = TableAdc;

    
    step = ((Max_ADC - Min_ADC) / 10);
    
//    Min_ADC = Bluecell_round(Min_ADC);
//    CurrentAdc = Bluecell_round(CurrentAdc);
//    printf("1:STEP : %f , %f  > %f > %f \r\n",step,Max_ADC,CurrentAdc,Min_ADC);
    for(double d = 0; d < 1; d += 0.1){
        CurrRet = CurrentAdc - Min_ADC;
        if(tempret >= CurrRet & CurrRet > 0){
//            printf("(%f >= %f)\r\n",tempret,CurrRet);
            tempret = CurrRet;
//            printf("2:STEP : %f , %f  > %f > %f \r\n",step,Max_ADC,CurrentAdc,Min_ADC);
            Min_ADC += step;
            dot = d;
        }
   }    
//    printf("dot : %f \r\n",dot);
    dot = AutoControl_Save[LastIndex] - dot;
    
//    printf("AutoControl_Save[LastIndex]:%d + dot:%f : %f \r\n",AutoControl_Save[LastIndex] + dot);
//    printf(" %f  > %f > %f \r\n",Max_ADC,CurrentAdc,Min_ADC);
    return dot;
}
#else
#if 0 // PYJ.2020.05.15_BEGIN -- 
int8_t AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size){
    double ret = 0xFF,CurrRet = 0,TableAdc; 
    uint8_t LastIndex = 0;
    for(int i =0; i < size / 2; i++){
        TableAdc = CompareAdc[i * 2] << 8;
        TableAdc += CompareAdc[i * 2 + 1];
        TableAdc /= 1000;
//        printf("TableAdc[%d] : %f \r\n",i,TableAdc);
        CurrRet = TableAdc - CurrentAdc;

        if(CurrRet < 0){
            CurrRet = (CurrRet * -2) + CurrRet;
        }
        
        if(ret > CurrRet){
            ret = CurrRet;
            LastIndex = i;
        }
        
    }
    return AutoControl_Save[LastIndex];
}
#else
double AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size){
    double ret = 0xFF,CurrRet = 0,TableAdc,NextTableAdc; 
    double Vitual_array[10] = {0,};
    double step = 0;
    uint8_t LastIndex = 0;
    uint8_t dot = 0;
    
    for(int i =0; i < size / 2; i++){
        TableAdc = CompareAdc[i * 2] << 8;
        TableAdc += CompareAdc[i * 2 + 1];
        TableAdc /= 1000;

        NextTableAdc = CompareAdc[i * 2 + 2] << 8;
        NextTableAdc += CompareAdc[i * 2 + 3];
        NextTableAdc /= 1000;        
//        printf("TableAdc[%d] : %f \r\n",i,TableAdc);
//        CurrRet = TableAdc - CurrentAdc;

        step = (TableAdc - NextTableAdc) / 10;
        for(int a = 0; a < 10; a++){
            Vitual_array[a] = TableAdc - (step * a);
            CurrRet = (Vitual_array[a]) - (CurrentAdc);
            if(CurrRet < 0){
                CurrRet = (CurrRet * -2) + CurrRet;
            }
            
            if(ret > CurrRet){
                ret = CurrRet;
                LastIndex = i;
                dot = a;
            }
        }
        
    }
    TableAdc = CompareAdc[LastIndex * 2] << 8;
    TableAdc += CompareAdc[LastIndex * 2 + 1];
    TableAdc /= 1000;    
    if(CurrentAdc < TableAdc)
        return (AutoControl_Save[LastIndex + 1] + (dot * 0.1));
    else
        return (AutoControl_Save[0]);
}


#endif // PYJ.2020.05.15_END -- 

#endif // PYJ.2020.05.12_END -- 
int32_t MinusConvert(uint8_t Temp_h, int32_t Value){
    int32_t ret;
    if((((bluecell_Currdatastatus.ATT_ALC1_MAX_H << 8) & 0xFF00) & 0xF000) == 0xF000){
        
        Value = 0x0000FFFF - (Value & 0x0000FFFF);
        Value += 0x01;
        Value *= -1;
    }
    Value /= 100;
    ret = Value;
     
    return ret;
}

void ALC_Function(){ //DL 
    double Volt_Calc_val = 3.3 / 4095;
    double ret = 0;
   // double CurrnALCValue = 0;
    double CurrentATTENVALUE = 0;
    int32_t CurrnALC_MAX_SettingValue = 0;    
    int32_t CurrnALC_MIN_SettingValue = 0;        
    int32_t ALC_Result = 0;
    double ResdBm = 0;
    uint8_t tempadc[100];
    Bluecell_StructCpy(&AutoControl_Save[0],&ALC_Table_ref.DET_UL_0,sizeof(ALC_dBm_t));
    Bluecell_StructCpy(&tempadc[0],&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
    if(ALCTimerCnt > 100){
        if(bluecell_Currdatastatus.ATT_ALC1_ONOFF == true){
#if 1 // PYJ.2020.04.29_BEGIN -- 
            //ret 현재 Voltage 값 출력 
            //ret 에 따른 현재 DBM 구현 
            ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
            ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
            ret *= Volt_Calc_val;
            ResdBm = AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
//            printf("db %f \r\n",ResdBm);
//            HAL_Delay(1000);
#if 0 // PYJ.2020.05.14_BEGIN -- 
            //            printf("==================================\r\n");
            //            printf("Current UL ADC VALUE : %f \r\n",ret);
            //            printf("ResdBm : UL1 : %f \r\n",ResdBm);
            //            HAL_Delay(1000);
            CurrnALC_MAX_SettingValue = bluecell_Currdatastatus.ATT_ALC1_MAX_H << 8;
            CurrnALC_MAX_SettingValue += bluecell_Currdatastatus.ATT_ALC1_MAX_L;
            CurrnALC_MAX_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL1_IN_H,CurrnALC_MAX_SettingValue);
            
            CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC1_MIN_H << 8;
            CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC1_MIN_L;
            CurrnALC_MIN_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL1_IN_H,CurrnALC_MIN_SettingValue);

//            printf("CurrnALC_MAX_SettingValue : %d \r\n",CurrnALC_MAX_SettingValue);      
//            printf("CurrnALC_MIN_SettingValue : %d \r\n",CurrnALC_MIN_SettingValue);                  
//            printf("I WILL GIVE YOU ATTEN MAX : %d \r\n",ResdBm - CurrnALC_MAX_SettingValue);
//            printf("I WILL GIVE YOU ATTEN MIN : %d \r\n",ResdBm - CurrnALC_MIN_SettingValue);
//            printf("==================================\r\n");            
            ALC_Result  = ResdBm - CurrnALC_MAX_SettingValue;
            if(ALC_Result > 0){
                ALC_Result *= 100;
                ALC_Result +=  bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
                bluecell_Currdatastatus.ATT_UL1_H =  ((ALC_Result & 0xFF00) >> 8);
                bluecell_Currdatastatus.ATT_UL1_L =  ALC_Result & 0x00FF;               
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
            }else{
            }
#endif // PYJ.2020.05.14_END -- 
            CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC_Threshold_H << 8;
            CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC_Threshold_L;
            CurrnALC_MIN_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL1_IN_H,CurrnALC_MIN_SettingValue);

            CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL1_H,bluecell_Currdatastatus.ATT_UL1_L);
            uint16_t tempValue = 0;
            if(CurrnALC_MIN_SettingValue > ResdBm && CurrentATTENVALUE > 0){
                tempValue = (CurrentATTENVALUE*10);
                tempValue %= 10;
                if(tempValue > 0){
                    ALC_Result = CurrentATTENVALUE *10 -50;
                }else{
                    ALC_Result = CurrentATTENVALUE *10 -100;
                }
                 bluecell_Currdatastatus.ATT_UL1_H = ((ALC_Result & 0xFF00) >> 8);
                 bluecell_Currdatastatus.ATT_UL1_L = ALC_Result & 0x00FF;

                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
                
            }else{
            }
#else

#endif // PYJ.2020.04.29_END -- 
        }
        if(bluecell_Currdatastatus.ATT_ALC2_ONOFF == true){
            ret  = bluecell_Currdatastatus.DET_UL2_IN_H << 8;
            ret += bluecell_Currdatastatus.DET_UL2_IN_L;   
            ret *= Volt_Calc_val;
            ResdBm = AutoControl_ADC_Compare(ret,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
//            printf("db %f \r\n",ResdBm);

#if 0 // PYJ.2020.05.14_BEGIN -- 
            CurrnALC_MAX_SettingValue = bluecell_Currdatastatus.ATT_ALC2_MAX_H << 8;
            CurrnALC_MAX_SettingValue += bluecell_Currdatastatus.ATT_ALC2_MAX_L;
            CurrnALC_MAX_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL2_IN_H,CurrnALC_MAX_SettingValue);
            ALC_Result  = ResdBm - CurrnALC_MAX_SettingValue;
            
            if(ALC_Result > 0){
                ALC_Result *= 100;
                ALC_Result +=  bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L;
                bluecell_Currdatastatus.ATT_UL2_H =  ((ALC_Result & 0xFF00) >> 8);
                bluecell_Currdatastatus.ATT_UL2_L =  ALC_Result & 0x00FF;               
                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
            }
#endif // PYJ.2020.05.14_END -- 
            CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC_Threshold_H << 8;
            CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC_Threshold_L;
            CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL2_H,bluecell_Currdatastatus.ATT_UL2_L);
            uint16_t tempValue = 0;
            if(CurrnALC_MIN_SettingValue > ResdBm && CurrentATTENVALUE > 0){
                tempValue = (CurrentATTENVALUE*10);
                tempValue %= 10;
                if(tempValue > 0){
                    ALC_Result = CurrentATTENVALUE *10 -50;
                }else{
                    ALC_Result = CurrentATTENVALUE *10 -100;
                }
                 bluecell_Currdatastatus.ATT_UL2_H = ((ALC_Result & 0xFF00) >> 8);
                 bluecell_Currdatastatus.ATT_UL2_L = ALC_Result & 0x00FF;

                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
                
           }
        }
        if(bluecell_Currdatastatus.ATT_ALC3_ONOFF == true){
             ret  = bluecell_Currdatastatus.DET_UL3_IN_H << 8;
             ret += bluecell_Currdatastatus.DET_UL3_IN_L;   
             ret *= Volt_Calc_val;
             ResdBm = AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
#if 0 // PYJ.2020.05.14_BEGIN -- 
             CurrnALC_MAX_SettingValue = bluecell_Currdatastatus.ATT_ALC3_MAX_H << 8;
             CurrnALC_MAX_SettingValue += bluecell_Currdatastatus.ATT_ALC3_MAX_L;
             CurrnALC_MAX_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL3_IN_H,CurrnALC_MAX_SettingValue);
             ALC_Result  = ResdBm - CurrnALC_MAX_SettingValue;
             
             if(ALC_Result > 0){
                 ALC_Result *= 100;
                 ALC_Result +=  bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L;
                 bluecell_Currdatastatus.ATT_UL3_H =  ((ALC_Result & 0xFF00) >> 8);
                 bluecell_Currdatastatus.ATT_UL3_L =  ALC_Result & 0x00FF;               
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
             }
#endif // PYJ.2020.05.14_END -- 
             CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC_Threshold_H << 8;
             CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC_Threshold_L;
             CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL3_H,bluecell_Currdatastatus.ATT_UL3_L);
             uint16_t tempValue = 0;
             if(CurrnALC_MIN_SettingValue > ResdBm && CurrentATTENVALUE > 0){
                 tempValue = (CurrentATTENVALUE*10);
                 tempValue %= 10;
                 if(tempValue > 0){
                     ALC_Result = CurrentATTENVALUE *10 -50;
                 }else{
                     ALC_Result = CurrentATTENVALUE *10 -100;
                 }
                  bluecell_Currdatastatus.ATT_UL3_H = ((ALC_Result & 0xFF00) >> 8);
                  bluecell_Currdatastatus.ATT_UL3_L = ALC_Result & 0x00FF;
            
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
                 
            }

        }
        if(bluecell_Currdatastatus.ATT_ALC4_ONOFF == true){
             ret  = bluecell_Currdatastatus.DET_UL4_IN_H << 8;
             ret += bluecell_Currdatastatus.DET_UL4_IN_L;   
             ret *= Volt_Calc_val;
             ResdBm = AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
#if 0 // PYJ.2020.05.14_BEGIN -- 
             CurrnALC_MAX_SettingValue = bluecell_Currdatastatus.ATT_ALC4_MAX_H << 8;
             CurrnALC_MAX_SettingValue += bluecell_Currdatastatus.ATT_ALC4_MAX_L;
             CurrnALC_MAX_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL4_IN_H,CurrnALC_MAX_SettingValue);
             ALC_Result  = ResdBm - CurrnALC_MAX_SettingValue;
             if(ALC_Result > 0){
                 ALC_Result *= 100;
                 ALC_Result +=  bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L;
                 bluecell_Currdatastatus.ATT_UL4_H =  ((ALC_Result & 0xFF00) >> 8);
                 bluecell_Currdatastatus.ATT_UL4_L =  ALC_Result & 0x00FF;               
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
             }
#endif // PYJ.2020.05.14_END -- 
             
             CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC4_MIN_H << 8;
             CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC4_MIN_L;
             CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL4_H,bluecell_Currdatastatus.ATT_UL4_L);
             uint16_t tempValue = 0;
             if(CurrnALC_MIN_SettingValue > ResdBm && CurrentATTENVALUE > 0){
                 tempValue = (CurrentATTENVALUE*10);
                 tempValue %= 10;
                 if(tempValue > 0){
                     ALC_Result = CurrentATTENVALUE *10 -50;
                 }else{
                     ALC_Result = CurrentATTENVALUE *10 -100;
                 }
                  bluecell_Currdatastatus.ATT_UL4_H = ((ALC_Result & 0xFF00) >> 8);
                  bluecell_Currdatastatus.ATT_UL4_L = ALC_Result & 0x00FF;
            
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
                 
            }

        }
        ALCTimerCnt = 0;
    }
}
//-15 ~ -5
int8_t AGC_Calc(int8_t threshold,int8_t CurrDet){
    int8_t Attenret = 0;
    if(threshold > CurrDet)
        return Attenret;
    
    if(threshold != CurrDet){
        Attenret = (threshold - CurrDet) * -1;
    }
//    printf("Attenret : %d \r\n",Attenret);
    return Attenret;
}
void AGC_Function(){//DL
    double Volt_Calc_val = 3.3 / 4095;
    double ret = 0;
    int8_t ResdBm = 0;
    int i = 0;
    int16_t Limitdata = 0;
    uint16_t IwillgiveAtten = 0;
    if(AGCTimerCnt > 100){
        Bluecell_StructCpy(&AutoControl_Save[0],&AGC_Table_ref[0],sizeof(AGC_dBm_t));

        if(bluecell_Currdatastatus.DLI_AGC_ON_OFF == true){

                        //ret 현재 Voltage 값 출력 
            //ret 에 따른 현재 DBM 구현 
            ret  = bluecell_Currdatastatus.DET_DL1_IN_H << 8;
            ret += bluecell_Currdatastatus.DET_DL1_IN_L;   
            ret *= Volt_Calc_val;
            ResdBm = AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
            for(i = 0; i < sizeof(AGC_dBm_t); i++){
                if(AGC_Table_ref[i] == ResdBm)
                    break;
            }
            Limitdata = (( bluecell_Currdatastatus.DLI_AGC_Threshold_H << 8) & 0xFF00) ;
            Limitdata +=  bluecell_Currdatastatus.DLI_AGC_Threshold_L ;
            Limitdata /= 10;

        
//            printf("==================================\r\n");
//            printf("Current DL ADC VALUE : %f \r\n",ret);
//            printf("ResdBm : DL1 : %d \r\n",ResdBm);
//            printf("AGC_Table_ref[%d] : %d\r\n",i,AGC_Table_ref[i]);
//            printf("I WILL GIVE YOU ATTEN  : %d\r\n",AGC_Calc(Limitdata,ResdBm));            
//            printf("AGC  : %d\r\n",Limitdata);            
//            HAL_Delay(1000);
            IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
            bluecell_Currdatastatus.ATT_DL1_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
            bluecell_Currdatastatus.ATT_DL1_L = (((IwillgiveAtten * 10) & 0x00FF));    

#if 0 // PYJ.2020.05.18_BEGIN -- 
            bluecell_Currdatastatus.ATT_DL1_H = (((AGC_ATTEN_ref[i] * 10) & 0xFF00) >> 8) ;
            bluecell_Currdatastatus.ATT_DL1_L = (((AGC_ATTEN_ref[i] * 10) & 0x00FF));    
#endif // PYJ.2020.05.18_END -- 
            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);








           ret  = bluecell_Currdatastatus.DET_DL2_IN_H << 8;
            ret += bluecell_Currdatastatus.DET_DL2_IN_L;   
            ret *= Volt_Calc_val;
            ResdBm = AutoControl_ADC_Compare(ret,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
            for(i = 0; i < sizeof(AGC_dBm_t); i++){
                if(AGC_Table_ref[i] == ResdBm)
                    break;
            }
            Limitdata = (( bluecell_Currdatastatus.DLI_AGC_Threshold_H << 8) & 0xFF00) ;
            Limitdata +=  bluecell_Currdatastatus.DLI_AGC_Threshold_L ;
            Limitdata /= 10;

            IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
            bluecell_Currdatastatus.ATT_DL2_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
            bluecell_Currdatastatus.ATT_DL2_L = (((IwillgiveAtten * 10) & 0x00FF));     
            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);



            ret  = bluecell_Currdatastatus.DET_DL3_IN_H << 8;
            ret += bluecell_Currdatastatus.DET_DL3_IN_L;   
            ret *= Volt_Calc_val;
            ResdBm = AutoControl_ADC_Compare(ret,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
            for(i = 0; i < sizeof(AGC_dBm_t); i++){
                if(AGC_Table_ref[i] == ResdBm)
                    break;
            }
            Limitdata = (( bluecell_Currdatastatus.DLI_AGC_Threshold_H << 8) & 0xFF00) ;
            Limitdata +=  bluecell_Currdatastatus.DLI_AGC_Threshold_L ;
            Limitdata /= 10;

            IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
            bluecell_Currdatastatus.ATT_DL3_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
            bluecell_Currdatastatus.ATT_DL3_L = (((IwillgiveAtten * 10) & 0x00FF));     
            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);





            ret  = bluecell_Currdatastatus.DET_DL4_IN_H << 8;
            ret += bluecell_Currdatastatus.DET_DL4_IN_L;   
            ret *= Volt_Calc_val;
            ResdBm = AutoControl_ADC_Compare(ret,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
            for(i = 0; i < sizeof(AGC_dBm_t); i++){
                if(AGC_Table_ref[i] == ResdBm)
                    break;
            }
            Limitdata = (( bluecell_Currdatastatus.DLI_AGC_Threshold_H << 8) & 0xFF00) ;
            Limitdata +=  bluecell_Currdatastatus.DLI_AGC_Threshold_L ;
            Limitdata /= 10;

            IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
            bluecell_Currdatastatus.ATT_DL4_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
            bluecell_Currdatastatus.ATT_DL4_L = (((IwillgiveAtten * 10) & 0x00FF));     
            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
        }
        AGCTimerCnt = 0;
    }
}
void Alarm_Check(){
    double temp = 0;
    double Volt_Calc_val = 3.3 / 4095;
    double ret = 0;
    int8_t ResdBm[4] = {0,};
#if 0 // PYJ.2020.05.18_BEGIN -- 
    if(bluecell_Currdatastatus.ALARM_MASK1 != true)
        return;
#endif // PYJ.2020.05.18_END -- 

    /******************************TEMP START*******************************************/ 
    if(bluecell_Currdatastatus.Temp_High_Threshold > bluecell_Currdatastatus.DET_TEMP){
        bluecell_Currdatastatus.ALARM_TEMP_HIGH == ENVIRONMENT_TEMPHIGH;
    }
    /******************************TEMP END*******************************************/ 

    /******************************ULO LEVEL START*******************************************/ 

    temp = ((bluecell_Currdatastatus.ULO_Level_High_Threshold_H << 8) & 0xFF00);
    temp += (bluecell_Currdatastatus.ULO_Level_High_Threshold_L & 0x00FF);
    
    ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
    ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
    ret *= Volt_Calc_val;
    ResdBm[0] = AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
    ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
    ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
    ret *= Volt_Calc_val;
    ResdBm[1] = AutoControl_ADC_Compare(ret,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));

    ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
    ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
    ret *= Volt_Calc_val;
    ResdBm[2] = AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
    ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
    ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
    ret *= Volt_Calc_val;
    ResdBm[3] = AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
    
    /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */
    if(temp > ResdBm[0]){
        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P1_LEVEL_HIGH;
    }
    if( temp > ResdBm[1]){
        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P2_LEVEL_HIGH;
    }
    if(temp > ResdBm[2]){
        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P3_LEVEL_HIGH;
    }
    if(temp > ResdBm[3]){
        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P4_LEVEL_HIGH;
    }
    /******************************ULO LEVEL END*******************************************/ 
    /******************************ULO ALC Start*******************************************/ 
    temp = ((bluecell_Currdatastatus.ATT_ALC_Threshold_H << 8) & 0xFF00);
    temp += (bluecell_Currdatastatus.ATT_ALC_Threshold_L & 0x00FF);
    if(temp > ResdBm[0]){
        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ALC_P1;
    }
    if( temp > ResdBm[1]){
        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ALC_P2;
    }
    if(temp > ResdBm[2]){
        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ALC_P3;
    }
    if(temp > ResdBm[3]){
        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ALC_P4;
    }
    /******************************ULO ALC END*******************************************/ 
    temp = ((bluecell_Currdatastatus.ULO_Shutdown_Threshold_H << 8) & 0xFF00);
    temp += (bluecell_Currdatastatus.ULO_Shutdown_Threshold_L & 0x00FF);    
    if(temp > ResdBm[0]){
        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P1;
    }
    if( temp > ResdBm[1]){
        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P2;
    }
    if(temp > ResdBm[2]){
        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P3;
    }
    if(temp > ResdBm[3]){
        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P4;
    }

    /******************************DLI LEVEL START*******************************************/ 

    ret  = bluecell_Currdatastatus.DET_DL1_IN_H << 8;
    ret += bluecell_Currdatastatus.DET_DL1_IN_L;   
    ret *= Volt_Calc_val;
    ResdBm[0] = AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));

    ret  = bluecell_Currdatastatus.DET_DL2_IN_H << 8;
    ret += bluecell_Currdatastatus.DET_DL2_IN_L;   
    ret *= Volt_Calc_val;
    ResdBm[1] = AutoControl_ADC_Compare(ret,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));

    ret  = bluecell_Currdatastatus.DET_DL3_IN_H << 8;
    ret += bluecell_Currdatastatus.DET_DL3_IN_L;   
    ret *= Volt_Calc_val;
    ResdBm[2] = AutoControl_ADC_Compare(ret,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));

    ret  = bluecell_Currdatastatus.DET_DL4_IN_H << 8;
    ret += bluecell_Currdatastatus.DET_DL4_IN_L;   
    ret *= Volt_Calc_val;
    ResdBm[3] = AutoControl_ADC_Compare(ret,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));

    temp = ((bluecell_Currdatastatus.DLI_Level_High_Threshold_H << 8) & 0xFF00);
    temp += (bluecell_Currdatastatus.DLI_Level_High_Threshold_L & 0x00FF);
    /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */
    if(temp < ResdBm[0]){
        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_HIGH;
    }
    if( temp < ResdBm[1]){
        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_HIGH;
    }
    if(temp < ResdBm[2]){
        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_HIGH;
    }
    if(temp < ResdBm[3]){
        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_HIGH;
    }

    temp = ((bluecell_Currdatastatus.DLI_Level_Low_Threshold_H << 8) & 0xFF00);
    temp += (bluecell_Currdatastatus.DLI_Level_Low_Threshold_L & 0x00FF);
    /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */
    if(temp > ResdBm[0]){
        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_HIGH;
    }
    if( temp > ResdBm[1]){
        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_HIGH;
    }
    if(temp > ResdBm[2]){
        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_HIGH;
    }
    if(temp > ResdBm[3]){
        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_HIGH;
    }    
    /******************************DLI LEVEL END*******************************************/     
    /******************************DLI AGC START******************************************/     
    

    
    temp = ((bluecell_Currdatastatus.ATT_DL1_H << 8) & 0xFF00);
    temp += (bluecell_Currdatastatus.ATT_DL1_L & 0x00FF);
    temp /= 10;
    if(temp >= 15){
        printf("ALARM_AGC_P1 OCCUR\r\n");
        bluecell_Currdatastatus.DLI_AGC_Alarm1 |= ALARM_AGC_P1;
    }
    if( temp < ResdBm[1]){
        bluecell_Currdatastatus.DLI_AGC_Alarm2 |= ALARM_AGC_P2;
    }
    if(temp < ResdBm[2]){
        bluecell_Currdatastatus.DLI_AGC_Alarm3 |= ALARM_AGC_P3;
    }
    if(temp < ResdBm[3]){
        bluecell_Currdatastatus.DLI_AGC_Alarm4 |= ALARM_AGC_P4;
    }   
    /******************************DLI AGC END******************************************/     
    /******************************DLI ShutDown Start******************************************/     


    temp = ((bluecell_Currdatastatus.DLI_Shutdown_Threshold_H << 8) & 0xFF00);
    temp += (bluecell_Currdatastatus.DLI_Shutdown_Threshold_L & 0x00FF);

    
    if(temp > ResdBm[0]){
        bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P1;
    }
    if( temp > ResdBm[1]){
        bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P2;
    }
    if(temp > ResdBm[2]){
        bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P3;
    }
    if(temp > ResdBm[3]){
        bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P4;
    }  

    /******************************DLI ShutDown END******************************************/     

    
}