STM32F103ZET_JDASMBIC/Bluecell_Src/Bluecell_operate.c

#include <stdio.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);
uint8_t Alarm_Status[MAX_ALARM_Len] = {0,};
//uint8_t data123[10000];
uint8_t ResultData[1024] = {0,};








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

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];

	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];

	return ResultData;
}

typedef enum{
BLUECELL_HEADER,
BLUECELL_TYPE,
BLUECELL_LENGTH,
BLUECELL_CRCINDEX,
BLUECELL_DATA,
}BLUECELLProt_st;
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;

extern ALL_PE43711_st ALL_ATT;
BLUESTATUS_st bluecell_Currdatastatus;
BLUESTATUS_st bluecell_Prevdatastatus;

uint8_t PE43711_Calc(uint8_t high_bit,uint8_t low_bit){
    uint16_t tmp_h = 0,tmp_l = 0;
    double ret = 0;
    uint8_t val = 0;
    tmp_h = high_bit;
    tmp_l = low_bit;
    ret += ((tmp_h << 8) & 0xFF00);
    ret += (tmp_l & 0x00FF);
    ret /= 100;
    val = PE43711_DataToHexConvert(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){
        bluecell_Prevdatastatus.ATT_DL1_H = bluecell_Currdatastatus.ATT_DL1_H;
        bluecell_Prevdatastatus.ATT_DL1_L = bluecell_Currdatastatus.ATT_DL1_L;
        val = PE43711_Calc(Curr.ATT_DL1_H,Curr.ATT_DL1_L);
//        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)){
        bluecell_Prevdatastatus.ATT_DL2_H = bluecell_Currdatastatus.ATT_DL2_H;
        bluecell_Prevdatastatus.ATT_DL2_L = bluecell_Currdatastatus.ATT_DL2_L;
        val = PE43711_Calc(Curr.ATT_DL2_H,Curr.ATT_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){
        bluecell_Prevdatastatus.ATT_DL3_H = bluecell_Currdatastatus.ATT_DL3_H;
        bluecell_Prevdatastatus.ATT_DL3_L = bluecell_Currdatastatus.ATT_DL3_L;
        val = PE43711_Calc(Curr.ATT_DL3_H,Curr.ATT_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){
        bluecell_Prevdatastatus.ATT_DL4_H = bluecell_Currdatastatus.ATT_DL4_H;
        bluecell_Prevdatastatus.ATT_DL4_L = bluecell_Currdatastatus.ATT_DL4_L;
        val = PE43711_Calc(Curr.ATT_DL4_H,Curr.ATT_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){
        bluecell_Prevdatastatus.ATT_UL1_H = bluecell_Currdatastatus.ATT_UL1_H;
        bluecell_Prevdatastatus.ATT_UL1_L = bluecell_Currdatastatus.ATT_UL1_L;
        val = PE43711_Calc(Curr.ATT_UL1_H,Curr.ATT_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){
        bluecell_Prevdatastatus.ATT_UL2_H = bluecell_Currdatastatus.ATT_UL2_H;
        bluecell_Prevdatastatus.ATT_UL2_L = bluecell_Currdatastatus.ATT_UL2_L;
        val = PE43711_Calc(Curr.ATT_UL2_H,Curr.ATT_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){
        bluecell_Prevdatastatus.ATT_UL3_H = bluecell_Currdatastatus.ATT_UL3_H;
        bluecell_Prevdatastatus.ATT_UL3_L = bluecell_Currdatastatus.ATT_UL3_L;
        
        val = PE43711_Calc(Curr.ATT_UL3_H,Curr.ATT_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){
        bluecell_Prevdatastatus.ATT_UL4_H = bluecell_Currdatastatus.ATT_UL4_H;
        bluecell_Prevdatastatus.ATT_UL4_L = bluecell_Currdatastatus.ATT_UL4_L;
        
        val = PE43711_Calc(Curr.ATT_UL4_H,Curr.ATT_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_H != Prev.ATT_ALC1_H
     ||Curr.ATT_ALC1_L != Prev.ATT_ALC1_L){
     
        bluecell_Prevdatastatus.ATT_ALC1_H = bluecell_Currdatastatus.ATT_ALC1_H;
        bluecell_Prevdatastatus.ATT_ALC1_L = bluecell_Currdatastatus.ATT_ALC1_L;
        val = PE43711_Calc(Curr.ATT_ALC1_H,Curr.ATT_ALC1_L);
//        val = PE43711_DataToHexConvert(ret);
//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
    if(Curr.ATT_ALC2_H != Prev.ATT_ALC2_H
     ||Curr.ATT_ALC2_L != Prev.ATT_ALC2_L){
        bluecell_Prevdatastatus.ATT_ALC2_H = bluecell_Currdatastatus.ATT_ALC2_H;
        bluecell_Prevdatastatus.ATT_ALC2_L = bluecell_Currdatastatus.ATT_ALC2_L;
        val = PE43711_Calc(Curr.ATT_ALC2_H,Curr.ATT_ALC2_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
    if(Curr.ATT_ALC3_H != Prev.ATT_ALC3_H
     ||Curr.ATT_ALC3_L != Prev.ATT_ALC3_L){
        bluecell_Prevdatastatus.ATT_ALC3_H = bluecell_Currdatastatus.ATT_ALC3_H;
        bluecell_Prevdatastatus.ATT_ALC3_L = bluecell_Currdatastatus.ATT_ALC3_L;
        val = PE43711_Calc(Curr.ATT_ALC3_H,Curr.ATT_ALC3_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
    if(Curr.ATT_ALC4_H != Prev.ATT_ALC4_H
     ||Curr.ATT_ALC4_L != Prev.ATT_ALC4_L){
        printf("Curr.ATT_ALC4_H : %x Curr.ATT_ALC4_L : %x\r\n",Curr.ATT_ALC4_H,Curr.ATT_ALC4_L);
        bluecell_Prevdatastatus.ATT_ALC4_H = bluecell_Currdatastatus.ATT_ALC4_H;
        bluecell_Prevdatastatus.ATT_ALC4_L = bluecell_Currdatastatus.ATT_ALC4_L;
        val = PE43711_Calc(Curr.ATT_ALC4_H,Curr.ATT_ALC4_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }

    
    if(Curr.ATT_AGC1_H != Prev.ATT_AGC1_H
     ||Curr.ATT_AGC1_L != Prev.ATT_AGC1_L){
        bluecell_Prevdatastatus.ATT_AGC1_H = bluecell_Currdatastatus.ATT_AGC1_H;
        bluecell_Prevdatastatus.ATT_AGC1_L = bluecell_Currdatastatus.ATT_AGC1_L;
        val = PE43711_Calc(Curr.ATT_AGC1_H,Curr.ATT_AGC1_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
    if(Curr.ATT_AGC2_H != Prev.ATT_AGC2_H
     ||Curr.ATT_AGC2_L != Prev.ATT_AGC2_L){
        bluecell_Prevdatastatus.ATT_AGC2_H = bluecell_Currdatastatus.ATT_AGC2_H;
        bluecell_Prevdatastatus.ATT_AGC2_L = bluecell_Currdatastatus.ATT_AGC2_L;
        val = PE43711_Calc(Curr.ATT_AGC2_H,Curr.ATT_AGC2_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
    if(Curr.ATT_AGC3_H != Prev.ATT_AGC3_H
     ||Curr.ATT_AGC3_L != Prev.ATT_AGC3_L){
        bluecell_Prevdatastatus.ATT_AGC3_H = bluecell_Currdatastatus.ATT_AGC3_H;
        bluecell_Prevdatastatus.ATT_AGC3_L = bluecell_Currdatastatus.ATT_AGC3_L;
        val = PE43711_Calc(Curr.ATT_AGC3_H,Curr.ATT_AGC3_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
    if(Curr.ATT_AGC4_H != Prev.ATT_AGC4_H
     ||Curr.ATT_AGC4_L != Prev.ATT_AGC4_L){
        bluecell_Prevdatastatus.ATT_AGC4_H = bluecell_Currdatastatus.ATT_AGC4_H;
        bluecell_Prevdatastatus.ATT_AGC4_L = bluecell_Currdatastatus.ATT_AGC4_L;
        val = PE43711_Calc(Curr.ATT_AGC4_H,Curr.ATT_AGC4_L);

//        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);

    }
#endif // PYJ.2020.04.21_END -- 
     
}
void Bluecell_DataCopy(){

}

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;
    
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;
void Bluecell_StructCopyFunction(uint16_t* dst,uint8_t* src,uint8_t size){
  for(int i = 0; i < size; i++){
    dst[i]  = ((src[i * 2] << 8) & 0xFF00);
    dst[i]  += src[i * 2 + 1] & 0x00FF;
  }
}
void Bluecell_StructCpy(uint8_t* dst,uint8_t* src,uint8_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; 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("%x ",dst[i]);
  }
}

void Bluecell_TableLoad(uint8_t* data){
    uint8_t tabletype = data[BLUECELL_DATA];
//    OneByteToTwoByte data;
//    printf("%s : %x \r\n",__func__,tabletype);

    switch(tabletype){
        case Bluecell_Table_ATT_DL1: 
          EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_BASE,1),&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
          Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
          Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
          data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
          break;
        case Bluecell_Table_ATT_UL1: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
        break;
        case Bluecell_Table_ATT_DL2: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
            break;
        case Bluecell_Table_ATT_UL2: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
            break;
        case Bluecell_Table_ATT_DL3: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
            break;
        case Bluecell_Table_ATT_UL3: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
            break;
        case Bluecell_Table_ATT_DL4: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
            break;
        case Bluecell_Table_ATT_UL4: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
            break;
        case Bluecell_Table_DET_DL1: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_DL1.Table_Det5_dBm,sizeof(DET_TABLEDL_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
            break;
        case Bluecell_Table_DET_UL1: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_UL1.Table_Det_15_dBm,sizeof(DET_TABLEUL_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
            break;
        case Bluecell_Table_DET_DL2: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_DL2.Table_Det5_dBm,sizeof(DET_TABLEDL_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
            break;
        case Bluecell_Table_DET_UL2: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_UL2.Table_Det_15_dBm,sizeof(DET_TABLEUL_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;

            break;
        case Bluecell_Table_DET_DL3: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_DL3.Table_Det5_dBm,sizeof(DET_TABLEDL_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
            break;
        case Bluecell_Table_DET_UL3: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_UL3.Table_Det_15_dBm,sizeof(DET_TABLEUL_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
            break;
        case Bluecell_Table_DET_DL4: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_DL4.Table_Det5_dBm,sizeof(DET_TABLEDL_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
            break;
        case Bluecell_Table_DET_UL4: 
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_UL4.Table_Det_15_dBm,sizeof(DET_TABLEUL_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;

            break;
        case Bluecell_Table_TEMP_DL1:
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_DL1.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;

            break;
        case Bluecell_Table_TEMP_UL1:
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_UL1.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;

            break;
        case Bluecell_Table_TEMP_DL2:
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_DL2.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;

            break;
        case Bluecell_Table_TEMP_UL2:
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_UL2.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;

            break;
        case Bluecell_Table_TEMP_DL3:
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_DL3.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;

            break;
        case Bluecell_Table_TEMP_UL3:
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_UL3.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;

            break;
        case Bluecell_Table_TEMP_DL4:
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_DL4.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
        data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;

        break;
        case Bluecell_Table_TEMP_UL4:
            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_UL4.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;

            break;
    }
        
    
}

void Bluecell_TableSave(uint8_t* data){
    uint8_t tabletype = data[BLUECELL_DATA];
    
    //printf("%s : %x \r\n",__func__,tabletype);
    switch(tabletype){
        case Bluecell_Table_ATT_DL1: 
            Bluecell_StructCopyFunction(&Att_DL1.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);
//            printf("%x\r\n",Att_DL1.Table_0_0_dBm);   
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_BASE,1),&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
//            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_BASE,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
//            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_BASE,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
//            EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_BASE,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
//         
//            EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
//            printf("%x\r\n",Att_DL1.Table_0_0_dBm);        
//            EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
        break;
        case Bluecell_Table_ATT_DL2: 
            Bluecell_StructCopyFunction(&Att_DL2.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_DL1_TABLE_ADDRESDS,1),&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            break;
        case Bluecell_Table_ATT_DL3: 
            Bluecell_StructCopyFunction(&Att_DL3.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_DL2_TABLE_ADDRESDS,1),&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            break;
        case Bluecell_Table_ATT_DL4: 
            Bluecell_StructCopyFunction(&Att_DL4.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_DL3_TABLE_ADDRESDS,1),&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            break;

            
        case Bluecell_Table_ATT_UL1: 
            Bluecell_StructCopyFunction(&Att_UL1.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_DL4_TABLE_ADDRESDS,1),&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            break;
        case Bluecell_Table_ATT_UL2: 
            Bluecell_StructCopyFunction(&Att_UL2.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_UL1_TABLE_ADDRESDS,1),&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            break;
        case Bluecell_Table_ATT_UL3: 
            Bluecell_StructCopyFunction(&Att_UL3.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_UL2_TABLE_ADDRESDS,1),&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            break;
        case Bluecell_Table_ATT_UL4: 
            Bluecell_StructCopyFunction(&Att_UL4.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_UL3_TABLE_ADDRESDS,1),&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));
            break;
        case Bluecell_Table_DET_DL1: 



        
            Bluecell_StructCopyFunction(&Det_DL1.Table_Det5_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_UL4_TABLE_ADDRESDS,1),&Det_DL1.Table_Det5_dBm,sizeof(DET_TABLEDL_st));
            break;
        case Bluecell_Table_DET_DL2: 
            Bluecell_StructCopyFunction(&Det_DL2.Table_Det5_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_DL1_TABLE_ADDRESDS,1),&Det_DL2.Table_Det5_dBm,sizeof(DET_TABLEDL_st));
            break;
        case Bluecell_Table_DET_DL3: 
            Bluecell_StructCopyFunction(&Det_DL3.Table_Det5_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_DL2_TABLE_ADDRESDS,1),&Det_DL3.Table_Det5_dBm,sizeof(DET_TABLEDL_st));
        case Bluecell_Table_DET_DL4: 
            Bluecell_StructCopyFunction(&Det_DL4.Table_Det5_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_DL3_TABLE_ADDRESDS,1),&Det_DL4.Table_Det5_dBm,sizeof(DET_TABLEDL_st));
            break;



            
        case Bluecell_Table_DET_UL1: 
            Bluecell_StructCopyFunction(&Det_UL1.Table_Det_15_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_DL4_TABLE_ADDRESDS,1),&Det_UL1.Table_Det_15_dBm,sizeof(DET_TABLEUL_st));            
            break;
        case Bluecell_Table_DET_UL2: 
            Bluecell_StructCopyFunction(&Det_UL2.Table_Det_15_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_UL1_TABLE_ADDRESDS,1),&Det_UL2.Table_Det_15_dBm,sizeof(DET_TABLEUL_st));            
        break;
    case Bluecell_Table_DET_UL3: 
            Bluecell_StructCopyFunction(&Det_UL3.Table_Det_15_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_UL2_TABLE_ADDRESDS,1),&Det_UL3.Table_Det_15_dBm,sizeof(DET_TABLEUL_st));            
            break;
        case Bluecell_Table_DET_UL4: 
            Bluecell_StructCopyFunction(&Det_UL4.Table_Det_15_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_UL3_TABLE_ADDRESDS,1),&Det_UL4.Table_Det_15_dBm,sizeof(DET_TABLEUL_st));            

            break;



            
        case Bluecell_Table_TEMP_DL1:
            Bluecell_StructCopyFunction(&Temp_DL1.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_UL4_TABLE_ADDRESDS,1),&Temp_DL1.Table_10_Temp,sizeof(TEMP_TABLE_st));                    
            break;
        case Bluecell_Table_TEMP_DL2:
            Bluecell_StructCopyFunction(&Temp_DL2.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_DL1_TABLE_ADDRESDS,1),&Temp_DL2.Table_10_Temp,sizeof(TEMP_TABLE_st));                    

            break;
        case Bluecell_Table_TEMP_DL3:
            Bluecell_StructCopyFunction(&Temp_DL3.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_DL2_TABLE_ADDRESDS,1),&Temp_DL3.Table_10_Temp,sizeof(TEMP_TABLE_st));                    

            break;
        case Bluecell_Table_TEMP_DL4:
            Bluecell_StructCopyFunction(&Temp_DL4.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_DL3_TABLE_ADDRESDS,1),&Temp_DL4.Table_10_Temp,sizeof(TEMP_TABLE_st));                    

            break;
        case Bluecell_Table_TEMP_UL1:
            Bluecell_StructCopyFunction(&Temp_UL1.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_DL4_TABLE_ADDRESDS,1),&Temp_UL1.Table_10_Temp,sizeof(TEMP_TABLE_st));                            
            break;
        case Bluecell_Table_TEMP_UL2:
            Bluecell_StructCopyFunction(&Temp_UL2.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_UL1_TABLE_ADDRESDS,1),&Temp_UL2.Table_10_Temp,sizeof(TEMP_TABLE_st));                            
            break;
        case Bluecell_Table_TEMP_UL3:
            Bluecell_StructCopyFunction(&Temp_UL3.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_UL2_TABLE_ADDRESDS,1),&Temp_UL3.Table_10_Temp,sizeof(TEMP_TABLE_st));                            
            break;
        case Bluecell_Table_TEMP_UL4:
            Bluecell_StructCopyFunction(&Temp_UL4.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_UL3_TABLE_ADDRESDS,1),&Temp_UL4.Table_10_Temp,sizeof(TEMP_TABLE_st));                                
            break;
    }
        
    
}
uint8_t Txdata[512];
bool Bluecell_Operate(uint8_t* data){
  uint8_t datatype = data[BLUECELL_TYPE];

  uint16_t tmp_h = 0,tmp_l = 0;
  double ret = 0 ,tmp = 0.1;
  uint8_t val = 0;
  uint8_t i = 0;
  switch(datatype){
	case ATTSET 				 :
//		printf("Function : %s Line %d \r\n",__func__,__LINE__);
        bluecell_Currdatastatus.ATT_DL1_H = 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_DL1_L = data[BLUECELL_DATA + i++];
        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_AGC1_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_AGC1_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_AGC2_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_AGC2_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_AGC3_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_AGC3_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_AGC4_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_AGC4_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC1_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC1_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC2_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC2_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC3_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC3_L = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC4_H = data[BLUECELL_DATA + i++];
        bluecell_Currdatastatus.ATT_ALC4_L = data[BLUECELL_DATA + i++];
//        printf("bluecell_Currdatastatus.ATT_ALC4_H : %x \r\nbluecell_Currdatastatus.ATT_ALC4_L : %x\r\n",
            //bluecell_Currdatastatus.ATT_ALC4_H,bluecell_Currdatastatus.ATT_ALC4_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
//            printf("ATT_DL1_PATH ON\r\n");
        }
	

		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

        }
//        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
        }
//		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
        }
//		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
        }
		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
        }
//		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
        }
//		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
        }
