#include #include #include #include "main.h" #include "Bluecell_operate.h" #include "PE43711.h" #include "eeprom.h" /***************************************************************************************/ /* Extern Function */ /***************************************************************************************/ extern void PE43711_atten_ctrl(PE43711_st ATT ,uint8_t data); extern void Uart1_Data_Send(uint8_t* data,uint8_t size); extern HAL_StatusTypeDef EEPROM_M24C08_Zerowrite(uint8_t devid,uint16_t Address); /***************************************************************************************/ /* Extern Valuable */ /***************************************************************************************/ extern volatile bool AlarmTimerOnSet; extern volatile bool AlarmTimerOffSet; extern volatile uint32_t AlarmTimerOnCnt; extern volatile uint32_t AlarmTimerOffCnt; extern volatile uint32_t AGCAlarmTimerCnt[AGC_Alarm_DL_Index_MAX]; extern ALL_PE43711_st ALL_ATT; extern volatile uint16_t ADC1valuearray[4][ADC_AVERAGECNT]; extern volatile uint16_t ADC3valuearray[5][ADC_AVERAGECNT]; extern volatile uint32_t LedTimerCnt; extern volatile uint32_t AdcTimerCnt; extern volatile uint32_t DET_UL_On_AlarmTimerCnt[DET_Alarm_UL_Index_MAX]; extern volatile uint32_t DET_DL_On_AlarmTimerCnt[DET_Alarm_DL_Index_MAX]; extern volatile uint32_t DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL_Index_MAX]; extern volatile uint32_t DET_DL_Off_AlarmTimerCnt[DET_Alarm_DL_Index_MAX]; /***************************************************************************************/ /* Function */ /***************************************************************************************/ 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(); 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); void Booting_LED_Check(void); double Bluecell_TestPro(double value ); double AGC_AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size); /***************************************************************************************/ /* Valuable */ /***************************************************************************************/ bool Alarm_LED_OnSet = false; uint8_t DataWrite[sizeof(BLUESTATUS_st)] = {0,}; uint8_t Txdata[512]; int8_t AutoControl_Save[sizeof(ALC_dBm_t)]; uint16_t ADC1Ret[4]; uint16_t ADC3Ret[5]; 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; BLUESTATUS_st bluecell_Currdatastatus; BLUESTATUS_st bluecell_Prevdatastatus; #if 0 // PYJ.2020.05.21_BEGIN -- int8_t AGC_ATTEN_ref[16] = { 15 , 14 , 13 , 12 , 11 , 10 , 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0 , }; #endif // PYJ.2020.05.21_END -- uint8_t MBIC_TxDataArray[256] = {0,}; void Booting_LedInit(void){ HAL_GPIO_WritePin(BOOT_LED_GPIO_Port,BOOT_LED_Pin,GPIO_PIN_RESET); HAL_GPIO_WritePin(LED_ACT_GPIO_Port,LED_ACT_Pin,GPIO_PIN_SET); HAL_GPIO_WritePin(LED_FAIL_GPIO_Port,LED_FAIL_Pin,GPIO_PIN_SET); } void Booting_LED_Check(void){ for(int i = 0; i < 6; i ++){ 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); HAL_Delay(1000); } } void Boot_LED_Toggle(void){ if(LedTimerCnt > 1000){ HAL_GPIO_TogglePin(BOOT_LED_GPIO_Port,BOOT_LED_Pin); HAL_GPIO_TogglePin(LED_FAIL_GPIO_Port,LED_FAIL_Pin); // if(AlarmTimerOnCnt > 3000){ if(Alarm_LED_OnSet == true){ HAL_GPIO_WritePin(LED_ACT_GPIO_Port,LED_ACT_Pin,GPIO_PIN_SET); }else{ HAL_GPIO_WritePin(LED_ACT_GPIO_Port,LED_ACT_Pin,GPIO_PIN_RESET); } printf("Alarm_LED_OnSet : %d\r\n",Alarm_LED_OnSet); LedTimerCnt = 0; } } 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); // Hidden Atten Calc ret += PE43711_Double(offset_h,offset_l);//Plus User Atten Calc ret += PE43711_Double(0,HIDDENATTEN);//Plus Default Atten 5 // 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; #if 0 // PYJ.2020.05.22_BEGIN -- 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; #else ret = ((((high_bit << 8) & 0xFF00) | (low_bit)) / 10); #if 0 // PYJ.2020.05.22_BEGIN -- if(ret > 6000){ printf("high_bit : %x LOW BIT : %x \r\n",high_bit,low_bit); } #endif // PYJ.2020.05.22_END -- #endif // PYJ.2020.05.22_END -- // 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; } #if 1 // PYJ.2020.05.25_BEGIN -- void Bluecell_AttenInitialize(){ uint8_t val = 0; 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, // Table Offset bluecell_Currdatastatus.ATT_DL1_H, // Hidden Atten High bit bluecell_Currdatastatus.ATT_DL1_L, // Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_DL1_H, // User Atten High Bit bluecell_Currdatastatus.bluecell_User_DL1_L);// User Atten Low Bit PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val); 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, // Table Offset bluecell_Currdatastatus.ATT_DL2_H, // Hidden Atten High bit bluecell_Currdatastatus.ATT_DL2_L, // Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_DL2_H, // User Atten High Bit bluecell_Currdatastatus.bluecell_User_DL2_L);// User Atten Low Bit PE43711_atten_ctrl(ALL_ATT.ATT_DL2,val); 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, // Table Offset bluecell_Currdatastatus.ATT_DL3_H, // Hidden Atten High bit bluecell_Currdatastatus.ATT_DL3_L, // Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_DL3_H, // User Atten High Bit bluecell_Currdatastatus.bluecell_User_DL3_L);// User Atten Low Bit PE43711_atten_ctrl(ALL_ATT.ATT_DL3,val); 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, // Table Offset bluecell_Currdatastatus.ATT_DL4_H, // Hidden Atten High bit bluecell_Currdatastatus.ATT_DL4_L, // Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_DL4_H, // User Atten High Bit bluecell_Currdatastatus.bluecell_User_DL4_L);// User Atten Low Bit PE43711_atten_ctrl(ALL_ATT.ATT_DL4,val); 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,// Table Offset bluecell_Currdatastatus.ATT_UL1_H,// Hidden Atten High bit bluecell_Currdatastatus.ATT_UL1_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_UL1_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_UL1_L);// User Atten Low Bit // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_UL1,val); 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,// Table Offset bluecell_Currdatastatus.ATT_UL2_H,// Hidden Atten High bit bluecell_Currdatastatus.ATT_UL2_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_UL2_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_UL2_L);// User Atten Low Bit // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_UL2,val); 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,// Table Offset bluecell_Currdatastatus.ATT_UL3_H,// Hidden Atten High bit bluecell_Currdatastatus.ATT_UL3_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_UL3_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_UL3_L);// User Atten Low Bit // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_UL3,val); 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,// Table Offset bluecell_Currdatastatus.ATT_UL4_H,// Hidden Atten High bit bluecell_Currdatastatus.ATT_UL4_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_UL4_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_UL4_L);// User Atten Low Bit // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_UL4,val); } 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, // Table Offset Curr.ATT_DL1_H, // Hidden Atten High bit Curr.ATT_DL1_L, // Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_DL1_H, // User Atten High Bit bluecell_Currdatastatus.bluecell_User_DL1_L);// User Atten Low Bit // 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,// Table Offset Curr.ATT_DL2_H,// Hidden Atten High bit Curr.ATT_DL2_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_DL2_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_DL2_L);// User Atten Low Bit // 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,// Table Offset Curr.ATT_DL3_H,// Hidden Atten High bit Curr.ATT_DL3_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_DL3_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_DL3_L);// User Atten Low Bit // 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,// Table Offset Curr.ATT_DL4_H,// Hidden Atten High bit Curr.ATT_DL4_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_DL4_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_DL4_L);// User Atten Low Bit // 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,// Table Offset Curr.ATT_UL1_H,// Hidden Atten High bit Curr.ATT_UL1_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_UL1_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_UL1_L);// User Atten Low Bit // 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,// Table Offset Curr.ATT_UL2_H,// Hidden Atten High bit Curr.ATT_UL2_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_UL2_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_UL2_L);// User Atten Low Bit // 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,// Table Offset Curr.ATT_UL3_H,// Hidden Atten High bit Curr.ATT_UL3_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_UL3_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_UL3_L);// User Atten Low Bit // 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,// Table Offset Curr.ATT_UL4_H,// Hidden Atten High bit Curr.ATT_UL4_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_UL4_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_UL4_L);// User Atten Low Bit // 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 0 // PYJ.2020.04.21_BEGIN -- if((Curr.ULO_ALC_Threshold_H != Prev.ULO_ALC_Threshold_H ||Curr.ULO_ALC_Threshold_L != Prev.ULO_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.ULO_ALC_Threshold_H = bluecell_Currdatastatus.ULO_ALC_Threshold_H; bluecell_Prevdatastatus.ULO_ALC_Threshold_L = bluecell_Currdatastatus.ULO_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_UL1.Table_0_0_dBm, Curr.ULO_ALC_Threshold_H, Curr.ULO_ALC_Threshold_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.ULO_ALC_Threshold_H != Prev.ULO_ALC_Threshold_H ||Curr.ULO_ALC_Threshold_L != Prev.ULO_ALC_Threshold_L) ||(Curr.bluecell_User_UL2_H != Prev.bluecell_User_UL2_H ||Curr.bluecell_User_UL2_L != Prev.bluecell_User_UL2_L)){ bluecell_Prevdatastatus.ULO_ALC_Threshold_H = bluecell_Currdatastatus.ULO_ALC_Threshold_H; bluecell_Prevdatastatus.ULO_ALC_Threshold_L = bluecell_Currdatastatus.ULO_ALC_Threshold_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.ULO_ALC_Threshold_H != Prev.ULO_ALC_Threshold_H ||Curr.ULO_ALC_Threshold_L != Prev.ULO_ALC_Threshold_L) ||(Curr.bluecell_User_UL3_H != Prev.bluecell_User_UL3_H ||Curr.bluecell_User_UL3_L != Prev.bluecell_User_UL3_L)){ bluecell_Prevdatastatus.ULO_ALC_Threshold_H = bluecell_Currdatastatus.ULO_ALC_Threshold_H; bluecell_Prevdatastatus.ULO_ALC_Threshold_L = bluecell_Currdatastatus.ULO_ALC_Threshold_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.ULO_ALC_Threshold_H != Prev.ULO_ALC_Threshold_H ||Curr.ULO_ALC_Threshold_L != Prev.ULO_ALC_Threshold_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.ULO_ALC_Threshold_H = bluecell_Currdatastatus.ULO_ALC_Threshold_H; bluecell_Prevdatastatus.ULO_ALC_Threshold_L = bluecell_Currdatastatus.ULO_ALC_Threshold_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.ULO_ALC_Threshold_H != Prev.ULO_ALC_Threshold_H ||Curr.ULO_ALC_Threshold_L != Prev.ULO_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.ULO_ALC_Threshold_H = bluecell_Currdatastatus.ULO_ALC_Threshold_H; bluecell_Prevdatastatus.ULO_ALC_Threshold_L = bluecell_Currdatastatus.ULO_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.ULO_ALC_Threshold_H, Curr.ULO_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 -- } #else void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){ uint8_t val = 0; 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, // Table Offset Curr.ATT_DL1_H, // Hidden Atten High bit Curr.ATT_DL1_L, // Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_DL1_H, // User Atten High Bit bluecell_Currdatastatus.bluecell_User_DL1_L);// User Atten Low Bit // printf("%s : %d \r\n",__func__,__LINE__); // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val); 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,// Table Offset Curr.ATT_DL2_H,// Hidden Atten High bit Curr.ATT_DL2_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_DL2_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_DL2_L);// User Atten Low Bit // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_DL2,val); 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,// Table Offset Curr.ATT_DL3_H,// Hidden Atten High bit Curr.ATT_DL3_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_DL3_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_DL3_L);// User Atten Low Bit // 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); 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,// Table Offset Curr.ATT_DL4_H,// Hidden Atten High bit Curr.ATT_DL4_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_DL4_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_DL4_L);// User Atten Low Bit // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_DL4,val); 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,// Table Offset Curr.ATT_UL1_H,// Hidden Atten High bit Curr.ATT_UL1_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_UL1_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_UL1_L);// User Atten Low Bit // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_UL1,val); 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,// Table Offset Curr.ATT_UL2_H,// Hidden Atten High bit Curr.ATT_UL2_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_UL2_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_UL2_L);// User Atten Low Bit // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_UL2,val); 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,// Table Offset Curr.ATT_UL3_H,// Hidden Atten High bit Curr.ATT_UL3_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_UL3_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_UL3_L);// User Atten Low Bit // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_UL3,val); 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,// Table Offset Curr.ATT_UL4_H,// Hidden Atten High bit Curr.ATT_UL4_L,// Hidden Atten Low bit bluecell_Currdatastatus.bluecell_User_UL4_H,// User Atten High Bit bluecell_Currdatastatus.bluecell_User_UL4_L);// User Atten Low Bit // 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 0 // PYJ.2020.04.21_BEGIN -- if((Curr.ULO_ALC_Threshold_H != Prev.ULO_ALC_Threshold_H ||Curr.ULO_ALC_Threshold_L != Prev.ULO_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.ULO_ALC_Threshold_H = bluecell_Currdatastatus.ULO_ALC_Threshold_H; bluecell_Prevdatastatus.ULO_ALC_Threshold_L = bluecell_Currdatastatus.ULO_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_UL1.Table_0_0_dBm, Curr.ULO_ALC_Threshold_H, Curr.ULO_ALC_Threshold_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.ULO_ALC_Threshold_H != Prev.ULO_ALC_Threshold_H ||Curr.ULO_ALC_Threshold_L != Prev.ULO_ALC_Threshold_L) ||(Curr.bluecell_User_UL2_H != Prev.bluecell_User_UL2_H ||Curr.bluecell_User_UL2_L != Prev.bluecell_User_UL2_L)){ bluecell_Prevdatastatus.ULO_ALC_Threshold_H = bluecell_Currdatastatus.ULO_ALC_Threshold_H; bluecell_Prevdatastatus.ULO_ALC_Threshold_L = bluecell_Currdatastatus.ULO_ALC_Threshold_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.ULO_ALC_Threshold_H != Prev.ULO_ALC_Threshold_H ||Curr.ULO_ALC_Threshold_L != Prev.ULO_ALC_Threshold_L) ||(Curr.bluecell_User_UL3_H != Prev.bluecell_User_UL3_H ||Curr.bluecell_User_UL3_L != Prev.bluecell_User_UL3_L)){ bluecell_Prevdatastatus.ULO_ALC_Threshold_H = bluecell_Currdatastatus.ULO_ALC_Threshold_H; bluecell_Prevdatastatus.ULO_ALC_Threshold_L = bluecell_Currdatastatus.ULO_ALC_Threshold_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.ULO_ALC_Threshold_H != Prev.ULO_ALC_Threshold_H ||Curr.ULO_ALC_Threshold_L != Prev.ULO_ALC_Threshold_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.ULO_ALC_Threshold_H = bluecell_Currdatastatus.ULO_ALC_Threshold_H; bluecell_Prevdatastatus.ULO_ALC_Threshold_L = bluecell_Currdatastatus.ULO_ALC_Threshold_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.ULO_ALC_Threshold_H != Prev.ULO_ALC_Threshold_H ||Curr.ULO_ALC_Threshold_L != Prev.ULO_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.ULO_ALC_Threshold_H = bluecell_Currdatastatus.ULO_ALC_Threshold_H; bluecell_Prevdatastatus.ULO_ALC_Threshold_L = bluecell_Currdatastatus.ULO_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.ULO_ALC_Threshold_H, Curr.ULO_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 -- } #endif // PYJ.2020.05.25_END -- void Bluecell_StructCpy(uint8_t* dst,uint8_t* src,uint16_t size){ for(int i = 0; i < size; i++){ dst[i] = src[i]; } } int16_t ConvertTo2byte(uint8_t highbit, uint8_t lowbit){ int16_t ret = 0; ret += ((highbit << 8) & 0xFF00); ret += (lowbit & 0x00FF); return ret; } 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) ); 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) ); 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; } } 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 Bluecell_ATT_DL1 : // 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); /* Atten Ctrl Function */ CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case Bluecell_ATT_DL2 : bluecell_Currdatastatus.ATT_DL2_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_DL2_L = data[BLUECELL_DATA + i++]; /* Atten Ctrl Function */ CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case Bluecell_ATT_DL3 : bluecell_Currdatastatus.ATT_DL3_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_DL3_L = data[BLUECELL_DATA + i++]; /* Atten Ctrl Function */ CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case Bluecell_ATT_DL4 : bluecell_Currdatastatus.ATT_DL4_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_DL4_L = data[BLUECELL_DATA + i++]; /* Atten Ctrl Function */ CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case Bluecell_ATT_UL1 : bluecell_Currdatastatus.ATT_UL1_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL1_L = data[BLUECELL_DATA + i++]; /* Atten Ctrl Function */ CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); // printf("bluecell_Currdatastatus.ATT_UL1_H : %x\r\n",bluecell_Currdatastatus.ATT_UL1_H); // printf("bluecell_Currdatastatus.ATT_UL1_L : %x\r\n",bluecell_Currdatastatus.ATT_UL1_L); break; case Bluecell_ATT_UL2 : bluecell_Currdatastatus.ATT_UL2_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL2_L = data[BLUECELL_DATA + i++]; /* Atten Ctrl Function */ CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case Bluecell_ATT_UL3 : bluecell_Currdatastatus.ATT_UL3_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL3_L = data[BLUECELL_DATA + i++]; /* Atten Ctrl Function */ CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case Bluecell_ATT_UL4 : bluecell_Currdatastatus.ATT_UL4_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL4_L = data[BLUECELL_DATA + i++]; /* 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 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,94); 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]; // printf("AGC ON OFF SET : %d \r\n",bluecell_Currdatastatus.DLI_AGC_ON_OFF); break; case Bluecell_ULO_ALC_ON_OFF: bluecell_Currdatastatus.ULO_ALC_ON_OFF = 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("DLI_Level_High_Threshold : %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("DLI_Level_Low_Threshold : %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("ULO_Level_High_Threshold : %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.ULO_ALC_Threshold_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ULO_ALC_Threshold_L = data[BLUECELL_DATA + i++]; tempdata = (( bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8) & 0xFF00) ; tempdata += bluecell_Currdatastatus.ULO_ALC_Threshold_L ; tempdata /= 10; printf("ULO_ALC_Threshold : %d\r\n",tempdata); // bluecell_Currdatastatus.ULO_ALC_Threshold_H = ((tempdata & 0xFF00) >> 8); // bluecell_Currdatastatus.ULO_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.ULO_ALC_Threshold_H = MBIC_ULO_ALC_Threshold_Default_H; bluecell_Currdatastatus.ULO_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; case Bluecell_Alarm_Mask: bluecell_Currdatastatus.ALARM_MASK1 = data[BLUECELL_DATA + i+ 1]; printf("%s : %d ALARM_MASK1 : %d \r\n",__func__,__LINE__,bluecell_Currdatastatus.ALARM_MASK1); 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)); // EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_WINDOW_STATUS_ADDRESDS,&bluecell_Currdatastatus.bluecell_header,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 ResultData[1024] = {0,}; uint8_t* MBIC_HeaderDataSetting(uint8_t* data){ static uint8_t ResultData[1024] = {0,}; /*NOT YET*/ 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){ } } 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.DLI_Level1_H << 8) & 0xFF00 |(bluecell_Currdatastatus.DLI_Level1_L)); data[MBIC_PAYLOADSTART + i++] = ((Temp_ADC & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (Temp_ADC & 0x00FF); Temp_ADC = ((bluecell_Currdatastatus.DLI_Level2_H << 8) & 0xFF00 |(bluecell_Currdatastatus.DLI_Level2_L)); data[MBIC_PAYLOADSTART + i++] = ((Temp_ADC & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (Temp_ADC & 0x00FF); Temp_ADC = ((bluecell_Currdatastatus.DLI_Level3_H << 8) & 0xFF00 |(bluecell_Currdatastatus.DLI_Level3_L)); data[MBIC_PAYLOADSTART + i++] = ((Temp_ADC & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (Temp_ADC & 0x00FF); Temp_ADC = ((bluecell_Currdatastatus.DLI_Level4_H << 8) & 0xFF00 |(bluecell_Currdatastatus.DLI_Level4_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.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; /*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.DLI_Level1_H << 8 | bluecell_Currdatastatus.DLI_Level1_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.DLI_Level2_H << 8 | bluecell_Currdatastatus.DLI_Level2_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.DLI_Level3_H << 8 | bluecell_Currdatastatus.DLI_Level3_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.DLI_Level4_H << 8 | bluecell_Currdatastatus.DLI_Level4_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.ULO_Level1_H << 8 | bluecell_Currdatastatus.ULO_Level1_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.ULO_Level2_H << 8 | bluecell_Currdatastatus.ULO_Level2_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.ULO_Level3_H << 8 | bluecell_Currdatastatus.ULO_Level3_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.ULO_Level4_H << 8 | bluecell_Currdatastatus.ULO_Level4_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.ULO_ALC_Threshold_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_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.ULO_ALC_Threshold_H = data[MBIC_PAYLOADSTART + 0]; bluecell_Currdatastatus.ULO_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; } bool ADC_Alarm_DL_Set[DET_Alarm_DL_Index_MAX] = {false,} ; bool ADC_Alarm_UL_Set[DET_Alarm_UL_Index_MAX] = {false,} ; void DET_LevelAlarmCheck(){ int16_t DL[DET_Alarm_DL_Index_MAX] = {0,}; int16_t UL[DET_Alarm_UL_Index_MAX] = {0,}; int16_t LimitData_UL_High = 0; int16_t LimitData_DL_High = 0; int16_t LimitData_DL_Low = 0; double ret = 0; int8_t Res_DL_dBm[DET_Alarm_DL_Index_MAX] = {0,}; int8_t Res_UL_dBm[DET_Alarm_UL_Index_MAX] = {0,}; LimitData_UL_High = ConvertTo2byte(bluecell_Currdatastatus.ULO_Level_High_Threshold_H,bluecell_Currdatastatus.ULO_Level_High_Threshold_L) / 10; LimitData_DL_High = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level_High_Threshold_H,bluecell_Currdatastatus.DLI_Level_High_Threshold_L)/ 10; LimitData_DL_Low = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level_Low_Threshold_H,bluecell_Currdatastatus.DLI_Level_Low_Threshold_L)/ 10; DL[DET_Alarm_DL1_Index] = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level1_H,bluecell_Currdatastatus.DLI_Level1_L); DL[DET_Alarm_DL2_Index] = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level2_H,bluecell_Currdatastatus.DLI_Level2_L); DL[DET_Alarm_DL3_Index] = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level3_H,bluecell_Currdatastatus.DLI_Level3_L); DL[DET_Alarm_DL4_Index] = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level4_H,bluecell_Currdatastatus.DLI_Level4_L); UL[DET_Alarm_UL1_Index] = ConvertTo2byte(bluecell_Currdatastatus.ULO_Level1_H,bluecell_Currdatastatus.ULO_Level1_L); UL[DET_Alarm_UL2_Index] = ConvertTo2byte(bluecell_Currdatastatus.ULO_Level2_H,bluecell_Currdatastatus.ULO_Level2_L); UL[DET_Alarm_UL3_Index] = ConvertTo2byte(bluecell_Currdatastatus.ULO_Level3_H,bluecell_Currdatastatus.ULO_Level3_L); UL[DET_Alarm_UL4_Index] = ConvertTo2byte(bluecell_Currdatastatus.ULO_Level4_H,bluecell_Currdatastatus.ULO_Level4_L); ret = bluecell_Currdatastatus.DLI_Level1_H << 8; ret += bluecell_Currdatastatus.DLI_Level1_L; ret *= 0.001; Res_DL_dBm[DET_Alarm_DL1_Index] = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st))); ret = bluecell_Currdatastatus.DLI_Level2_H << 8; ret += bluecell_Currdatastatus.DLI_Level2_L; ret *= 0.001; Res_DL_dBm[DET_Alarm_DL2_Index] = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st))); ret = bluecell_Currdatastatus.DLI_Level3_H << 8; ret += bluecell_Currdatastatus.DLI_Level3_L; ret *= 0.001; Res_DL_dBm[DET_Alarm_DL3_Index] = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st))); ret = bluecell_Currdatastatus.DLI_Level4_H << 8; ret += bluecell_Currdatastatus.DLI_Level4_L; ret *= 0.001; Res_DL_dBm[DET_Alarm_DL4_Index] = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st))); ret = bluecell_Currdatastatus.ULO_Level1_H << 8; ret += bluecell_Currdatastatus.ULO_Level1_L; ret *= 0.001; Res_UL_dBm[DET_Alarm_UL1_Index] = (int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st))); // printf("LimitData_UL_High : %d \r\n",LimitData_UL_High); // printf("DET_High : %d \r\n",Res_UL_dBm[DET_Alarm_UL1_Index] ); ret = bluecell_Currdatastatus.ULO_Level2_H << 8; ret += bluecell_Currdatastatus.ULO_Level2_L; ret *= 0.001; Res_UL_dBm[DET_Alarm_UL2_Index] = (int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st))); ret = bluecell_Currdatastatus.ULO_Level3_H << 8; ret += bluecell_Currdatastatus.ULO_Level3_L; ret *= 0.001; Res_UL_dBm[DET_Alarm_UL3_Index] = (int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st))); ret = bluecell_Currdatastatus.ULO_Level4_H << 8; ret += bluecell_Currdatastatus.ULO_Level4_L; ret *= 0.001; Res_UL_dBm[DET_Alarm_UL4_Index] = (int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st))); // printf("LimitData_DL_High : %d \r\n",LimitData_DL_High); // printf("LimitData_DL_Low : %d \r\n",LimitData_DL_Low); for(int i = 0 ; i < DET_Alarm_UL_Index_MAX; i++){ if(LimitData_UL_High > Res_UL_dBm[DET_Alarm_UL1_Index + i]){ ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i] = true; // printf("ADC_Alarm_UL_Set %d ,Value : %d\r\n",DET_Alarm_UL1_Index + i,ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i]); } else{ ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i] = false; // printf("ADC_Alarm_UL_Set %d ,Value : %d\r\n",DET_Alarm_UL1_Index + i,ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i] ); } } #if 1 // PYJ.2020.05.27_BEGIN -- for(int i = 0 ; i < DET_Alarm_DL_Index_MAX; i++){ if(LimitData_DL_High > Res_DL_dBm[DET_Alarm_DL1_Index + i] &&LimitData_DL_Low < Res_DL_dBm[DET_Alarm_DL1_Index + i]) ADC_Alarm_DL_Set[DET_Alarm_DL1_Index + i] = true; else ADC_Alarm_DL_Set[DET_Alarm_DL1_Index + i] = false; } // HAL_Delay(1000); #endif // PYJ.2020.05.27_END -- } void ADC_Check(void){ //static uint8_t Cnt = 0; double ADC1DoubleRet[4]; double ADC3DoubleRet[5]; uint32_t ADC1_Average_value[ADC1_CNT]; uint32_t ADC3_Average_value[ADC3_CNT]; // double ret = 0; uint16_t MIN_ADC[ADC3_CNT] = {0,}; uint16_t cnt[ADC3_CNT] = {0,}; double temp; // if(AdcTimerCnt > 10){ // 정렬할 배열, 요소 개수, 요소 크기, 비교 함수를 넣어줌 if(adc3cnt >= 500){ // printf("%f\r\n",ADC3value[4]*3.3/4095); #if 1 // PYJ.2020.05.25_BEGIN -- 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 < ADC3_CNT; i++){ ADC3DoubleRet[i] = (((ADC3_Average_value[i] / cnt[i]) * 3.3 /4095) * 1000); ADC3Ret[i] = ADC3DoubleRet[i]; ADC3_Average_value[i] = 0; } bluecell_Currdatastatus.DLI_Level1_H = ((ADC3Ret[1] & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_Level1_L = ((ADC3Ret[1] & 0x00FF)); bluecell_Currdatastatus.DLI_Level2_H = ((ADC3Ret[2] & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_Level2_L = ((ADC3Ret[2] & 0x00FF) ); bluecell_Currdatastatus.DLI_Level3_H = ((ADC3Ret[3] & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_Level3_L = ((ADC3Ret[3] & 0x00FF) ); bluecell_Currdatastatus.DLI_Level4_H = ((ADC3Ret[4] & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_Level4_L = ((ADC3Ret[4] & 0x00FF) ); bluecell_Currdatastatus.ULO_Level4_H = ((ADC3Ret[0] & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_Level4_L = ((ADC3Ret[0] & 0x00FF) ); #endif // PYJ.2020.05.25_END -- #if 0 // PYJ.2020.04.26_BEGIN -- double ret = 0; ret = (ADC3Ret[0]) * 0.001; printf("ADC3Ret[0] : %d UL4 : %f\r\n",ADC3Ret[0],ret); ret = (ADC3Ret[1]) * 0.001; printf("ADC3Ret[1] : %d DL1 : %f\r\n",ADC3Ret[1],ret); ret = (ADC3Ret[2]) * 0.001; printf("ADC3Ret[2] : %d DL2 : %f\r\n",ADC3Ret[2],ret); ret = (ADC3Ret[3]) * 0.001; printf("ADC3Ret[3] : %d DL3 : %f\r\n",ADC3Ret[3],ret); ret = (ADC3Ret[4]) * 0.001; printf("ADC3Ret[4] : %d DL4 : %f\r\n",ADC3Ret[4],ret); #endif // PYJ.2020.04.26_END -- adc3cnt = 0; } 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++){ ADC1DoubleRet[i] = (((ADC1_Average_value[i] / cnt[i]) * 3.3 /4095) * 1000); ADC1Ret[i] = ADC1DoubleRet[i]; // ADC1Ret[i] = ADC1_Average_value[i] / cnt[i]; ADC1_Average_value[i] = 0; } bluecell_Currdatastatus.ULO_Level1_H = ((ADC1Ret[0] & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_Level1_L = ((ADC1Ret[0] & 0x00FF) ); bluecell_Currdatastatus.ULO_Level2_H = ((ADC1Ret[1] & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_Level2_L = ((ADC1Ret[1] & 0x00FF) ); bluecell_Currdatastatus.ULO_Level3_H = ((ADC1Ret[2] & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_Level3_L = ((ADC1Ret[2] & 0x00FF) ); // printf("ADC1_Average_value[%d] : %d / %f \r\n",i,ADC1_Average_value[i],ADC1_Average_value[i]/cnt[i] * Volt_Calc_val); #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] * 0.001); // printf("DetEnd"); // 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); adc1cnt = 0; } } #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; } /*One Point round*/ double Bluecell_TestPro(double value ) { int16_t temp = (value * 10); double temp_float = 0; bool minus_set = 0; // printf("0. temp : %d\r\n",temp); temp = temp % 10; // printf("1. temp : %d\r\n",temp); if((int16_t)temp == 0) return value; if(temp < 0){ temp *= -1;//Convert Minus To plus // printf("2. temp : %d\r\n",temp); minus_set = true; } temp_float = temp * 0.1; // printf("3. temp_float: %f temp : %f\r\n",temp_float,temp); // printf("4. value : %f temp : %d temp_float : %f \r\n",value,temp,temp_float); if(temp >= 5){ if(minus_set == true){ value -= 1; value += temp_float; }else{ value += 1; value -= temp_float; } // printf("temp_float : %f \r\n",temp_float); } else{ #if 1 // PYJ.2020.05.25_BEGIN -- if(minus_set == true){ value += temp_float; } else{ value -= temp_float; } #else value -= temp_float; #endif // PYJ.2020.05.25_END -- // printf("temp_float : %f \r\n",temp_float); } // printf("temp : %f \r\n",value); return (value); } #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); // printf("Vitual_array[%d] : %f \r\n",a,Vitual_array[a]); if(CurrRet < 0){ CurrRet = (CurrRet * -2) + CurrRet; } if(ret > CurrRet){ ret = CurrRet; LastIndex = i; dot = a; } } } TableAdc = CompareAdc[0] << 8; TableAdc += CompareAdc[1]; TableAdc /= 1000; if(CurrentAdc < TableAdc){ // printf("LastIndex : %d / dot : %d TableAdc : %f \r\n",LastIndex,dot,(AutoControl_Save[LastIndex] - (dot * 0.1))); return (AutoControl_Save[LastIndex] - (dot * 0.1)); } else{ // printf("CurrentAdc : %f TableAdc : %f \r\n",CurrentAdc,TableAdc); return (AutoControl_Save[0]); } } double AGC_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); // printf("Vitual_array[%d] : %f \r\n",a,Vitual_array[a]); if(CurrRet < 0){ CurrRet = (CurrRet * -2) + CurrRet; } if(ret > CurrRet){ ret = CurrRet; LastIndex = i; dot = a; } } } TableAdc = CompareAdc[0] << 8; TableAdc += CompareAdc[1]; TableAdc /= 1000; if(CurrentAdc < TableAdc){ // printf("LastIndex : %d / dot : %d TableAdc : %f \r\n",LastIndex,dot,(AutoControl_Save[LastIndex] - (dot * 0.1))); return (AutoControl_Save[LastIndex] - (dot * 0.1)); } else{ // printf("CurrentAdc : %f TableAdc : %f \r\n",CurrentAdc,TableAdc); // for(int a = 0; a < sizeof(AGC_dBm_t); a++) // printf("AutoControl_Save[%d] : %d \r\n",a,AutoControl_Save[a]); return (AutoControl_Save[0]); } } #endif // PYJ.2020.05.15_END -- #endif // PYJ.2020.05.12_END -- #if 0 // PYJ.2020.05.21_BEGIN -- 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; } #endif // PYJ.2020.05.21_END -- typedef enum{ ALC_Alarm_UL1_Index = 0, ALC_Alarm_UL2_Index, ALC_Alarm_UL3_Index, ALC_Alarm_UL4_Index, ALC_Alarm_UL_Index_MAX, }; uint8_t ALC_AlarmSet[ALC_Alarm_UL_Index_MAX] = {0,}; double ALC_Calc(uint8_t num,double CurrAtten ,int8_t threshold,double CurrDet){ double ret = 0; // ret = CurrDet - threshold; #if 0 // PYJ.2020.05.25_BEGIN -- if(CurrAtten >= 20){ if(CurrDet - threshold < 0){ if(CurrAtten + (CurrDet - threshold) > 0){ // ret = CurrAtten + (CurrDet - threshold); printf("5. %f : %f %d\r\n",ret,CurrDet,threshold); } else{ ret = CurrAtten * -1; printf("6. %f : %f %d\r\n",ret,CurrDet,threshold); } }else{ ALC_AlarmSet[num] = true; } printf("4. %f : %f %d\r\n",ret,CurrDet,threshold); return ret; } #endif // PYJ.2020.05.25_END -- if(CurrDet < threshold){ ret = CurrDet - threshold; // printf("1. %f : %f %d\r\n",ret,CurrDet,threshold); // if(((ret * 10) % 10 ) != 0) ret = Bluecell_TestPro(ret); // printf("ret = %f \r\n",rset); } else if(CurrDet > threshold){ ret = CurrDet - threshold; // printf("2. %f : %f %d\r\n",ret,CurrDet,threshold); // if(((ret * 10) % 10 ) != 0) ret = Bluecell_TestPro(ret); // printf("Result : ret = %f \r\n",ret); } if(CurrAtten + ret <= 0){ ret = CurrAtten * -1; // printf("3. ret0 : %f \r\n",ret); }else{ ALC_AlarmSet[num] = false; } if(CurrAtten + ret > 20){ ret = 20 - CurrAtten; ALC_AlarmSet[num] = true; } // printf("ret3 : %f \r\n",ret); return ret; } void ALC_Function(){ //DL double Volt_Calc_val = 3.3 / 4095; double tempret = 0; double ret = 0; // double CurrnALCValue = 0; double CurrentATTENVALUE = 0; uint8_t tempcurratten = 0; // int32_t CurrnALC_MAX_SettingValue = 0; // int32_t CurrnALC_MIN_SettingValue = 0; // int32_t ALC_Result = 0; int16_t Limitdata = 0; double ResdBm = 0; int16_t IwillGiveAtten = 0; uint8_t tempadc[100]; 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 , }; 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 > 400){ if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){ /***************************************************************************************************************/ /* ALC 1 */ /***************************************************************************************************************/ //ret 현재 Voltage 값 출력 //ret 에 따른 현재 DBM 구현 ret = bluecell_Currdatastatus.ULO_Level1_H << 8; ret += bluecell_Currdatastatus.ULO_Level1_L; ret *= 0.001; Limitdata = (( bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8) & 0xFF00) ; Limitdata += bluecell_Currdatastatus.ULO_ALC_Threshold_L ; Limitdata /= 10; ResdBm = AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL1_H,bluecell_Currdatastatus.ATT_UL1_L); // tempret = (((bluecell_Currdatastatus.ATT_UL1_H << 8) & 0xFF00) | (bluecell_Currdatastatus.ATT_UL1_L & 0x00FF)) / 10; //if(ResdBm < Limitdata && CurrentATTENVALUE != 0){ // printf("db %f \r\n",ResdBm); // printf("==================START================\r\n"); // printf("Current UL ADC VALUE : %f \r\n",ret); // printf("ResdBm : UL1 : %f \r\n",ResdBm); //CurrnALC_MIN_SettingValue = MinusConvert(bluecell_Currdatastatus.ULO_Level1_H,CurrnALC_MIN_SettingValue); // Limitdata = (( bluecell_Currdatastatus.ATT_UL1_H << 8) & 0xFF00) ; // Limitdata += bluecell_Currdatastatus.ATT_UL1_L ; // // Limitdata /= 10; // printf("CurrentATTENVALUE : %d\r\n",CurrentATTENVALUE); IwillGiveAtten = ALC_Calc(ALC_Alarm_UL1_Index,CurrentATTENVALUE,Limitdata,ResdBm); // printf("CurrentATTENVALUE : %f \r\n",CurrentATTENVALUE); // if(CurrentATTENVALUE < 20 && IwillGiveAtten != 0){ // IwillGiveAtten = CurrentATTENVALUE + IwillGiveAtten ; // } // printf("ADC : %f Current : %f Threas : %d : I WILL GIVE ATTEN : %d \r\n",ret,ResdBm , Limitdata,IwillGiveAtten); // printf("CurrentATTENVALUE : %d I WILL GIVE ATTEN : %d \r\n",CurrentATTENVALUE,IwillGiveAtten); // printf("CurrentATTENVALUE : %d I WILL GIVE ATTEN : %d \r\n",CurrentATTENVALUE,IwillGiveAtten); // if(IwillGiveAtten < 0) // printf("CurrentATTENVALUE %f \r\n",CurrentATTENVALUE); if( (IwillGiveAtten > 0) || (CurrentATTENVALUE >= (IwillGiveAtten * -1))){ IwillGiveAtten *=10; tempcurratten = CurrentATTENVALUE * 10; #if 1 // PYJ.2020.05.23_BEGIN -- //if(((ResdBm > (Limitdata + 0.5)) || (ResdBm < (Limitdata - 0.5))) && IwillGiveAtten != 0){ bluecell_Currdatastatus.ATT_UL1_H = (((tempcurratten + IwillGiveAtten) & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL1_L = (tempcurratten + IwillGiveAtten) & 0x00FF; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); // } } CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL1_H,bluecell_Currdatastatus.ATT_UL1_L); // printf("CurrentATTENVALUE : %f\r\n",CurrentATTENVALUE ); // printf("==================END================\r\n"); #endif // PYJ.2020.05.23_END -- // HAL_Delay(1000); //} #if 1 // PYJ.2020.05.22_BEGIN -- /***************************************************************************************************************/ /* ALC 2 */ /***************************************************************************************************************/ //ret 현재 Voltage 값 출력 //ret 에 따른 현재 DBM 구현 ret = bluecell_Currdatastatus.ULO_Level2_H << 8; ret += bluecell_Currdatastatus.ULO_Level2_L; ret *= 0.001; Limitdata = (( bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8) & 0xFF00) ; Limitdata += bluecell_Currdatastatus.ULO_ALC_Threshold_L ; Limitdata /= 10; ResdBm = AutoControl_ADC_Compare(ret,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL2_H,bluecell_Currdatastatus.ATT_UL2_L); IwillGiveAtten = ALC_Calc(ALC_Alarm_UL2_Index,CurrentATTENVALUE,Limitdata,ResdBm); if( (IwillGiveAtten > 0) || (CurrentATTENVALUE >= (IwillGiveAtten * -1))){ IwillGiveAtten *=10; tempcurratten = CurrentATTENVALUE * 10; bluecell_Currdatastatus.ATT_UL2_H = (((tempcurratten + IwillGiveAtten) & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL2_L = (tempcurratten + IwillGiveAtten) & 0x00FF; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); } CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL2_H,bluecell_Currdatastatus.ATT_UL2_L); /***************************************************************************************************************/ /* ALC 3 */ /***************************************************************************************************************/ //ret 현재 Voltage 값 출력 //ret 에 따른 현재 DBM 구현 ret = bluecell_Currdatastatus.ULO_Level3_H << 8; ret += bluecell_Currdatastatus.ULO_Level3_L; ret *= 0.001; Limitdata = (( bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8) & 0xFF00) ; Limitdata += bluecell_Currdatastatus.ULO_ALC_Threshold_L ; Limitdata /= 10; // printf("==================START================\r\n"); ResdBm = AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL3_H,bluecell_Currdatastatus.ATT_UL3_L); IwillGiveAtten = ALC_Calc(ALC_Alarm_UL3_Index,CurrentATTENVALUE,Limitdata,ResdBm); // printf("ADC : %f Current : %f Threas : %d : I WILL GIVE ATTEN : %d \r\n",ret,ResdBm , Limitdata,IwillGiveAtten); if( (IwillGiveAtten > 0) || (CurrentATTENVALUE >= (IwillGiveAtten * -1))){ IwillGiveAtten *=10; tempcurratten = CurrentATTENVALUE * 10; bluecell_Currdatastatus.ATT_UL3_H = (((tempcurratten + IwillGiveAtten) & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL3_L = (tempcurratten + IwillGiveAtten) & 0x00FF; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); } CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL3_H,bluecell_Currdatastatus.ATT_UL3_L); // printf("CurrentATTENVALUE : %f\r\n",CurrentATTENVALUE ); // printf("==================END================\r\n"); /***************************************************************************************************************/ /* ALC 4 */ /***************************************************************************************************************/ //ret 현재 Voltage 값 출력 //ret 에 따른 현재 DBM 구현 ret = bluecell_Currdatastatus.ULO_Level4_H << 8; ret += bluecell_Currdatastatus.ULO_Level4_L; ret *= 0.001; Limitdata = (( bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8) & 0xFF00) ; Limitdata += bluecell_Currdatastatus.ULO_ALC_Threshold_L ; Limitdata /= 10; ResdBm = AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL4_H,bluecell_Currdatastatus.ATT_UL4_L); IwillGiveAtten = ALC_Calc(ALC_Alarm_UL4_Index,CurrentATTENVALUE,Limitdata,ResdBm); if( (IwillGiveAtten > 0) || (CurrentATTENVALUE >= (IwillGiveAtten * -1))){ IwillGiveAtten *=10; tempcurratten = CurrentATTENVALUE * 10; bluecell_Currdatastatus.ATT_UL4_H = (((tempcurratten + IwillGiveAtten) & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL4_L = (tempcurratten + IwillGiveAtten) & 0x00FF; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); } CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL4_H,bluecell_Currdatastatus.ATT_UL4_L); #endif // PYJ.2020.05.22_END -- 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; } bool AGC_AlarmSet[AGC_Alarm_DL_Index_MAX] = {0,}; bool AGC_AlarmTimerSet[AGC_Alarm_DL_Index_MAX] = {false,}; void AGC_Alarm_Check(uint8_t Path_Index,double AGC_Det,uint8_t* AGC_Table,uint16_t CurrAtten){ double TableAdc = 0; double PrevTableAdc = 0; double step = 0; TableAdc = AGC_Table[0] << 8; TableAdc += AGC_Table[1]; TableAdc /= 1000; PrevTableAdc = AGC_Table[2] << 8; PrevTableAdc += AGC_Table[3]; PrevTableAdc /= 1000; step = TableAdc - PrevTableAdc; if(AGC_Det > TableAdc + step){/*Alarm Enable*/ AGC_AlarmSet[Path_Index] = true; /*Alarm Check val*/ // AGC_AlarmTimerSet[Path_Index] = false;/*Alarm Timer Setting Val*/ // AGCAlarmTimerCnt[Path_Index] = 0;/*Alarm Time Cnt Val*/ // printf("AGC ALARM ON %d \r\n",Path_Index + 1); }else{/*Alarm Disable*/ // if(AGC_AlarmSet[Path_Index] == true && CurrAtten <= 18){/*Alarm Disalbe Condition*/ // AGC_AlarmTimerSet[Path_Index] = true; // }else{/*Alarm Disalbe Fail*/ // AGC_AlarmTimerSet[Path_Index] = false; // AGCAlarmTimerCnt[Path_Index] = 0; // } // if(AGCAlarmTimerCnt[Path_Index] > 3000){ AGC_AlarmSet[Path_Index] = false; // } } } void AGC_Function(){//DL double ret = 0; int8_t ResdBm = 0; int i = 0; int16_t Limitdata = 0; uint16_t IwillgiveAtten = 0; 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 , }; if(AGCTimerCnt > 100){ Bluecell_StructCpy(&AutoControl_Save[0],&AGC_Table_ref[0],sizeof(AGC_dBm_t)); if(bluecell_Currdatastatus.DLI_AGC_ON_OFF == true){ #if 1 // PYJ.2020.05.25_BEGIN -- //ret 현재 Voltage 값 출력 //ret 에 따른 현재 DBM 구현 ret = bluecell_Currdatastatus.DLI_Level1_H << 8; ret += bluecell_Currdatastatus.DLI_Level1_L; ret *= 0.001; ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_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 DL1 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); AGC_Alarm_Check(AGC_Alarm_DL1_Index,ret,&Det_DL1.Table_Det5_dBm_H,IwillgiveAtten); bluecell_Currdatastatus.ATT_DL1_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ; bluecell_Currdatastatus.ATT_DL1_L = (((IwillgiveAtten * 10) & 0x00FF)); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); ret = bluecell_Currdatastatus.DLI_Level2_H << 8; ret += bluecell_Currdatastatus.DLI_Level2_L; ret *= 0.001; ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_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 DL2 ADC VALUE : %f \r\n",ret); // printf("ResdBm : DL2 : %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); AGC_Alarm_Check(AGC_Alarm_DL2_Index,ret,&Det_DL2.Table_Det5_dBm_H,IwillgiveAtten); 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.DLI_Level3_H << 8; ret += bluecell_Currdatastatus.DLI_Level3_L; ret *= 0.001; ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_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 DL3 ADC VALUE : %f \r\n",ret); // printf("ResdBm : DL3 : %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); AGC_Alarm_Check(AGC_Alarm_DL3_Index,ret,&Det_DL3.Table_Det5_dBm_H,IwillgiveAtten); bluecell_Currdatastatus.ATT_DL3_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ; bluecell_Currdatastatus.ATT_DL3_L = (((IwillgiveAtten * 10) & 0x00FF)); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); #endif // PYJ.2020.05.25_END -- ret = bluecell_Currdatastatus.DLI_Level4_H << 8; ret += bluecell_Currdatastatus.DLI_Level4_L; ret *= 0.001; ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_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 DL4 ADC VALUE : %f \r\n",ret); // printf("ResdBm : DL4 : %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); AGC_Alarm_Check(AGC_Alarm_DL4_Index,ret,&Det_DL4.Table_Det5_dBm_H,IwillgiveAtten); 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 ret = 0; int8_t ResdBm[4] = {0,}; if(bluecell_Currdatastatus.ALARM_MASK1 == false) return; if(bluecell_Currdatastatus.ALARM_TEMP_HIGH > 0 || bluecell_Currdatastatus.ALARM_DLI_Level > 0 || bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN > 0 || bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm > 0 || bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm > 0 || bluecell_Currdatastatus.ALARM_ULO_Level > 0 || bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN > 0){ AlarmTimerOnSet = true; AlarmTimerOffSet = false; if(AlarmTimerOnCnt > 3000){ Alarm_LED_OnSet = true; } }else{ AlarmTimerOffSet = true;// False if(AlarmTimerOffCnt > 10000){ AlarmTimerOnSet = false; Alarm_LED_OnSet = false; // printf("=================AlarmTimerOffCnt=================\r\n"); } } /******************************TEMP START*******************************************/ if(bluecell_Currdatastatus.Temp_High_Threshold < (bluecell_Currdatastatus.DET_TEMP )){ bluecell_Currdatastatus.ALARM_TEMP_HIGH |= ENVIRONMENT_TEMPHIGH; }else{ bluecell_Currdatastatus.ALARM_TEMP_HIGH &= ~ENVIRONMENT_TEMPHIGH; } /******************************TEMP END*******************************************/ /******************************DLI AGC START******************************************/ if(bluecell_Currdatastatus.DLI_AGC_ON_OFF == true){ temp = ((bluecell_Currdatastatus.ATT_DL1_H << 8) & 0xFF00); temp += (bluecell_Currdatastatus.ATT_DL1_L & 0x00FF); temp /= 10; if(AGC_AlarmSet[AGC_Alarm_DL1_Index] == true){ printf("ALARM_AGC_P1 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm |= ALARM_AGC_P1; bluecell_Currdatastatus.DLI_AGC_Alarm1 = true; }else{ bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm &= ~ALARM_AGC_P1; } if(AGC_AlarmSet[AGC_Alarm_DL2_Index] == true){ printf("ALARM_AGC_P2 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm |= ALARM_AGC_P2; bluecell_Currdatastatus.DLI_AGC_Alarm2 = true; }else{ bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm &= ~ALARM_AGC_P2; bluecell_Currdatastatus.DLI_AGC_Alarm2 = false; } if(AGC_AlarmSet[AGC_Alarm_DL3_Index] == true){ printf("ALARM_AGC_P3 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm |= ALARM_AGC_P3; bluecell_Currdatastatus.DLI_AGC_Alarm3 = true; }else{ bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm &= ~ALARM_AGC_P3; bluecell_Currdatastatus.DLI_AGC_Alarm3 = false; } if(AGC_AlarmSet[AGC_Alarm_DL4_Index] == true){ printf("ALARM_AGC_P4 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm |= ALARM_AGC_P4; bluecell_Currdatastatus.DLI_AGC_Alarm4 = true; }else{ bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm &= ~ALARM_AGC_P4; bluecell_Currdatastatus.DLI_AGC_Alarm4 = false; } } /******************************DLI AGC END******************************************/ /******************************DLI ALC START******************************************/ if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){ // ALC ON /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */ if(ALC_AlarmSet[ALC_Alarm_UL1_Index] == true){ printf("ULO_ALC_Alarm1 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ALC_P1; bluecell_Currdatastatus.ULO_ALC_Alarm1 = true; }else{ bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ALC_P1; bluecell_Currdatastatus.ULO_ALC_Alarm1 = false; } if(ALC_AlarmSet[ALC_Alarm_UL2_Index] == true){ printf("ULO_ALC_Alarm2 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ALC_P2; bluecell_Currdatastatus.ULO_ALC_Alarm2 = true; }else{ bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ALC_P2; bluecell_Currdatastatus.ULO_ALC_Alarm2 = false; } if(ALC_AlarmSet[ALC_Alarm_UL3_Index] == true){ printf("ULO_ALC_Alarm3 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ALC_P3; bluecell_Currdatastatus.ULO_ALC_Alarm3 = true; }else{ bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ALC_P3; bluecell_Currdatastatus.ULO_ALC_Alarm3 = false; } if(ALC_AlarmSet[ALC_Alarm_UL4_Index] == true){ printf("ULO_ALC_Alarm4 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ALC_P4; bluecell_Currdatastatus.ULO_ALC_Alarm4 = true; }else{ bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ALC_P4; bluecell_Currdatastatus.ULO_ALC_Alarm4 = false; } } /******************************DLI ALC END******************************************/ /******************************ULO LEVEL START*******************************************/ #if 0 // PYJ.2020.05.27_BEGIN -- if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL1_Index] >= 3000){ bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P1_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm1 = true; // printf("ULO_Level_High_Alarm1 OCCUR\r\n"); }else if(DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL1_Index] >= 10000){ bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P1_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm1 = false; } if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL2_Index] >= 3000){ bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P2_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm2 = true; // printf("ULO_Level_High_Alarm2 OCCUR\r\n"); }else{ bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P2_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm2 = false; } if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL3_Index] >= 3000){ bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P3_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm3 = true; // printf("ULO_Level_High_Alarm3 OCCUR\r\n"); }else{ bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P3_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm3 = false; } if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL4_Index] >= 3000){ bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P4_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm4 = true; // printf("ULO_Level_High_Alarm4 OCCUR\r\n"); }else{ bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P4_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm4 = false; } #else if(ADC_Alarm_UL_Set[DET_Alarm_UL1_Index] == true){ bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P1_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm1 = true; }else{ bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P1_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm1 = false; } if(ADC_Alarm_UL_Set[DET_Alarm_UL2_Index] == true){ bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P2_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm2 = true; }else{ bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P2_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm2 = false; } if(ADC_Alarm_UL_Set[DET_Alarm_UL3_Index] == true){ bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P3_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm3 = true; }else{ bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P3_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm3 = false; } if(ADC_Alarm_UL_Set[DET_Alarm_UL4_Index] == true){ bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P4_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm4 = true; }else{ bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P4_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm4 = false; } #endif // PYJ.2020.05.27_END -- /******************************ULO LEVEL END*******************************************/ /******************************DLI LEVEL START*******************************************/ if(ADC_Alarm_DL_Set[DET_Alarm_DL1_Index] == true){ bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm1 = true; }else{ bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P1_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm1 = false; } if(ADC_Alarm_DL_Set[DET_Alarm_DL2_Index] == true){ bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm2 = true; }else{ bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P2_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm2 = false; } if(ADC_Alarm_DL_Set[DET_Alarm_DL3_Index] == true){ bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm3 = true; }else{ bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P3_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm3 = false; } if(ADC_Alarm_DL_Set[DET_Alarm_DL4_Index] == true){ bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm4 = true; }else{ bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P4_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm4 = false; } /******************************DLI LEVEL END*******************************************/ /******************************DLI ShutDown Start******************************************/ /******************************DLI ShutDown END******************************************/ }