//		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
        }
//		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        

        }
//		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
        }
//		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
	  }
//		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.ATT_AGC1_ONOFF = false;
        }
        else{
            bluecell_Currdatastatus.ATT_AGC1_ONOFF = true;
        }
    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);
    break;
    case ATT_TableGet:
        Bluecell_TableLoad(data);
        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]);
        }
        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[Txdata[BLUECELL_LENGTH] + 1] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]);
#if 1 // PYJ.2020.04.22_BEGIN -- 
        for(int i = 0 ; i < Txdata[BLUECELL_LENGTH] + 3; i++ ){
            printf("%x ",Txdata[i]);
        }
        printf("\r\n");
#endif // PYJ.2020.04.22_END --    
        Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st));
        break;
    case Bluecell_StatusSave:
//        printf("Copy Complete");
        EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_UL4_TABLE_ADDRESDS,1),&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
        Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
        Txdata[Txdata[BLUECELL_LENGTH] + 1] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]);
        Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st));        
        break;
  }
  return true;
}
void DataStatusSet(void){
        bluecell_Currdatastatus.bluecell_header = 0xbe;
        bluecell_Currdatastatus.bluecell_type = Bluecell_StatusReq;
        bluecell_Currdatastatus.bluecell_length = sizeof(bluecell_Currdatastatus) - 3;    
        bluecell_Currdatastatus.bluecell_crcindex = sizeof(bluecell_Currdatastatus) - 2 + 1;    
        bluecell_Currdatastatus.Selftest0 = HAL_GPIO_ReadPin(_PATH_SW1_GPIO_Port,_PATH_SW1_Pin);
        bluecell_Currdatastatus.Selftest1 = HAL_GPIO_ReadPin(_PATH_SW2_GPIO_Port,_PATH_SW2_Pin);
        bluecell_Currdatastatus.Selftest2 = HAL_GPIO_ReadPin(_PATH_SW3_GPIO_Port,_PATH_SW3_Pin);
        bluecell_Currdatastatus.Selftest3 = HAL_GPIO_ReadPin(_PATH_SW4_GPIO_Port,_PATH_SW4_Pin);
        bluecell_Currdatastatus.ATT_DL1_PATH = HAL_GPIO_ReadPin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin);//CLOCK;
        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;
        /*bluecell_Currdatastatus.ATT_AGC1_ONOFF;
        bluecell_Currdatastatus.ATT_ALC1_ONOFF;
        bluecell_Currdatastatus.ATT_AGC2_ONOFF;
        bluecell_Currdatastatus.ATT_ALC2_ONOFF;
        bluecell_Currdatastatus.ATT_AGC3_ONOFF;
        bluecell_Currdatastatus.ATT_ALC3_ONOFF;
        bluecell_Currdatastatus.ATT_AGC4_ONOFF;
        bluecell_Currdatastatus.ATT_ALC4_ONOFF;
        bluecell_Currdatastatus.ATT_AGC1_H;
        bluecell_Currdatastatus.ATT_AGC1_L;
        bluecell_Currdatastatus.ATT_ALC1_H;
        bluecell_Currdatastatus.ATT_ALC1_L;
        bluecell_Currdatastatus.ATT_AGC2_H;
        bluecell_Currdatastatus.ATT_AGC2_L;
        bluecell_Currdatastatus.ATT_ALC2_H;
        bluecell_Currdatastatus.ATT_ALC2_L;
        bluecell_Currdatastatus.ATT_AGC3_H;
        bluecell_Currdatastatus.ATT_AGC3_L;
        bluecell_Currdatastatus.ATT_ALC3_H;
        bluecell_Currdatastatus.ATT_ALC3_L;
        bluecell_Currdatastatus.ATT_AGC4_H;
        bluecell_Currdatastatus.ATT_AGC4_L;
        bluecell_Currdatastatus.ATT_ALC4_H;
        bluecell_Currdatastatus.ATT_ALC4_L;  */
}
 void Bluecell_DataInit(){
    HAL_GPIO_WritePin(PATH_SW1_GPIO_Port,_PATH_SW1_Pin,bluecell_Currdatastatus.Selftest0   );     
    HAL_GPIO_WritePin(_PATH_SW1_GPIO_Port,_PATH_SW1_Pin,bluecell_Currdatastatus.Selftest0   );     
    
    HAL_GPIO_WritePin(PATH_SW2_GPIO_Port,_PATH_SW2_Pin,bluecell_Currdatastatus.Selftest1   );     
    HAL_GPIO_WritePin(_PATH_SW2_GPIO_Port,_PATH_SW2_Pin,bluecell_Currdatastatus.Selftest1   );     
    
    HAL_GPIO_WritePin(PATH_SW3_GPIO_Port,_PATH_SW3_Pin,bluecell_Currdatastatus.Selftest2   );     
    HAL_GPIO_WritePin(_PATH_SW3_GPIO_Port,_PATH_SW3_Pin,bluecell_Currdatastatus.Selftest2   );     
    
    HAL_GPIO_WritePin(PATH_SW4_GPIO_Port,_PATH_SW4_Pin,bluecell_Currdatastatus.Selftest3   );     
    HAL_GPIO_WritePin(_PATH_SW4_GPIO_Port,_PATH_SW4_Pin,bluecell_Currdatastatus.Selftest3   );     


    
    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);


    DataStatusSet();
    Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
    Txdata[Txdata[BLUECELL_LENGTH] + 1] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]);    
    Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st));
}
bool MBIC_Operate(uint8_t* data){
	uint16_t datatype = 0;

	switch(datatype){
		case Alarm_Bit_List:
			Uart1_Data_Send(&Alarm_Status[0],MAX_ALARM_Len);
		break;
		case Alarm_Mask:

		break;
		case Alarm_Test_Mode:

		break;
		case Alarm_Test_Dummy:

		break;
		case CPU_Version:

		break;
		case ModuleINFORMATION_null1:

		break;
		case CPU_Current_Bank:

		break;
		case CPU_Bank_Select_Reboot_by:
		break;
		case CPU_Bank1_Image_Version:
		break;
		case CPU_Bank1_Image_BuildTime:
		break;
		case CPU_Bank1_Image_Name:
		break;
		case CPU_Bank2_Image_Version:
		break;
		case CPU_Bank2_Image_BuildTime:
		break;
		case CPU_Bank2_Image_Name:
		break;
		case SW_Reset:
		break;
		case Factory_Set_Initialization:
		break;
		case Temperature:

		break;
		case Temperature_Offset:
			break;
		case Temp_High_Threshold:
			break;
		case Temp_High_Threshold_Default:
			break;
		case Temp_High_Alarm:
			break;
		case LED_TEST:
		break;
		case Node:
			break;
		case Type:
			break;
		case PCB_Version:
			break;
		case Serial_Number:
			break;
		case Manufacture:
			break;
		case Manufacture_Date:
			break;
		case ENVIRONMENT_INVENTORY_null1:
//			printf("Function : %s .... Line : %d\r\n",__func__,__LINE__);
			break;
		case Freq_ID:
			break;
		case Carrier_ID:
			break;
		case Carrier_ON_OFF:
			break;

	}
	return true;

}



extern volatile uint32_t ADC1_Average_value[4];
extern volatile uint32_t ADC3_Average_value[5];

void ADC_Check(void){
    static uint8_t Cnt = 0;
    double Volt_Calc_val = 3.3 / 4095;
    uint16_t ret = 0;
//    if(AdcTimerCnt > 10){
    
    if(adc3cnt > 100){
        for(int i = 0; i < 6; i++){
            ADC3value[i] = ADC3_Average_value[i] / adc3cnt;
        }
        adc3cnt = 0;
        bluecell_Currdatastatus.DET_DL1_IN_H 
            = (uint16_t)((ADC3value[1] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_DL1_IN_L 
            = (uint16_t)((ADC3value[1] & 0x00FF));
        

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

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

            
        bluecell_Currdatastatus.DET_DL4_IN_H 
            = (uint16_t)((ADC3value[4] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_DL4_IN_L 
            = (uint16_t)((ADC3value[4] & 0x00FF) );
        bluecell_Currdatastatus.DET_UL4_IN_H 
            = (uint16_t)((ADC3value[0] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_UL4_IN_L 
            = (uint16_t)((ADC3value[0] & 0x00FF) );
    }
    if(adc1cnt > 100){ 
        for(int i = 0; i < 5; i++){
            ADC1value[i] = ADC1_Average_value[i] / adc1cnt;
        }
        adc1cnt = 0;
        bluecell_Currdatastatus.DET_UL1_IN_H 
            = (uint16_t)((ADC1value[0] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_UL1_IN_L 
            = (uint16_t)((ADC1value[0] & 0x00FF) );

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

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

            

            
        bluecell_Currdatastatus.DET_TEMP_H  
            =(uint16_t)((ADC1value[3] & 0xFF00) >> 8);
        bluecell_Currdatastatus.DET_TEMP_L  
            =(uint16_t)((ADC1value[3] & 0x00FF) );
       
    }
#if 0 // PYJ.2020.04.22_BEGIN -- 
    if(Cnt >= 250){

    ret = (ADC3value[0]) * Volt_Calc_val;
    printf("UL4 : %f\r\n",ret);
    ret = (ADC3value[1]) * Volt_Calc_val;
    printf("DL1 : %f\r\n",ret);
    ret = (ADC3value[2]) * Volt_Calc_val;
    printf("DL2 : %f\r\n",ret);
    ret = (ADC3value[3]) * Volt_Calc_val;
    printf("DL3 : %f\r\n",ret);
    ret = (ADC3value[4]) * Volt_Calc_val;
    printf("DL4 : %f\r\n",ret);



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

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

    ret = ((ADC1value[2]) * Volt_Calc_val);
    printf("UL3 : %f\r\n",ret);
    Cnt = 0;
    }else{
Cnt++;
    }
#else
    
#if 0 // PYJ.2020.04.22_BEGIN -- 
if(Cnt >= 250){
    ret = (ADC3value[0]);
    printf("UL4 : %x\r\n",ret);
    ret = (ADC3value[1]);
    printf("DL1 : %x\r\n",ret);
    ret = (ADC3value[2]);
    printf("DL2 : %x\r\n",ret);
    ret = (ADC3value[3]);
    printf("DL3 : %x\r\n",ret);
    ret = (ADC3value[4]);
    printf("DL4 : %x\r\n",ret);
    ret = ((ADC1value[0]));
    printf("UL1 : %x\r\n",ret);
    ret = ((ADC1value[1]));
    printf("UL2 : %x\r\n",ret);
    ret = ((ADC1value[2]));
    printf("UL3 : %\r\n",ret);  
    Cnt = 0;
}else{
    Cnt++;
}
#endif // PYJ.2020.04.22_END -- 
#endif // PYJ.2020.04.22_END -- 

}