#include #include #include #include #include #include "main.h" #include "Bluecell_operate.h" #include "PE43711.h" #include "eeprom.h" /***************************************************************************************/ /* Extern Function */ /***************************************************************************************/ extern uint32_t ShutdownCnt_Get(uint8_t index); extern void ShutdownCnt_Set(uint8_t index,uint8_t val); extern void PE43711_atten_ctrl(PE43711_st ATT ,uint8_t data); extern void Uart1_Data_Send(uint8_t* data,uint16_t size); extern HAL_StatusTypeDef EEPROM_M24C08_Zerowrite(uint8_t devid,uint16_t Address); extern uint8_t Chksum_Create(uint8_t *data); extern uint16_t CRC16_Generate(uint8_t* buf_ptr, int len); extern uint8_t MBIC_APIFLASH_Func(uint8_t* data,uint32_t size); extern void MBIC_Bootloader_FirmwareUpdate(uint8_t* data); extern uint8_t* MBIC_HeaderMergeFunction(uint8_t* data,uint16_t Length ); extern void PE43711_atten_ctrl2(PE43711_st* ATT ,uint8_t data); extern void PE43711_UL4_atten_ctrl(uint8_t data); /***************************************************************************************/ /* Extern Valuable */ /***************************************************************************************/ extern volatile bool AlarmTimerOnSet; extern volatile bool AlarmTimerOffSet; extern volatile uint32_t AlarmTimerOnCnt; extern volatile uint32_t AlarmTimerOffCnt; extern volatile uint32_t AGC_On_AlarmTimerCnt[AGC_Alarm_DL_Index_MAX]; extern volatile uint32_t AGC_Off_AlarmTimerCnt[AGC_Alarm_DL_Index_MAX]; extern volatile uint32_t DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL_Index_MAX] ; extern volatile uint32_t DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL_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 uint16_t ADC1Desc_valuearray[4][ADC_AVERAGECNT]; extern volatile uint16_t ADC3Desc_valuearray[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_UL_Off_AlarmTimerCnt[DET_Alarm_UL_Index_MAX]; extern volatile uint32_t DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL_Index_MAX]; extern volatile uint32_t DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL_Index_MAX]; extern volatile uint32_t DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL_Index_MAX]; extern volatile uint32_t DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL_Index_MAX]; extern volatile uint32_t ALC_On_AlarmTimerCnt[ALC_Alarm_UL_Index_MAX]; extern volatile uint32_t ALC_Off_AlarmTimerCnt[ALC_Alarm_UL_Index_MAX]; extern volatile uint32_t DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL_Index_MAX]; extern volatile uint32_t DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL_Index_MAX]; extern volatile uint32_t DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL_Index_MAX]; extern volatile uint32_t DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL_Index_MAX]; extern uint8_t* MBIC_UL_ShutdownCount; extern uint8_t* MBIC_DL_ShutdownCount; extern uint8_t* PrevMBIC_UL_ShutdownCount; extern uint8_t* PrevMBIC_DL_ShutdownCount; extern volatile uint32_t Alarm_Temp_TimerOffCnt ; extern volatile uint32_t Alarm_Temp_TimerOnCnt ; extern volatile uint32_t Alarm_DL_Level_TimerOffCnt ; extern volatile uint32_t Alarm_DL_Level_TimerOnCnt ; extern volatile uint32_t Alarm_UL_Level_TimerOffCnt ; extern volatile uint32_t Alarm_UL_Level_TimerOnCnt ; extern volatile uint32_t ADC_100ms_Cnt; extern volatile uint32_t HFR_ADC1value[ADC1_CNT]; extern volatile uint32_t HFR_ADC3value[ADC3_CNT]; extern volatile uint32_t ALC_Delay_Cnt[ALC_Alarm_UL_Index_MAX]; volatile uint8_t Selftest_DL_PrevAttenSave[8] = {0,}; volatile uint8_t Selftest_UL_PrevAttenSave[8] = {0,}; uint8_t TempShutdown_DL_SaveData[4] = {false,}; uint8_t TempShutdown_UL_SaveData[4] = {false,}; extern volatile uint32_t AlarmReport_TimerCnt; extern uint8_t Led_ToggleCntSet; extern volatile uint32_t SelfTestLifeCnt; volatile uint8_t Prev_ALC_OnOff = 0; volatile uint8_t Prev_AGC_OnOff = 0; volatile uint8_t Prev_DL_Shutdown_OnOff = 0; volatile uint8_t Prev_UL_Shutdown_OnOff = 0; volatile bool timeset_init = false; uint8_t Last_Day = 0; uint8_t Prev_Last_Day = 0; /***************************************************************************************/ /* Function */ /***************************************************************************************/ double AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size,int8_t* RefTable_Data); 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); double PE43711_Double(uint8_t high_bit,uint8_t low_bit); double Bluecell_TestPro(double value ); double AGC_AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size,int8_t* RefTable_Data); void ALC_Alarm_TimerSet(uint8_t num,int16_t threshold,double CurrDet,int16_t CurrAtten,int16_t MainAtten); void Carrier_ONOFF(uint8_t val); void DL_Path_OnOff(uint8_t Index,uint8_t value,uint8_t* path,uint8_t* PrevAtten,uint8_t* retrycnt,uint8_t* PrevRetryCnt); void Factory_Set(); void SelfTest_Ctrl(uint8_t num,uint8_t val,uint8_t* selftest,uint8_t* DL_Atten,uint8_t* UL_Atten,uint8_t* Prev_DL_Atten,uint8_t* Prev_UL_Atten,uint8_t* ALC_Atten,uint8_t* Prev_ALC_Atten); void TimeSetting(uint8_t* data); void Temp_Shutdown_ONOFF(uint8_t val); void UL_Path_OnOff(uint8_t Index,uint8_t value,uint8_t* path,uint8_t* PrevAtten,uint8_t* retrycnt,uint8_t* PrevRetryCnt); int16_t Temperature_Offset_Get(int8_t* Temp_Table,int8_t CurrTemp); int Bluecell_RoundCalc(double data); void DLI_FRBT_ONOFF_Set(bool); /***************************************************************************************/ /* Valuable */ /***************************************************************************************/ int8_t DL_DET_Table_ref[AGC_Table_DL_Ref_Index_MAX][TABLE_LENGTH_MAX]; int8_t UL_DET_Table_ref[ALC_Table_UL_Ref_Index_MAX][TABLE_LENGTH_MAX]; bool Alarm_LED_OnSet; uint8_t DataWrite[sizeof(BLUESTATUS_st)]; uint8_t Txdata[1024]; int8_t AutoControl_Save[MBIC_Table_INDEX][sizeof(ALC_dBm_t)]; uint16_t ADC1Ret[4]; bool UL_ALC_GainAttenSet[ALC_Alarm_UL_Index_MAX]; int16_t ALC_Level_Save[ALC_Alarm_UL_Index_MAX]; bool Initialize; bool AGC_AlarmSet[AGC_Alarm_DL_Index_MAX]; uint8_t FRBT_UserCtrl = 0; uint16_t ADC3Ret[5]; volatile uint8_t LED_TestCnt = 0; uint8_t TxData[2048]; 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; int16_t DL_AGC_StartAtten[AGC_Alarm_DL_Index_MAX] = {0,}; int16_t DL_PrevIwillgiveAtten[AGC_Alarm_DL_Index_MAX] = {0,}; bool DL_PathUserHandl[4] = {0,}; bool UL_PathUserHandl[4] = {0,}; typedef enum{ DLI_FRBT_Time_Year = 0, DLI_FRBT_Time_Month, DLI_FRBT_Time_Day, DLI_FRBT_Time_Hour, DLI_FRBT_Time_Minute, DLI_FRBT_Time_Second, DLI_FRBT_Time_Index_Max, }; volatile uint8_t StartTimeFRBT_Day[6] = {0,}; /*Start day Register*/ uint8_t FRBT_Day[6] = {0,}; /*Curr day Register*/ uint8_t PrevFRBT_Day[6] = {0,}; /*Prev day Register*/ typedef enum{ Path1_OnOff = 0, Path2_OnOff, Path3_OnOff, Path4_OnOff, }; typedef enum{ Atten_H = 0, Atten_L, }; typedef enum{ SelfTest1 = 0, SelfTest2, SelfTest3, SelfTest4, }; typedef enum{ MBIC_3_7G = 0x80 , MBIC_3_8G , MBIC_3_9G , MBIC_4_0G , MBIC_4_1G , MBIC_4_6G , MBIC_4_7G , MBIC_4_8G , MBIC_4_9G , MBIC_5_0G , MBIC_DCM , MBIC_SBM , MBIC_KDDI , }MBIC_CardType_t; typedef enum{ BLUECELL_3_7G = 0 , BLUECELL_3_8G , BLUECELL_3_9G , BLUECELL_4_0G , BLUECELL_4_1G , BLUECELL_4_6G , BLUECELL_SBM , BLUECELL_DCM , BLUECELL_KDDI , BLUECELL_4_7G , BLUECELL_4_8G , BLUECELL_4_9G , BLUECELL_5_0G , }Bluecell_CardType_t; typedef enum{ DLI_AGC_H = 0, DLI_AGC_L, }; 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 Boot_LED_Toggle(void){ if(bluecell_Currdatastatus.LED_TEST == false){ if(LedTimerCnt > 500){ HAL_GPIO_TogglePin(BOOT_LED_GPIO_Port,BOOT_LED_Pin); HAL_GPIO_TogglePin(LED_ACT_GPIO_Port,LED_ACT_Pin); // if(AlarmTimerOnCnt > 3000){ if(Alarm_LED_OnSet == true){ HAL_GPIO_WritePin(LED_FAIL_GPIO_Port,LED_FAIL_Pin,GPIO_PIN_SET); }else{ HAL_GPIO_WritePin(LED_FAIL_GPIO_Port,LED_FAIL_Pin,GPIO_PIN_RESET); } // printf("Alarm_LED_OnSet : %d\r\n",Alarm_LED_OnSet); LedTimerCnt = 0; } }else{ if(LedTimerCnt > 500){ // printf("LED TESTING....\r\n"); if(LED_TestCnt % 2){ HAL_GPIO_WritePin(BOOT_LED_GPIO_Port,BOOT_LED_Pin,GPIO_PIN_SET); HAL_GPIO_WritePin(LED_FAIL_GPIO_Port,LED_FAIL_Pin,GPIO_PIN_RESET); HAL_GPIO_WritePin(LED_ACT_GPIO_Port,LED_ACT_Pin,GPIO_PIN_RESET); }else{ HAL_GPIO_WritePin(BOOT_LED_GPIO_Port,BOOT_LED_Pin,GPIO_PIN_RESET); HAL_GPIO_WritePin(LED_FAIL_GPIO_Port,LED_FAIL_Pin,GPIO_PIN_SET); HAL_GPIO_WritePin(LED_ACT_GPIO_Port,LED_ACT_Pin,GPIO_PIN_SET); } LED_TestCnt++; LedTimerCnt = 0; /*Set LED TEST variable False after 12 flashes*/ if(LED_TestCnt >= Led_ToggleCntSet){ bluecell_Currdatastatus.LED_TEST = false; Led_ToggleCntSet = 20; LED_TestCnt = 0; } } } } void FRBT_UserCtrl_Set(uint8_t set){ FRBT_UserCtrl = set; } uint8_t FRBT_UserCtrl_Get(){ return FRBT_UserCtrl; } uint8_t MBIC_DL_PE43711_Calc(uint8_t* Table,int16_t MBIC_Val,int16_t MBIC_UserVal){ double ret = 0; double ret2 = 0; double ret3 = 0; uint8_t Result = 0; //ret = PE43711_Double(MBIC_Val); // Hidden Atten Calc // printf("MBIC_UserVal : %x \r\n",MBIC_UserVal); // 2 ret = MBIC_Val; ret /= 10; ret *= -1; ret2 += MBIC_UserVal; ret2 /= 10; ret2 *= -1; ret += ret2; ret += HIDDENATTEN/10;//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 MBIC_UL_PE43711_Calc(uint8_t* Table,int16_t MBIC_Val,int16_t MBIC_UserVal,int16_t MBIC_ALCVal){ double ret = 0; double ret2 = 0; double ret3 = 0; uint8_t Result = 0; if(MBIC_Val + MBIC_ALCVal < -200) MBIC_Val = MBIC_ALCVal = -100; //ret = PE43711_Double(MBIC_Val); // Hidden Atten Calc // printf("MBIC_UserVal : %x \r\n",MBIC_UserVal); // 2 ret = MBIC_Val; ret /= 10; ret *= -1; ret2 += MBIC_UserVal; ret2 /= 10; ret2 *= -1; ret3 += MBIC_ALCVal; ret3 /= 10; ret3 *= -1; ret =ret + ret2 + ret3; // printf("ret1 : %f \r\n",ret); // 2 ret = TableAtteGuarantee(Table,ret);//Table Guarantee // printf("ret2 : %f \r\n",ret); Result = PE43711_DataToHexConvert(ret); // printf("Result %x \r\n",Result); return Result; } /*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; int16_t tmp = 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 tmp = (int16_t)((high_bit << 8) | low_bit); ret = tmp * 0.1; #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("cnt : %d \r\n",cnt); // printf("H : %x L : %x \r\n",GuaranteeData[cnt * 2],GuaranteeData[cnt * 2 + 1]); ret = GuaranteeData[cnt] * 0.5; //= 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 Table_DataSetting(int8_t* pdata,int8_t RefData,double step,uint8_t size){ // step /= 10; for(int i =0; i < size; i++){ pdata[i] = RefData; // printf("pdata[%d] %d \r\n",i,pdata[i]); RefData += step; } } void Table_Init(){ // printf("Table Initialize\r\n"); Table_DataSetting(&DL_DET_Table_ref[AGC_Table_DL1_Ref_Index][TABLE_MAX_VALUE],Det_DL1.Table_Ref,TableDataSetting_ATT_DL_LEVEL_STEP,Det_DL1.Table_Length); Table_DataSetting(&DL_DET_Table_ref[AGC_Table_DL2_Ref_Index][TABLE_MAX_VALUE],Det_DL2.Table_Ref,TableDataSetting_ATT_DL_LEVEL_STEP,Det_DL2.Table_Length); Table_DataSetting(&DL_DET_Table_ref[AGC_Table_DL3_Ref_Index][TABLE_MAX_VALUE],Det_DL3.Table_Ref,TableDataSetting_ATT_DL_LEVEL_STEP,Det_DL3.Table_Length); Table_DataSetting(&DL_DET_Table_ref[AGC_Table_DL4_Ref_Index][TABLE_MAX_VALUE],Det_DL4.Table_Ref,TableDataSetting_ATT_DL_LEVEL_STEP,Det_DL4.Table_Length); Table_DataSetting(&UL_DET_Table_ref[ALC_Table_UL1_Ref_Index][TABLE_MAX_VALUE],Det_UL1.Table_Ref,TableDataSetting_ATT_UL_LEVEL_STEP,Det_UL1.Table_Length); Table_DataSetting(&UL_DET_Table_ref[ALC_Table_UL2_Ref_Index][TABLE_MAX_VALUE],Det_UL2.Table_Ref,TableDataSetting_ATT_UL_LEVEL_STEP,Det_UL2.Table_Length); Table_DataSetting(&UL_DET_Table_ref[ALC_Table_UL3_Ref_Index][TABLE_MAX_VALUE],Det_UL3.Table_Ref,TableDataSetting_ATT_UL_LEVEL_STEP,Det_UL3.Table_Length); Table_DataSetting(&UL_DET_Table_ref[ALC_Table_UL4_Ref_Index][TABLE_MAX_VALUE],Det_UL4.Table_Ref,TableDataSetting_ATT_UL_LEVEL_STEP,Det_UL4.Table_Length); // EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_UL4_TABLE_ADDRESDS,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) ); // EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL1_TABLE_ADDRESDS,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) ); // EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL2_TABLE_ADDRESDS,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) ); // EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL3_TABLE_ADDRESDS,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) ); // // // EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL4_TABLE_ADDRESDS,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) ); // EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL1_TABLE_ADDRESDS,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) ); // EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL2_TABLE_ADDRESDS,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) ); // EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL3_TABLE_ADDRESDS,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) ); } void Bluecell_AttenInitialize(){ uint8_t val = 0; int16_t MBIC_ALC_Val = 0,MBIC_Val = 0,MBIC_UserVal = 0; // Bluecell_StructCpy(&AutoControl_Save[MBIC_Table_DL1_INDEX],&DL_DET_Table_ref[AGC_Table_DL1_Ref_Index][TABLE_MAX_VALUE],sizeof(AGC_dBm_t)); // Bluecell_StructCpy(&AutoControl_Save[MBIC_Table_DL2_INDEX],&DL_DET_Table_ref[AGC_Table_DL2_Ref_Index][TABLE_MAX_VALUE],sizeof(AGC_dBm_t)); // Bluecell_StructCpy(&AutoControl_Save[MBIC_Table_DL3_INDEX],&DL_DET_Table_ref[AGC_Table_DL3_Ref_Index][TABLE_MAX_VALUE],sizeof(AGC_dBm_t)); // Bluecell_StructCpy(&AutoControl_Save[MBIC_Table_DL4_INDEX],&DL_DET_Table_ref[AGC_Table_DL4_Ref_Index][TABLE_MAX_VALUE],sizeof(AGC_dBm_t)); // Bluecell_StructCpy(&AutoControl_Save[MBIC_Table_UL1_INDEX],&UL_DET_Table_ref[ALC_Table_UL1_Ref_Index][TABLE_MAX_VALUE],sizeof(ALC_dBm_t)); // Bluecell_StructCpy(&AutoControl_Save[MBIC_Table_UL2_INDEX],&UL_DET_Table_ref[ALC_Table_UL2_Ref_Index][TABLE_MAX_VALUE],sizeof(ALC_dBm_t)); // Bluecell_StructCpy(&AutoControl_Save[MBIC_Table_UL3_INDEX],&UL_DET_Table_ref[ALC_Table_UL3_Ref_Index][TABLE_MAX_VALUE],sizeof(ALC_dBm_t)); // Bluecell_StructCpy(&AutoControl_Save[MBIC_Table_UL4_INDEX],&UL_DET_Table_ref[ALC_Table_UL4_Ref_Index][TABLE_MAX_VALUE],sizeof(ALC_dBm_t)); // for(int a = 0; a < MBIC_Table_INDEX; a++){ // printf("========================START %d=====================================\r\n",a); // if(a <= MBIC_Table_DL4_INDEX) // for(int i = 0; i < sizeof(AGC_dBm_t); i++) // printf("ref Tabe: %d \r\n",AutoControl_Save[MBIC_Table_DL1_INDEX + a][i] ); // else // for(int i = 0; i < sizeof(ALC_dBm_t); i++) // printf("ref Tabe: %d \r\n",AutoControl_Save[MBIC_Table_DL1_INDEX + a][i] ); // } //// // 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; MBIC_Val = bluecell_Currdatastatus.ATT_DL1_H << 8 | bluecell_Currdatastatus.ATT_DL1_L; MBIC_UserVal = bluecell_Currdatastatus.bluecell_User_DL1_H << 8 | bluecell_Currdatastatus.bluecell_User_DL1_L; // printf("MBIC_UserVal : %d \r\n",MBIC_UserVal); val = MBIC_DL_PE43711_Calc(&Att_DL1.Table_0_0_dBm, // Table Offset MBIC_Val, MBIC_UserVal);// 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; MBIC_Val = bluecell_Currdatastatus.ATT_DL2_H << 8 | bluecell_Currdatastatus.ATT_DL2_L; MBIC_UserVal = bluecell_Currdatastatus.bluecell_User_DL2_H << 8 | bluecell_Currdatastatus.bluecell_User_DL2_L; val = MBIC_DL_PE43711_Calc(&Att_DL2.Table_0_0_dBm, // Table Offset MBIC_Val, MBIC_UserVal);// 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; MBIC_Val = bluecell_Currdatastatus.ATT_DL3_H << 8 | bluecell_Currdatastatus.ATT_DL3_L; MBIC_UserVal = bluecell_Currdatastatus.bluecell_User_DL3_H << 8 | bluecell_Currdatastatus.bluecell_User_DL3_L; // printf("DL 3 MAIN ATTEN :%x \r\n",MBIC_Val); // printf("DL 3 OFSSET ATTEN :%x \r\n",MBIC_UserVal); val = MBIC_DL_PE43711_Calc(&Att_DL3.Table_0_0_dBm, // Table Offset MBIC_Val, MBIC_UserVal);// 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; MBIC_Val = bluecell_Currdatastatus.ATT_DL4_H << 8 | bluecell_Currdatastatus.ATT_DL4_L; MBIC_UserVal = bluecell_Currdatastatus.bluecell_User_DL4_H << 8 | bluecell_Currdatastatus.bluecell_User_DL4_L; val = MBIC_DL_PE43711_Calc(&Att_DL4.Table_0_0_dBm, // Table Offset MBIC_Val, MBIC_UserVal);// 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; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten1_H = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten1_L = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L; MBIC_Val = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L; MBIC_ALC_Val = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L; MBIC_UserVal = bluecell_Currdatastatus.bluecell_User_UL1_H << 8 | bluecell_Currdatastatus.bluecell_User_UL1_L; val = MBIC_UL_PE43711_Calc(&Att_UL1.Table_0_0_dBm, // Table Offset MBIC_Val, MBIC_UserVal, MBIC_ALC_Val);// 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; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten2_H = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten2_L = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L; MBIC_Val = bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L; bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H = 0; bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L = 0; MBIC_ALC_Val = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L; MBIC_UserVal = bluecell_Currdatastatus.bluecell_User_UL2_H << 8 | bluecell_Currdatastatus.bluecell_User_UL2_L; // printf("MBIC_ALC_Val : %x \r\n",MBIC_ALC_Val); val = MBIC_UL_PE43711_Calc(&Att_UL1.Table_0_0_dBm, // Table Offset MBIC_Val, MBIC_UserVal, MBIC_ALC_Val);// 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; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten3_H = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten3_L = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L; MBIC_Val = bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L; MBIC_ALC_Val = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L; MBIC_UserVal = bluecell_Currdatastatus.bluecell_User_UL3_H << 8 | bluecell_Currdatastatus.bluecell_User_UL3_L; val = MBIC_UL_PE43711_Calc(&Att_UL3.Table_0_0_dBm, // Table Offset MBIC_Val, MBIC_UserVal, MBIC_ALC_Val);// 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; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_H = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_L = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L; MBIC_Val = bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L; MBIC_ALC_Val = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L; MBIC_UserVal = bluecell_Currdatastatus.bluecell_User_UL4_H << 8 | bluecell_Currdatastatus.bluecell_User_UL4_L; val = MBIC_UL_PE43711_Calc(&Att_UL4.Table_0_0_dBm, // Table Offset MBIC_Val, MBIC_UserVal, MBIC_ALC_Val);// User Atten Low Bit // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_UL4,val); } typedef enum{ ATTEN_H = 0, ATTEN_L, }; void Atten_DL_Ctrl_Function(PE43711_st* ATT,ATT_TABLE_st* Table,uint8_t* CurrAtten,uint8_t* PrevAtten,uint8_t* CurrHiddenAtten,uint8_t* PrevHiddenAtten){ uint16_t MBIC_Val = 0; uint16_t MBIC_ALC_Val = 0; uint16_t MBIC_UserVal = 0; uint8_t val = 0; if(CurrAtten[ATTEN_H] != CurrAtten[ATTEN_H] ||CurrAtten[ATTEN_H] != CurrAtten[ATTEN_L] ||CurrHiddenAtten[ATTEN_H] != CurrHiddenAtten[ATTEN_H] ||CurrHiddenAtten[ATTEN_H] != CurrHiddenAtten[ATTEN_L]){ PrevAtten[ATTEN_H] = CurrAtten[ATTEN_H]; PrevAtten[ATTEN_L] = CurrAtten[ATTEN_L]; PrevHiddenAtten[ATTEN_H] = CurrHiddenAtten[ATTEN_H]; PrevHiddenAtten[ATTEN_L] = CurrHiddenAtten[ATTEN_L]; MBIC_Val = CurrAtten[ATTEN_H] << 8 | CurrAtten[ATTEN_L]; MBIC_UserVal = CurrHiddenAtten[ATTEN_H] << 8 | CurrHiddenAtten[ATTEN_L]; val = MBIC_DL_PE43711_Calc(&Table->Table_0_0_dBm, // Table Offset MBIC_Val, MBIC_UserVal);// User Atten Low Bit // printf("%s : %d \r\n",__func__,__LINE__); // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl2(ATT,val); } } typedef enum{ ATTEN_DL1= 0 , ATTEN_DL2, ATTEN_DL3, ATTEN_DL4, ATTEN_UL1, ATTEN_UL2, ATTEN_UL3, ATTEN_UL4, }; void Atten_UL_Ctrl_Function(uint8_t index,ATT_TABLE_st* Table,uint8_t* CurrAtten,uint8_t* PrevAtten,uint8_t* CurrHiddenAtten,uint8_t* PrevHiddenAtten,uint8_t* CurrALCAtten,uint8_t* PrevALCAtten){ int16_t MBIC_Val = 0; int16_t MBIC_UserVal = 0; int16_t MBIC_ALCVal = 0; uint8_t val = 0; if(CurrAtten[ATTEN_H] != CurrAtten[ATTEN_H] ||CurrAtten[ATTEN_L] != CurrAtten[ATTEN_L] ||CurrHiddenAtten[ATTEN_H] != CurrHiddenAtten[ATTEN_H] ||CurrHiddenAtten[ATTEN_L] != CurrHiddenAtten[ATTEN_L] ||PrevALCAtten[ATTEN_H] != CurrALCAtten[ATTEN_H] ||PrevALCAtten[ATTEN_L] != CurrALCAtten[ATTEN_L]){ PrevAtten[ATTEN_H] = CurrAtten[ATTEN_H]; PrevAtten[ATTEN_L] = CurrAtten[ATTEN_L]; PrevHiddenAtten[ATTEN_H] = CurrHiddenAtten[ATTEN_H]; PrevHiddenAtten[ATTEN_L] = CurrHiddenAtten[ATTEN_L]; CurrALCAtten[ATTEN_H] = CurrALCAtten[ATTEN_H]; CurrALCAtten[ATTEN_L] = CurrALCAtten[ATTEN_L]; MBIC_Val = CurrAtten[ATTEN_H] << 8 | CurrAtten[ATTEN_L]; MBIC_UserVal = CurrHiddenAtten[ATTEN_H] << 8 | CurrHiddenAtten[ATTEN_L]; MBIC_ALCVal= CurrALCAtten[ATTEN_H] << 8 | CurrALCAtten[ATTEN_L]; val = MBIC_UL_PE43711_Calc(&Table->Table_0_0_dBm, // Table Offset MBIC_Val, MBIC_UserVal, MBIC_ALCVal);// User Atten Low Bit // printf("%s : %d \r\n",__func__,__LINE__); // printf("%d val = %x \r\n",__LINE__,val); switch(index){ case ATTEN_UL1: PE43711_atten_ctrl(ALL_ATT.ATT_UL1,val);break; case ATTEN_UL2: PE43711_atten_ctrl(ALL_ATT.ATT_UL2,val);break; case ATTEN_UL3: PE43711_atten_ctrl(ALL_ATT.ATT_UL3,val);break; case ATTEN_UL4: PE43711_UL4_atten_ctrl(val);break; } } } typedef enum{ DL_ATTEN_H, DL_ATTEN_L, }; void DL_AttenOperate(uint8_t* Atten,uint8_t* PrevAtten,uint8_t* UserAtten,uint8_t* PrevUserAtten,PE43711_st ATT){ uint8_t val = 0; uint16_t MBIC_Val = 0; uint16_t MBIC_ALC_Val = 0; uint16_t MBIC_UserVal = 0; if((Atten[DL_ATTEN_H] != PrevAtten[DL_ATTEN_H]) ||(Atten[DL_ATTEN_L] != PrevAtten[DL_ATTEN_L]) ||(UserAtten[DL_ATTEN_H] != PrevUserAtten[DL_ATTEN_H]) ||(UserAtten[DL_ATTEN_L] != PrevUserAtten[DL_ATTEN_L])){ // printf("%s : %d \r\n",__func__,__LINE__); Atten[DL_ATTEN_H] = PrevAtten[DL_ATTEN_H]; Atten[DL_ATTEN_L] = PrevAtten[DL_ATTEN_L]; UserAtten[DL_ATTEN_H] = PrevUserAtten[DL_ATTEN_H]; UserAtten[DL_ATTEN_L] = PrevUserAtten[DL_ATTEN_L]; MBIC_Val =Atten[DL_ATTEN_H] << 8 |Atten[DL_ATTEN_L]; MBIC_UserVal = UserAtten[DL_ATTEN_H] << 8 | UserAtten[DL_ATTEN_L]; val = MBIC_DL_PE43711_Calc(&Att_DL1.Table_0_0_dBm, // Table Offset MBIC_Val, MBIC_UserVal);// User Atten Low Bit // printf("%s : %d \r\n",__func__,__LINE__); // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ATT,val); } } typedef enum{ UserAtten_H = 0, UserAtten_L, }; void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){ uint8_t val = 0; uint16_t MBIC_Val = 0; uint16_t MBIC_ALC_Val = 0; uint16_t MBIC_UserVal = 0; #if 1 // PYJ.2020.07.01_BEGIN -- 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; MBIC_Val =Curr.ATT_DL1_H << 8 | Curr.ATT_DL1_L; MBIC_UserVal = Curr.bluecell_User_DL1_H << 8 | Curr.bluecell_User_DL1_L; val = MBIC_DL_PE43711_Calc(&Att_DL1.Table_0_0_dBm, // Table Offset MBIC_Val, MBIC_UserVal);// 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; MBIC_Val = Curr.ATT_DL2_H << 8 | Curr.ATT_DL2_L; MBIC_UserVal = Curr.bluecell_User_DL2_H << 8 | Curr.bluecell_User_DL2_L; val = MBIC_DL_PE43711_Calc(&Att_DL2.Table_0_0_dBm,// Table Offset MBIC_Val,// Hidden Atten Low bit MBIC_UserVal);// 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; MBIC_Val = Curr.ATT_DL3_H << 8 | Curr.ATT_DL3_L; MBIC_UserVal = Curr.bluecell_User_DL3_H << 8 | Curr.bluecell_User_DL3_L; val = MBIC_DL_PE43711_Calc(&Att_DL3.Table_0_0_dBm,// Table Offset MBIC_Val,// Hidden Atten Low bit MBIC_UserVal);// 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; MBIC_Val = (Curr.ATT_DL4_H << 8 | Curr.ATT_DL4_L); // printf("\r\nCurr.ATT_DL4_H : %x \rCurr.ATT_DL4_L : %x \r\n",Curr.ATT_DL4_H,Curr.ATT_DL4_L); MBIC_UserVal = Curr.bluecell_User_DL4_H << 8 | Curr.bluecell_User_DL4_L; // printf("\r\nCurr.bluecell_User_DL4_H : %x \rCurr.bluecell_User_DL4_L : %x \r\n",Curr.bluecell_User_DL4_H,Curr.bluecell_User_DL4_L); // printf("MBIC_UserVal : %x \r\n",MBIC_UserVal); // 2 val = MBIC_DL_PE43711_Calc(&Att_DL4.Table_0_0_dBm,// Table Offset MBIC_Val,// Hidden Atten Low bit MBIC_UserVal);// User Atten Low Bit // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_DL4,val); } #else DL_AttenOperate(&bluecell_Currdatastatus.ATT_DL1_H,&bluecell_Prevdatastatus.ATT_DL1_L, &bluecell_Currdatastatus.bluecell_User_DL1_H,&bluecell_Prevdatastatus.bluecell_User_DL1_L,ALL_ATT.ATT_DL1); DL_AttenOperate(&bluecell_Currdatastatus.ATT_DL2_H,&bluecell_Prevdatastatus.ATT_DL2_L, &bluecell_Currdatastatus.bluecell_User_DL2_H,&bluecell_Prevdatastatus.bluecell_User_DL2_L,ALL_ATT.ATT_DL2); DL_AttenOperate(&bluecell_Currdatastatus.ATT_DL3_H,&bluecell_Prevdatastatus.ATT_DL3_L, &bluecell_Currdatastatus.bluecell_User_DL3_H,&bluecell_Prevdatastatus.bluecell_User_DL3_L,ALL_ATT.ATT_DL3); DL_AttenOperate(&bluecell_Currdatastatus.ATT_DL4_H,&bluecell_Prevdatastatus.ATT_DL4_L, &bluecell_Currdatastatus.bluecell_User_DL4_H,&bluecell_Prevdatastatus.bluecell_User_DL4_L,ALL_ATT.ATT_DL4); #endif // PYJ.2020.07.01_END -- if(bluecell_Prevdatastatus.bluecell_User_UL1_H != 0xFF) bluecell_Prevdatastatus.bluecell_User_UL1_H =0xFF; if(bluecell_Prevdatastatus.bluecell_User_UL2_H != 0xFF) bluecell_Prevdatastatus.bluecell_User_UL2_H =0xFF; if(bluecell_Prevdatastatus.bluecell_User_UL3_H != 0xFF) bluecell_Prevdatastatus.bluecell_User_UL3_H =0xFF; if(bluecell_Prevdatastatus.bluecell_User_UL4_H != 0xFF) bluecell_Prevdatastatus.bluecell_User_UL4_H =0xFF; #if 1 // PYJ.2020.06.27_BEGIN -- 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) ||(Curr.MBIC_ULO_ALC_Atten1_H != Prev.MBIC_ULO_ALC_Atten1_H) ||(Curr.MBIC_ULO_ALC_Atten1_L != Prev.MBIC_ULO_ALC_Atten1_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; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten1_H = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten1_L = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L; MBIC_Val = Curr.ATT_UL1_H << 8 | Curr.ATT_UL1_L; MBIC_ALC_Val = Curr.MBIC_ULO_ALC_Atten1_H << 8 | Curr.MBIC_ULO_ALC_Atten1_L; MBIC_UserVal = Curr.bluecell_User_UL1_H << 8 | Curr.bluecell_User_UL1_L; val = MBIC_UL_PE43711_Calc(&Att_UL1.Table_0_0_dBm,// Table Offset MBIC_Val,// Hidden Atten Low bit MBIC_UserVal, MBIC_ALC_Val);// User Atten Low Bit //("%d val = %x \r\n",__LINE__,val); // printf("MBIC_Val : %x \r\n",MBIC_Val); // printf("MBIC_ALC_Val : %x \r\n",MBIC_ALC_Val); // printf("MBIC_UserVal : %x \r\n",MBIC_UserVal); PE43711_atten_ctrl(ALL_ATT.ATT_UL1,val); } // Atten_UL_Ctrl_Function(ATTEN_UL1, // &Att_UL1.Table_0_0_dBm, // &bluecell_Currdatastatus.ATT_UL1_H, // &bluecell_Prevdatastatus.ATT_UL1_L, // &bluecell_Currdatastatus.bluecell_User_UL1_H, // &bluecell_Prevdatastatus.bluecell_User_UL1_L, // &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H, // &bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten1_L); #endif // PYJ.2020.06.27_END -- 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) ||(Curr.MBIC_ULO_ALC_Atten2_H != Prev.MBIC_ULO_ALC_Atten2_H) ||(Curr.MBIC_ULO_ALC_Atten2_L != Prev.MBIC_ULO_ALC_Atten2_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; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten2_H = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten2_L = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L; MBIC_Val = Curr.ATT_UL2_H << 8 | Curr.ATT_UL2_L; MBIC_ALC_Val = Curr.MBIC_ULO_ALC_Atten2_H << 8 | Curr.MBIC_ULO_ALC_Atten2_L; MBIC_UserVal = Curr.bluecell_User_UL2_H << 8 | Curr.bluecell_User_UL2_L; // printf("UL 2MBIC_Val : %02X \r\n",MBIC_Val); // printf("UL 2MBIC_UserVal : %02X \r\n",MBIC_UserVal); // printf("UL 2MBIC_ALC_Val : %02X \r\n",MBIC_ALC_Val); val = MBIC_UL_PE43711_Calc(&Att_UL2.Table_0_0_dBm,// Table Offset MBIC_Val,// Hidden Atten Low bit MBIC_UserVal, MBIC_ALC_Val);// User Atten Low Bit // printf("UL 2 LINE: %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) ||(Curr.MBIC_ULO_ALC_Atten3_H != Prev.MBIC_ULO_ALC_Atten3_H) ||(Curr.MBIC_ULO_ALC_Atten3_L != Prev.MBIC_ULO_ALC_Atten3_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; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten3_H = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten3_L = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L; MBIC_Val = Curr.ATT_UL3_H << 8 | Curr.ATT_UL3_L; MBIC_ALC_Val = Curr.MBIC_ULO_ALC_Atten3_H << 8 | Curr.MBIC_ULO_ALC_Atten3_L; MBIC_UserVal = Curr.bluecell_User_UL3_H << 8 | Curr.bluecell_User_UL3_L; val = MBIC_UL_PE43711_Calc(&Att_UL3.Table_0_0_dBm,// Table Offset MBIC_Val,// Hidden Atten Low bit MBIC_UserVal, MBIC_ALC_Val);// User Atten Low Bit // printf("bluecell_Currdatastatus.ATT_UL3_H : %0x \r\n",bluecell_Currdatastatus.ATT_UL3_H); // printf("bluecell_Currdatastatus.ATT_UL3_L : %0x \r\n",bluecell_Currdatastatus.ATT_UL3_L); // printf("bluecell_Currdatastatus.bluecell_User_UL3_H : %0x \r\n",bluecell_Currdatastatus.bluecell_User_UL3_H); // printf("bluecell_Currdatastatus.bluecell_User_UL3_L : %0x \r\n",bluecell_Currdatastatus.bluecell_User_UL3_L); // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_UL3,val); } if((Curr.ATT_UL4_H != Prev.ATT_UL4_H) ||(Curr.ATT_UL4_L != Prev.ATT_UL4_L) ||(Curr.bluecell_User_UL4_H != Prev.bluecell_User_UL4_H) ||(Curr.bluecell_User_UL4_L != Prev.bluecell_User_UL4_L) ||(Curr.MBIC_ULO_ALC_Atten4_H != Prev.MBIC_ULO_ALC_Atten4_H) ||(Curr.MBIC_ULO_ALC_Atten4_L != Prev.MBIC_ULO_ALC_Atten4_L)) { // printf("bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_H : %02x \r\n",bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_H); // printf("bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_L : %02x \r\n",bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_L); // printf("bluecell_Prevdatastatus.ATT_UL4_H : %02x \r\n",bluecell_Prevdatastatus.ATT_UL4_H); // printf("bluecell_Prevdatastatus.ATT_UL4_L : %02x \r\n",bluecell_Prevdatastatus.ATT_UL4_L); // printf("bluecell_Prevdatastatus.bluecell_User_UL4_H : %02x \r\n",bluecell_Prevdatastatus.bluecell_User_UL4_H); // printf("bluecell_Prevdatastatus.bluecell_User_UL4_L : %02x \r\n",bluecell_Prevdatastatus.bluecell_User_UL4_L); // printf("============================================================\r\n"); // printf("bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H : %02x \r\n",bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H); // printf("bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L : %02x \r\n",bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L); // printf("bluecell_Currdatastatus.ATT_UL4_H : %02x \r\n",bluecell_Currdatastatus.ATT_UL4_H); // printf("bluecell_Currdatastatus.ATT_UL4_L : %02x \r\n",bluecell_Currdatastatus.ATT_UL4_L); // printf("bluecell_Currdatastatus.bluecell_User_UL4_H : %02x \r\n",bluecell_Currdatastatus.bluecell_User_UL4_H); // printf("bluecell_Currdatastatus.bluecell_User_UL4_L : %02x \r\n",bluecell_Currdatastatus.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; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_H = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H; bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_L = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L; MBIC_Val = Curr.ATT_UL4_H << 8 | Curr.ATT_UL4_L; MBIC_ALC_Val = Curr.MBIC_ULO_ALC_Atten4_H << 8 | Curr.MBIC_ULO_ALC_Atten4_L; MBIC_UserVal = Curr.bluecell_User_UL4_H << 8 | Curr.bluecell_User_UL4_L; // printf("UL 4MBIC_Val : %02X \r\n",MBIC_Val); // printf("UL 4MBIC_UserVal : %02X \r\n",MBIC_UserVal); // printf("UL 4MBIC_ALC_Val : %02X \r\n",MBIC_ALC_Val); val = MBIC_UL_PE43711_Calc(&Att_UL4.Table_0_0_dBm,// Table Offset MBIC_Val,// Hidden Atten Low bit MBIC_UserVal, MBIC_ALC_Val);// User Atten Low Bit // printf("%d val = %x \r\n",__LINE__,val); PE43711_UL4_atten_ctrl(val); } // memcpy(&bluecell_Prevdatastatus.ATT_DL1_H,&bluecell_Currdatastatus.ATT_DL1_H,32); } #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; } void Bluecell_DataCopy(uint8_t* dst,uint8_t* src,uint16_t size){ // printf("Setting Start Value\r\n"); for(int i = 0; i < size; i++){ dst[i] = src[i]; // printf("%02x ",src[i]); } // printf("Setting Start Value END \r\n"); } void MBIC_TableDataCopy(uint8_t* dst,uint8_t* src,uint16_t size){ dst[MBIC_TableIndex_Unit_Type] = UNIT_TYPE_MBIC; dst[MBIC_TableIndex_Reseved] = 0; dst[MBIC_TableIndex_Number] = dst[MBIC_TableIndex_Number]; // printf("\r\dst[MBIC_TableIndex_Number] : %d \r\n",dst[MBIC_TableIndex_Number]); dst[MBIC_TableIndex_Ref] = UNIT_TYPE_MBIC; // Check // Att_DL1.Table_Length = ATTENTABLEDLUL_LENGTH; // Att_DL2.Table_Length = ATTENTABLEDLUL_LENGTH; // Att_DL3.Table_Length = ATTENTABLEDLUL_LENGTH; // Att_DL4.Table_Length = ATTENTABLEDLUL_LENGTH; // Att_UL1.Table_Length = ATTENTABLEDLUL_LENGTH; // Att_UL2.Table_Length = ATTENTABLEDLUL_LENGTH; // Att_UL3.Table_Length = ATTENTABLEDLUL_LENGTH; // Att_UL4.Table_Length = ATTENTABLEDLUL_LENGTH; // Det_DL1.Table_Length = ATTENTABLEDET_DL_LENGTH; // Det_DL2.Table_Length = ATTENTABLEDET_DL_LENGTH; // Det_DL3.Table_Length = ATTENTABLEDET_DL_LENGTH; // Det_DL4.Table_Length = ATTENTABLEDET_DL_LENGTH; // Det_UL1.Table_Length = ATTENTABLEDET_UL_LENGTH; // Det_UL2.Table_Length = ATTENTABLEDET_UL_LENGTH; // Det_UL3.Table_Length = ATTENTABLEDET_UL_LENGTH; // Det_UL4.Table_Length = ATTENTABLEDET_UL_LENGTH; // Temp_DL1.Table_Length = ATTENTABLE_TEMP_LENGTH; // Temp_DL2.Table_Length = ATTENTABLE_TEMP_LENGTH; // Temp_DL3.Table_Length = ATTENTABLE_TEMP_LENGTH; // Temp_DL4.Table_Length = ATTENTABLE_TEMP_LENGTH; // Temp_UL1.Table_Length = ATTENTABLE_TEMP_LENGTH; // Temp_UL2.Table_Length = ATTENTABLE_TEMP_LENGTH; // Temp_UL3.Table_Length = ATTENTABLE_TEMP_LENGTH; // Temp_UL4.Table_Length = ATTENTABLE_TEMP_LENGTH; if(dst[MBIC_TableIndex_Number] >= DLI_P1_ATT_Accuracy_Table_Number &&dst[MBIC_TableIndex_Number] <= ULO_P4_ATT_Accuracy_Table_Number ){ dst[MBIC_TableIndex_Length] = size; // } else{ dst[MBIC_TableIndex_Length] = size / 2; // } for(int i = 0; i < size; i++){ dst[i + MBIC_TableIndex_Max] = src[i]; // printf("SRC : %x \r\n",src[i]); } } void MBIC_TableHeaderCopy(uint8_t* src,uint16_t size){ src[MBIC_TableIndex_Unit_Type] = UNIT_TYPE_MBIC; src[MBIC_TableIndex_Reseved] = 0; src[MBIC_TableIndex_Number] = src[MBIC_PAYLOADSTART + 2]; if(src[MBIC_TableIndex_Number] >= DLI_P1_ATT_Accuracy_Table_Number &&src[MBIC_TableIndex_Number] <= ULO_P4_ATT_Accuracy_Table_Number ){ src[MBIC_TableIndex_Length] = size; // } else{ src[MBIC_TableIndex_Length] = size / 2; // } } 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)); // printf("Table_Length : %d , Table_Ref : %d ",Att_DL1.Table_Length,Att_DL1.Table_Ref); // Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st)); data[BLUECELL_LENGTH_H] = 0; data[BLUECELL_LENGTH_L] = (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_L] = (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_L] = (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_L] = (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_L] = (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_L] = (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_L] = (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_L] = (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)); // printf("Table_Length : %d , Table_Ref : %d ",Det_DL1.Table_Length,Det_DL1.Table_Ref); data[BLUECELL_LENGTH_L] = (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)); // for(int i = 0 ; i < sizeof(DET_TABLEDL_st);i++) // printf("[%d Dbm] : %f \r\n",UL_DET_Table_ref[i],((data[BLUECELL_DATA + 1 + (i * 2)] << 8)| data[BLUECELL_DATA + 1 + (i * 2)+ 1]) * 0.001 ); data[BLUECELL_LENGTH_L] = (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_L] = (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_L] = (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)); // for(int i = 0 ; i < sizeof(DET_TABLEUL_st);i++) // printf("[%d Dbm] : %f \r\n",UL_DET_Table_ref[i],((data[BLUECELL_DATA + 1 + (i * 2)] << 8)| data[BLUECELL_DATA + 1 + (i * 2)+ 1]) * 0.001 ); data[BLUECELL_LENGTH_L] = (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)); // for(int i = 0 ; i < sizeof(DET_TABLEUL_st);i++) // printf("[%d Dbm] : %f \r\n",UL_DET_Table_ref[i],((data[BLUECELL_DATA + 1 + (i * 2)] << 8)| data[BLUECELL_DATA + 1 + (i * 2)+ 1]) * 0.001 ); data[BLUECELL_LENGTH_L] = (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)); // for(int i = 0 ; i < sizeof(DET_TABLEUL_st);i++) // printf("[%d Dbm] : %f \r\n",UL_DET_Table_ref[i],((data[BLUECELL_DATA + 1 + (i * 2)] << 8)| data[BLUECELL_DATA + 1 + (i * 2)+ 1]) * 0.001 ); data[BLUECELL_LENGTH_L] = (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)); // for(int i = 0 ; i < sizeof(DET_TABLEUL_st);i++) // printf("[%d Dbm] : %f \r\n",UL_DET_Table_ref[i],((data[BLUECELL_DATA + 1 + (i * 2)] << 8)| data[BLUECELL_DATA + 1 + (i * 2)+ 1]) * 0.001 ); data[BLUECELL_LENGTH_L] = (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_1_Temp,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH_L] = (sizeof(TEMP_TABLE_st)) + 7 - 3; // printf("Table_Length : %d , Table_Ref : %d ",Temp_DL1.Table_Length,Temp_DL1.Table_Ref); break; case DLI_P2_ATT_Temp_guarantee_Table_Number: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL1_TABLE_ADDRESDS),&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH_L] = (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_1_Temp,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH_L] = (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_1_Temp,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH_L] = (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_1_Temp,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH_L] = (sizeof(TEMP_TABLE_st)) + 7 - 3; // printf("Table_Length : %d , Table_Ref : %d ",Temp_UL1.Table_Length,Temp_UL1.Table_Ref); break; case ULO_P2_ATT_Temp_guarantee_Table_Number: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH_L] = (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_1_Temp,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH_L] = (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_1_Temp,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH_L] = (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)); Att_DL1.Table_Ref = ATTENTABLEDL_REF; Att_DL1.Table_Length = ATTENTABLEDLUL_LENGTH; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_BASE) ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) ); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_BASE) ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) ); // printf("Function : %s Line %d \r\n",__func__,__LINE__); break; case DLI_P2_ATT_Accuracy_Table_Number: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Att_DL2.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); Att_DL2.Table_Ref = ATTENTABLEDL_REF; Att_DL2.Table_Length = ATTENTABLEDLUL_LENGTH; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL1_TABLE_ADDRESDS),&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) ); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_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: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Att_DL3.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); Att_DL3.Table_Ref = ATTENTABLEDL_REF; Att_DL3.Table_Length = ATTENTABLEDLUL_LENGTH; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL2_TABLE_ADDRESDS),&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL2_TABLE_ADDRESDS),&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st)); break; case DLI_P4_ATT_Accuracy_Table_Number: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Att_DL4.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); Att_DL4.Table_Ref = ATTENTABLEDL_REF; Att_DL4.Table_Length = ATTENTABLEDLUL_LENGTH; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL3_TABLE_ADDRESDS),&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL3_TABLE_ADDRESDS),&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st)); break; case ULO_P1_ATT_Accuracy_Table_Number: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Att_UL1.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); Att_UL1.Table_Length = ATTENTABLEDLUL_LENGTH; Att_UL1.Table_Ref = ATTENTABLEUL_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL4_TABLE_ADDRESDS),&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL4_TABLE_ADDRESDS),&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st)); break; case ULO_P2_ATT_Accuracy_Table_Number: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Att_UL2.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); Att_UL2.Table_Length = ATTENTABLEDLUL_LENGTH; Att_UL2.Table_Ref = ATTENTABLEUL_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL1_TABLE_ADDRESDS),&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL1_TABLE_ADDRESDS),&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st)); break; case ULO_P3_ATT_Accuracy_Table_Number: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Att_UL3.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); Att_UL3.Table_Length = ATTENTABLEDLUL_LENGTH; Att_UL3.Table_Ref = ATTENTABLEUL_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL2_TABLE_ADDRESDS),&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL2_TABLE_ADDRESDS),&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st)); break; case ULO_P4_ATT_Accuracy_Table_Number: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Att_UL4.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); Att_UL4.Table_Length = ATTENTABLEDLUL_LENGTH; Att_UL4.Table_Ref = ATTENTABLEUL_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL3_TABLE_ADDRESDS),&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL3_TABLE_ADDRESDS),&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st)); break; case DLI_P1_Level_Table_Number: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Det_DL1.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)); Det_DL1.Table_Length = ATTENTABLEDET_DL_LENGTH; Det_DL1.Table_Ref = ATTENTABLEDET_DL_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL4_TABLE_ADDRESDS),&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL4_TABLE_ADDRESDS),&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); break; case DLI_P2_Level_Table_Number: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Det_DL2.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)); Det_DL2.Table_Length = ATTENTABLEDET_DL_LENGTH; Det_DL2.Table_Ref = ATTENTABLEDET_DL_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL1_TABLE_ADDRESDS),&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL1_TABLE_ADDRESDS),&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); break; case DLI_P3_Level_Table_Number: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Det_DL3.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)); Det_DL3.Table_Length = ATTENTABLEDET_DL_LENGTH; Det_DL3.Table_Ref = ATTENTABLEDET_DL_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL2_TABLE_ADDRESDS),&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL2_TABLE_ADDRESDS),&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); break; case DLI_P4_Level_Table_Number://printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Det_DL4.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)); Det_DL4.Table_Length = ATTENTABLEDET_DL_LENGTH; Det_DL4.Table_Ref = ATTENTABLEDET_DL_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL3_TABLE_ADDRESDS),&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL3_TABLE_ADDRESDS),&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); break; case ULO_P1_Level_Table_Number: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Det_UL1.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)); Det_UL1.Table_Length = ATTENTABLEDET_UL_LENGTH; Det_UL1.Table_Ref = ATTENTABLEDET_UL_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL4_TABLE_ADDRESDS),&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); EEPROM_M24C08_Read(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: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Det_UL2.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)); Det_UL2.Table_Length = ATTENTABLEDET_UL_LENGTH; Det_UL2.Table_Ref = ATTENTABLEDET_UL_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL1_TABLE_ADDRESDS),&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); EEPROM_M24C08_Read(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: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Det_UL3.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)); Det_UL3.Table_Length = ATTENTABLEDET_UL_LENGTH; Det_UL3.Table_Ref = ATTENTABLEDET_UL_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL2_TABLE_ADDRESDS),&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); EEPROM_M24C08_Read(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: //printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Det_UL4.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)); Det_UL4.Table_Length = ATTENTABLEDET_UL_LENGTH; Det_UL4.Table_Ref = ATTENTABLEDET_UL_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL3_TABLE_ADDRESDS),&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL3_TABLE_ADDRESDS),&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); break; case DLI_P1_ATT_Temp_guarantee_Table_Number://printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Temp_DL1.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); Temp_DL1.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_DL1.Table_Ref= ATTENTABLE_TEMP_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st)); break; case DLI_P2_ATT_Temp_guarantee_Table_Number://printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Temp_DL2.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); Temp_DL2.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_DL2.Table_Ref= ATTENTABLE_TEMP_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL1_TABLE_ADDRESDS),&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL1_TABLE_ADDRESDS),&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st)); break; case DLI_P3_ATT_Temp_guarantee_Table_Number://printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Temp_DL3.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); Temp_DL3.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_DL3.Table_Ref= ATTENTABLE_TEMP_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st)); break; case DLI_P4_ATT_Temp_guarantee_Table_Number://printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Temp_DL4.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); Temp_DL4.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_DL4.Table_Ref= ATTENTABLE_TEMP_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL3_TABLE_ADDRESDS),&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL3_TABLE_ADDRESDS),&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st)); break; case ULO_P1_ATT_Temp_guarantee_Table_Number://printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Temp_UL1.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); Temp_UL1.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_UL1.Table_Ref= ATTENTABLE_TEMP_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st)); break; case ULO_P2_ATT_Temp_guarantee_Table_Number: Bluecell_DataCopy(&Temp_UL2.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); Temp_UL2.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_UL2.Table_Ref= ATTENTABLE_TEMP_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st)); break; case ULO_P3_ATT_Temp_guarantee_Table_Number://printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Temp_UL3.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); Temp_UL3.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_UL3.Table_Ref= ATTENTABLE_TEMP_REF; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL2_TABLE_ADDRESDS),&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL2_TABLE_ADDRESDS),&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st)); break; case ULO_P4_ATT_Temp_guarantee_Table_Number://printf("Function : %s Line %d \r\n",__func__,__LINE__); Bluecell_DataCopy(&Temp_UL4.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); Temp_UL4.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_UL4.Table_Ref= ATTENTABLE_TEMP_REF; EEPROM_M24C08_write((uint8_t)EEPROM_M24C08_ID ,(EEPROM_TEMP_UL3_TABLE_ADDRESDS),&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL3_TABLE_ADDRESDS),&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st)); break; } } //uint8_t tableTest[sizeof(DET_TABLEDL_st)] ={0,}; void MBIC_TableLoad(uint8_t* data,uint8_t type){ uint8_t tabletype = type; // OneByteToTwoByte data; // printf("%s : %x \r\n",__func__,tabletype); //INDEX :5 COpy Start data[MBIC_CMD_0] = 0xC0; if( data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] > 70) data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = 70; // printf("\r\ntabletype : %d \r\n",tabletype); 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Att_DL1.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Att_DL1.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Att_DL2.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Att_DL2.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Att_DL3.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Att_DL3.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Att_DL4.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Att_DL4.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Att_UL1.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Att_UL1.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Att_UL2.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Att_UL2.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Att_UL3.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Att_UL3.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Att_UL4.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Att_UL4.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Det_DL1.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Det_DL1.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Det_DL2.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Det_DL2.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Det_DL3.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Det_DL3.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Det_DL4.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Det_DL4.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Det_UL1.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Det_UL1.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Det_UL2.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Det_UL2.Table_Length; // printf("Det_UL2.Table_Length : %d \r\n",Det_UL2.Table_Length); 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Det_UL3.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Det_UL3.Table_Length; 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) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Det_UL4.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Det_UL4.Table_Length; break; case DLI_P1_ATT_Temp_guarantee_Table_Number: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Temp_DL1.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Temp_DL1.Table_Length; break; case DLI_P2_ATT_Temp_guarantee_Table_Number: MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Temp_DL2.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Temp_DL2.Table_Length; break; case DLI_P3_ATT_Temp_guarantee_Table_Number: MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Temp_DL3.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Temp_DL3.Table_Length; break; case DLI_P4_ATT_Temp_guarantee_Table_Number: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL3_TABLE_ADDRESDS),&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Temp_DL4.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Temp_DL4.Table_Length; break; case ULO_P1_ATT_Temp_guarantee_Table_Number: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Temp_UL1.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Temp_UL1.Table_Length; break; case ULO_P2_ATT_Temp_guarantee_Table_Number: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Temp_UL2.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Temp_UL2.Table_Length; break; case ULO_P3_ATT_Temp_guarantee_Table_Number: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL2_TABLE_ADDRESDS),&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Temp_UL3.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Temp_UL3.Table_Length; break; case ULO_P4_ATT_Temp_guarantee_Table_Number: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL3_TABLE_ADDRESDS),&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st) ); MBIC_TableDataCopy(&data[MBIC_PAYLOADSTART],&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st)); data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref] = Temp_UL4.Table_Ref; data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Temp_UL4.Table_Length; break; } // printf("\rLoad MBIC_TableIndex_Number : %x \r\n",data[MBIC_PAYLOADSTART + MBIC_TableIndex_Number]); } void MBIC_TableSave(uint8_t* data,uint8_t type){ uint8_t tabletype = type; // printf("%s : %x \r\n",__func__,tabletype); if( data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] > 70) data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = 70; // printf("data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] : %d \r\n",sizeof(ATT_TABLE_st) ); data[MBIC_CMD_0] = 0xC1; switch(tabletype){ case DLI_P1_ATT_Accuracy_Table_Number: Bluecell_DataCopy(&Att_DL1.Table_0_0_dBm,&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st) ); Att_DL1.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; // Check Att_DL1.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_BASE) ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) ); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case DLI_P2_ATT_Accuracy_Table_Number: Bluecell_DataCopy(&Att_DL2.Table_0_0_dBm,&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st) ); Att_DL2.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; // Check Att_DL2.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL1_TABLE_ADDRESDS),&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) ); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],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[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st) ); Att_DL3.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; // Check Att_DL3.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL2_TABLE_ADDRESDS),&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case DLI_P4_ATT_Accuracy_Table_Number: Bluecell_DataCopy(&Att_DL4.Table_0_0_dBm,&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st) ); Att_DL4.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; // Check Att_DL4.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL3_TABLE_ADDRESDS),&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case ULO_P1_ATT_Accuracy_Table_Number: Bluecell_DataCopy(&Att_UL1.Table_0_0_dBm,&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); Att_UL1.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; // Check Att_UL1.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL4_TABLE_ADDRESDS),&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case ULO_P2_ATT_Accuracy_Table_Number: Bluecell_DataCopy(&Att_UL2.Table_0_0_dBm,&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st) ); Att_UL2.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Att_UL2.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL1_TABLE_ADDRESDS),&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case ULO_P3_ATT_Accuracy_Table_Number: Bluecell_DataCopy(&Att_UL3.Table_0_0_dBm,&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st) ); Att_UL3.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; // Check Att_UL3.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL2_TABLE_ADDRESDS),&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case ULO_P4_ATT_Accuracy_Table_Number: Bluecell_DataCopy(&Att_UL4.Table_0_0_dBm,&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st) ); Att_UL4.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; // Check Att_UL4.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL3_TABLE_ADDRESDS),&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case DLI_P1_Level_Table_Number: Bluecell_DataCopy(&Det_DL1.Table_Det5_dBm_H,&data[MBIC_PAYLOADSTART + 5],sizeof(DET_TABLEDL_st)); Det_DL1.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; // Check Det_DL1.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; // printf("Det_DL1.Table_Ref : %d \r\n",Det_DL1.Table_Ref); // printf("Det_DL1.Table_Length : %d \r\n",Det_DL1.Table_Length); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL4_TABLE_ADDRESDS),&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); // EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL4_TABLE_ADDRESDS),tableTest,sizeof(DET_TABLEDL_st)); // for(int i = 0 ; i < sizeof(DET_TABLEDL_st); i++) // printf("tableTest : %x\r\n",tableTest[i]); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case DLI_P2_Level_Table_Number: Bluecell_DataCopy(&Det_DL2.Table_Det5_dBm_H,&data[MBIC_PAYLOADSTART + 5],sizeof(DET_TABLEDL_st)); Det_DL2.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; // Check Det_DL2.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL1_TABLE_ADDRESDS),&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case DLI_P3_Level_Table_Number: Bluecell_DataCopy(&Det_DL3.Table_Det5_dBm_H,&data[MBIC_PAYLOADSTART + 5],sizeof(DET_TABLEDL_st)); Det_DL3.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Det_DL3.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL2_TABLE_ADDRESDS),&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case DLI_P4_Level_Table_Number: Bluecell_DataCopy(&Det_DL4.Table_Det5_dBm_H,&data[MBIC_PAYLOADSTART + 5],sizeof(DET_TABLEDL_st)); Det_DL4.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Det_DL4.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL3_TABLE_ADDRESDS),&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case ULO_P1_Level_Table_Number: Bluecell_DataCopy(&Det_UL1.Table_Det_15_dBm_H,&data[MBIC_PAYLOADSTART + 5],sizeof(DET_TABLEUL_st)); Det_UL1.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Det_UL1.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL4_TABLE_ADDRESDS),&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case ULO_P2_Level_Table_Number: Bluecell_DataCopy(&Det_UL2.Table_Det_15_dBm_H,&data[MBIC_PAYLOADSTART + 5],sizeof(DET_TABLEUL_st)); Det_UL2.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Det_UL2.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL1_TABLE_ADDRESDS),&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case ULO_P3_Level_Table_Number: Bluecell_DataCopy(&Det_UL3.Table_Det_15_dBm_H,&data[MBIC_PAYLOADSTART + 5],sizeof(DET_TABLEUL_st)); Det_UL3.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Det_UL3.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL2_TABLE_ADDRESDS),&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case ULO_P4_Level_Table_Number: Bluecell_DataCopy(&Det_UL4.Table_Det_15_dBm_H,&data[MBIC_PAYLOADSTART + 5],sizeof(DET_TABLEUL_st)); Det_UL4.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Det_UL4.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL3_TABLE_ADDRESDS),&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case DLI_P1_ATT_Temp_guarantee_Table_Number: Bluecell_DataCopy(&Temp_DL1.Table_1_Temp,&data[MBIC_PAYLOADSTART + 5],sizeof(TEMP_TABLE_st) ); Temp_DL1.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Temp_DL1.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); // printf("Temp_DL1 Length : %d \r\n",data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]); break; case DLI_P2_ATT_Temp_guarantee_Table_Number: Bluecell_DataCopy(&Temp_DL2.Table_1_Temp,&data[MBIC_PAYLOADSTART + 5],sizeof(TEMP_TABLE_st) ); Temp_DL2.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Temp_DL2.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL1_TABLE_ADDRESDS),&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case DLI_P3_ATT_Temp_guarantee_Table_Number: Bluecell_DataCopy(&Temp_DL3.Table_1_Temp,&data[MBIC_PAYLOADSTART + 5],sizeof(TEMP_TABLE_st) ); Temp_DL3.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Temp_DL3.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case DLI_P4_ATT_Temp_guarantee_Table_Number: Bluecell_DataCopy(&Temp_DL4.Table_1_Temp,&data[MBIC_PAYLOADSTART + 5],sizeof(TEMP_TABLE_st) ); Temp_DL4.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Temp_DL4.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL3_TABLE_ADDRESDS),&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case ULO_P1_ATT_Temp_guarantee_Table_Number: Bluecell_DataCopy(&Temp_UL1.Table_1_Temp,&data[MBIC_PAYLOADSTART + 5],sizeof(TEMP_TABLE_st) ); Temp_UL1.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Temp_UL1.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case ULO_P2_ATT_Temp_guarantee_Table_Number: Bluecell_DataCopy(&Temp_UL2.Table_1_Temp,&data[MBIC_PAYLOADSTART + 5],sizeof(TEMP_TABLE_st) ); Temp_UL2.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Temp_UL2.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case ULO_P3_ATT_Temp_guarantee_Table_Number: Bluecell_DataCopy(&Temp_UL3.Table_1_Temp,&data[MBIC_PAYLOADSTART + 5],sizeof(TEMP_TABLE_st) ); Temp_UL3.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Temp_UL3.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; // printf("Temp_UL3.Table_Length : %d \r\n",Temp_UL3.Table_Length); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL2_TABLE_ADDRESDS),&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; case ULO_P4_ATT_Temp_guarantee_Table_Number: Bluecell_DataCopy(&Temp_UL4.Table_1_Temp,&data[MBIC_PAYLOADSTART + 5],sizeof(TEMP_TABLE_st)); Temp_UL4.Table_Ref = data[MBIC_PAYLOADSTART + MBIC_TableIndex_Ref]; Temp_UL4.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]; EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL3_TABLE_ADDRESDS),&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st)); MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st)); break; } // printf("\rSetting MBIC_TableIndex_Number : %x \r\n",data[MBIC_PAYLOADSTART + MBIC_TableIndex_Number]); } void Table_LengSet(){ Att_DL1.Table_Ref = ATTENTABLEDL_REF; Att_DL2.Table_Ref = ATTENTABLEDL_REF; Att_DL3.Table_Ref = ATTENTABLEDL_REF; Att_DL4.Table_Ref = ATTENTABLEDL_REF; Att_UL1.Table_Ref = ATTENTABLEUL_REF; Att_UL2.Table_Ref = ATTENTABLEUL_REF; Att_UL3.Table_Ref = ATTENTABLEUL_REF; Att_UL4.Table_Ref = ATTENTABLEUL_REF; Det_DL1.Table_Ref = ATTENTABLEDET_DL_REF; Det_DL2.Table_Ref = ATTENTABLEDET_DL_REF; Det_DL3.Table_Ref = ATTENTABLEDET_DL_REF; Det_DL4.Table_Ref = ATTENTABLEDET_DL_REF; Det_UL1.Table_Ref = ATTENTABLEDET_UL_REF; Det_UL2.Table_Ref = ATTENTABLEDET_UL_REF; Det_UL3.Table_Ref = ATTENTABLEDET_UL_REF; Det_UL4.Table_Ref = ATTENTABLEDET_UL_REF; Temp_DL1.Table_Ref= ATTENTABLE_TEMP_REF; Temp_DL2.Table_Ref= ATTENTABLE_TEMP_REF; Temp_DL3.Table_Ref= ATTENTABLE_TEMP_REF; Temp_DL4.Table_Ref= ATTENTABLE_TEMP_REF; Temp_UL1.Table_Ref= ATTENTABLE_TEMP_REF; Temp_UL2.Table_Ref= ATTENTABLE_TEMP_REF; Temp_UL3.Table_Ref= ATTENTABLE_TEMP_REF; Temp_UL4.Table_Ref= ATTENTABLE_TEMP_REF; Att_DL1.Table_Length = ATTENTABLEDLUL_LENGTH; Att_DL2.Table_Length = ATTENTABLEDLUL_LENGTH; Att_DL3.Table_Length = ATTENTABLEDLUL_LENGTH; Att_DL4.Table_Length = ATTENTABLEDLUL_LENGTH; Att_UL1.Table_Length = ATTENTABLEDLUL_LENGTH; Att_UL2.Table_Length = ATTENTABLEDLUL_LENGTH; Att_UL3.Table_Length = ATTENTABLEDLUL_LENGTH; Att_UL4.Table_Length = ATTENTABLEDLUL_LENGTH; Det_DL1.Table_Length = ATTENTABLEDET_DL_LENGTH; Det_DL2.Table_Length = ATTENTABLEDET_DL_LENGTH; Det_DL3.Table_Length = ATTENTABLEDET_DL_LENGTH; Det_DL4.Table_Length = ATTENTABLEDET_DL_LENGTH; Det_UL1.Table_Length = ATTENTABLEDET_UL_LENGTH; Det_UL2.Table_Length = ATTENTABLEDET_UL_LENGTH; Det_UL3.Table_Length = ATTENTABLEDET_UL_LENGTH; Det_UL4.Table_Length = ATTENTABLEDET_UL_LENGTH; Temp_DL1.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_DL2.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_DL3.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_DL4.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_UL1.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_UL2.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_UL3.Table_Length= ATTENTABLE_TEMP_LENGTH; Temp_UL4.Table_Length= ATTENTABLE_TEMP_LENGTH; EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_BASE ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_DL1_TABLE_ADDRESDS,&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_DL2_TABLE_ADDRESDS,&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_DL3_TABLE_ADDRESDS,&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_DL4_TABLE_ADDRESDS,&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_UL1_TABLE_ADDRESDS,&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_UL2_TABLE_ADDRESDS,&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_UL3_TABLE_ADDRESDS,&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_UL4_TABLE_ADDRESDS,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL1_TABLE_ADDRESDS,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL2_TABLE_ADDRESDS,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL3_TABLE_ADDRESDS,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL4_TABLE_ADDRESDS,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL1_TABLE_ADDRESDS,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL2_TABLE_ADDRESDS,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL3_TABLE_ADDRESDS,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL4_TABLE_ADDRESDS,&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_DL1_TABLE_ADDRESDS,&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_DL2_TABLE_ADDRESDS,&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_DL3_TABLE_ADDRESDS,&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_DL4_TABLE_ADDRESDS,&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_UL1_TABLE_ADDRESDS,&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_UL2_TABLE_ADDRESDS,&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) ); EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_UL3_TABLE_ADDRESDS,&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st) ); } typedef enum{ ATT_DL_PATH1, ATT_DL_PATH2, ATT_DL_PATH3, ATT_DL_PATH4, ATT_UL_PATH1, ATT_UL_PATH2, ATT_UL_PATH3, ATT_UL_PATH4, }; typedef enum{ ATT_DL_ShutdownCnt1, ATT_DL_ShutdownCnt2, ATT_DL_ShutdownCnt3, ATT_DL_ShutdownCnt4, ATT_UL_ShutdownCnt1, ATT_UL_ShutdownCnt2, ATT_UL_ShutdownCnt3, ATT_UL_ShutdownCnt4, }; void Path_Ctrl(uint8_t onoff,uint8_t* Status){ if(onoff == true){ DL_Path_OnOff(Path1_OnOff, onoff, &bluecell_Currdatastatus.ATT_DL1_PATH, &bluecell_Prevdatastatus.ATT_DL1_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count1); DL_Path_OnOff(Path2_OnOff, onoff, &bluecell_Currdatastatus.ATT_DL2_PATH, &bluecell_Prevdatastatus.ATT_DL2_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count2); DL_Path_OnOff(Path3_OnOff, onoff, &bluecell_Currdatastatus.ATT_DL3_PATH, &bluecell_Prevdatastatus.ATT_DL3_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count3); DL_Path_OnOff(Path4_OnOff, onoff, &bluecell_Currdatastatus.ATT_DL4_PATH, &bluecell_Prevdatastatus.ATT_DL4_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count4); UL_Path_OnOff(Path1_OnOff, onoff, &bluecell_Currdatastatus.ATT_UL1_PATH, &bluecell_Prevdatastatus.ATT_UL1_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count1); UL_Path_OnOff(Path2_OnOff, onoff, &bluecell_Currdatastatus.ATT_UL2_PATH, &bluecell_Prevdatastatus.ATT_UL2_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count2); UL_Path_OnOff(Path3_OnOff, onoff, &bluecell_Currdatastatus.ATT_UL3_PATH, &bluecell_Prevdatastatus.ATT_UL3_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count3); UL_Path_OnOff(Path4_OnOff, onoff, &bluecell_Currdatastatus.ATT_UL4_PATH, &bluecell_Prevdatastatus.ATT_UL4_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count4); }else{ DL_Path_OnOff(Path1_OnOff, Status[ATT_DL_PATH1], &bluecell_Currdatastatus.ATT_DL1_PATH, &bluecell_Prevdatastatus.ATT_DL1_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count1); DL_Path_OnOff(Path2_OnOff, Status[ATT_DL_PATH2], &bluecell_Currdatastatus.ATT_DL2_PATH, &bluecell_Prevdatastatus.ATT_DL2_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count2); DL_Path_OnOff(Path3_OnOff, Status[ATT_DL_PATH3], &bluecell_Currdatastatus.ATT_DL3_PATH, &bluecell_Prevdatastatus.ATT_DL3_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count3); DL_Path_OnOff(Path4_OnOff, Status[ATT_DL_PATH4], &bluecell_Currdatastatus.ATT_DL4_PATH, &bluecell_Prevdatastatus.ATT_DL4_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count4); UL_Path_OnOff(Path1_OnOff, Status[ATT_UL_PATH1], &bluecell_Currdatastatus.ATT_UL1_PATH, &bluecell_Prevdatastatus.ATT_UL1_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count1); UL_Path_OnOff(Path2_OnOff, Status[ATT_UL_PATH2], &bluecell_Currdatastatus.ATT_UL2_PATH, &bluecell_Prevdatastatus.ATT_UL2_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count2); UL_Path_OnOff(Path3_OnOff, Status[ATT_UL_PATH3], &bluecell_Currdatastatus.ATT_UL3_PATH, &bluecell_Prevdatastatus.ATT_UL3_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count3); UL_Path_OnOff(Path4_OnOff, Status[ATT_UL_PATH4], &bluecell_Currdatastatus.ATT_UL4_PATH, &bluecell_Prevdatastatus.ATT_UL4_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count4); } } uint8_t Prev_PathStatus[8]; uint8_t Prev_ShutdownCnt[8]; void SelfTest_Operate(uint8_t onoff){ // Carrier_ONOFF(bluecell_Currdatastatus.Carrier_ON_OFF); SelfTest_Ctrl(SelfTest1, onoff, &bluecell_Currdatastatus.SelfTest, &bluecell_Currdatastatus.ATT_DL1_H, &bluecell_Currdatastatus.ATT_UL1_H, &bluecell_Currdatastatus.SelfTest_ATT_DL1_H, &bluecell_Currdatastatus.SelfTest_ATT_UL1_H, &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H, &bluecell_Currdatastatus.Prev_ATT_ALC1_H); SelfTest_Ctrl(SelfTest2,onoff, &bluecell_Currdatastatus.SelfTest, &bluecell_Currdatastatus.ATT_DL2_H, &bluecell_Currdatastatus.ATT_UL2_H, &bluecell_Currdatastatus.SelfTest_ATT_DL2_H, &bluecell_Currdatastatus.SelfTest_ATT_UL2_H, &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H, &bluecell_Currdatastatus.Prev_ATT_ALC2_H); SelfTest_Ctrl(SelfTest3, onoff, &bluecell_Currdatastatus.SelfTest, &bluecell_Currdatastatus.ATT_DL3_H, &bluecell_Currdatastatus.ATT_UL3_H, &bluecell_Currdatastatus.SelfTest_ATT_DL3_H, &bluecell_Currdatastatus.SelfTest_ATT_UL3_H, &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H, &bluecell_Currdatastatus.Prev_ATT_ALC3_H); SelfTest_Ctrl(SelfTest4,onoff, &bluecell_Currdatastatus.SelfTest, &bluecell_Currdatastatus.ATT_DL4_H, &bluecell_Currdatastatus.ATT_UL4_H, &bluecell_Currdatastatus.SelfTest_ATT_DL4_H, &bluecell_Currdatastatus.SelfTest_ATT_UL4_H, &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H, &bluecell_Currdatastatus.Prev_ATT_ALC4_H); HAL_Delay(500);/*HFR Request List*/ if(onoff == true){ Prev_ALC_OnOff = bluecell_Currdatastatus.ULO_ALC_ON_OFF; Prev_AGC_OnOff = bluecell_Currdatastatus.DLI_AGC_ON_OFF; Prev_DL_Shutdown_OnOff = bluecell_Currdatastatus.DLI_Shutdown_ON_OFF; Prev_UL_Shutdown_OnOff = bluecell_Currdatastatus.ULO_Shutdown_ON_OFF; bluecell_Currdatastatus.DLI_AGC_ON_OFF = false; bluecell_Currdatastatus.ULO_ALC_ON_OFF = false; bluecell_Currdatastatus.DLI_Shutdown_ON_OFF = false; bluecell_Currdatastatus.ULO_Shutdown_ON_OFF = false; Prev_PathStatus[ATT_DL_PATH1] = bluecell_Currdatastatus.ATT_DL1_PATH; Prev_PathStatus[ATT_DL_PATH2] = bluecell_Currdatastatus.ATT_DL2_PATH; Prev_PathStatus[ATT_DL_PATH3] = bluecell_Currdatastatus.ATT_DL3_PATH; Prev_PathStatus[ATT_DL_PATH4] = bluecell_Currdatastatus.ATT_DL4_PATH; Prev_PathStatus[ATT_UL_PATH1] = bluecell_Currdatastatus.ATT_UL1_PATH; Prev_PathStatus[ATT_UL_PATH2] = bluecell_Currdatastatus.ATT_UL2_PATH; Prev_PathStatus[ATT_UL_PATH3] = bluecell_Currdatastatus.ATT_UL3_PATH; Prev_PathStatus[ATT_UL_PATH4] = bluecell_Currdatastatus.ATT_UL4_PATH; // bluecell_Currdatastatus.Carrier_ON_OFF = onoff; // printf("ALC AGC OFF\r\n"); } else{ bluecell_Currdatastatus.ULO_ALC_ON_OFF = Prev_ALC_OnOff; bluecell_Currdatastatus.DLI_AGC_ON_OFF = Prev_AGC_OnOff; bluecell_Currdatastatus.DLI_Shutdown_ON_OFF = Prev_DL_Shutdown_OnOff; bluecell_Currdatastatus.ULO_Shutdown_ON_OFF = Prev_UL_Shutdown_OnOff; bluecell_Currdatastatus.ATT_DL1_PATH = Prev_PathStatus[ATT_DL_PATH1]; bluecell_Currdatastatus.ATT_DL2_PATH = Prev_PathStatus[ATT_DL_PATH2]; bluecell_Currdatastatus.ATT_DL3_PATH = Prev_PathStatus[ATT_DL_PATH3]; bluecell_Currdatastatus.ATT_DL4_PATH = Prev_PathStatus[ATT_DL_PATH4]; bluecell_Currdatastatus.ATT_UL1_PATH = Prev_PathStatus[ATT_UL_PATH1]; bluecell_Currdatastatus.ATT_UL2_PATH = Prev_PathStatus[ATT_UL_PATH2]; bluecell_Currdatastatus.ATT_UL3_PATH = Prev_PathStatus[ATT_UL_PATH3]; bluecell_Currdatastatus.ATT_UL4_PATH = Prev_PathStatus[ATT_UL_PATH4]; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 = Prev_ShutdownCnt[ATT_DL_ShutdownCnt1]; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 = Prev_ShutdownCnt[ATT_DL_ShutdownCnt2]; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = Prev_ShutdownCnt[ATT_DL_ShutdownCnt3]; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 = Prev_ShutdownCnt[ATT_DL_ShutdownCnt4]; bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1 = Prev_ShutdownCnt[ATT_UL_ShutdownCnt1]; bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2 = Prev_ShutdownCnt[ATT_UL_ShutdownCnt2]; bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3 = Prev_ShutdownCnt[ATT_UL_ShutdownCnt3]; bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 = Prev_ShutdownCnt[ATT_UL_ShutdownCnt4]; } Path_Ctrl(onoff,&Prev_PathStatus); } bool Bluecell_Operate(uint8_t* data){ uint8_t datatype = data[BLUECELL_TYPE]; //double ret = 0 ,tmp = 0.1; int16_t tempdata = 0; int16_t CurrAtten = 0; int16_t ALC_TEMP[4] ={0,}; int16_t Tmpdata = 0 ,Tmpdata2 = 0; double tmpedata2 = 0; uint8_t i = 0; uint16_t Crcret = 0; uint16_t Length = 0; switch(datatype){ case BLUECELL_SOFTWARERESET: // for(int i = 0; i < 20; i++){ // printf("%02x ",data[i]); // } printf("Bluecell Reset \r\n"); // Table_Init(); Table_LengSet(); // Table_LengSet(); 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); CurrAtten = bluecell_Currdatastatus.ATT_DL1_H << 8 | bluecell_Currdatastatus.ATT_DL1_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); DL_PrevIwillgiveAtten[AGC_Alarm_DL1_Index] = 0; /* 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++]; // printf("bluecell_Currdatastatus.ATT_DL2_H : %x\r\n",bluecell_Currdatastatus.ATT_DL2_H); // printf("bluecell_Currdatastatus.ATT_DL2_L : %x\r\n",bluecell_Currdatastatus.ATT_DL2_L); CurrAtten = bluecell_Currdatastatus.ATT_DL2_H << 8 | bluecell_Currdatastatus.ATT_DL2_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); DL_PrevIwillgiveAtten[AGC_Alarm_DL2_Index] = 0; /* 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++]; CurrAtten = bluecell_Currdatastatus.ATT_DL3_H << 8 | bluecell_Currdatastatus.ATT_DL3_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); DL_PrevIwillgiveAtten[AGC_Alarm_DL3_Index] = 0; /* 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++]; CurrAtten = bluecell_Currdatastatus.ATT_DL4_H << 8 | bluecell_Currdatastatus.ATT_DL4_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); DL_PrevIwillgiveAtten[AGC_Alarm_DL4_Index] = 0; /* Atten Ctrl Function */ CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case Bluecell_ATT_UL1 : #if 0 // PYJ.2020.12.22_BEGIN -- bluecell_Currdatastatus.ATT_UL1_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL1_L =data[BLUECELL_DATA + i++]; if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){ Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L; Tmpdata2 = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L; if(Tmpdata + Tmpdata2 <= -200){ Tmpdata2 = -200 + (Tmpdata * -1); bluecell_Currdatastatus.ATT_UL1_H = ((Tmpdata2 & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL1_L = Tmpdata2 & 0x00FF; } UL_ALC_GainAttenSet[ALC_Alarm_UL1_Index] = true; ALC_Level_Save[ALC_Alarm_UL1_Index] = bluecell_Currdatastatus.ULO_Level1_H << 8 | bluecell_Currdatastatus.ULO_Level1_L; } CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); #else if(bluecell_Currdatastatus.SelfTest == true)break; bluecell_Currdatastatus.ATT_UL1_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL1_L = data[BLUECELL_DATA + i++]; Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L; Tmpdata2 = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L; // printf("ALC Atten : %d /// UL Atten : %d \r\n",Tmpdata,Tmpdata2); if(Tmpdata + Tmpdata2 <= -200){ Tmpdata2 = -200 + (Tmpdata * -1); bluecell_Currdatastatus.ATT_UL1_H = ((Tmpdata2 & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL1_L = Tmpdata2 & 0x00FF; } UL_ALC_GainAttenSet[ALC_Alarm_UL1_Index] = true; ALC_Level_Save[ALC_Alarm_UL1_Index] = bluecell_Currdatastatus.ULO_Level1_H << 8 | bluecell_Currdatastatus.ULO_Level1_L; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); #endif // PYJ.2020.12.22_END -- // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); /* Atten Ctrl Function */ ALCTimerCnt = 0; // 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++]; // if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){ Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L; Tmpdata2 = bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L; if(Tmpdata + Tmpdata2 <= -200){ Tmpdata2 = -200 + (Tmpdata * -1); bluecell_Currdatastatus.ATT_UL2_H = ((Tmpdata2 & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL2_L = Tmpdata2 & 0x00FF; } UL_ALC_GainAttenSet[ALC_Alarm_UL2_Index] = true; ALC_Level_Save[ALC_Alarm_UL2_Index] = bluecell_Currdatastatus.ULO_Level2_H << 8 | bluecell_Currdatastatus.ULO_Level2_L; // } // CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); /* Atten Ctrl Function */ CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); ALCTimerCnt = 0; break; case Bluecell_ATT_UL3 : bluecell_Currdatastatus.ATT_UL3_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL3_L = data[BLUECELL_DATA + i++]; // if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){ Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L; Tmpdata2 = bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L; if(Tmpdata + Tmpdata2 <= -200){ Tmpdata2 = -200 + (Tmpdata * -2); bluecell_Currdatastatus.ATT_UL3_H = ((Tmpdata2 & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL3_L = Tmpdata2 & 0x00FF; } UL_ALC_GainAttenSet[ALC_Alarm_UL3_Index] = true; ALC_Level_Save[ALC_Alarm_UL3_Index] = bluecell_Currdatastatus.ULO_Level3_H << 8 | bluecell_Currdatastatus.ULO_Level3_L; // } // CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); /* Atten Ctrl Function */ CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); ALCTimerCnt = 0; break; case Bluecell_ATT_UL4 : bluecell_Currdatastatus.ATT_UL4_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL4_L = data[BLUECELL_DATA + i++]; // if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){ Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L; Tmpdata2 = bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L; if(Tmpdata + Tmpdata2 <= -200){ Tmpdata2 = -200 + (Tmpdata * -2); bluecell_Currdatastatus.ATT_UL4_H = ((Tmpdata2 & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL4_L = Tmpdata2 & 0x00FF; } UL_ALC_GainAttenSet[ALC_Alarm_UL4_Index] = true; ALC_Level_Save[ALC_Alarm_UL4_Index] = bluecell_Currdatastatus.ULO_Level4_H << 8 | bluecell_Currdatastatus.ULO_Level4_L; // } // CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); ALCTimerCnt = 0; /* Atten Ctrl Function */ CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); // printf("ret : %f ,tmp %f \r\n",ret,tmp ); break; case ATT_DL1_PATH : // printf("DL PATH 1 : %d \r\n",data[BLUECELL_DATA]); if(bluecell_Currdatastatus.Carrier_ON_OFF == false) return true; if(data[BLUECELL_DATA] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x80; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x80; DL_Path_OnOff(Path1_OnOff, data[BLUECELL_DATA], &bluecell_Currdatastatus.ATT_DL1_PATH, &bluecell_Prevdatastatus.ATT_DL1_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count1) ; break; case ATT_UL1_PATH : if(bluecell_Currdatastatus.Carrier_ON_OFF == false) return true; if(data[BLUECELL_DATA] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x08; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x08; // printf("%d : bluecell_Currdatastatus.Path_TempSave_Bit : %x \r\n",data[BLUECELL_DATA], bluecell_Currdatastatus.Path_TempSave_Bit); UL_Path_OnOff(Path1_OnOff, data[BLUECELL_DATA], &bluecell_Currdatastatus.ATT_UL1_PATH, &bluecell_Prevdatastatus.ATT_UL1_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count1) ; bluecell_Currdatastatus.ATT_UL1_PATH = data[BLUECELL_DATA]; // printf("Function : %s Line %d \r\n",__func__,__LINE__); break; case ATT_SelfTest : SelfTest_Operate(data[BLUECELL_DATA]); // printf("bluecell_Currdatastatus.SelfTest : %d \r\n",bluecell_Currdatastatus.SelfTest); break; case Bluecell_Path1_GainValue: bluecell_Currdatastatus.Path1_GainValue = data[BLUECELL_DATA + 1]; // printf("Path1 Setting %d \r\n",bluecell_Currdatastatus.Path1_GainValue); break; case Bluecell_Path2_GainValue: bluecell_Currdatastatus.Path2_GainValue = data[BLUECELL_DATA + 1]; break; case Bluecell_Path3_GainValue: bluecell_Currdatastatus.Path3_GainValue = data[BLUECELL_DATA + 1]; break; case Bluecell_Path4_GainValue: bluecell_Currdatastatus.Path4_GainValue = data[BLUECELL_DATA + 1]; break; case ATT_DL2_PATH : if(bluecell_Currdatastatus.Carrier_ON_OFF == false) return true; if(data[BLUECELL_DATA] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x40; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x40; // printf("%d : bluecell_Currdatastatus.Path_TempSave_Bit : %x \r\n",data[BLUECELL_DATA], bluecell_Currdatastatus.Path_TempSave_Bit); DL_Path_OnOff(Path2_OnOff, data[BLUECELL_DATA], &bluecell_Currdatastatus.ATT_DL2_PATH, &bluecell_Prevdatastatus.ATT_DL2_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count2) ; break; break; case ATT_UL2_PATH : if(bluecell_Currdatastatus.Carrier_ON_OFF == false) return true; if(data[BLUECELL_DATA] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x04; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x04; // printf("%d : bluecell_Currdatastatus.Path_TempSave_Bit : %x \r\n",data[BLUECELL_DATA], bluecell_Currdatastatus.Path_TempSave_Bit); UL_Path_OnOff(Path2_OnOff, data[BLUECELL_DATA], &bluecell_Currdatastatus.ATT_UL2_PATH, &bluecell_Prevdatastatus.ATT_UL2_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count2) ; break; #if 0 // PYJ.2020.09.03_BEGIN -- case ATT_SelfTest2 : SelfTest_Ctrl(SelfTest2,data[BLUECELL_DATA],&bluecell_Currdatastatus.Selftest2,&bluecell_Currdatastatus.ATT_DL2_H,&bluecell_Currdatastatus.ATT_UL2_H); break; #endif // PYJ.2020.09.03_END -- case ATT_DL3_PATH : #if 0 // PYJ.2020.07.03_BEGIN -- bluecell_Currdatastatus.ATT_DL3_PATH = data[BLUECELL_DATA]; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = 0; bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count3 = 0xFF; if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin,GPIO_PIN_RESET);//CLOCK DL_PathUserHandl[2] = true; } else{ bluecell_Prevdatastatus.ATT_DL3_H = 0xFF; bluecell_Prevdatastatus.ATT_DL3_L =0xFF; DL_PathUserHandl[2] = false; HAL_GPIO_WritePin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin,GPIO_PIN_SET);//CLOCK } CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); #else if(bluecell_Currdatastatus.Carrier_ON_OFF == false) return true; if(data[BLUECELL_DATA] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x20; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x20; // printf("%d : bluecell_Currdatastatus.Path_TempSave_Bit : %x \r\n",data[BLUECELL_DATA], bluecell_Currdatastatus.Path_TempSave_Bit); DL_Path_OnOff(Path3_OnOff, data[BLUECELL_DATA], &bluecell_Currdatastatus.ATT_DL3_PATH, &bluecell_Prevdatastatus.ATT_DL3_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count3) ; #endif // PYJ.2020.07.03_END -- break; case ATT_UL3_PATH : #if 0 // PYJ.2020.07.03_BEGIN -- if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(PATH_EN_UL3_GPIO_Port,PATH_EN_UL3_Pin,GPIO_PIN_RESET);//CLOCK bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3 = 0; } else{ HAL_GPIO_WritePin(PATH_EN_UL3_GPIO_Port,PATH_EN_UL3_Pin,GPIO_PIN_SET);//CLOCK bluecell_Prevdatastatus.ATT_UL3_H = 0xFF; bluecell_Prevdatastatus.ATT_UL3_L =0xFF; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); } bluecell_Currdatastatus.ATT_UL3_PATH = data[BLUECELL_DATA]; #else if(bluecell_Currdatastatus.Carrier_ON_OFF == false) return true; if(data[BLUECELL_DATA] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x02; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x02; // printf("%d : bluecell_Currdatastatus.Path_TempSave_Bit : %x \r\n",data[BLUECELL_DATA], bluecell_Currdatastatus.Path_TempSave_Bit); UL_Path_OnOff(Path3_OnOff, data[BLUECELL_DATA], &bluecell_Currdatastatus.ATT_UL3_PATH, &bluecell_Prevdatastatus.ATT_UL3_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count3) ; #endif // PYJ.2020.07.03_END -- break; #if 0 // PYJ.2020.09.03_BEGIN -- case ATT_SelfTest3 : SelfTest_Ctrl(SelfTest3,data[BLUECELL_DATA],&bluecell_Currdatastatus.Selftest3,&bluecell_Currdatastatus.ATT_DL3_H,&bluecell_Currdatastatus.ATT_UL3_H); break; #endif // PYJ.2020.09.03_END -- case ATT_DL4_PATH : if(bluecell_Currdatastatus.Carrier_ON_OFF == false) return true; if(data[BLUECELL_DATA] != 0){ bluecell_Currdatastatus.Path_TempSave_Bit |= 0x10; } else{ bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x10; } // printf("data[BLUECELL_DATA] : %d \r\n",data[BLUECELL_DATA]); // printf("3.bluecell_Currdatastatus.Path_TempSave_Bit : %x \r\n",bluecell_Currdatastatus.Path_TempSave_Bit); DL_Path_OnOff(Path4_OnOff, data[BLUECELL_DATA], &bluecell_Currdatastatus.ATT_DL4_PATH, &bluecell_Prevdatastatus.ATT_DL4_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count4) ; break; case ATT_UL4_PATH: #if 0 // PYJ.2020.07.03_BEGIN -- bluecell_Currdatastatus.ATT_UL4_PATH = data[BLUECELL_DATA]; printf("PATH : %d \r\n",bluecell_Currdatastatus.ATT_UL4_PATH); bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 = 0; bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count4 = 0xFF; if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(PATH_EN_UL4_GPIO_Port,PATH_EN_UL4_Pin,GPIO_PIN_RESET);//CLOCK UL_PathUserHandl[3] = true; } else{ bluecell_Prevdatastatus.ATT_UL4_H = 0xFF; bluecell_Prevdatastatus.ATT_UL4_L =0xFF; UL_PathUserHandl[3] = false; HAL_GPIO_WritePin(PATH_EN_UL4_GPIO_Port,PATH_EN_UL4_Pin,GPIO_PIN_SET);//CLOCK } CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); #else if(bluecell_Currdatastatus.Carrier_ON_OFF == false) return true; if(data[BLUECELL_DATA] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x01; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x01; // printf("%d : bluecell_Currdatastatus.Path_TempSave_Bit : %x \r\n",data[BLUECELL_DATA], bluecell_Currdatastatus.Path_TempSave_Bit); UL_Path_OnOff(Path4_OnOff, data[BLUECELL_DATA], &bluecell_Currdatastatus.ATT_UL4_PATH, &bluecell_Prevdatastatus.ATT_UL4_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count4) ; #endif // PYJ.2020.07.03_END -- // printf("Function : %s Line %d \r\n",__func__,__LINE__); break; #if 0 // PYJ.2020.09.03_BEGIN -- case ATT_SelfTest4 : SelfTest_Ctrl(SelfTest4,data[BLUECELL_DATA],&bluecell_Currdatastatus.Selftest4,&bluecell_Currdatastatus.ATT_DL4_H,&bluecell_Currdatastatus.ATT_UL4_H); break; #endif // PYJ.2020.09.03_END -- case ATT_TableSet: Bluecell_TableSave(data, data[BLUECELL_DATA]); Bluecell_TableLoad(data, data[BLUECELL_DATA]); data[BLUECELL_TYPE] = ATT_TableGet; Crcret = CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH_L]); data[data[BLUECELL_LENGTH_L] + 1] = ((Crcret & 0xFF00) >> 8); data[data[BLUECELL_LENGTH_L] + 2] = (Crcret & 0x00FF); data[data[BLUECELL_LENGTH_L] + 3] = 0xEB; Bluecell_StructCpy(&Txdata[0],&data[0],data[BLUECELL_LENGTH_L] + 4); Uart1_Data_Send(&Txdata[0], Txdata[BLUECELL_LENGTH_L] + 4); break; case ATT_TableGet: Bluecell_TableLoad(data, data[BLUECELL_DATA]); data[BLUECELL_TYPE] = ATT_TableGet; Crcret = CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH_L]); data[data[BLUECELL_LENGTH_L] + 1] = ((Crcret & 0xFF00) >> 8); data[data[BLUECELL_LENGTH_L] + 2] = (Crcret & 0x00FF); data[data[BLUECELL_LENGTH_L] + 3] = 0xEB; Bluecell_StructCpy(&Txdata[0],&data[0],data[BLUECELL_LENGTH_L] + 4); Uart1_Data_Send(&Txdata[0], Txdata[BLUECELL_LENGTH_L] + 4); #if 0 // PYJ.2020.04.22_BEGIN -- for(int i = 0 ; i < data[BLUECELL_LENGTH_L] + 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_L] + 6 : %d\r\n",data[0],data[BLUECELL_LENGTH_L] + 6); break; case Bluecell_StatusReq: if(Initialize == false){ // printf("Atten Init \r\n"); Bluecell_DataInit(); HAL_Delay(10); Bluecell_AttenInitialize(); Initialize = true; } DataStatusSet(); #if 0 // PYJ.2020.05.28_BEGIN -- Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,94); Txdata[BLUECELL_LENGTH_L] = 94 - 3;//sizeof(BLUESTATUS_st) - 3; Txdata[94 - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH_L]); #else // printf("bluecell_Currdatastatus.DLI_Level_High_Threshold_H : %x \r\n",bluecell_Currdatastatus.DLI_Level_High_Threshold_H); // printf("bluecell_Currdatastatus.DLI_Level_High_Threshold_L : %x \r\n",bluecell_Currdatastatus.DLI_Level_High_Threshold_L); // printf("bluecell_Currdatastatus.ATT_UL4_L : %0x \r\n",bluecell_Currdatastatus.ATT_UL4_L); Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st)); Txdata[BLUECELL_LENGTH_L] = sizeof(BLUESTATUS_st) - 3;//sizeof(BLUESTATUS_st) - 3; // Txdata[sizeof(BLUESTATUS_st) - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH_L]); Length = sizeof(BLUESTATUS_st) - 4; Txdata[BLUECELL_LENGTH_H] = ((Length & 0xFF00) >> 8); Txdata[BLUECELL_LENGTH_L] = ((Length & 0x00FF)); Crcret = ((CRC16_Generate(&Txdata[BLUECELL_TYPE], Length) )); Txdata[sizeof(BLUESTATUS_st) - 3] = ((Crcret & 0xFF00) >> 8 ); Txdata[sizeof(BLUESTATUS_st) - 2] = ((Crcret & 0x00FF)); #endif // PYJ.2020.05.28_END -- Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st)); 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\r\n Reset Start \r\n"); 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++]; CurrAtten = bluecell_Currdatastatus.bluecell_User_DL1_H << 8 | bluecell_Currdatastatus.bluecell_User_DL1_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); 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++]; CurrAtten = bluecell_Currdatastatus.bluecell_User_DL2_H << 8 | bluecell_Currdatastatus.bluecell_User_DL2_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); 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++]; CurrAtten = bluecell_Currdatastatus.bluecell_User_DL3_H << 8 | bluecell_Currdatastatus.bluecell_User_DL3_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); 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++]; CurrAtten = bluecell_Currdatastatus.bluecell_User_DL4_H << 8 | bluecell_Currdatastatus.bluecell_User_DL4_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); 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++]; CurrAtten = bluecell_Currdatastatus.bluecell_User_UL1_H << 8 | bluecell_Currdatastatus.bluecell_User_UL1_L; if(CurrAtten >= 0 ) CurrAtten = bluecell_Currdatastatus.bluecell_User_UL1_H = bluecell_Currdatastatus.bluecell_User_UL1_L = 0; else if(CurrAtten <= -50 ) CurrAtten = - 50; bluecell_Currdatastatus.bluecell_User_UL1_H = (CurrAtten & 0xFF00) >> 8; bluecell_Currdatastatus.bluecell_User_UL1_L = CurrAtten & 0x00FF; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); 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++]; CurrAtten = bluecell_Currdatastatus.bluecell_User_UL2_H << 8 | bluecell_Currdatastatus.bluecell_User_UL2_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); if(CurrAtten >= 0 ) CurrAtten = bluecell_Currdatastatus.bluecell_User_UL2_H = bluecell_Currdatastatus.bluecell_User_UL2_L = 0; else if(CurrAtten <= -50 ) CurrAtten = - 50; 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++]; CurrAtten = bluecell_Currdatastatus.bluecell_User_UL3_H << 8 | bluecell_Currdatastatus.bluecell_User_UL3_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); if(CurrAtten >= 0 ) CurrAtten = bluecell_Currdatastatus.bluecell_User_UL3_H = bluecell_Currdatastatus.bluecell_User_UL3_L = 0; else if(CurrAtten <= -50 ) CurrAtten = - 50; 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++]; CurrAtten = bluecell_Currdatastatus.bluecell_User_UL4_H << 8 | bluecell_Currdatastatus.bluecell_User_UL4_L; if(CurrAtten >= 0 ) CurrAtten = bluecell_Currdatastatus.bluecell_User_UL4_H = bluecell_Currdatastatus.bluecell_User_UL4_L = 0; else if(CurrAtten <= -50 ) CurrAtten = - 50; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); 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]; if( bluecell_Currdatastatus.DLI_AGC_ON_OFF == false){ AGC_AlarmSet[AGC_Alarm_DL1_Index] = false; AGC_AlarmSet[AGC_Alarm_DL2_Index] = false; AGC_AlarmSet[AGC_Alarm_DL3_Index] = false; AGC_AlarmSet[AGC_Alarm_DL4_Index] = false; bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm = 0; } DL_AGC_StartAtten[AGC_Alarm_DL1_Index] = bluecell_Currdatastatus.ATT_DL1_H << 8 | bluecell_Currdatastatus.ATT_DL1_L; DL_AGC_StartAtten[AGC_Alarm_DL2_Index] = bluecell_Currdatastatus.ATT_DL2_H << 8 | bluecell_Currdatastatus.ATT_DL2_L; DL_AGC_StartAtten[AGC_Alarm_DL3_Index] = bluecell_Currdatastatus.ATT_DL3_H << 8 | bluecell_Currdatastatus.ATT_DL3_L; DL_AGC_StartAtten[AGC_Alarm_DL4_Index] = bluecell_Currdatastatus.ATT_DL4_H << 8 | bluecell_Currdatastatus.ATT_DL4_L; for(int i = 0; i < AGC_Alarm_DL_Index_MAX; i++){ DL_PrevIwillgiveAtten[i]= 0; } break; case Bluecell_ULO_ALC_ON_OFF: bluecell_Currdatastatus.ULO_ALC_ON_OFF = data[BLUECELL_DATA + i]; // printf("ALC ON OFF SET : %d \r\n",bluecell_Currdatastatus.ULO_ALC_ON_OFF); if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == 0) bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm = 0; 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 DLI_Shutdown_ON_OFF : %d \r\n",__func__,__LINE__,bluecell_Currdatastatus.DLI_Shutdown_ON_OFF); 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("bluecell_Currdatastatus.DLI_Shutdown_Threshold_H : %x \r\n",bluecell_Currdatastatus.DLI_Shutdown_Threshold_H); // printf("bluecell_Currdatastatus.DLI_Shutdown_Threshold_L : %x \r\n",bluecell_Currdatastatus.DLI_Shutdown_Threshold_L); // 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 = true; // printf("%s : %d Value : %d \r\n",__func__,__LINE__,bluecell_Currdatastatus.LED_TEST); 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 Temps_High_Threshold : %d\r\n",__func__,__LINE__,bluecell_Currdatastatus.Temp_High_Threshold); // printf("Temp_High_Threshold : %d : Det %d \r\n",bluecell_Currdatastatus.Temp_High_Threshold,bluecell_Currdatastatus.DET_TEMP); // printf("Temp_High_Alarm : %d \r\n",bluecell_Currdatastatus.Temp_High_Alarm); // printf("Txdata : %d \r\n",Txdata[201]); 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 : // printf("%s Bluecell_ULO_Shutdown_ON_OFF : %d \r\n",__func__,bluecell_Currdatastatus.ULO_Shutdown_ON_OFF ); bluecell_Currdatastatus.ULO_Shutdown_ON_OFF = data[BLUECELL_DATA + i++]; 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] * 0.1); // printf("%s : %d ALARM_MASK1 : %d \r\n",__func__,__LINE__,bluecell_Currdatastatus.ALARM_MASK1); // printf("Txdata : %d \r\n",Txdata[107]); break; case BLuecell_ATT_ALC1: bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L = data[BLUECELL_DATA + i++]; CurrAtten = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case BLuecell_ATT_ALC2: bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L = data[BLUECELL_DATA + i++]; CurrAtten = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case BLuecell_ATT_ALC3: bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L = data[BLUECELL_DATA + i++]; CurrAtten = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case BLuecell_ATT_ALC4: bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L = data[BLUECELL_DATA + i++]; CurrAtten = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L; // printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case Bluecell_BankSelect: bluecell_Currdatastatus.CPU_Bank_Select = data[BLUECELL_DATA + i++]; if(bluecell_Currdatastatus.CPU_Bank_Select == HFR_AUTO_SEL){ // printf("Curr Bank : %d \r\n",bluecell_Currdatastatus.CPU_Current_Bank); if(bluecell_Currdatastatus.CPU_Current_Bank == HFR_BANK1_SEL){ bluecell_Currdatastatus.CPU_Bank_Select = HFR_BANK2_SEL; }else{ bluecell_Currdatastatus.CPU_Bank_Select = HFR_BANK1_SEL; } } // printf("bluecell_Currdatastatus.CPU_Bank_Select : %d \r\n",bluecell_Currdatastatus.CPU_Bank_Select); break; case Bluecell_TimeSetting: TimeSetting(&data[BLUECELL_CRCINDEX]); break; case Bluecell_Factory_Set: bluecell_Currdatastatus.Factory_Set_Initialization = data[BLUECELL_DATA + i++]; // printf("Factory Set\r\n"); if(bluecell_Currdatastatus.Factory_Set_Initialization == 1){ Factory_Set(); } break; case Bluecell_CarrierOnOff: bluecell_Currdatastatus.Carrier_ON_OFF = data[BLUECELL_DATA + i++]; Carrier_ONOFF(bluecell_Currdatastatus.Carrier_ON_OFF); // printf("Carrier %d \r\n",bluecell_Currdatastatus.Carrier_ON_OFF); break; case Bluecell_PCBVersionSet: // printf("Bluecell_PCBVersionSet\r\n"); for(int i = 0; i < 2; i++){ // printf("%d",data[BLUECELL_DATA + i]); bluecell_Currdatastatus.PCB_Version[i] = data[BLUECELL_DATA + i]; } break; case Bluecell_SerialNumberSet: // printf("Bluecell_SerialNumberSet\r\n"); for(int i = 0; i < 20; i++){ // printf("%c",data[BLUECELL_DATA + i]); bluecell_Currdatastatus.Serial_Number[i] = data[BLUECELL_DATA + i]; } break; case Bluecell_ManufactureDateSet: for(int i = 0; i < 3; i++){ // printf("Manufacture_Date : %d \r\n",data[BLUECELL_DATA + i]); bluecell_Currdatastatus.Manufacture_Date[i] = data[BLUECELL_DATA + i]; } break; case Bluecell_FRBT_DaySetting: bluecell_Currdatastatus.DLI_FRBT_D_Day = data[BLUECELL_DATA + 1]; break; case DLI_FRBT_ON_OFF: #if 0 // PYJ.2020.12.16_BEGIN -- if(data[BLUECELL_DATA + i] == false){ for(int i = 0; i < DLI_FRBT_Time_Index_Max; i++){ PrevFRBT_Day[DLI_FRBT_Time_Year + i] = FRBT_Day[DLI_FRBT_Time_Year + i] = 0; } Last_Day = 0; Prev_Last_Day = 0; FRBT_UserCtrl = 0; bluecell_Currdatastatus.DLI_FRBT_Status = FRBT_IDEL; } else{ bluecell_Currdatastatus.DLI_FRBT_Status = FRBT_TRACKING; } bluecell_Currdatastatus.DLI_FRBT_D_Day = DLI_FRBT_DAY_DEFAULT; bluecell_Currdatastatus.DLI_FRBT_Atten1_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten2_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten3_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten4_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten1_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten2_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten3_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten4_L= DLI_FRBT_ATTEN_DEFALUT; DLI_FRBT_ON_OFF_Set(data[BLUECELL_DATA + i]); // printf("BLUECELL FRBT : %d \r\n",bluecell_Currdatastatus.DLI_FRBT_Status); break; #else DLI_FRBT_ONOFF_Set(data[BLUECELL_DATA + i]); #endif // PYJ.2020.12.16_END -- #if 0 // PYJ.2020.09.03_BEGIN -- case Bluecell_DL_Det_ALL_Offset: bluecell_Currdatastatus.DL_Det_ALL_Offset = data[BLUECELL_DATA]; break; case Bluecell_UL_Det_Path1_Offset: bluecell_Currdatastatus.UL_Det_Path_Offset[0] = data[BLUECELL_DATA]; // printf("Bluecell_UL_Det_Path1_Offset : %d \r\n",bluecell_Currdatastatus.UL_Det_Path_Offset[0]); break; case Bluecell_UL_Det_Path2_Offset: bluecell_Currdatastatus.UL_Det_Path_Offset[1] = data[BLUECELL_DATA]; // printf("Bluecell_UL_Det_Path2_Offset : %d \r\n",bluecell_Currdatastatus.UL_Det_Path_Offset[1]); break; case Bluecell_UL_Det_Path3_Offset: bluecell_Currdatastatus.UL_Det_Path_Offset[2] = data[BLUECELL_DATA]; // printf("Bluecell_UL_Det_Path3_Offset : %d \r\n",bluecell_Currdatastatus.UL_Det_Path_Offset[2]); break; case Bluecell_UL_Det_Path4_Offset: bluecell_Currdatastatus.UL_Det_Path_Offset[3] = data[BLUECELL_DATA]; // printf("Bluecell_UL_Det_Path4_Offset : %d \r\n",bluecell_Currdatastatus.UL_Det_Path_Offset[3]); break; #endif // PYJ.2020.09.03_END -- case Bluecell_DL_UL_SUM_PATH_ON_OFF: bluecell_Currdatastatus.DL_UL_Sum_Path_ON_OFF = data[BLUECELL_DATA]; // printf("data[BLUECELL_DATA] : %d \r\n",data[BLUECELL_DATA]); // printf("DL_UL_Sum_Path_ON_OFF : %d \r\n",bluecell_Currdatastatus.DL_UL_Sum_Path_ON_OFF); Temp_Shutdown_ONOFF(bluecell_Currdatastatus.DL_UL_Sum_Path_ON_OFF); break; } if(datatype != Bluecell_StatusReq && datatype != Bluecell_LED_TEST && datatype != ATT_TableSet && datatype != ATT_TableGet && datatype != Bluecell_DL_UL_SUM_PATH_ON_OFF) { // Bluecell_StructCpy(&DataWrite[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS),&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st)); // EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS),&DataWrite[0],sizeof(BLUESTATUS_st)); // Bluecell_StructCpy(&Txdata[0],&DataWrite[0],sizeof(BLUESTATUS_st)); // Txdata[sizeof(BLUESTATUS_st) - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], sizeof(BLUESTATUS_st) - 3); // Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st)); } // EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_WINDOW_STATUS_ADDRESDS,&bluecell_Currdatastatus.bluecell_header,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_DL1_PATH = HAL_GPIO_ReadPin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin);//CLOCK; // bluecell_Currdatastatus.ATT_DL2_PATH = HAL_GPIO_ReadPin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin);//CLOCK; // bluecell_Currdatastatus.ATT_DL3_PATH = HAL_GPIO_ReadPin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin);//CLOCK; // bluecell_Currdatastatus.ATT_DL4_PATH = HAL_GPIO_ReadPin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin);//CLOCK; // bluecell_Currdatastatus.ATT_UL1_PATH = HAL_GPIO_ReadPin(PATH_EN_UL1_GPIO_Port,PATH_EN_UL1_Pin);//CLOCK; // bluecell_Currdatastatus.ATT_UL2_PATH = HAL_GPIO_ReadPin(PATH_EN_UL2_GPIO_Port,PATH_EN_UL2_Pin);//CLOCK; // bluecell_Currdatastatus.ATT_UL3_PATH = HAL_GPIO_ReadPin(PATH_EN_UL3_GPIO_Port,PATH_EN_UL3_Pin);//CLOCK; // bluecell_Currdatastatus.ATT_UL4_PATH = HAL_GPIO_ReadPin(PATH_EN_UL4_GPIO_Port,PATH_EN_UL4_Pin);//CLOCK; bluecell_Currdatastatus.bluecell_etx = 0xeb; } void HFR_TypeInit(){ uint8_t type = 0; type = HAL_GPIO_ReadPin(UNIT_ID0_GPIO_Port,UNIT_ID0_Pin); type += HAL_GPIO_ReadPin(UNIT_ID1_GPIO_Port,UNIT_ID1_Pin) << 1; type += HAL_GPIO_ReadPin(UNIT_ID2_GPIO_Port,UNIT_ID2_Pin) << 2; type += HAL_GPIO_ReadPin(UNIT_ID3_GPIO_Port,UNIT_ID3_Pin) << 3; // printf("0: %d \r\n",HAL_GPIO_ReadPin(UNIT_ID0_GPIO_Port,UNIT_ID0_Pin)); // printf("1: %d \r\n",HAL_GPIO_ReadPin(UNIT_ID1_GPIO_Port,UNIT_ID1_Pin)); // printf("2: %d \r\n",HAL_GPIO_ReadPin(UNIT_ID2_GPIO_Port,UNIT_ID2_Pin)); // printf("3: %d \r\n",HAL_GPIO_ReadPin(UNIT_ID3_GPIO_Port,UNIT_ID3_Pin)); // printf("ret : %x \r\n",type); switch(type){ case BLUECELL_3_7G: bluecell_Currdatastatus.Freq_ID = bluecell_Currdatastatus.Type = 0x80;bluecell_Currdatastatus.Carrier_ID = 0x01;break;//printf("Type BLUECELL_3_7G Ready....\r\n"); break; case BLUECELL_3_8G: bluecell_Currdatastatus.Freq_ID = bluecell_Currdatastatus.Type = 0x81;bluecell_Currdatastatus.Carrier_ID = 0x02;break; //printf("Type BLUECELL_3_8G Ready....\r\n");break; case BLUECELL_3_9G: bluecell_Currdatastatus.Freq_ID = bluecell_Currdatastatus.Type = 0x82;bluecell_Currdatastatus.Carrier_ID = 0x04;break;//printf("Type BLUECELL_3_9G Ready....\r\n"); break; case BLUECELL_4_0G: bluecell_Currdatastatus.Freq_ID = bluecell_Currdatastatus.Type = 0x83;bluecell_Currdatastatus.Carrier_ID = 0x03;break;// printf("Type BLUECELL_4_0G Ready....\r\n");break; case BLUECELL_4_1G: bluecell_Currdatastatus.Freq_ID = bluecell_Currdatastatus.Type = 0x84;bluecell_Currdatastatus.Carrier_ID = 0x02;break;//printf("Type BLUECELL_4_1G Ready....\r\n");break; case BLUECELL_4_6G: bluecell_Currdatastatus.Freq_ID = bluecell_Currdatastatus.Type = 0x85;bluecell_Currdatastatus.Carrier_ID = 0x01;break;// printf("Type BLUECELL_4_6G Ready....\r\n");break; case BLUECELL_4_7G: bluecell_Currdatastatus.Freq_ID = bluecell_Currdatastatus.Type = 0x86;bluecell_Currdatastatus.Carrier_ID = 0x00;break;// printf("Type BLUECELL_4_7G Ready....\r\n");break; case BLUECELL_4_8G: bluecell_Currdatastatus.Freq_ID = bluecell_Currdatastatus.Type = 0x87;bluecell_Currdatastatus.Carrier_ID = 0x00;break;// printf("Type BLUECELL_4_8G Ready....\r\n");break; case BLUECELL_4_9G: bluecell_Currdatastatus.Freq_ID = bluecell_Currdatastatus.Type = 0x88;bluecell_Currdatastatus.Carrier_ID = 0x00;break;// printf("Type BLUECELL_4_9G Ready....\r\n");break; case BLUECELL_5_0G: bluecell_Currdatastatus.Freq_ID = bluecell_Currdatastatus.Type = 0x89;bluecell_Currdatastatus.Carrier_ID = 0x00;break;// printf("Type BLUECELL_5_0G Ready....\r\n");break; case BLUECELL_DCM : bluecell_Currdatastatus.Freq_ID = bluecell_Currdatastatus.Type = 0x8A;bluecell_Currdatastatus.Carrier_ID = 0x01;break;//printf("Type BLUECELL_DCM Ready....\r\n"); break; case BLUECELL_KDDI: bluecell_Currdatastatus.Freq_ID = bluecell_Currdatastatus.Type = 0x8B;bluecell_Currdatastatus.Carrier_ID = 0x02;break; //printf("Type BLUECELL_KDDI Ready....\r\n");break; case BLUECELL_SBM: bluecell_Currdatastatus.Freq_ID = bluecell_Currdatastatus.Type = 0x8C;bluecell_Currdatastatus.Carrier_ID = 0x03;break;//printf("Type BLUECELL_SBM Ready....\r\n"); break; // default : printf("Type %x Ready....\r\n",bluecell_Currdatastatus.Type);break; } // printf("Type %x Ready....\r\n",bluecell_Currdatastatus.Type); // printf("bluecell_Currdatastatus.Type : %02x \r\n",bluecell_Currdatastatus.Type); } void Bluecell_DataInit(){ /* MBIC Request List Turn off all paths at boot */ MBIC_UL_ShutdownCount = &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1; MBIC_DL_ShutdownCount = &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1; PrevMBIC_UL_ShutdownCount = &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count1; PrevMBIC_DL_ShutdownCount = &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count1; for(int i = 0; i < DET_Alarm_DL_Shutdown_Index_MAX; i++){ PrevMBIC_UL_ShutdownCount[i] = 0xFF; PrevMBIC_DL_ShutdownCount[i] = 0xFF; } #if 1 // PYJ.2020.06.17_BEGIN -- // printf("bluecell_Currdatastatus.Path_TempSave_Bit : %x \r\n",bluecell_Currdatastatus.Path_TempSave_Bit); if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x80) bluecell_Currdatastatus.ATT_DL1_PATH = true; else bluecell_Currdatastatus.ATT_DL1_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x40) bluecell_Currdatastatus.ATT_DL2_PATH = true; else bluecell_Currdatastatus.ATT_DL2_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x20) bluecell_Currdatastatus.ATT_DL3_PATH = true; else bluecell_Currdatastatus.ATT_DL3_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x10) bluecell_Currdatastatus.ATT_DL4_PATH = true; else bluecell_Currdatastatus.ATT_DL4_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x08) bluecell_Currdatastatus.ATT_UL1_PATH = true; else bluecell_Currdatastatus.ATT_UL1_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x04) bluecell_Currdatastatus.ATT_UL2_PATH = true; else bluecell_Currdatastatus.ATT_UL2_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x02) bluecell_Currdatastatus.ATT_UL3_PATH = true; else bluecell_Currdatastatus.ATT_UL3_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x01) bluecell_Currdatastatus.ATT_UL4_PATH = true; else bluecell_Currdatastatus.ATT_UL4_PATH = false; 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); // printf("bluecell_Currdatastatus.ATT_UL2_PATH : %d \r\n",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); #endif // PYJ.2020.06.17_END -- HAL_Delay(10); // printf("UL 1 H : %x \r\n",bluecell_Currdatastatus.ATT_UL4_H); // printf("UL 1 L : %x \r\n",bluecell_Currdatastatus.ATT_UL4_L); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); if(bluecell_Currdatastatus.SelfTest==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 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 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 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("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 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 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 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(); } uint32_t MBIC_DataSend(uint8_t* data){ uint32_t i = 0; uint32_t Length = 0; uint16_t Crcret = 0; int16_t tmpdata = 0; uint32_t HeaderLength = 0;//80; /*ALARM BIT LIST*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Alarm_Bit_List; HeaderLength++; Length += 10; data[MBIC_PAYLOADSTART + i++] = 10; // LENGTH data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK1; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK2; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK3; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK4; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK5; if(bluecell_Currdatastatus.SelfTest == true){ data[MBIC_PAYLOADSTART + i++] = 0; data[MBIC_PAYLOADSTART + i++] = 0; data[MBIC_PAYLOADSTART + i++] = 0; data[MBIC_PAYLOADSTART + i++] = 0; data[MBIC_PAYLOADSTART + i++] = 0; } else if(bluecell_Currdatastatus.Carrier_ON_OFF == false || bluecell_Currdatastatus.ALARM_TESTMODE == true) {/*Carrier OFF -> Alarm OFF*/ if(bluecell_Currdatastatus.ALARM_TESTMODE == false){ data[MBIC_PAYLOADSTART + i++] = 0; data[MBIC_PAYLOADSTART + i++] = 0; data[MBIC_PAYLOADSTART + i++] = 0; data[MBIC_PAYLOADSTART + i++] = 0; data[MBIC_PAYLOADSTART + i++] = 0; }else{ data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_Test_Dummy1 & bluecell_Currdatastatus.ALARM_MASK1; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_Test_Dummy2 & bluecell_Currdatastatus.ALARM_MASK2; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_Test_Dummy3 & bluecell_Currdatastatus.ALARM_MASK3; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_Test_Dummy4 & bluecell_Currdatastatus.ALARM_MASK4; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_Test_Dummy5 & bluecell_Currdatastatus.ALARM_MASK5; } // printf("Alarm Test Mode ON \r\n"); } else { if(bluecell_Currdatastatus.ALARM_MASK1 != false) data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_TEMP_HIGH; else data[MBIC_PAYLOADSTART + i++] = 0; // printf("bluecell_Currdatastatus.ALARM_DLI_Level : %x \r\n",bluecell_Currdatastatus.ALARM_DLI_Level); // printf("bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm : %x \r\n",bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm); // printf("bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN : %x \r\n",bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN); // printf("bluecell_Currdatastatus.ALARM_ULO_Level : %x \r\n",bluecell_Currdatastatus.ALARM_ULO_Level); // printf("bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm : %x \r\n",bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm); // printf("bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN : %x \r\n",bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN); data[MBIC_PAYLOADSTART + i++] = 0; if(bluecell_Currdatastatus.ALARM_MASK2 & 0x80){ data[MBIC_PAYLOADSTART + i - 1] = (bluecell_Currdatastatus.ALARM_DLI_Level & 0x80); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x80; } if(bluecell_Currdatastatus.ALARM_MASK2 & 0x40){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x40); } else{ data[MBIC_PAYLOADSTART + i - 1 ] &= ~0x40; } if(bluecell_Currdatastatus.ALARM_MASK2 & 0x20){ data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x20); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x20; } if(bluecell_Currdatastatus.ALARM_MASK2 & 0x10){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x10); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x10; } if(bluecell_Currdatastatus.ALARM_MASK2 & 0x08){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x08); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x08; } if(bluecell_Currdatastatus.ALARM_MASK2 & 0x04){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x04); } else{ data[MBIC_PAYLOADSTART + i - 1 ] &= ~0x04; } if(bluecell_Currdatastatus.ALARM_MASK2 & 0x02){ data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x02); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x02; } if(bluecell_Currdatastatus.ALARM_MASK2 & 0x01){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x01); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x01; } data[MBIC_PAYLOADSTART + i++] = 0; if(bluecell_Currdatastatus.ALARM_MASK3 & 0x80){ data[MBIC_PAYLOADSTART + i - 1] = (bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & 0x80); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x80; } if(bluecell_Currdatastatus.ALARM_MASK3 & 0x40){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & 0x40); } else{ data[MBIC_PAYLOADSTART + i - 1 ] &= ~0x40; } if(bluecell_Currdatastatus.ALARM_MASK3 & 0x20){ data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & 0x20); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x20; } if(bluecell_Currdatastatus.ALARM_MASK3 & 0x10){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & 0x10); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x10; } if(bluecell_Currdatastatus.ALARM_MASK3 & 0x08){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & 0x08); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x08; } if(bluecell_Currdatastatus.ALARM_MASK3 & 0x04){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & 0x04); } else{ data[MBIC_PAYLOADSTART + i - 1 ] &= ~0x04; } if(bluecell_Currdatastatus.ALARM_MASK3 & 0x02){ data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & 0x02); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x02; } if(bluecell_Currdatastatus.ALARM_MASK3 & 0x01){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & 0x01); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x01; } // printf("(bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN ) : %x \r\n",(bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN )); data[MBIC_PAYLOADSTART + i++] = 0; if(bluecell_Currdatastatus.ALARM_MASK4 & 0x08){ data[MBIC_PAYLOADSTART + i - 1] = (bluecell_Currdatastatus.ALARM_ULO_Level & 0x08); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x08; } if(bluecell_Currdatastatus.ALARM_MASK4 & 0x04){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_Level & 0x04); } else{ data[MBIC_PAYLOADSTART + i - 1 ] &= ~0x04; } if(bluecell_Currdatastatus.ALARM_MASK4 & 0x02){ data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_ULO_Level & 0x02); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x02; } if(bluecell_Currdatastatus.ALARM_MASK4 & 0x01){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_Level & 0x01); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x01; } ////////////////////////////////// data[MBIC_PAYLOADSTART + i++] = 0; if(bluecell_Currdatastatus.ALARM_MASK5 & 0x80){ data[MBIC_PAYLOADSTART + i - 1] = (bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & 0x80); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x80; } if(bluecell_Currdatastatus.ALARM_MASK5 & 0x40){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & 0x40); } else{ data[MBIC_PAYLOADSTART + i - 1 ] &= ~0x40; } if(bluecell_Currdatastatus.ALARM_MASK5 & 0x20){ data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & 0x20); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x20; } if(bluecell_Currdatastatus.ALARM_MASK5 & 0x10){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & 0x10); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x10; } // printf("(bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN ) : %x \r\n",(bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN )); if(bluecell_Currdatastatus.ALARM_MASK5 & 0x08){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & 0x08); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x08; } if(bluecell_Currdatastatus.ALARM_MASK5 & 0x04){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & 0x04); } else{ data[MBIC_PAYLOADSTART + i - 1 ] &= ~0x04; } if(bluecell_Currdatastatus.ALARM_MASK5 & 0x02){ data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & 0x02); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x02; } if(bluecell_Currdatastatus.ALARM_MASK5 & 0x01){ data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & 0x01); } else{ data[MBIC_PAYLOADSTART + i - 1] &= ~0x01; } } /*ALARM BIT MASK*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Alarm_Mask; Length += 5; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = 5; // LENGTH data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK1; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK2; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK3; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK4; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK5; /*Alarm_Test_Mode*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Alarm_Test_Mode; Length += 1; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_TESTMODE; /*Alarm_Test_Mode*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Alarm_Test_Dummy; Length += 5; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = 5; // LENGTH 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.ALARM_Test_Dummy4; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_Test_Dummy5; /*CPU_Version*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = CPU_Version; Length += 3; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = 3; // LENGTH data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPUVERSION1; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPUVERSION2; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPUVERSION3; // printf("Version [3] : %x\r\n ",bluecell_Currdatastatus.CPUVERSION3); /*CPU_Current_Bank*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = CPU_Current_Bank; Length += 1; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Current_Bank; /*CPU_Bank1_Image_Version*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = CPU_Bank1_Image_Version; data[MBIC_PAYLOADSTART + i++] = 3; // LENGTH Length += 3; HeaderLength++; 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; /*CPU_Bank1_Image_BuildTime*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = CPU_Bank1_Image_BuildTime; data[MBIC_PAYLOADSTART + i++] = 6; // LENGTH Length += 6; HeaderLength++; 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; /*CPU_Bank1_Image_Name*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = CPU_Bank1_Image_Name; data[MBIC_PAYLOADSTART + i++] = 32; // LENGTH Length += 32; HeaderLength++; uint8_t* tmpstr; tmpstr = &bluecell_Currdatastatus.CPU_Bank1_Image_Name; for(int a = 0; a < 32; a++){ data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank1_Image_Name[a]; // printf("%x ",tmpstr[a]); } // printf("\r\n"); /*CPU_Bank2_Image_Version*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = CPU_Bank2_Image_Version; data[MBIC_PAYLOADSTART + i++] = 3; // LENGTH Length += 3; HeaderLength++; 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; /*CPU_Bank2_Image_BuildTime*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = CPU_Bank2_Image_BuildTime; data[MBIC_PAYLOADSTART + i++] = 6; // LENGTH Length += 6; HeaderLength++; 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; /*CPU_Bank2_Image_Name*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = CPU_Bank2_Image_Name; data[MBIC_PAYLOADSTART + i++] = 32; // LENGTH Length += 32; HeaderLength++; for(int a = 0; a < 32; a++){ data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.CPU_Bank2_Image_Name[a]; } /*Temperature*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Temperature; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_TEMP; /*Temperature_Offset*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Temperature_Offset; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET; /*Temperature_Threshold*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Temp_High_Threshold; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Temp_High_Threshold; /*Node*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Node; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.NODE; /*Type*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Type; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Type; // printf(" bluecell_Currdatastatus.Type : %x \r\n", bluecell_Currdatastatus.Type); /*PCB_Version*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = PCB_Version; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.PCB_Version[0]; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.PCB_Version[1]; /*Serial_Number*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Serial_Number; data[MBIC_PAYLOADSTART + i++] = 20; // LENGTH Length += 20 ; HeaderLength++; for(int a = 0; a < 20; a++){ data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Serial_Number[a]; } /*Manufacture*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Manufacture; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Manufacture = 0x01; /*Manufacture_Date*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Manufacture_Date; data[MBIC_PAYLOADSTART + i++] = 3; // LENGTH Length += 3 ;HeaderLength++; 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]; /*Manufacture_Date*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DL_UL_SUM_PATH_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DL_UL_Sum_Path_ON_OFF; /*Freq_ID*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Freq_ID; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Freq_ID; /*Carrier_ID*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Carrier_ID; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Carrier_ID; /*Carrier_ID*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = Carrier_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Carrier_ON_OFF; /*DLI_P1_Level*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_P1_Level; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_P1_Level1_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_P1_Level1_L; /*DLI_P2_Level*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_P2_Level; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_P2_Level2_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_P2_Level2_L; /*DLI_P3_Level*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_P3_Level; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_P3_Level3_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_P3_Level3_L; /*DLI_P4_Level*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_P4_Level; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_P4_Level4_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_P4_Level4_L; /*ULO_P1_Level*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_P1_Level; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_P1_Level1_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_P1_Level1_L; /*ULO_P2_Level*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_P2_Level; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_P2_Level2_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_P2_Level2_L; /*ULO_P3_Level*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_P3_Level; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_P3_Level3_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_P3_Level3_L; /*ULO_P4_Level*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_P4_Level; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_P4_Level4_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_P4_Level4_L; /*DLI_RF_Path1_ON_OFF*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_RF_Path1_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_DL1_PATH; /*DLI_RF_Path2_ON_OFF*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_RF_Path2_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_DL2_PATH; /*DLI_RF_Path3_ON_OFF*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_RF_Path3_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_DL3_PATH; /*DLI_RF_Path4_ON_OFF*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_RF_Path4_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_DL4_PATH; /*DLI_Gain_Atten1*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Gain_Atten1; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ;HeaderLength++; tmpdata = bluecell_Currdatastatus.ATT_DL1_H << 8 | bluecell_Currdatastatus.ATT_DL1_L; // tmpdata *= 10; // printf("1tmpdata : %d \r\n",tmpdata); data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); /*DLI_Gain_Atten2*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Gain_Atten2; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; tmpdata = bluecell_Currdatastatus.ATT_DL2_H << 8 | bluecell_Currdatastatus.ATT_DL2_L; // tmpdata *= 10; // printf("2tmpdata : %d \r\n",tmpdatas); data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); /*DLI_Gain_Atten3*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Gain_Atten3; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ;HeaderLength++; tmpdata = bluecell_Currdatastatus.ATT_DL3_H << 8 | bluecell_Currdatastatus.ATT_DL3_L; // tmpdata *= 10; // printf("3tmpdata : %d \r\n",tmpdata); data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); /*DLI_Gain_Atten4*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Gain_Atten4; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; tmpdata = bluecell_Currdatastatus.ATT_DL4_H << 8 | bluecell_Currdatastatus.ATT_DL4_L; // tmpdata *= 10; // printf("4tmpdata : %d \r\n",tmpdata); data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); /*DLI_Gain_Atten_Offset1*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Gain_Atten_Offset1; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2;HeaderLength++; tmpdata = bluecell_Currdatastatus.bluecell_User_DL1_H << 8 | bluecell_Currdatastatus.bluecell_User_DL1_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); /*DLI_Gain_Atten_Offset2*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Gain_Atten_Offset2; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ;HeaderLength++; tmpdata = bluecell_Currdatastatus.bluecell_User_DL2_H << 8 | bluecell_Currdatastatus.bluecell_User_DL2_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); /*DLI_Gain_Atten_Offset3*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Gain_Atten_Offset3; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ;HeaderLength++; tmpdata = bluecell_Currdatastatus.bluecell_User_DL3_H << 8 | bluecell_Currdatastatus.bluecell_User_DL3_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); /*DLI_Gain_Atten_Offset4*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Gain_Atten_Offset4; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ;HeaderLength++; tmpdata = bluecell_Currdatastatus.bluecell_User_DL4_H << 8 | bluecell_Currdatastatus.bluecell_User_DL4_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); /*DLI_Level_High_Threshold*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Level_High_Threshold; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Threshold_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Threshold_L; /*DLI_Level_Low_Threshold*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Level_Low_Threshold; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_Low_Threshold_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_Low_Threshold_L; /*DLI_Level*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Level; data[MBIC_PAYLOADSTART + i++] = 8; // LENGTH Length += 8 ;HeaderLength++; tmpdata = bluecell_Currdatastatus.DLI_Level1_H << 8 | bluecell_Currdatastatus.DLI_Level1_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); tmpdata = bluecell_Currdatastatus.DLI_Level2_H << 8 | bluecell_Currdatastatus.DLI_Level2_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); tmpdata = bluecell_Currdatastatus.DLI_Level3_H << 8 | bluecell_Currdatastatus.DLI_Level3_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); tmpdata = bluecell_Currdatastatus.DLI_Level4_H << 8 | bluecell_Currdatastatus.DLI_Level4_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); /*DLI_FRBT_Atten*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_FRBT_Atten; data[MBIC_PAYLOADSTART + i++] = 8; // LENGTH Length += 8 ;HeaderLength++; 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; /*DLI_FRBT_D_Day*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_FRBT_D_Day; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_FRBT_D_Day; /*DLI_FRBT_Status*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_FRBT_Status; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_FRBT_Status; /*DLI_FRBT_ONOFF*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_FRBT_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_FRBT_ON_OFF; /*DLI_AGC_ON_OFF*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_AGC_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_AGC_ON_OFF; /*DLI_AGC_Threshold*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_AGC_Threshold; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_AGC_Threshold_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_AGC_Threshold_L; /*DLI_Shutdown_ON_OFF*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Shutdown_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_ON_OFF; /*DLI_Shutdown_ON_OFF*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Shutdown_Threshold; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_Threshold_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Shutdown_Threshold_L; /*DLI_Shutdown_Count*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = DLI_Shutdown_Count; data[MBIC_PAYLOADSTART + i++] = 4; // LENGTH Length += 4 ;HeaderLength++; 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; /*ULO_RF_Path1_ON_OFF*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_RF_Path1_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL1_PATH; /*ULO_RF_Path3_ON_OFF*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_RF_Path2_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL2_PATH; /*ULO_RF_Path3_ON_OFF*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_RF_Path3_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL3_PATH; /*ULO_RF_Path4_ON_OFF*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_RF_Path4_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL4_PATH; /*ULO_Gain_Atten1*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_Gain_Atten1; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL1_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL1_L; /*ULO_Gain_Atten2*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_Gain_Atten2; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL2_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL2_L; /*ULO_Gain_Atten3*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_Gain_Atten3; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL3_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL3_L; /*ULO_Gain_Atten4*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_Gain_Atten4; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL4_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_UL4_L; /*ULO_Gain_Atten_Offset1*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_Gain_Atten_Offset1; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; tmpdata = bluecell_Currdatastatus.bluecell_User_UL1_H << 8 | bluecell_Currdatastatus.bluecell_User_UL1_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); /*ULO_Gain_Atten_Offset2*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_Gain_Atten_Offset2; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; tmpdata = bluecell_Currdatastatus.bluecell_User_UL2_H << 8 | bluecell_Currdatastatus.bluecell_User_UL2_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); /*ULO_Gain_Atten_Offset3*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_Gain_Atten_Offset3; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; tmpdata = bluecell_Currdatastatus.bluecell_User_UL3_H << 8 | bluecell_Currdatastatus.bluecell_User_UL3_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); /*ULO_Gain_Atten_Offset4*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_Gain_Atten_Offset4; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; tmpdata = bluecell_Currdatastatus.bluecell_User_UL4_H << 8 | bluecell_Currdatastatus.bluecell_User_UL4_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); /*ULO_Level_High_Threshold*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_Level_High_Threshold; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level_High_Threshold_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level_High_Threshold_L; /*ULO_Level*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_Level; data[MBIC_PAYLOADSTART + i++] = 8; // LENGTH Length += 8 ;HeaderLength++; tmpdata = bluecell_Currdatastatus.ULO_Level1_H << 8 | bluecell_Currdatastatus.ULO_Level1_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); tmpdata = bluecell_Currdatastatus.ULO_Level2_H << 8 | bluecell_Currdatastatus.ULO_Level2_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); tmpdata = bluecell_Currdatastatus.ULO_Level3_H << 8 | bluecell_Currdatastatus.ULO_Level3_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); tmpdata = bluecell_Currdatastatus.ULO_Level4_H << 8 | bluecell_Currdatastatus.ULO_Level4_L; // tmpdata *= 10; data[MBIC_PAYLOADSTART + i++] = ((tmpdata & 0xFF00) >> 8); data[MBIC_PAYLOADSTART + i++] = (tmpdata & 0x00FF); data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_PATH1_GAIN; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Path1_GainValue; data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_PATH2_GAIN; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Path2_GainValue; data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_PATH3_GAIN; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Path3_GainValue; data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_PATH4_GAIN; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Path4_GainValue; data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_SelfTest_ONOFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.SelfTest; /*ULO_ALC_ON_OFF*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_ALC_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_ALC_ON_OFF; /*ULO_ALC_Threshold*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_ALC_Threshold; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2 ; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_ALC_Threshold_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_ALC_Threshold_L; /*ULO_ALC_Threshold*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_Shutdown_ON_OFF; data[MBIC_PAYLOADSTART + i++] = 1; // LENGTH Length += 1; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_ON_OFF; /*ULO_ALC_Threshold*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_Shutdown_Threshold; data[MBIC_PAYLOADSTART + i++] = 2; // LENGTH Length += 2; HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_Threshold_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Shutdown_Threshold_L; /*ULO_Shutdown_Threshold*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_Shutdown_Retry_Count; data[MBIC_PAYLOADSTART + i++] = 4; // LENGTH Length += 4; HeaderLength++; 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; #if 1 // PYJ.2020.06.20_BEGIN -- /*ULO_ALC_Atten*/ data[MBIC_PAYLOADSTART + i++] = MBIC_AID; data[MBIC_PAYLOADSTART + i++] = ULO_ALC_Atten; data[MBIC_PAYLOADSTART + i++] = 8; // LENGTH Length += 8 ;HeaderLength++; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H; data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L; #endif // PYJ.2020.06.20_END -- Length = (Length + (3 * HeaderLength)); data[MBIC_LENGTH_0] = ((Length & 0xFF00) >> 8); data[MBIC_LENGTH_1] = (Length & 0x00FF); Crcret =CRC16_Generate(&data[MBIC_PAYLOADSTART], Length); data[MBIC_HEADERCHECKSUM_0] = Chksum_Create(data); data[MBIC_PAYLOADSTART + i++] = (Crcret & 0xFF00) >> 8; data[MBIC_PAYLOADSTART + i++] = (Crcret & 0x00FF); data[MBIC_PAYLOADSTART + i++] = 0x03; // printf("CRC ret : %X \r\n",Crcret); Uart1_Data_Send(data, Length + 22 + 3); return Length; } void Factory_Set(){ int16_t tempdata = 0; uint8_t type = 0; type = HAL_GPIO_ReadPin(UNIT_ID0_GPIO_Port,UNIT_ID0_Pin); type += HAL_GPIO_ReadPin(UNIT_ID1_GPIO_Port,UNIT_ID1_Pin) << 1; type += HAL_GPIO_ReadPin(UNIT_ID2_GPIO_Port,UNIT_ID2_Pin) << 2; type += HAL_GPIO_ReadPin(UNIT_ID3_GPIO_Port,UNIT_ID3_Pin) << 3; // printf("Factory Set Start \r\n"); /*ALARM MASK*/ bluecell_Currdatastatus.ALARM_MASK1 = 0x80; bluecell_Currdatastatus.ALARM_MASK2 = 0xFF ; bluecell_Currdatastatus.ALARM_MASK3 = 0xFF; bluecell_Currdatastatus.ALARM_MASK4 = 0x0F ; bluecell_Currdatastatus.ALARM_MASK5 = 0xFF; /*Temp OFFSET*/ // bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET = TEMP_OFFSET_DEFAULT; /*Temp High Thread Hold*/ bluecell_Currdatastatus.Temp_High_Threshold = Temp_THREADHOLD_DEFAULT; /*Carrier On off*/ bluecell_Currdatastatus.Carrier_ON_OFF = CARRIER_DEFAULT; /*DL PATH */ bluecell_Currdatastatus.ATT_DL1_PATH = PATH_DEFAULT; bluecell_Currdatastatus.ATT_DL2_PATH = PATH_DEFAULT; bluecell_Currdatastatus.ATT_DL3_PATH = PATH_DEFAULT; bluecell_Currdatastatus.ATT_DL4_PATH = PATH_DEFAULT; /*DL GAIN Atten*/ bluecell_Currdatastatus.ATT_DL1_H = DLI_ATTEN_DEFAULT; bluecell_Currdatastatus.ATT_DL2_H = DLI_ATTEN_DEFAULT; bluecell_Currdatastatus.ATT_DL3_H = DLI_ATTEN_DEFAULT; bluecell_Currdatastatus.ATT_DL4_H = DLI_ATTEN_DEFAULT; bluecell_Currdatastatus.ATT_DL1_L = DLI_ATTEN_DEFAULT; bluecell_Currdatastatus.ATT_DL2_L = DLI_ATTEN_DEFAULT; bluecell_Currdatastatus.ATT_DL3_L = DLI_ATTEN_DEFAULT; bluecell_Currdatastatus.ATT_DL4_L = DLI_ATTEN_DEFAULT; bluecell_Currdatastatus.Path_TempSave_Bit = 0xFF; /*DL GAIN OFFSET*/ #if 0 // PYJ.2020.09.11_BEGIN -- tempdata = ATTEN_OFFSET_DEFAULT; bluecell_Currdatastatus.bluecell_User_DL1_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.bluecell_User_DL1_L = ((tempdata & 0x00FF)); bluecell_Currdatastatus.bluecell_User_DL2_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.bluecell_User_DL2_L = ((tempdata & 0x00FF)); bluecell_Currdatastatus.bluecell_User_DL3_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.bluecell_User_DL3_L = ((tempdata & 0x00FF)); bluecell_Currdatastatus.bluecell_User_DL4_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.bluecell_User_DL4_L = ((tempdata & 0x00FF)); #endif // PYJ.2020.09.11_END -- if(type == BLUECELL_SBM){ tempdata = DLI_ATTEN_HIGHTHREADHOLD_SBM_DEFAULT; } else if(type == BLUECELL_DCM){ tempdata = DLI_ATTEN_HIGHTHREADHOLD_DOCOMO_DEFAULT; } else if(type == BLUECELL_KDDI){ tempdata = DLI_ATTEN_HIGHTHREADHOLD_KDDI_DEFAULT; }else{ tempdata = DLI_ATTEN_HIGHTHREADHOLD_DEFAULT; } bluecell_Currdatastatus.DLI_Level_High_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_Level_High_Threshold_L = ((tempdata & 0x00FF)); if(type == BLUECELL_SBM){ tempdata = DLI_ATTEN_LOWTHREADHOLD_SBM_DEFAULT; } else if(type == BLUECELL_DCM){ tempdata = DLI_ATTEN_LOWTHREADHOLD_DOCOMO_DEFAULT; } else if(type == BLUECELL_KDDI){ tempdata = DLI_ATTEN_LOWTHREADHOLD_KDDI_DEFAULT; }else{ tempdata = DLI_ATTEN_LOWTHREADHOLD_DEFAULT; } //printf("temp data : %d \r\n",tempdata); bluecell_Currdatastatus.DLI_Level_Low_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_Level_Low_Threshold_L = ((tempdata & 0x00FF)); bluecell_Currdatastatus.DLI_FRBT_D_Day = DLI_FRBT_DAY_DEFAULT; bluecell_Currdatastatus.DLI_FRBT_Status = FRBT_TRACKING; bluecell_Currdatastatus.DLI_FRBT_ON_OFF = false; FRBT_UserCtrl = false; bluecell_Currdatastatus.DLI_FRBT_Atten1_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten2_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten3_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten4_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten1_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten2_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten3_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten4_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_AGC_ON_OFF = DLI_AGC_ONOFF_DEFAULT; //Card Type Carrier AGC Limit Shutdown Limit High Limit Low Limit //MBIC-3.52G DoCoMo | -4 | 13 | 12 | -25 | //MBIC-3.56G KDDI | -7 | 10 | 9 | -25 | //MBIC-3.6G SBM | -4 | 13 | 12 | -25 | if(type == BLUECELL_SBM){ tempdata = DLI_AGC_THREADHOLD_SBM_DEFAULT; } else if(type == BLUECELL_DCM){ tempdata = DLI_AGC_THREADHOLD_DOCOMO_DEFAULT; } else if(type == BLUECELL_KDDI){ tempdata = DLI_AGC_THREADHOLD_KDDI_DEFAULT; }else{ tempdata = DLI_AGC_THREADHOLD_DEFAULT; } bluecell_Currdatastatus.DLI_AGC_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_AGC_Threshold_L = ((tempdata & 0x00FF)); bluecell_Currdatastatus.DLI_Shutdown_ON_OFF = DLI_SHUTDOWN_ONOFF_DEFAULT; if(type == BLUECELL_SBM){ tempdata = DLI_SHUTDOWN_THREADHOLD_SBM_DEFAULT; } else if(type == BLUECELL_DCM){ tempdata = DLI_SHUTDOWN_THREADHOLD_DOCOMO_DEFAULT; } else if(type == BLUECELL_KDDI){ tempdata = DLI_SHUTDOWN_THREADHOLD_KDDI_DEFAULT; }else{ tempdata = DLI_SHUTDOWN_THREADHOLD_DEFAULT; } //printf("Shutdown : %d \r\n",tempdata); //tempdata = DLI_SHUTDOWN_THREADHOLD_DEFAULT; bluecell_Currdatastatus.DLI_Shutdown_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_Shutdown_Threshold_L = ((tempdata & 0x00FF)); // bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 = 0; // bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 = 0; // bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = 0; // bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 = 0; DL_Path_OnOff(Path1_OnOff, bluecell_Currdatastatus.ATT_DL1_PATH, &bluecell_Currdatastatus.ATT_DL1_PATH, &bluecell_Prevdatastatus.ATT_DL1_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count1) ; DL_Path_OnOff(Path2_OnOff, bluecell_Currdatastatus.ATT_DL2_PATH, &bluecell_Currdatastatus.ATT_DL2_PATH, &bluecell_Prevdatastatus.ATT_DL2_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count2) ; DL_Path_OnOff(Path3_OnOff, bluecell_Currdatastatus.ATT_DL3_PATH, &bluecell_Currdatastatus.ATT_DL3_PATH, &bluecell_Prevdatastatus.ATT_DL3_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count3) ; DL_Path_OnOff(Path4_OnOff, bluecell_Currdatastatus.ATT_DL4_PATH, &bluecell_Currdatastatus.ATT_DL4_PATH, &bluecell_Prevdatastatus.ATT_DL4_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count4) ; bluecell_Currdatastatus.ATT_UL1_PATH = PATH_DEFAULT; bluecell_Currdatastatus.ATT_UL2_PATH = PATH_DEFAULT; bluecell_Currdatastatus.ATT_UL3_PATH = PATH_DEFAULT; bluecell_Currdatastatus.ATT_UL4_PATH = PATH_DEFAULT; tempdata = ULO_ATTEN_DEFAULT; bluecell_Currdatastatus.ATT_UL1_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL1_L = ((tempdata & 0x00FF)); bluecell_Currdatastatus.ATT_UL2_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL2_L = ((tempdata & 0x00FF)); bluecell_Currdatastatus.ATT_UL3_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL3_L = ((tempdata & 0x00FF)); bluecell_Currdatastatus.ATT_UL4_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL4_L = ((tempdata & 0x00FF)); #if 0 // PYJ.2020.09.11_BEGIN -- tempdata = ATTEN_OFFSET_DEFAULT; bluecell_Currdatastatus.bluecell_User_UL1_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.bluecell_User_UL1_L = ((tempdata & 0x00FF)); bluecell_Currdatastatus.bluecell_User_UL2_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.bluecell_User_UL2_L = ((tempdata & 0x00FF)); bluecell_Currdatastatus.bluecell_User_UL3_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.bluecell_User_UL3_L = ((tempdata & 0x00FF)); bluecell_Currdatastatus.bluecell_User_UL4_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.bluecell_User_UL4_L = ((tempdata & 0x00FF)); #endif // PYJ.2020.09.11_END -- tempdata = ULO_LEVEL_HIGH_THREADHOLD_DEFAULT; bluecell_Currdatastatus.ULO_Level_High_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_Level_High_Threshold_L = ((tempdata & 0x00FF)); bluecell_Currdatastatus.SelfTest = SELFTEST_DEFALULT_DEFAULT; bluecell_Currdatastatus.ULO_ALC_ON_OFF = ULO_ALC_ONOFF_DEFAULT; tempdata = ULO_ALC_THREADHOLD_DEFAULT; bluecell_Currdatastatus.ULO_ALC_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_ALC_Threshold_L = ((tempdata & 0x00FF)); bluecell_Currdatastatus.ULO_Shutdown_ON_OFF = ULO_SHUTDOWN_ONOFF_DEFAULT; tempdata = ULO_SHUTDOWN_THREADHOLD_DEFAULT; bluecell_Currdatastatus.ULO_Shutdown_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_Shutdown_Threshold_L = ((tempdata & 0x00FF)); UL_Path_OnOff(Path1_OnOff, bluecell_Currdatastatus.ATT_UL1_PATH, &bluecell_Currdatastatus.ATT_UL1_PATH, &bluecell_Prevdatastatus.ATT_UL1_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count1) ; UL_Path_OnOff(Path2_OnOff, bluecell_Currdatastatus.ATT_UL2_PATH, &bluecell_Currdatastatus.ATT_UL2_PATH, &bluecell_Prevdatastatus.ATT_UL2_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count2) ; UL_Path_OnOff(Path3_OnOff, bluecell_Currdatastatus.ATT_UL3_PATH, &bluecell_Currdatastatus.ATT_UL3_PATH, &bluecell_Prevdatastatus.ATT_UL3_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count3) ; UL_Path_OnOff(Path4_OnOff, bluecell_Currdatastatus.ATT_UL4_PATH, &bluecell_Currdatastatus.ATT_UL4_PATH, &bluecell_Prevdatastatus.ATT_UL4_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count4) ; DL_PrevIwillgiveAtten[0] = 99; DL_PrevIwillgiveAtten[1] = 99; DL_PrevIwillgiveAtten[2] = 99; DL_PrevIwillgiveAtten[3] = 99; bluecell_Prevdatastatus.ATT_DL1_H = 0xFF; bluecell_Prevdatastatus.ATT_DL2_H = 0xFF; bluecell_Prevdatastatus.ATT_DL3_H = 0xFF; bluecell_Prevdatastatus.ATT_DL4_H = 0xFF; bluecell_Prevdatastatus.ATT_DL1_L = 0xFF; bluecell_Prevdatastatus.ATT_DL2_L = 0xFF; bluecell_Prevdatastatus.ATT_DL3_L = 0xFF; bluecell_Prevdatastatus.ATT_DL4_L = 0xFF; bluecell_Prevdatastatus.ATT_UL1_H = 0xFF; bluecell_Prevdatastatus.ATT_UL2_H = 0xFF; bluecell_Prevdatastatus.ATT_UL3_H = 0xFF; bluecell_Prevdatastatus.ATT_UL4_H = 0xFF; bluecell_Prevdatastatus.ATT_UL1_L = 0xFF; bluecell_Prevdatastatus.ATT_UL2_L = 0xFF; bluecell_Prevdatastatus.ATT_UL3_L = 0xFF; bluecell_Prevdatastatus.ATT_UL4_L = 0xFF; DLI_FRBT_ONOFF_Set(true); } /*When using the shutdown function, you should never use this function to turn onoff Because this function initializes Shutdown related Count and alarm.*/ void DL_Path_OnOff(uint8_t Index,uint8_t value,uint8_t* path,uint8_t* PrevAtten,uint8_t* retrycnt,uint8_t* PrevRetryCnt){ GPIO_TypeDef *Port = 0; uint16_t Pin = 0; switch(Index){ case Path1_OnOff: Port = PATH_EN_DL1_GPIO_Port; Pin = PATH_EN_DL1_Pin; bluecell_Currdatastatus.DLI_Shutdown_Alarm1 = false; bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P1; break; case Path2_OnOff: Port = PATH_EN_DL2_GPIO_Port; Pin = PATH_EN_DL2_Pin; bluecell_Currdatastatus.DLI_Shutdown_Alarm2 = false; bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P2; break; case Path3_OnOff: Port = PATH_EN_DL3_GPIO_Port; Pin = PATH_EN_DL3_Pin; bluecell_Currdatastatus.DLI_Shutdown_Alarm3 = false; bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P3; break; case Path4_OnOff: Port = PATH_EN_DL4_GPIO_Port; Pin = PATH_EN_DL4_Pin; bluecell_Currdatastatus.DLI_Shutdown_Alarm4 = false; bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P4; break; } *path = value; *retrycnt = 0; *PrevRetryCnt = 0xFF; if(value==0){ HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_RESET);//CLOCK DL_PathUserHandl[0] = true; } else{ PrevAtten[Atten_H] = 0xFF; PrevAtten[Atten_L] = 0xFF; DL_PathUserHandl[Index] = false; HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK } CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); } /*When using the shutdown function, you should never use this function to turn onoff Because this function initializes Shutdown related Count and alarm.*/ void UL_Path_OnOff(uint8_t Index,uint8_t value,uint8_t* path,uint8_t* PrevAtten,uint8_t* retrycnt,uint8_t* PrevRetryCnt){ GPIO_TypeDef *Port = 0; uint16_t Pin = 0; switch(Index){ case Path1_OnOff: Port = PATH_EN_UL1_GPIO_Port; Pin = PATH_EN_UL1_Pin; bluecell_Currdatastatus.ULO_Shutdown_Alarm1 = false; bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~ALARM_ULO_SHUTDOWN_P1; break; case Path2_OnOff: Port = PATH_EN_UL2_GPIO_Port; Pin = PATH_EN_UL2_Pin; bluecell_Currdatastatus.ULO_Shutdown_Alarm2 = false; bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~ALARM_ULO_SHUTDOWN_P2; break; case Path3_OnOff: Port = PATH_EN_UL3_GPIO_Port; Pin = PATH_EN_UL3_Pin; bluecell_Currdatastatus.ULO_Shutdown_Alarm3 = false; bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~ALARM_ULO_SHUTDOWN_P3; break; case Path4_OnOff: Port = PATH_EN_UL4_GPIO_Port; Pin = PATH_EN_UL4_Pin; bluecell_Currdatastatus.ULO_Shutdown_Alarm4 = false; bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~ALARM_ULO_SHUTDOWN_P4; break; } *path = value; *retrycnt = 0; *PrevRetryCnt = 0xFF; if(value == 0){ HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_RESET);//CLOCK } else{ PrevAtten[Atten_H] = 0xFF; PrevAtten[Atten_L] = 0xFF; HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK } CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); } uint8_t TimeCalc(){ time_t tm_st; time_t tm_nd; int tm_day, tm_hour, tm_min, tm_sec; double d_diff; struct tm user_stime; struct tm user_stime2; user_stime.tm_year = (2000 + PrevFRBT_Day[DLI_FRBT_Time_Year]) -1900; // 주의 :년도는 1900년부터 시작 user_stime.tm_mon = PrevFRBT_Day[DLI_FRBT_Time_Month] -1; // 주의 :월은 0부터 시작 user_stime.tm_mday = PrevFRBT_Day[DLI_FRBT_Time_Day]; user_stime.tm_hour = PrevFRBT_Day[DLI_FRBT_Time_Hour]; user_stime.tm_min = PrevFRBT_Day[DLI_FRBT_Time_Minute]; user_stime.tm_sec = PrevFRBT_Day[DLI_FRBT_Time_Second]; user_stime.tm_isdst = 0; // 썸머 타임 사용 안함 user_stime2.tm_year = (2000 + FRBT_Day[DLI_FRBT_Time_Year]) -1900; // 주의 :년도는 1900년부터 시작 user_stime2.tm_mon = FRBT_Day[DLI_FRBT_Time_Month] -1; // 주의 :월은 0부터 시작 user_stime2.tm_mday = FRBT_Day[DLI_FRBT_Time_Day]; user_stime2.tm_hour = FRBT_Day[DLI_FRBT_Time_Hour]; user_stime2.tm_min = FRBT_Day[DLI_FRBT_Time_Minute]; user_stime2.tm_sec = FRBT_Day[DLI_FRBT_Time_Second]; user_stime2.tm_isdst = 0; // 썸머 타임 사용 안함 tm_st = mktime( &user_stime); tm_nd = mktime( &user_stime2); d_diff = difftime( tm_nd, tm_st); tm_day = d_diff / ( 60 *60 * 24); d_diff = d_diff - ( tm_day *60 *60 *24); tm_hour = d_diff / ( 60 *60); d_diff = d_diff - ( tm_hour *60 *60); tm_min = d_diff / 60; d_diff = d_diff - ( tm_min *60); tm_sec = d_diff; // printf( "%d Day %d Hour %d Minute %d Second Bye \n", tm_day, tm_hour, tm_min, tm_sec); return tm_day; } void TimeSetting(uint8_t* data){ if(bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_IDEL || bluecell_Currdatastatus.DLI_FRBT_ON_OFF == false) return; // printf("DLI_FRBT_Status : %d \r\n",bluecell_Currdatastatus.DLI_FRBT_Status); // printf("DLI_AGC_ON_OFF : %d \r\n",bluecell_Currdatastatus.DLI_AGC_ON_OFF); // printf("DLI_FRBT_D_Day : %d \r\n",bluecell_Currdatastatus.DLI_FRBT_D_Day); // printf("Curr Day %d \r\n ",FRBT_UserCtrl); if(bluecell_Currdatastatus.DLI_AGC_ON_OFF == true // && FRBT_UserCtrl < bluecell_Currdatastatus.DLI_FRBT_D_Day && bluecell_Currdatastatus.DLI_FRBT_Status != FRBT_RUNNING){ for(int i = 0; i < DLI_FRBT_Time_Index_Max; i++){ FRBT_Day[DLI_FRBT_Time_Year + i] = data[i]; /* Curr day */ } if(timeset_init == false){ // PrevFRBT_Day[DLI_FRBT_Time_Day] = FRBT_Day[DLI_FRBT_Time_Day]; for(int i = 0; i < DLI_FRBT_Time_Index_Max; i++){ PrevFRBT_Day[DLI_FRBT_Time_Year + i] = FRBT_Day[DLI_FRBT_Time_Year + i]; /* Curr day */ } timeset_init = true; Prev_Last_Day = Last_Day = TimeCalc(); return; }else{ Last_Day = TimeCalc(); } // printf("Last Day : %d Prev Day : %d \r\n",Last_Day,Prev_Last_Day); #if 0 // PYJ.2020.11.12_BEGIN -- printf("BLUECELL TIME APPLY : %d - %d - %d - %d - %d - %d ", FRBT_Day[DLI_FRBT_Time_Year], FRBT_Day[DLI_FRBT_Time_Month], FRBT_Day[DLI_FRBT_Time_Day], FRBT_Day[DLI_FRBT_Time_Hour], FRBT_Day[DLI_FRBT_Time_Minute], FRBT_Day[DLI_FRBT_Time_Second]); printf("/// %d - %d - %d " ,FRBT_Day[DLI_FRBT_Time_Hour] - PrevFRBT_Day[DLI_FRBT_Time_Hour] ,FRBT_Day[DLI_FRBT_Time_Minute] - PrevFRBT_Day[DLI_FRBT_Time_Minute] ,FRBT_Day[DLI_FRBT_Time_Second] - PrevFRBT_Day[DLI_FRBT_Time_Second]); printf("\r\n"); printf("PREV BLUECELL TIME APPLY : %d - %d - %d - %d - %d - %d \r\n", PrevFRBT_Day[DLI_FRBT_Time_Year], PrevFRBT_Day[DLI_FRBT_Time_Month], PrevFRBT_Day[DLI_FRBT_Time_Day], PrevFRBT_Day[DLI_FRBT_Time_Hour], PrevFRBT_Day[DLI_FRBT_Time_Minute], PrevFRBT_Day[DLI_FRBT_Time_Second]); #endif // PYJ.2020.11.12_END -- #if 0 // PYJ.2020.11.12_BEGIN -- if(FRBT_Day[DLI_FRBT_Time_Day] != PrevFRBT_Day[DLI_FRBT_Time_Day] // &&FRBT_Day[DLI_FRBT_Time_Hour] >= PrevFRBT_Day[DLI_FRBT_Time_Hour] // &&FRBT_Day[DLI_FRBT_Time_Minute] >= PrevFRBT_Day[DLI_FRBT_Time_Minute] // &&FRBT_Day[DLI_FRBT_Time_Second] >= PrevFRBT_Day[DLI_FRBT_Time_Second] ){ #endif // PYJ.2020.11.12_END -- if(Last_Day != Prev_Last_Day){ if(bluecell_Currdatastatus.DLI_FRBT_D_Day != 0){ bluecell_Currdatastatus.DLI_FRBT_D_Day -=(Last_Day - Prev_Last_Day); } Prev_Last_Day = Last_Day; // printf("FRBT_Day[DLI_FRBT_Time_Day] : %d PrevFRBT_Day[DLI_FRBT_D_Day] : %d \r\n", // FRBT_Day[DLI_FRBT_Time_Day] , // PrevFRBT_Day[DLI_FRBT_Time_Day]); // FRBT_UserCtrl++; // bluecell_Currdatastatus.DLI_FRBT_D_Day--; if(bluecell_Currdatastatus.DLI_FRBT_D_Day > 7) bluecell_Currdatastatus.DLI_FRBT_D_Day = 7; bluecell_Currdatastatus.DLI_FRBT_Status = FRBT_TRACKING; // printf("D day Plus : %d \r\n",FRBT_UserCtrl); } // for(int i = 0; i < DLI_FRBT_Time_Index_Max; i++){ // PrevFRBT_Day[DLI_FRBT_Time_Year + i] = FRBT_Day[DLI_FRBT_Time_Year + i]; /* Curr day */ // } // printf("BLUECELL TIME APPLY : %d - %d - %d - %d - %d - %d \r\n", // PrevFRBT_Day[DLI_FRBT_Time_Year], // PrevFRBT_Day[DLI_FRBT_Time_Month], // PrevFRBT_Day[DLI_FRBT_Time_Day], // PrevFRBT_Day[DLI_FRBT_Time_Hour], // PrevFRBT_Day[DLI_FRBT_Time_Minute], // PrevFRBT_Day[DLI_FRBT_Time_Second]); // printf("FRBT_Day[DLI_FRBT_Time_Day] : %d PrevFRBT_Day[DLI_FRBT_D_Day] : %d \r\n", // FRBT_Day[DLI_FRBT_Time_Day] , // PrevFRBT_Day[DLI_FRBT_Time_Day]); } // printf("Time Set Complete\r\n"); } void Carrier_ONOFF(uint8_t val){ if(val != 0){ bluecell_Currdatastatus.ATT_DL1_PATH = PATH_DEFAULT; bluecell_Currdatastatus.ATT_DL2_PATH = PATH_DEFAULT; bluecell_Currdatastatus.ATT_DL3_PATH = PATH_DEFAULT; bluecell_Currdatastatus.ATT_DL4_PATH = PATH_DEFAULT; bluecell_Currdatastatus.ATT_UL1_PATH = PATH_DEFAULT; bluecell_Currdatastatus.ATT_UL2_PATH = PATH_DEFAULT; bluecell_Currdatastatus.ATT_UL3_PATH = PATH_DEFAULT; bluecell_Currdatastatus.ATT_UL4_PATH = PATH_DEFAULT; bluecell_Currdatastatus.Path_TempSave_Bit = 0xFF; DL_Path_OnOff(Path1_OnOff, true, &bluecell_Currdatastatus.ATT_DL1_PATH, &bluecell_Prevdatastatus.ATT_DL1_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count1) ; DL_Path_OnOff(Path2_OnOff, true, &bluecell_Currdatastatus.ATT_DL2_PATH, &bluecell_Prevdatastatus.ATT_DL2_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count2) ; DL_Path_OnOff(Path3_OnOff, true, &bluecell_Currdatastatus.ATT_DL3_PATH, &bluecell_Prevdatastatus.ATT_DL3_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count3) ; DL_Path_OnOff(Path4_OnOff, true, &bluecell_Currdatastatus.ATT_DL4_PATH, &bluecell_Prevdatastatus.ATT_DL4_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count4) ; UL_Path_OnOff(Path1_OnOff, true, &bluecell_Currdatastatus.ATT_UL1_PATH, &bluecell_Prevdatastatus.ATT_UL1_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count1) ; UL_Path_OnOff(Path2_OnOff, true, &bluecell_Currdatastatus.ATT_UL2_PATH, &bluecell_Prevdatastatus.ATT_UL2_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count2) ; UL_Path_OnOff(Path3_OnOff, true, &bluecell_Currdatastatus.ATT_UL3_PATH, &bluecell_Prevdatastatus.ATT_UL3_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count3) ; UL_Path_OnOff(Path4_OnOff, true, &bluecell_Currdatastatus.ATT_UL4_PATH, &bluecell_Prevdatastatus.ATT_UL4_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count4) ; // HAL_Delay(10); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); } else{ bluecell_Currdatastatus.ATT_DL1_PATH = false; bluecell_Currdatastatus.ATT_DL2_PATH = false; bluecell_Currdatastatus.ATT_DL3_PATH = false; bluecell_Currdatastatus.ATT_DL4_PATH = false; bluecell_Currdatastatus.ATT_UL1_PATH = false; bluecell_Currdatastatus.ATT_UL2_PATH = false; bluecell_Currdatastatus.ATT_UL3_PATH = false; bluecell_Currdatastatus.ATT_UL4_PATH = false; bluecell_Currdatastatus.Path_TempSave_Bit = 0x00; DL_Path_OnOff(Path1_OnOff, false, &bluecell_Currdatastatus.ATT_DL1_PATH, &bluecell_Prevdatastatus.ATT_DL1_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count1) ; DL_Path_OnOff(Path2_OnOff, false, &bluecell_Currdatastatus.ATT_DL2_PATH, &bluecell_Prevdatastatus.ATT_DL2_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count2) ; DL_Path_OnOff(Path3_OnOff, false, &bluecell_Currdatastatus.ATT_DL3_PATH, &bluecell_Prevdatastatus.ATT_DL3_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count3) ; DL_Path_OnOff(Path4_OnOff, false, &bluecell_Currdatastatus.ATT_DL4_PATH, &bluecell_Prevdatastatus.ATT_DL4_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count4) ; UL_Path_OnOff(Path1_OnOff, false, &bluecell_Currdatastatus.ATT_UL1_PATH, &bluecell_Prevdatastatus.ATT_UL1_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count1) ; UL_Path_OnOff(Path2_OnOff, false, &bluecell_Currdatastatus.ATT_UL2_PATH, &bluecell_Prevdatastatus.ATT_UL2_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count2) ; UL_Path_OnOff(Path3_OnOff, false, &bluecell_Currdatastatus.ATT_UL3_PATH, &bluecell_Prevdatastatus.ATT_UL3_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count3) ; UL_Path_OnOff(Path4_OnOff, false, &bluecell_Currdatastatus.ATT_UL4_PATH, &bluecell_Prevdatastatus.ATT_UL4_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count4) ; // bluecell_Currdatastatus.DLI_Shutdown_ON_OFF = false; // bluecell_Currdatastatus.ULO_Shutdown_ON_OFF = false; // bluecell_Currdatastatus.DLI_AGC_ON_OFF = false; // bluecell_Currdatastatus.ULO_ALC_ON_OFF = false; bluecell_Currdatastatus.ALARM_TEMP_HIGH = 0; bluecell_Currdatastatus.ALARM_DLI_Level = 0; bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN = 0; bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm = 0; bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm = 0; bluecell_Currdatastatus.ALARM_ULO_Level = 0; bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN = 0; bluecell_Currdatastatus.DLI_Shutdown_Alarm1 = false; bluecell_Currdatastatus.DLI_Shutdown_Alarm2 = false; bluecell_Currdatastatus.DLI_Shutdown_Alarm3 = false; bluecell_Currdatastatus.DLI_Shutdown_Alarm4 = false; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 = false; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 = false; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = false; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm1 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm2 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm3 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm4 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm1 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm2 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm3 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm4 = false; } } void Temp_Shutdown_ONOFF(uint8_t val){ // printf("val :%d \r\n",val); // printf("DL_UL_Sum_Path_ON_OFF : %d \r\n",bluecell_Currdatastatus.DL_UL_Sum_Path_ON_OFF); // printf(" bluecell_Currdatastatus.Path_TempSave_Bit : %x \r\n", bluecell_Currdatastatus.Path_TempSave_Bit); if(val == 1){// ON //Path ON #if 0 // PYJ.2020.08.14_BEGIN -- bluecell_Currdatastatus.ATT_DL1_PATH= TempShutdown_DL_SaveData[0]; bluecell_Currdatastatus.ATT_DL2_PATH= TempShutdown_DL_SaveData[1]; bluecell_Currdatastatus.ATT_DL3_PATH= TempShutdown_DL_SaveData[2]; bluecell_Currdatastatus.ATT_DL4_PATH= TempShutdown_DL_SaveData[3]; bluecell_Currdatastatus.ATT_UL1_PATH= TempShutdown_UL_SaveData[0]; bluecell_Currdatastatus.ATT_UL2_PATH= TempShutdown_UL_SaveData[1]; bluecell_Currdatastatus.ATT_UL3_PATH= TempShutdown_UL_SaveData[2]; bluecell_Currdatastatus.ATT_UL4_PATH= TempShutdown_UL_SaveData[3]; #endif // PYJ.2020.08.14_END -- if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x80) bluecell_Currdatastatus.ATT_DL1_PATH = true; else bluecell_Currdatastatus.ATT_DL1_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x40) bluecell_Currdatastatus.ATT_DL2_PATH = true; else bluecell_Currdatastatus.ATT_DL2_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x20) bluecell_Currdatastatus.ATT_DL3_PATH = true; else bluecell_Currdatastatus.ATT_DL3_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x10) bluecell_Currdatastatus.ATT_DL4_PATH = true; else bluecell_Currdatastatus.ATT_DL4_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x08) bluecell_Currdatastatus.ATT_UL1_PATH = true; else bluecell_Currdatastatus.ATT_UL1_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x04) bluecell_Currdatastatus.ATT_UL2_PATH = true; else bluecell_Currdatastatus.ATT_UL2_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x02) bluecell_Currdatastatus.ATT_UL3_PATH = true; else bluecell_Currdatastatus.ATT_UL3_PATH = false; if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x01) bluecell_Currdatastatus.ATT_UL4_PATH = true; else bluecell_Currdatastatus.ATT_UL4_PATH = false; // printf("Path ON \r\n"); } else{// OFF #if 0 // PYJ.2020.08.14_BEGIN -- TempShutdown_DL_SaveData[0] = bluecell_Currdatastatus.ATT_DL1_PATH; TempShutdown_DL_SaveData[1] = bluecell_Currdatastatus.ATT_DL2_PATH; TempShutdown_DL_SaveData[2] = bluecell_Currdatastatus.ATT_DL3_PATH; TempShutdown_DL_SaveData[3] = bluecell_Currdatastatus.ATT_DL4_PATH; TempShutdown_UL_SaveData[0] = bluecell_Currdatastatus.ATT_UL1_PATH; TempShutdown_UL_SaveData[1] = bluecell_Currdatastatus.ATT_UL2_PATH; TempShutdown_UL_SaveData[2] = bluecell_Currdatastatus.ATT_UL3_PATH; TempShutdown_UL_SaveData[3] = bluecell_Currdatastatus.ATT_UL4_PATH; #endif // PYJ.2020.08.14_END -- bluecell_Currdatastatus.ATT_DL1_PATH = false; bluecell_Currdatastatus.ATT_DL2_PATH = false; bluecell_Currdatastatus.ATT_DL3_PATH = false; bluecell_Currdatastatus.ATT_DL4_PATH = false; bluecell_Currdatastatus.ATT_UL1_PATH = false; bluecell_Currdatastatus.ATT_UL2_PATH = false; bluecell_Currdatastatus.ATT_UL3_PATH = false; bluecell_Currdatastatus.ATT_UL4_PATH = false; // printf("Path OFF \r\n"); bluecell_Currdatastatus.ALARM_TEMP_HIGH = 0; bluecell_Currdatastatus.ALARM_DLI_Level = 0; bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN = 0; bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm = 0; bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm = 0; bluecell_Currdatastatus.ALARM_ULO_Level = 0; bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN = 0; bluecell_Currdatastatus.DLI_Shutdown_Alarm1 = false; bluecell_Currdatastatus.DLI_Shutdown_Alarm2 = false; bluecell_Currdatastatus.DLI_Shutdown_Alarm3 = false; bluecell_Currdatastatus.DLI_Shutdown_Alarm4 = false; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 = false; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 = false; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = false; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm1 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm2 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm3 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm4 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm1 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm2 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm3 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm4 = false; } DL_Path_OnOff(Path1_OnOff, bluecell_Currdatastatus.ATT_DL1_PATH, &bluecell_Currdatastatus.ATT_DL1_PATH, &bluecell_Prevdatastatus.ATT_DL1_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count1) ; DL_Path_OnOff(Path2_OnOff, bluecell_Currdatastatus.ATT_DL2_PATH, &bluecell_Currdatastatus.ATT_DL2_PATH, &bluecell_Prevdatastatus.ATT_DL2_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count2) ; DL_Path_OnOff(Path3_OnOff, bluecell_Currdatastatus.ATT_DL3_PATH, &bluecell_Currdatastatus.ATT_DL3_PATH, &bluecell_Prevdatastatus.ATT_DL3_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count3) ; DL_Path_OnOff(Path4_OnOff, bluecell_Currdatastatus.ATT_DL4_PATH, &bluecell_Currdatastatus.ATT_DL4_PATH, &bluecell_Prevdatastatus.ATT_DL4_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count4) ; UL_Path_OnOff(Path1_OnOff, bluecell_Currdatastatus.ATT_UL1_PATH, &bluecell_Currdatastatus.ATT_UL1_PATH, &bluecell_Prevdatastatus.ATT_UL1_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count1) ; UL_Path_OnOff(Path2_OnOff, bluecell_Currdatastatus.ATT_UL2_PATH, &bluecell_Currdatastatus.ATT_UL2_PATH, &bluecell_Prevdatastatus.ATT_UL2_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count2) ; UL_Path_OnOff(Path3_OnOff, bluecell_Currdatastatus.ATT_UL3_PATH, &bluecell_Currdatastatus.ATT_UL3_PATH, &bluecell_Prevdatastatus.ATT_UL3_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count3) ; UL_Path_OnOff(Path4_OnOff, bluecell_Currdatastatus.ATT_UL4_PATH, &bluecell_Currdatastatus.ATT_UL4_PATH, &bluecell_Prevdatastatus.ATT_UL4_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count4) ; // HAL_Delay(10); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); } #define OVERPOWER_STR "Overpower" #define OVER_INPUT_STR "Over-Input" #define ALARM_REPORT_LENGTH 42 //uint8_t AlarmReport_History[Alarm_type_IndexMax] = {0,}; volatile uint8_t Alarm_ReportData[40 + 2 + 22 + 3] = {0,}; // 40 Alarm Data + 2 UNIT ID, 21 Header , 3 Tail void Alarm_Report_Send(uint16_t Alarm_type,uint8_t val){ // if(AlarmReport_History[Alarm_type] != true){ // return; // } uint8_t index = 0; Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0x00; //UNIT ID0 Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0xF1; //UNIT ID1 Alarm_ReportData[MBIC_PAYLOADSTART + index++] = (uint8_t)((Alarm_type & 0xFF00) >> 8); //A ID 0 Alarm_ReportData[MBIC_PAYLOADSTART + index++] = (uint8_t)(Alarm_type & 0x00FF); //A ID 1 Alarm_ReportData[MBIC_PAYLOADSTART + index++] = val; //Status 1 Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0; //Alarm Time Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0; //Alarm Time Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0; //Alarm Time Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0; //Alarm Time Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0; //Alarm Time Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0; //Alarm Time Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0; //Clear Time Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0; //Clear Time Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0; //Clear Time Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0; //Clear Time Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0; //Clear Time Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0; //Clear Time Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0; //Band ID : MBIC : 0x00 Default Alarm_ReportData[MBIC_PAYLOADSTART + index++] = bluecell_Currdatastatus.Carrier_ID; Alarm_ReportData[MBIC_PAYLOADSTART + index++] = bluecell_Currdatastatus.Freq_ID; Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;//Alarm SeqNum0 RF Board Default 0 Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;//Alarm SeqNum1 RF Board Default 0 // 0~ 19 for(int i = MBIC_PAYLOADSTART + 22; i < MBIC_PAYLOADSTART + ALARM_REPORT_LENGTH; i++) Alarm_ReportData[i] = 0; int16_t LimitData_UL_High = 0; int16_t LimitData_DL_High = 0; int16_t LimitData_DL_Low = 0; int16_t LimitData_DL_Shutdown = 0; int16_t LimitData_UL_Shutdown = 0; double ret = 0; int16_t Res_DL_dBm[DET_Alarm_DL_Index_MAX] = {0,}; int16_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) * 0.1; LimitData_DL_High = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level_High_Threshold_H,bluecell_Currdatastatus.DLI_Level_High_Threshold_L)* 0.1; LimitData_DL_Low = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level_Low_Threshold_H,bluecell_Currdatastatus.DLI_Level_Low_Threshold_L)* 0.1; LimitData_DL_Shutdown = ConvertTo2byte(bluecell_Currdatastatus.DLI_Shutdown_Threshold_H,bluecell_Currdatastatus.DLI_Shutdown_Threshold_L)* 0.1; LimitData_UL_Shutdown = ConvertTo2byte(bluecell_Currdatastatus.ULO_Shutdown_Threshold_H,bluecell_Currdatastatus.ULO_Shutdown_Threshold_L)* 0.1; ret = bluecell_Currdatastatus.DLI_P1_Level1_H << 8; ret += bluecell_Currdatastatus.DLI_P1_Level1_L; ret *= 0.001; Res_DL_dBm[DET_Alarm_DL1_Index] = bluecell_Currdatastatus.DLI_Level1_H << 8 | bluecell_Currdatastatus.DLI_Level1_L;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st))); ret = bluecell_Currdatastatus.DLI_P2_Level2_H << 8; ret += bluecell_Currdatastatus.DLI_P2_Level2_L; ret *= 0.001; Res_DL_dBm[DET_Alarm_DL2_Index] = bluecell_Currdatastatus.DLI_Level2_H << 8 | bluecell_Currdatastatus.DLI_Level2_L;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st))); ret = bluecell_Currdatastatus.DLI_P3_Level3_H << 8; ret += bluecell_Currdatastatus.DLI_P3_Level3_L; ret *= 0.001; Res_DL_dBm[DET_Alarm_DL3_Index] = bluecell_Currdatastatus.DLI_Level3_H << 8 | bluecell_Currdatastatus.DLI_Level3_L;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st))); ret = bluecell_Currdatastatus.DLI_P4_Level4_H << 8; ret += bluecell_Currdatastatus.DLI_P4_Level4_L; ret *= 0.001; Res_DL_dBm[DET_Alarm_DL4_Index] = bluecell_Currdatastatus.DLI_Level4_H << 8 | bluecell_Currdatastatus.DLI_Level4_L;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st))); ret = bluecell_Currdatastatus.ULO_P1_Level1_H << 8; ret += bluecell_Currdatastatus.ULO_P1_Level1_L; ret *= 0.001; Res_UL_dBm[DET_Alarm_UL1_Index] = bluecell_Currdatastatus.ULO_Level1_H << 8 | bluecell_Currdatastatus.ULO_Level1_L; //(int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,Det_UL1.Table_Length * 2)); ret = bluecell_Currdatastatus.ULO_P2_Level2_H << 8; ret += bluecell_Currdatastatus.ULO_P2_Level2_L; ret *= 0.001; Res_UL_dBm[DET_Alarm_UL2_Index] = bluecell_Currdatastatus.ULO_Level2_H << 8 | bluecell_Currdatastatus.ULO_Level2_L;//(int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL2.Table_Det_15_dBm_H,Det_UL2.Table_Length * 2)); ret = bluecell_Currdatastatus.ULO_P3_Level3_H << 8; ret += bluecell_Currdatastatus.ULO_P3_Level3_L; ret *= 0.001; Res_UL_dBm[DET_Alarm_UL3_Index] = bluecell_Currdatastatus.ULO_Level3_H << 8 | bluecell_Currdatastatus.ULO_Level3_L;//(int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,Det_UL3.Table_Length * 2)); ret = bluecell_Currdatastatus.ULO_P4_Level4_H << 8; ret += bluecell_Currdatastatus.ULO_P4_Level4_L; ret *= 0.001; Res_UL_dBm[DET_Alarm_UL4_Index] = bluecell_Currdatastatus.ULO_Level4_H << 8 | bluecell_Currdatastatus.ULO_Level4_L;//(int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,Det_UL4.Table_Length * 2)); for(int i = 0; i < DET_Alarm_DL_Index_MAX; i++) Res_DL_dBm[DET_Alarm_DL1_Index + i] *= 0.1; for(int i = 0; i < DET_Alarm_UL_Index_MAX; i++) Res_UL_dBm[DET_Alarm_UL1_Index + i] *= 0.1; switch(Alarm_type){ case Temp_High: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"Temp:%d, Th:%d",bluecell_Currdatastatus.DET_TEMP,bluecell_Currdatastatus.Temp_High_Threshold); break; case DLI_P4_Level_Low: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%d, Th:%d",Res_DL_dBm[DET_Alarm_DL1_Index],LimitData_DL_Low); break; case DLI_P3_Level_Low: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%d, Th:%d",Res_DL_dBm[DET_Alarm_DL2_Index],LimitData_DL_Low); break; case DLI_P2_Level_Low: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%d, Th:%d",Res_DL_dBm[DET_Alarm_DL3_Index],LimitData_DL_Low); break; case DLI_P1_Level_Low: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%d, Th:%d",Res_DL_dBm[DET_Alarm_DL4_Index],LimitData_DL_Low); break; case DLI_P4_Level_High: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%d, Th:%d",Res_DL_dBm[DET_Alarm_DL1_Index],LimitData_DL_High); break; case DLI_P3_Level_High: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%d, Th:%d",Res_DL_dBm[DET_Alarm_DL2_Index],LimitData_DL_High); break; case DLI_P2_Level_High: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%d, Th:%d",Res_DL_dBm[DET_Alarm_DL3_Index],LimitData_DL_High); break; case DLI_P1_Level_High: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%d, Th:%d",Res_DL_dBm[DET_Alarm_DL4_Index],LimitData_DL_High); break; case DLI_P4_AGC_Alarm: case DLI_P3_AGC_Alarm: case DLI_P2_AGC_Alarm: case DLI_P1_AGC_Alarm: break; case DLI_P4_Shutdown_Alarm: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVERPOWER_STR); break; case DLI_P3_Shutdown_Alarm: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVERPOWER_STR); break; case DLI_P2_Shutdown_Alarm: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVERPOWER_STR); break; case DLI_P1_Shutdown_Alarm: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVERPOWER_STR); break; case ULO_P4_Level_High: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"ULO:%d, Th:%d",Res_UL_dBm[DET_Alarm_UL1_Index],LimitData_UL_High); break; case ULO_P3_Level_High: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"ULO:%d, Th:%d",Res_UL_dBm[DET_Alarm_UL2_Index],LimitData_UL_High); break; case ULO_P2_Level_High: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"ULO:%d, Th:%d",Res_UL_dBm[DET_Alarm_UL3_Index],LimitData_UL_High); break; case ULO_P1_Level_High: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"ULO:%d, Th:%d",Res_UL_dBm[DET_Alarm_UL4_Index],LimitData_UL_High); break; case ULO_P4_ALC_Alarm: case ULO_P3_ALC_Alarm: case ULO_P2_ALC_Alarm: case ULO_P1_ALC_Alarm: break; case ULO_P4_Shutdown: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVER_INPUT_STR); break; case ULO_P3_Shutdown: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVER_INPUT_STR); break; case ULO_P2_Shutdown: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVER_INPUT_STR); break; case ULO_P1_Shutdown: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVER_INPUT_STR); break; default: printf("Wrong Type \r\n");break; } // Alarm_ReportData[MBIC_PAYLOADSTART + 1] = Alarm_type; // Alarm_ReportData[MBIC_PAYLOADSTART + 2] = val; // printf("%s \r\n",&Alarm_ReportData[MBIC_PAYLOADSTART + 22]); // printf("Type : %x size length : %d \r\n",Alarm_type,sizeof(Alarm_ReportData)); // MBIC_HeaderMergeFunction(Alarm_ReportData,ALARM_REPORT_LENGTH); Alarm_ReportData[MBIC_PREAMBLE_0] = MBIC_PREAMBLE0; Alarm_ReportData[MBIC_PREAMBLE_1] = MBIC_PREAMBLE1; Alarm_ReportData[MBIC_PREAMBLE_2] = MBIC_PREAMBLE2; Alarm_ReportData[MBIC_PREAMBLE_3] = MBIC_PREAMBLE3; Alarm_ReportData[MBIC_SUBUID_0] = MBIC_SUBUID0; Alarm_ReportData[MBIC_SUBUID_1] = MBIC_SUBUID1; Alarm_ReportData[MBIC_RCODE_0] = 0; Alarm_ReportData[MBIC_TRID_0] = 0; Alarm_ReportData[MBIC_TRID_1] = 0; Alarm_ReportData[MBIC_SEQSUM_0] = 0; Alarm_ReportData[MBIC_TTL_0] = 0; Alarm_ReportData[MBIC_TIME_0] = 0; Alarm_ReportData[MBIC_TIME_1] = 0; Alarm_ReportData[MBIC_TIME_2] = 0; Alarm_ReportData[MBIC_TIME_3] = 0; Alarm_ReportData[MBIC_TIME_4] = 0; Alarm_ReportData[MBIC_TIME_5] = 0; Alarm_ReportData[MBIC_ERRRESPONSE_0] = MBIC_ERRRESPONSE; Alarm_ReportData[MBIC_CMD_0] = 0xF1; Alarm_ReportData[MBIC_LENGTH_0] = (ALARM_REPORT_LENGTH & 0xFF00) >> 8; Alarm_ReportData[MBIC_LENGTH_1] = ALARM_REPORT_LENGTH & 0x00FF; Alarm_ReportData[MBIC_HEADERCHECKSUM_0] = Chksum_Create(Alarm_ReportData); uint16_t crcret =CRC16_Generate(&Alarm_ReportData[MBIC_PAYLOADSTART], ALARM_REPORT_LENGTH); // printf("\r\n crc ret : %x \r\n",crcret); Alarm_ReportData[MBIC_PAYLOADSTART + 42] =(( crcret & 0xFF00)>> 8); // printf(" Alarm_ReportData[MBIC_PAYLOADSTART + 41] : %x \r\n", Alarm_ReportData[MBIC_PAYLOADSTART + 41]); Alarm_ReportData[MBIC_PAYLOADSTART + 43] = (( crcret & 0x00FF)); // printf(" Alarm_ReportData[MBIC_PAYLOADSTART + 42] : %x \r\n", Alarm_ReportData[MBIC_PAYLOADSTART + 42]); Alarm_ReportData[MBIC_PAYLOADSTART + 44] = 0x03; // printf(" Alarm_ReportData[MBIC_PAYLOADSTART + 43] : %x \r\n", Alarm_ReportData[MBIC_PAYLOADSTART + 43]); Uart1_Data_Send(&Alarm_ReportData[0],sizeof(Alarm_ReportData)); // printf(" Alarm_ReportData[MBIC_PAYLOADSTART + 42] : %x \r\n", Alarm_ReportData[MBIC_PAYLOADSTART + 42]); } void DLI_FRBT_ONOFF_Set(bool val){ if(val == 0){ bluecell_Currdatastatus.DLI_FRBT_Status = FRBT_IDEL; for(int i = 0; i < DLI_FRBT_Time_Index_Max; i++){ PrevFRBT_Day[DLI_FRBT_Time_Year + i] = FRBT_Day[DLI_FRBT_Time_Year + i] = 0; } } else{ bluecell_Currdatastatus.DLI_FRBT_Status = FRBT_TRACKING; } bluecell_Currdatastatus.DLI_FRBT_ON_OFF = val; bluecell_Currdatastatus.DLI_FRBT_Atten1_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten2_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten3_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten4_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten1_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten2_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten3_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten4_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_D_Day = DLI_FRBT_DAY_DEFAULT; Last_Day = 0; Prev_Last_Day = 0; FRBT_UserCtrl = 0; timeset_init = false; // 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)); } bool MBIC_Operate(uint8_t* data){ // Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st)); uint8_t datatype = data[MBIC_PAYLOADSTART + 1]; // uint8_t Length = (data[MBIC_PROT_SUB_DATA_INDEX + 2]); uint8_t cmd = data[MBIC_PROT_CMD_INDEX]; int16_t Tmpdata = 0; int16_t Tmpdata2 = 0; int16_t tempdata = 0; /*Day Save*/ TimeSetting(&data[MBIC_TIME_0]); for(int k = 0; k < 2048; k++) TxData[k] = data[k]; data = TxData; uint16_t Length = data[MBIC_LENGTH_0] << 8 | data[MBIC_LENGTH_1]; //uint8_t* Tempdata; uint16_t occurlen = Length; /*AID*/ /* for(int i = 0; i < Length; i++){ SubData[i] = (data[MBIC_PROT_SUB_DATA_INDEX + 3 + i]); }*/ // SubData 임시 데이터 변수 선언 Subdata로 데이터 전송 // printf("%s : %d CMD : %x\r\n",__func__,__LINE__,data[MBIC_PROT_CMD_INDEX]); data[MBIC_PREAMBLE_0] = MBIC_PREAMBLE0; data[MBIC_PREAMBLE_1] = MBIC_PREAMBLE1; data[MBIC_PREAMBLE_2] = MBIC_PREAMBLE2; data[MBIC_PREAMBLE_3] = MBIC_PREAMBLE3; data[MBIC_SUBUID_0] = MBIC_SUBUID0; data[MBIC_SUBUID_1] = MBIC_SUBUID1; data[MBIC_RCODE_0] = data[MBIC_RCODE_0]; data[MBIC_TRID_0] = data[MBIC_TRID_0]; data[MBIC_TRID_1] = data[MBIC_TRID_1]; data[MBIC_SEQSUM_0] = data[MBIC_SEQSUM_0]; data[MBIC_TTL_0] = data[MBIC_TTL_0]; data[MBIC_TIME_0] = data[MBIC_TIME_0]; data[MBIC_TIME_1] = data[MBIC_TIME_1]; data[MBIC_TIME_2] = data[MBIC_TIME_2]; data[MBIC_TIME_3] = data[MBIC_TIME_3]; data[MBIC_TIME_4] = data[MBIC_TIME_4]; data[MBIC_TIME_5] = data[MBIC_TIME_5]; data[MBIC_ERRRESPONSE_0] = MBIC_ERRRESPONSE; if(cmd == MBIC_GET){ if(Initialize == false){ Bluecell_DataInit(); Bluecell_AttenInitialize(); Initialize = true; } HFR_TypeInit(); data[MBIC_CMD_0] = 0x80;//MBIC_ERRRESPONSE; Length = MBIC_DataSend(data); } else if(cmd == MBIC_SET){ protocolReplay: datatype = data[MBIC_PAYLOADSTART + 1]; // printf("datatype : %x \r\n",datatype); // printf("bluecell_Currdatastatus.Carrier_ON_OFF : %d \r\n",bluecell_Currdatastatus.Carrier_ON_OFF); switch(datatype){ case Alarm_Mask : bluecell_Currdatastatus.ALARM_MASK1 = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.ALARM_MASK2 = data[MBIC_PAYLOADSTART + 4]; bluecell_Currdatastatus.ALARM_MASK3 = data[MBIC_PAYLOADSTART + 5]; bluecell_Currdatastatus.ALARM_MASK4 = data[MBIC_PAYLOADSTART + 6]; bluecell_Currdatastatus.ALARM_MASK5 = data[MBIC_PAYLOADSTART + 7]; // printf("bluecell_Currdatastatus.ALARM_MASK1 : %x \r\n",data[MBIC_PAYLOADSTART + 3]); // printf("bluecell_Currdatastatus.ALARM_MASK2 : %x \r\n",data[MBIC_PAYLOADSTART + 4]); // printf("bluecell_Currdatastatus.ALARM_MASK3 : %x \r\n",data[MBIC_PAYLOADSTART + 5]); // printf("bluecell_Currdatastatus.ALARM_MASK4 : %x \r\n",data[MBIC_PAYLOADSTART + 6]); // printf("bluecell_Currdatastatus.ALARM_MASK5 : %x \r\n",data[MBIC_PAYLOADSTART + 7]); break; case Alarm_Test_Mode : bluecell_Currdatastatus.ALARM_TESTMODE = data[MBIC_PAYLOADSTART + 3]; // printf("Alarm Test mode Data : "); // for(int i = 0 ; i < 8 ; i++){ // printf("%x ",data[MBIC_PAYLOADSTART + 3 + i]); // } // printf("\r\n"); if(bluecell_Currdatastatus.ALARM_TESTMODE == false){ bluecell_Currdatastatus.ALARM_Test_Dummy1 = 0; bluecell_Currdatastatus.ALARM_Test_Dummy2 = 0; bluecell_Currdatastatus.ALARM_Test_Dummy3 = 0; bluecell_Currdatastatus.ALARM_Test_Dummy4 = 0; bluecell_Currdatastatus.ALARM_Test_Dummy5 = 0; } // printf("Alarm Test Mode start"); break; case Alarm_Test_Dummy : bluecell_Currdatastatus.ALARM_Test_Dummy1 = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.ALARM_Test_Dummy2 = data[MBIC_PAYLOADSTART + 4]; bluecell_Currdatastatus.ALARM_Test_Dummy3 = data[MBIC_PAYLOADSTART + 5]; bluecell_Currdatastatus.ALARM_Test_Dummy4 = data[MBIC_PAYLOADSTART + 6]; bluecell_Currdatastatus.ALARM_Test_Dummy5 = data[MBIC_PAYLOADSTART + 7]; // printf("Dummy 1 : %x \r\n",bluecell_Currdatastatus.ALARM_Test_Dummy1); // printf("Dummy 2 : %x \r\n",bluecell_Currdatastatus.ALARM_Test_Dummy2); // printf("Dummy 3 : %x \r\n",bluecell_Currdatastatus.ALARM_Test_Dummy3); // printf("Dummy 4 : %x \r\n",bluecell_Currdatastatus.ALARM_Test_Dummy4); // printf("Dummy 5 : %x \r\n",bluecell_Currdatastatus.ALARM_Test_Dummy5); break; case CPU_Bank_Select_Reboot_by : bluecell_Currdatastatus.CPU_Bank_Select = data[MBIC_PAYLOADSTART + 3]; if(bluecell_Currdatastatus.CPU_Bank_Select == HFR_AUTO_SEL){ // printf("Curr Bank : %d \r\n",bluecell_Currdatastatus.CPU_Current_Bank); if(bluecell_Currdatastatus.CPU_Current_Bank == HFR_BANK1_SEL){ bluecell_Currdatastatus.CPU_Bank_Select = HFR_BANK2_SEL; }else{ bluecell_Currdatastatus.CPU_Bank_Select = HFR_BANK1_SEL; } } 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) ); printf("bluecell_Currdatastatus.FRBT ON OFF : %d \r\n",bluecell_Currdatastatus.DLI_FRBT_ON_OFF); printf("bluecell_Currdatastatus.CPU_Bank_Select : %d \r\n",bluecell_Currdatastatus.CPU_Bank_Select); printf("I will Booting Bank : %d \r\n",bluecell_Currdatastatus.CPU_Current_Bank); printf("Reset : \r\n"); NVIC_SystemReset(); break; case SW_Reset : // Table_LengSet(); printf("MBIC SoftWare Reset Start \r\n"); bluecell_Currdatastatus.S_W_Reset = data[MBIC_PAYLOADSTART + 3]; NVIC_SystemReset(); break; case Factory_Set_Initialization : bluecell_Currdatastatus.Factory_Set_Initialization = data[MBIC_PAYLOADSTART + 3]; Factory_Set(); break; case Temperature_Offset : bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET = data[MBIC_PAYLOADSTART + 3]; // printf("%s : %d \r\n",__func__,__LINE__); break; case Temp_High_Threshold : bluecell_Currdatastatus.Temp_High_Threshold = data[MBIC_PAYLOADSTART + 3]; break; case Temp_High_Threshold_Default : bluecell_Currdatastatus.Temp_High_Threshold = Temp_THREADHOLD_DEFAULT; // bluecell_Currdatastatus.Temp_High_Threshold_Default = data[MBIC_PAYLOADSTART + 3]; break; case LED_TEST : bluecell_Currdatastatus.LED_TEST = data[MBIC_PAYLOADSTART + 3]; break; case PCB_Version: for(int i = 0 ; i < 2; i++) bluecell_Currdatastatus.PCB_Version[i] = data[MBIC_PAYLOADSTART + 3 + i]; break; case Serial_Number: for(int i = 0 ; i < 20; i++) bluecell_Currdatastatus.Serial_Number[i] = data[MBIC_PAYLOADSTART + 3 + i]; break; case Manufacture_Date: for(int i = 0 ; i < 3; i++) bluecell_Currdatastatus.Manufacture_Date[i] = data[MBIC_PAYLOADSTART + 3 + i]; break; case DL_UL_SUM_PATH_ON_OFF: bluecell_Currdatastatus.DL_UL_Sum_Path_ON_OFF = data[MBIC_PAYLOADSTART + 3]; // printf("bluecell_Currdatastatus.DL_UL_Sum_Path_ON_OFF : %d \r\n",bluecell_Currdatastatus.DL_UL_Sum_Path_ON_OFF); Temp_Shutdown_ONOFF(bluecell_Currdatastatus.DL_UL_Sum_Path_ON_OFF); // printf("bluecell_Currdatastatus.DL_UL_Sum_Path_ON_OFF : %d \r\n",bluecell_Currdatastatus.DL_UL_Sum_Path_ON_OFF); // printf(" bluecell_Currdatastatus.ATT_DL1_PATH : %d \r\n", bluecell_Currdatastatus.ATT_DL1_PATH); break; case Carrier_ON_OFF : // for(int tt = 0; tt < 4; tt++) // printf("Carrier : data[MBIC_PAYLOADSTART + %d] : %x \r\n",tt,data[MBIC_PAYLOADSTART + tt]); bluecell_Currdatastatus.Carrier_ON_OFF = data[MBIC_PAYLOADSTART + 3]; Carrier_ONOFF(bluecell_Currdatastatus.Carrier_ON_OFF); // printf("bluecell_Currdatastatus.Carrier_ON_OFF : %x \r\n",bluecell_Currdatastatus.Carrier_ON_OFF); break; case DLI_RF_Path1_ON_OFF : // printf("data[MBIC_PAYLOADSTART + 3] : %d \r\n",data[MBIC_PAYLOADSTART + 3]); if(bluecell_Currdatastatus.Carrier_ON_OFF == false){ break; // return true; } if(data[MBIC_PAYLOADSTART + 3] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x80; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x80; DL_Path_OnOff(Path1_OnOff, data[MBIC_PAYLOADSTART + 3], &bluecell_Currdatastatus.ATT_DL1_PATH, &bluecell_Prevdatastatus.ATT_DL1_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count1) ; break; case DLI_RF_Path2_ON_OFF : // printf("data[MBIC_PAYLOADSTART + 3] : %d \r\n",data[MBIC_PAYLOADSTART + 3]); if(bluecell_Currdatastatus.Carrier_ON_OFF == false){ break; // return true; } if(data[MBIC_PAYLOADSTART + 3] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x40; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x40; DL_Path_OnOff(Path2_OnOff, data[MBIC_PAYLOADSTART + 3], &bluecell_Currdatastatus.ATT_DL2_PATH, &bluecell_Prevdatastatus.ATT_DL2_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count2) ; break; case DLI_RF_Path3_ON_OFF : // printf("data[MBIC_PAYLOADSTART + 3] : %d \r\n",data[MBIC_PAYLOADSTART + 3]); if(bluecell_Currdatastatus.Carrier_ON_OFF == false){ break; // return true; } if(data[MBIC_PAYLOADSTART + 3] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x20; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x20; DL_Path_OnOff(Path3_OnOff, data[MBIC_PAYLOADSTART + 3], &bluecell_Currdatastatus.ATT_DL3_PATH, &bluecell_Prevdatastatus.ATT_DL3_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count3) ; break; case DLI_RF_Path4_ON_OFF : // printf("data[MBIC_PAYLOADSTART + 3] : %d \r\n",data[MBIC_PAYLOADSTART + 3]); if(bluecell_Currdatastatus.Carrier_ON_OFF == false){ break; // return true; } if(data[MBIC_PAYLOADSTART + 3] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x10; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x10; DL_Path_OnOff(Path4_OnOff, data[MBIC_PAYLOADSTART + 3], &bluecell_Currdatastatus.ATT_DL4_PATH, &bluecell_Prevdatastatus.ATT_DL4_H, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count4); break; case DLI_Gain_Atten1 : if(bluecell_Currdatastatus.SelfTest == true || bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_RUNNING)break; tempdata = bluecell_Currdatastatus.DLI_FRBT_Atten1_H << 8 | bluecell_Currdatastatus.DLI_FRBT_Atten1_L; Tmpdata2 = data[MBIC_PAYLOADSTART + 3] << 8 | data[MBIC_PAYLOADSTART + 4]; if(tempdata < Tmpdata2){ break; } // printf("DLI Gain Setting Complete: %d \r\n",Tmpdata2); bluecell_Currdatastatus.ATT_DL1_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.ATT_DL1_L = data[MBIC_PAYLOADSTART + 4]; DL_PrevIwillgiveAtten[AGC_Alarm_DL1_Index] = 0; // printf("bluecell_Currdatastatus.ATT_DL1_H : %x\r\n",bluecell_Currdatastatus.ATT_DL1_H); // printf("bluecell_Currdatastatus.ATT_DL1_L : %x\r\n",bluecell_Currdatastatus.ATT_DL1_L); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case DLI_Gain_Atten2 : if(bluecell_Currdatastatus.SelfTest == true || bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_RUNNING)break; tempdata = bluecell_Currdatastatus.DLI_FRBT_Atten2_H << 8 | bluecell_Currdatastatus.DLI_FRBT_Atten2_L; Tmpdata2 = data[MBIC_PAYLOADSTART + 3] << 8 | data[MBIC_PAYLOADSTART + 4]; if(tempdata < Tmpdata2){ break; } bluecell_Currdatastatus.ATT_DL2_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.ATT_DL2_L = data[MBIC_PAYLOADSTART + 4]; DL_PrevIwillgiveAtten[AGC_Alarm_DL2_Index] = 0; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); // printf("bluecell_Currdatastatus.ATT_DL2_H : %x\r\n",bluecell_Currdatastatus.ATT_DL2_H); // printf("bluecell_Currdatastatus.ATT_DL2_L : %x\r\n",bluecell_Currdatastatus.ATT_DL2_L); break; case DLI_Gain_Atten3 : if(bluecell_Currdatastatus.SelfTest == true || bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_RUNNING)break; tempdata = bluecell_Currdatastatus.DLI_FRBT_Atten3_H << 8 | bluecell_Currdatastatus.DLI_FRBT_Atten3_L; Tmpdata2 = data[MBIC_PAYLOADSTART + 3] << 8 | data[MBIC_PAYLOADSTART + 4]; if(tempdata < Tmpdata2){ break; } bluecell_Currdatastatus.ATT_DL3_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.ATT_DL3_L = data[MBIC_PAYLOADSTART + 4]; DL_PrevIwillgiveAtten[AGC_Alarm_DL3_Index] = 0; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case DLI_Gain_Atten4 : if(bluecell_Currdatastatus.SelfTest == true || bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_RUNNING)break; tempdata = bluecell_Currdatastatus.DLI_FRBT_Atten4_H << 8 | bluecell_Currdatastatus.DLI_FRBT_Atten4_L; Tmpdata2 = data[MBIC_PAYLOADSTART + 3] << 8 | data[MBIC_PAYLOADSTART + 4]; if(tempdata < Tmpdata2){ break; } bluecell_Currdatastatus.ATT_DL4_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.ATT_DL4_L = data[MBIC_PAYLOADSTART + 4]; DL_PrevIwillgiveAtten[AGC_Alarm_DL4_Index] = 0; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case DLI_Gain_Atten_Offset1 : bluecell_Currdatastatus.bluecell_User_DL1_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.bluecell_User_DL1_L = data[MBIC_PAYLOADSTART + 4]; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case DLI_Gain_Atten_Offset2 : bluecell_Currdatastatus.bluecell_User_DL2_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.bluecell_User_DL2_L = data[MBIC_PAYLOADSTART + 4]; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case DLI_Gain_Atten_Offset3 : bluecell_Currdatastatus.bluecell_User_DL3_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.bluecell_User_DL3_L = data[MBIC_PAYLOADSTART + 4]; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case DLI_Gain_Atten_Offset4 : bluecell_Currdatastatus.bluecell_User_DL4_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.bluecell_User_DL4_L = data[MBIC_PAYLOADSTART + 4]; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case DLI_Level_High_Threshold : bluecell_Currdatastatus.DLI_Level_High_Threshold_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.DLI_Level_High_Threshold_L = data[MBIC_PAYLOADSTART + 4]; break; case DLI_Level_Low_Threshold : bluecell_Currdatastatus.DLI_Level_Low_Threshold_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.DLI_Level_Low_Threshold_L = data[MBIC_PAYLOADSTART + 4]; break; case DLI_Level_High_Low_Threshold_default : tempdata = DLI_ATTEN_HIGHTHREADHOLD_DEFAULT; bluecell_Currdatastatus.DLI_Level_High_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_Level_High_Threshold_L = ((tempdata & 0x00FF)); tempdata = DLI_ATTEN_LOWTHREADHOLD_DEFAULT; bluecell_Currdatastatus.DLI_Level_Low_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_Level_Low_Threshold_L = ((tempdata & 0x00FF)); // bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default = data[MBIC_PAYLOADSTART + 3]; break; case DLI_FRBT_D_Day: bluecell_Currdatastatus.DLI_FRBT_D_Day = data[MBIC_PAYLOADSTART + 3]; if(bluecell_Currdatastatus.DLI_FRBT_D_Day > 7) bluecell_Currdatastatus.DLI_FRBT_D_Day = 7; break; case DLI_FRBT_ON_OFF: #if 0 // PYJ.2020.12.16_BEGIN -- if(data[MBIC_PAYLOADSTART + 3] == 0){ // FRBT OFF bluecell_Currdatastatus.DLI_FRBT_Status = FRBT_IDEL; for(int i = 0; i < DLI_FRBT_Time_Index_Max; i++){ PrevFRBT_Day[DLI_FRBT_Time_Year + i] = FRBT_Day[DLI_FRBT_Time_Year + i] = 0; } Last_Day = 0; Prev_Last_Day = 0; FRBT_UserCtrl = 0; } else{ bluecell_Currdatastatus.DLI_FRBT_Status = FRBT_TRACKING; } DLI_FRBT_ON_OFF_Set(data[MBIC_PAYLOADSTART + 3]); bluecell_Currdatastatus.DLI_FRBT_Atten1_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten2_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten3_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten4_H = DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten1_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten2_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten3_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_Atten4_L= DLI_FRBT_ATTEN_DEFALUT; bluecell_Currdatastatus.DLI_FRBT_D_Day = DLI_FRBT_DAY_DEFAULT; #else DLI_FRBT_ONOFF_Set(data[MBIC_PAYLOADSTART + 3]); #endif // PYJ.2020.12.16_END -- // printf("data[MBIC_PAYLOADSTART + 3] : %d \r\n",data[MBIC_PAYLOADSTART + 3]); break; case DLI_AGC_ON_OFF : /*AGC multi apply*/ bluecell_Currdatastatus.DLI_AGC_ON_OFF = data[MBIC_PAYLOADSTART + 3]; if( bluecell_Currdatastatus.DLI_AGC_ON_OFF == false){ AGC_AlarmSet[AGC_Alarm_DL1_Index] = false; AGC_AlarmSet[AGC_Alarm_DL2_Index] = false; AGC_AlarmSet[AGC_Alarm_DL3_Index] = false; AGC_AlarmSet[AGC_Alarm_DL4_Index] = false; bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm = 0; } DL_AGC_StartAtten[AGC_Alarm_DL1_Index] = bluecell_Currdatastatus.ATT_DL1_H << 8 | bluecell_Currdatastatus.ATT_DL1_L; DL_AGC_StartAtten[AGC_Alarm_DL2_Index] = bluecell_Currdatastatus.ATT_DL2_H << 8 | bluecell_Currdatastatus.ATT_DL2_L; DL_AGC_StartAtten[AGC_Alarm_DL3_Index] = bluecell_Currdatastatus.ATT_DL3_H << 8 | bluecell_Currdatastatus.ATT_DL3_L; DL_AGC_StartAtten[AGC_Alarm_DL4_Index] = bluecell_Currdatastatus.ATT_DL4_H << 8 | bluecell_Currdatastatus.ATT_DL4_L; for(int i = 0; i < AGC_Alarm_DL_Index_MAX; i++){ DL_PrevIwillgiveAtten[i]= 0; } break; case DLI_AGC_Threshold : tempdata = data[MBIC_PAYLOADSTART + 3] << 8 | data[MBIC_PAYLOADSTART + 4]; if(tempdata < -250){ tempdata = -250; // printf("Change SHUTDOWN THREAD HLOD : %d \r\n",tempdata); } bluecell_Currdatastatus.DLI_AGC_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_AGC_Threshold_L = ((tempdata & 0x00FF)); break; case DLI_AGC_Threshold_Default : tempdata = DLI_AGC_THREADHOLD_DEFAULT; bluecell_Currdatastatus.DLI_AGC_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_AGC_Threshold_L = ((tempdata & 0x00FF)); // bluecell_Currdatastatus.DLI_AGC_Threshold_default = data[MBIC_PAYLOADSTART + 3]; break; case DLI_Shutdown_ON_OFF : bluecell_Currdatastatus.DLI_Shutdown_ON_OFF = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 = 0; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 = 0; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = 0; bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 = 0; for(int i = 0; i < DET_Alarm_DL_Index_MAX; i++){ DET_DL_Shutdown_Off_AlarmTimerCnt[i] = 0; DET_DL_Shutdown_On_AlarmTimerCnt[i] = 0; DET_DL_Normal_Shutdown_On_AlarmTimerCnt[i] = 0; } break; case DLI_Shutdown_Threshold : tempdata = data[MBIC_PAYLOADSTART + 3] << 8 | data[MBIC_PAYLOADSTART + 4]; if(tempdata < -250){ tempdata = -250; // printf("Change SHUTDOWN THREAD HLOD : %d \r\n",tempdata); } bluecell_Currdatastatus.DLI_Shutdown_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_Shutdown_Threshold_L = ((tempdata & 0x00FF)); // printf("DLI SHUTDOWN THREAD HLOD : %d \r\n",tempdata); break; case DLI_Shutdown_Threshold_Default : tempdata = DLI_SHUTDOWN_THREADHOLD_DEFAULT; bluecell_Currdatastatus.DLI_Shutdown_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_Shutdown_Threshold_L = ((tempdata & 0x00FF)); break; case ULO_RF_Path1_ON_OFF : // printf("data[MBIC_PAYLOADSTART + 3] : %d \r\n",data[MBIC_PAYLOADSTART + 3]); if(bluecell_Currdatastatus.Carrier_ON_OFF == false){ break; // return true; } if(data[MBIC_PAYLOADSTART + 3] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x08; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x08; UL_Path_OnOff(Path1_OnOff, data[MBIC_PAYLOADSTART + 3], &bluecell_Currdatastatus.ATT_UL1_PATH, &bluecell_Prevdatastatus.ATT_UL1_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count1) ; break; case ULO_RF_Path2_ON_OFF : // printf("data[MBIC_PAYLOADSTART + 3] : %d \r\n",data[MBIC_PAYLOADSTART + 3]); if(bluecell_Currdatastatus.Carrier_ON_OFF == false){ break; // return true; } if(data[MBIC_PAYLOADSTART + 3] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x04; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x04; UL_Path_OnOff(Path2_OnOff, data[MBIC_PAYLOADSTART + 3], &bluecell_Currdatastatus.ATT_UL2_PATH, &bluecell_Prevdatastatus.ATT_UL2_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count2) ; break; case ULO_RF_Path3_ON_OFF : // printf("data[MBIC_PAYLOADSTART + 3] : %d \r\n",data[MBIC_PAYLOADSTART + 3]); if(bluecell_Currdatastatus.Carrier_ON_OFF == false){ break; // return true; } if(data[MBIC_PAYLOADSTART + 3] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x02; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x02; UL_Path_OnOff(Path3_OnOff, data[MBIC_PAYLOADSTART + 3], &bluecell_Currdatastatus.ATT_UL3_PATH, &bluecell_Prevdatastatus.ATT_UL3_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count3) ; break; case ULO_RF_Path4_ON_OFF : // printf("data[MBIC_PAYLOADSTART + 3] : %d \r\n",data[MBIC_PAYLOADSTART + 3]); if(bluecell_Currdatastatus.Carrier_ON_OFF == false){ break; // return true; } if(data[MBIC_PAYLOADSTART + 3] != 0) bluecell_Currdatastatus.Path_TempSave_Bit |= 0x01; else bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x01; UL_Path_OnOff(Path4_OnOff, data[MBIC_PAYLOADSTART + 3], &bluecell_Currdatastatus.ATT_UL4_PATH, &bluecell_Prevdatastatus.ATT_UL4_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4, &bluecell_Prevdatastatus.ULO_Shutdown_Retry_Count4) ; break; case ULO_Gain_Atten1 : if(bluecell_Currdatastatus.SelfTest == true)break; bluecell_Currdatastatus.ATT_UL1_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.ATT_UL1_L = data[MBIC_PAYLOADSTART + 4]; Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L; Tmpdata2 = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L; // printf("ALC Atten : %d /// UL Atten : %d \r\n",Tmpdata,Tmpdata2); if(Tmpdata + Tmpdata2 <= -200){ Tmpdata2 = -200 + (Tmpdata * -1); bluecell_Currdatastatus.ATT_UL1_H = ((Tmpdata2 & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL1_L = Tmpdata2 & 0x00FF; } UL_ALC_GainAttenSet[ALC_Alarm_UL1_Index] = true; ALC_Level_Save[ALC_Alarm_UL1_Index] = bluecell_Currdatastatus.ULO_Level1_H << 8 | bluecell_Currdatastatus.ULO_Level1_L; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case ULO_Gain_Atten2 : if(bluecell_Currdatastatus.SelfTest == true)break; bluecell_Currdatastatus.ATT_UL2_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.ATT_UL2_L = data[MBIC_PAYLOADSTART + 4]; // if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){ Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L; Tmpdata2 = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L; if(Tmpdata + Tmpdata2 <= -200){ Tmpdata2 = -200 + (Tmpdata * -1); bluecell_Currdatastatus.ATT_UL1_H = ((Tmpdata2 & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL1_L = Tmpdata2 & 0x00FF; } UL_ALC_GainAttenSet[ALC_Alarm_UL2_Index] = true; ALC_Level_Save[ALC_Alarm_UL2_Index] = bluecell_Currdatastatus.ULO_Level2_H << 8 | bluecell_Currdatastatus.ULO_Level2_L; // } CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case ULO_Gain_Atten3 : if(bluecell_Currdatastatus.SelfTest == true)break; bluecell_Currdatastatus.ATT_UL3_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.ATT_UL3_L = data[MBIC_PAYLOADSTART + 4]; // if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){ Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L; Tmpdata2 = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L; if(Tmpdata + Tmpdata2 <= -200){ Tmpdata2 = -200 + (Tmpdata * -1); bluecell_Currdatastatus.ATT_UL1_H = ((Tmpdata2 & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL1_L = Tmpdata2 & 0x00FF; } UL_ALC_GainAttenSet[ALC_Alarm_UL3_Index] = true; ALC_Level_Save[ALC_Alarm_UL3_Index] = bluecell_Currdatastatus.ULO_Level3_H << 8 | bluecell_Currdatastatus.ULO_Level3_L; // } CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case ULO_Gain_Atten4 : if(bluecell_Currdatastatus.SelfTest == true)break; bluecell_Currdatastatus.ATT_UL4_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.ATT_UL4_L = data[MBIC_PAYLOADSTART + 4]; // if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){ Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L; Tmpdata2 = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L; if(Tmpdata + Tmpdata2 <= -200){ Tmpdata2 = -200 + (Tmpdata * -1); bluecell_Currdatastatus.ATT_UL1_H = ((Tmpdata2 & 0xFF00) >> 8); bluecell_Currdatastatus.ATT_UL1_L = Tmpdata2 & 0x00FF; } UL_ALC_GainAttenSet[ALC_Alarm_UL4_Index] = true; ALC_Level_Save[ALC_Alarm_UL4_Index] = bluecell_Currdatastatus.ULO_Level4_H << 8 | bluecell_Currdatastatus.ULO_Level4_L ; // } // printf("data ctrl\r\n"); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case ULO_Gain_Atten_Offset1 : bluecell_Currdatastatus.bluecell_User_UL1_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.bluecell_User_UL1_L = data[MBIC_PAYLOADSTART + 4]; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case ULO_Gain_Atten_Offset2 : bluecell_Currdatastatus.bluecell_User_UL2_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.bluecell_User_UL2_L = data[MBIC_PAYLOADSTART + 4]; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case ULO_Gain_Atten_Offset3 : bluecell_Currdatastatus.bluecell_User_UL3_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.bluecell_User_UL3_L = data[MBIC_PAYLOADSTART + 4]; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case ULO_Gain_Atten_Offset4 : bluecell_Currdatastatus.bluecell_User_UL4_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.bluecell_User_UL4_L = data[MBIC_PAYLOADSTART + 4]; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; case ULO_Level_High_Threshold : bluecell_Currdatastatus.ULO_Level_High_Threshold_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.ULO_Level_High_Threshold_L = data[MBIC_PAYLOADSTART + 4]; break; case ULO_Level_High_Threshold_default : tempdata = ULO_LEVEL_HIGH_THREADHOLD_DEFAULT; bluecell_Currdatastatus.ULO_Level_High_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_Level_High_Threshold_L = ((tempdata & 0x00FF)); // bluecell_Currdatastatus.ULO_Level_High_Threshold_default = data[MBIC_PAYLOADSTART + 3]; break; #if 0 // PYJ.2020.09.03_BEGIN -- case ULO_SelfTest1: // SelfTest_Ctrl(SelfTest1,data[MBIC_PAYLOADSTART + 3],&bluecell_Currdatastatus.Selftest1,&bluecell_Currdatastatus.ATT_DL1_H,&bluecell_Currdatastatus.ATT_UL1_H); // printf("UL SelfTest1 \r\n"); break; case ULO_SelfTest2: // SelfTest_Ctrl(SelfTest2,data[MBIC_PAYLOADSTART + 3],&bluecell_Currdatastatus.Selftest2,&bluecell_Currdatastatus.ATT_DL2_H,&bluecell_Currdatastatus.ATT_UL2_H); // printf("UL SelfTest2 \r\n"); break; case ULO_SelfTest3: // SelfTest_Ctrl(SelfTest3,data[MBIC_PAYLOADSTART + 3],&bluecell_Currdatastatus.Selftest3,&bluecell_Currdatastatus.ATT_DL3_H,&bluecell_Currdatastatus.ATT_UL3_H); // printf("UL SelfTest3 \r\n"); break; case ULO_SelfTest4: // SelfTest_Ctrl(SelfTest4,data[MBIC_PAYLOADSTART + 3],&bluecell_Currdatastatus.Selftest4,&bluecell_Currdatastatus.ATT_DL4_H,&bluecell_Currdatastatus.ATT_UL4_H); // printf("UL SelfTest \r\n"); break; #endif // PYJ.2020.09.03_END -- case ULO_PATH1_GAIN: bluecell_Currdatastatus.Path1_GainValue = data[MBIC_PAYLOADSTART + 3]; break; case ULO_PATH2_GAIN: bluecell_Currdatastatus.Path2_GainValue = data[MBIC_PAYLOADSTART + 3]; break; case ULO_PATH3_GAIN: bluecell_Currdatastatus.Path3_GainValue = data[MBIC_PAYLOADSTART + 3]; break; case ULO_PATH4_GAIN: bluecell_Currdatastatus.Path4_GainValue = data[MBIC_PAYLOADSTART + 3]; break; case ULO_SelfTest_ONOFF: SelfTest_Operate(data[MBIC_PAYLOADSTART + 3]); break; case ULO_ALC_ON_OFF : bluecell_Currdatastatus.ULO_ALC_ON_OFF = data[MBIC_PAYLOADSTART + 3]; if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == 0) bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm = 0; break; case ULO_ALC_Threshold : bluecell_Currdatastatus.ULO_ALC_Threshold_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.ULO_ALC_Threshold_L = data[MBIC_PAYLOADSTART + 4]; break; case ULO_ALC_Threshold_Default : tempdata = ULO_ALC_THREADHOLD_DEFAULT; bluecell_Currdatastatus.ULO_ALC_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_ALC_Threshold_L = ((tempdata & 0x00FF)); // printf("ALC DEFAULT VALUE SETTING COMPLETE \r\n"); break; case ULO_Shutdown_ON_OFF : bluecell_Currdatastatus.ULO_Shutdown_ON_OFF = data[MBIC_PAYLOADSTART + 3]; break; case ULO_Shutdown_Threshold : bluecell_Currdatastatus.ULO_Shutdown_Threshold_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.ULO_Shutdown_Threshold_L = data[MBIC_PAYLOADSTART + 4]; break; case ULO_Shutdown_Threshold_Default : tempdata = ULO_SHUTDOWN_THREADHOLD_DEFAULT; bluecell_Currdatastatus.ULO_Shutdown_Threshold_H = ((tempdata & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_Shutdown_Threshold_L = ((tempdata & 0x00FF)); break; case ULO_ALC_Atten: bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H = data[MBIC_PAYLOADSTART + 3]; bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L = data[MBIC_PAYLOADSTART + 4]; bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H = data[MBIC_PAYLOADSTART + 5]; bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L = data[MBIC_PAYLOADSTART + 6]; bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H = data[MBIC_PAYLOADSTART + 7]; bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L = data[MBIC_PAYLOADSTART + 8]; bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H = data[MBIC_PAYLOADSTART + 9]; bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L = data[MBIC_PAYLOADSTART + 10]; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); break; } uint8_t tmpLength = data[MBIC_PAYLOADSTART + 2]; if(data[MBIC_PAYLOADSTART + tmpLength + 3 ] == 0xE0 && occurlen > 0){ occurlen -= tmpLength + 3; for(int k = 0; k < occurlen; k++){ data[MBIC_PAYLOADSTART + k] = data[MBIC_PAYLOADSTART + tmpLength+ 3 + k]; } goto protocolReplay; } data[MBIC_CMD_0] = 0x81;//MBIC_ERRRESPONSE; Length = MBIC_DataSend(data); 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)); // printf("HFR Command Exit\r\n"); } else if(cmd == MBIC_Table_Get){ /*Table Get */ // data[MBIC_PAYLOADSTART + 1] //Reserve Data //protocolTableLoadReplay: 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 : MBIC_TableLoad(data,data[MBIC_PAYLOADSTART + 2]); if(data[MBIC_PAYLOADSTART + MBIC_TableIndex_Number] >= DLI_P1_ATT_Accuracy_Table_Number &&data[MBIC_TableIndex_Number] <= ULO_P4_ATT_Accuracy_Table_Number ){ MBIC_HeaderMergeFunction(data,data[MBIC_PAYLOADSTART + 4] + 5); data[MBIC_HEADERCHECKSUM_0] = Chksum_Create(data); uint16_t crcret = ((CRC16_Generate(&data[MBIC_PAYLOADSTART], (data[MBIC_PAYLOADSTART + 4] ) + 5) ) ); // printf("\r\n crc ret : %x \r\n",crcret); data[MBIC_PAYLOADSTART + (data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] ) + 5] =(( crcret & 0xFF00)>> 8); data[MBIC_PAYLOADSTART + (data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] ) + 6] = (( crcret & 0x00FF)); data[MBIC_PAYLOADSTART + (data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] ) + 7] = 0x03; Uart1_Data_Send(data, (data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]) + 5 + 22 + 3); }else{ MBIC_HeaderMergeFunction(data,(data[MBIC_PAYLOADSTART + 4] * 2) + 5); data[MBIC_HEADERCHECKSUM_0] = Chksum_Create(data); uint16_t crcret = ((CRC16_Generate(&data[MBIC_PAYLOADSTART], (data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] * 2) + 5) ) ); // printf("\r\n crc ret : %x \r\n",crcret); data[MBIC_PAYLOADSTART + (data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] * 2) + 5] =(( crcret & 0xFF00)>> 8); data[MBIC_PAYLOADSTART + (data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] * 2) + 6] = (( crcret & 0x00FF)); data[MBIC_PAYLOADSTART + (data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] * 2) + 7] = 0x03; // printf("==data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] : %d \r\n",data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]); Uart1_Data_Send(data, ((data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] + 1) * 2) + 5 + 22 + 3); } break; } } else if(cmd == MBIC_Table_Set){ // printf("%s : %d \r\n",__func__,__LINE__); // protocolTableSaveReplay: // 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 추가 MBIC_TableSave(data,data[MBIC_PAYLOADSTART + 2]); if(data[MBIC_PAYLOADSTART + MBIC_TableIndex_Number] >= DLI_P1_ATT_Accuracy_Table_Number &&data[MBIC_TableIndex_Number] <= ULO_P4_ATT_Accuracy_Table_Number ){ MBIC_HeaderMergeFunction(data,1); data[MBIC_HEADERCHECKSUM_0] = Chksum_Create(data); // Uart1_Data_Send(data, (data[MBIC_PAYLOADSTART + 4]) + 5 + 22 + 3); uint16_t crcret = (CRC16_Generate(&data[MBIC_PAYLOADSTART], 1 ) ); // printf("\r\n crc ret : %x \r\n",crcret); data[MBIC_PAYLOADSTART + 1] =(( crcret & 0xFF00)>> 8); data[MBIC_PAYLOADSTART + 2] = (( crcret & 0x00FF)); data[MBIC_PAYLOADSTART + 3] = 0x03; Uart1_Data_Send(data, 22 + 3 + 1); } else{ MBIC_HeaderMergeFunction(data,1); data[MBIC_HEADERCHECKSUM_0] = Chksum_Create(data); uint16_t crcret = (CRC16_Generate(&data[MBIC_PAYLOADSTART], 1) ) ; // printf("\r\n crc ret : %x \r\n",crcret); data[MBIC_PAYLOADSTART + 1] =(( crcret & 0xFF00)>> 8); data[MBIC_PAYLOADSTART + 2] = (( crcret & 0x00FF)); data[MBIC_PAYLOADSTART + 3] = 0x03; Uart1_Data_Send(data, 22 + 3 + 1); } } } else{ MBIC_Bootloader_FirmwareUpdate(data); /*NOP*/ // printf("DATA Updating\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* src,uint32_t size ){ int temp; for(int i = 0 ; i < size - 1 ; i ++) { for(int j = i+1 ; j < size ; j ++) { if(src[i] < src[j]) { temp = src[j]; src[j] = src[i]; src[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_High_Set[DET_Alarm_DL_Index_MAX] = {false,} ; bool ADC_Alarm_DL_Low_Set[DET_Alarm_DL_Index_MAX] = {false,} ; bool ADC_Alarm_UL_Set[DET_Alarm_UL_Index_MAX] = {false,} ; bool ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL_Shutdown_Index_MAX] = {false,} ; bool ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL_Shutdown_Index_MAX] = {false,} ; bool ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL_Shutdown_Index_MAX] = {false,} ; bool ADC_Alarm_UL_Normal_Shutdown_Set[DET_Alarm_UL_Shutdown_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; int16_t LimitData_DL_Shutdown = 0; int16_t LimitData_UL_Shutdown = 0; double ret = 0; int16_t Res_Up_DL_dBm[DET_Alarm_DL_Index_MAX] = {0,}; int16_t Res_Down_DL_dBm[DET_Alarm_DL_Index_MAX] = {0,}; float temp_val = 0; int16_t Res_Up_UL_dBm[DET_Alarm_UL_Index_MAX] = {0,}; int16_t Res_Down_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) * 0.1; LimitData_DL_High = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level_High_Threshold_H,bluecell_Currdatastatus.DLI_Level_High_Threshold_L)* 0.1; LimitData_DL_Low = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level_Low_Threshold_H,bluecell_Currdatastatus.DLI_Level_Low_Threshold_L)* 0.1; LimitData_DL_Shutdown = ConvertTo2byte(bluecell_Currdatastatus.DLI_Shutdown_Threshold_H,bluecell_Currdatastatus.DLI_Shutdown_Threshold_L)* 0.1; LimitData_UL_Shutdown = ConvertTo2byte(bluecell_Currdatastatus.ULO_Shutdown_Threshold_H,bluecell_Currdatastatus.ULO_Shutdown_Threshold_L)* 0.1; ret = bluecell_Currdatastatus.DLI_P1_Level1_H << 8; ret += bluecell_Currdatastatus.DLI_P1_Level1_L; ret *= 0.001; Res_Down_DL_dBm[DET_Alarm_DL1_Index] = bluecell_Currdatastatus.DLI_Level1_H << 8 | bluecell_Currdatastatus.DLI_Level1_L;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st))); ret = bluecell_Currdatastatus.DLI_P2_Level2_H << 8; ret += bluecell_Currdatastatus.DLI_P2_Level2_L; ret *= 0.001; Res_Down_DL_dBm[DET_Alarm_DL2_Index] = bluecell_Currdatastatus.DLI_Level2_H << 8 | bluecell_Currdatastatus.DLI_Level2_L;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st))); ret = bluecell_Currdatastatus.DLI_P3_Level3_H << 8; ret += bluecell_Currdatastatus.DLI_P3_Level3_L; ret *= 0.001; Res_Down_DL_dBm[DET_Alarm_DL3_Index] = bluecell_Currdatastatus.DLI_Level3_H << 8 | bluecell_Currdatastatus.DLI_Level3_L;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st))); ret = bluecell_Currdatastatus.DLI_P4_Level4_H << 8; ret += bluecell_Currdatastatus.DLI_P4_Level4_L; ret *= 0.001; Res_Down_DL_dBm[DET_Alarm_DL4_Index] = bluecell_Currdatastatus.DLI_Level4_H << 8 | bluecell_Currdatastatus.DLI_Level4_L;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st))); // printf("Res_DL_dBm[DET_Alarm_DL1_Index] : %d \r\n",Res_DL_dBm[DET_Alarm_DL1_Index]); for(int i = 0; i < DET_Alarm_DL_Index_MAX; i++){ #if 0 // PYJ.2020.10.16_BEGIN -- if(Res_DL_dBm[DET_Alarm_DL1_Index + i] > 0){ if(Res_DL_dBm[DET_Alarm_DL1_Index + i] % 10 != 0){ Res_DL_dBm[DET_Alarm_DL1_Index + i] = Res_DL_dBm[DET_Alarm_DL1_Index + i] + 5; } }else{ if(Res_DL_dBm[DET_Alarm_DL1_Index + i] % 10 != 0){ Res_DL_dBm[DET_Alarm_DL1_Index + i] = Res_DL_dBm[DET_Alarm_DL1_Index + i] - 5; } } Res_DL_dBm[DET_Alarm_DL1_Index + i] *= 0.1; #else // if(i == 2){ // printf("======================================================\r\n"); // printf("Res_Down_DL_dBm[DET_Alarm_DL1_Index + i] : %d \r\n",Res_Down_DL_dBm[DET_Alarm_DL1_Index + i]); // } Res_Up_DL_dBm[DET_Alarm_DL1_Index + i] = Res_Down_DL_dBm[DET_Alarm_DL1_Index + i]; if(Res_Up_DL_dBm[DET_Alarm_DL1_Index + i] < 0) Res_Up_DL_dBm[DET_Alarm_DL1_Index + i] -= 9; else if(Res_Up_DL_dBm[DET_Alarm_DL1_Index + i] > 0) Res_Up_DL_dBm[DET_Alarm_DL1_Index + i] += 9; Res_Down_DL_dBm[DET_Alarm_DL1_Index + i] *= 0.1; // down Res_Up_DL_dBm[DET_Alarm_DL1_Index + i] *= 0.1; // Round #endif // PYJ.2020.10.15_END -- } // printf("Res_DL_dBm[DET_Alarm_DL1_Index] : %d \r\n",Res_DL_dBm[DET_Alarm_DL1_Index]); // Res_DL_dBm[DET_Alarm_DL1_Index] *= 0.1; // Res_DL_dBm[DET_Alarm_DL2_Index] *= 0.1; // Res_DL_dBm[DET_Alarm_DL4_Index] *= 0.1; // Res_DL_dBm[DET_Alarm_DL3_Index] *= 0.1; ret = bluecell_Currdatastatus.ULO_P1_Level1_H << 8; ret += bluecell_Currdatastatus.ULO_P1_Level1_L; ret *= 0.001; Res_Down_UL_dBm[DET_Alarm_UL1_Index] = bluecell_Currdatastatus.ULO_Level1_H << 8 | bluecell_Currdatastatus.ULO_Level1_L; //(int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,Det_UL1.Table_Length * 2)); ret = bluecell_Currdatastatus.ULO_P2_Level2_H << 8; ret += bluecell_Currdatastatus.ULO_P2_Level2_L; ret *= 0.001; Res_Down_UL_dBm[DET_Alarm_UL2_Index] = bluecell_Currdatastatus.ULO_Level2_H << 8 | bluecell_Currdatastatus.ULO_Level2_L;//(int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL2.Table_Det_15_dBm_H,Det_UL2.Table_Length * 2)); ret = bluecell_Currdatastatus.ULO_P3_Level3_H << 8; ret += bluecell_Currdatastatus.ULO_P3_Level3_L; ret *= 0.001; Res_Down_UL_dBm[DET_Alarm_UL3_Index] = bluecell_Currdatastatus.ULO_Level3_H << 8 | bluecell_Currdatastatus.ULO_Level3_L;//(int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,Det_UL3.Table_Length * 2)); ret = bluecell_Currdatastatus.ULO_P4_Level4_H << 8; ret += bluecell_Currdatastatus.ULO_P4_Level4_L; ret *= 0.001; Res_Down_UL_dBm[DET_Alarm_UL4_Index] = bluecell_Currdatastatus.ULO_Level4_H << 8 | bluecell_Currdatastatus.ULO_Level4_L;//(int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,Det_UL4.Table_Length * 2)); // Res_UL_dBm[DET_Alarm_UL1_Index] *= 0.1; // Res_UL_dBm[DET_Alarm_UL2_Index] *= 0.1; // Res_UL_dBm[DET_Alarm_UL3_Index] *= 0.1; // Res_UL_dBm[DET_Alarm_UL4_Index] *= 0.1; #if 0 // PYJ.2020.10.16_BEGIN -- for(int i = 0; i < DET_Alarm_UL_Index_MAX; i++){ if(Res_UL_dBm[DET_Alarm_UL1_Index + i] % 10 != 0){ Res_UL_dBm[DET_Alarm_UL1_Index + i] *= 0.1; if(Res_UL_dBm[DET_Alarm_UL1_Index + i] < 0) Res_UL_dBm[DET_Alarm_UL1_Index + i]--; else Res_UL_dBm[DET_Alarm_UL1_Index + i]++; }else{ Res_UL_dBm[DET_Alarm_UL1_Index + i] *= 0.1; } } #else for(int i = 0; i < DET_Alarm_UL_Index_MAX; i++){ Res_Up_UL_dBm[DET_Alarm_UL1_Index + i] = Res_Down_UL_dBm[DET_Alarm_UL1_Index + i]; Res_Up_UL_dBm[DET_Alarm_UL1_Index + i] -= 9; Res_Down_UL_dBm[DET_Alarm_UL1_Index + i] *= 0.1; // down Res_Up_UL_dBm[DET_Alarm_UL1_Index + i] *= 0.1; // Round } #endif // PYJ.2020.10.16_END -- /* DL Level Alarm Check Part */ // printf("======================================================\r\n"); uint8_t* AlarmStatus = &bluecell_Currdatastatus.DLI_Level_Low_Alarm1; uint8_t* Alarm_High_Status = &bluecell_Currdatastatus.DLI_Level_High_Alarm1; uint8_t* PathStatus = &bluecell_Currdatastatus.ATT_DL1_PATH; for(int i = 0 ; i < DET_Alarm_DL_Index_MAX; i++){ // if(i != 0) continue; if( Res_Down_DL_dBm[DET_Alarm_DL1_Index + i] > 0 ){ if(LimitData_DL_High <= Res_Down_DL_dBm[DET_Alarm_DL1_Index + i]){ ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i] = true; // printf("1DL High Threadhold : %d |||| DL Det : %d \r\n",LimitData_DL_High,Res_Down_DL_dBm[DET_Alarm_DL1_Index + i]); // printf("1ADC_Alarm_DL_High_Set %d ,Value : %d\r\n",DET_Alarm_DL1_Index + i,ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i]); } else{ if(LimitData_DL_High - 2 >= Res_Up_DL_dBm[DET_Alarm_DL1_Index + i]) ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i] = false; else{ if(Alarm_High_Status[DET_Alarm_DL1_Index + i] == true){ ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i] = true; }else{ ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i] = false; } } // printf("3ADC_Alarm_DL_High_Set %d ,Value : %d\r\n",DET_Alarm_DL1_Index + i,ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i]); } } else{ if(LimitData_DL_High <= Res_Up_DL_dBm[DET_Alarm_DL1_Index + i]){ ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i] = true; // printf("2DL High Threadhold : %d |||| DL Det : %d \r\n",LimitData_DL_High,Res_Up_DL_dBm[DET_Alarm_DL1_Index + i]); // printf("2ADC_Alarm_DL_High_Set %d ,Value : %d\r\n",DET_Alarm_DL1_Index + i,ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i]); } else{ if(LimitData_DL_High - 2 >= Res_Down_DL_dBm[DET_Alarm_DL1_Index + i]) ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i] = false; else{ if(Alarm_High_Status[DET_Alarm_DL1_Index + i] == true){ ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i] = true; }else{ ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i] = false; } } // printf("5Res_Down_DL_dBm[DET_Alarm_DL1_Index + i] : %d ADC_Alarm_DL_High_Set %d ,Value : %d\r\n",Res_Down_DL_dBm[DET_Alarm_DL1_Index + i],DET_Alarm_DL1_Index + i,ADC_Alarm_DL_High_Set[DET_Alarm_UL1_Index + i]); } } #if 0 // PYJ.2020.06.22_BEGIN -- printf("LimitData_DL_High: %d Res_DL_dBm [%d] : %d ,Value : %d\r\n", LimitData_DL_High, DET_Alarm_UL1_Index + i, Res_DL_dBm[DET_Alarm_DL1_Index + i], ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i]); #endif // PYJ.2020.06.22_END -- } /* DL Shutdown Alarm Check Part */ uint8_t* DL_PathStatus = &bluecell_Currdatastatus.ATT_DL1_PATH ; uint8_t* DL_RetryCount = &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 ; int16_t DL_Atten[DET_Alarm_DL_Shutdown_Index_MAX] = {0,}; DL_Atten[DET_Alarm_DL1_Index] = bluecell_Currdatastatus.ATT_DL1_H << 8 | bluecell_Currdatastatus.ATT_DL1_L; DL_Atten[DET_Alarm_DL2_Index] = bluecell_Currdatastatus.ATT_DL2_H << 8 | bluecell_Currdatastatus.ATT_DL2_L; DL_Atten[DET_Alarm_DL3_Index] = bluecell_Currdatastatus.ATT_DL3_H << 8 | bluecell_Currdatastatus.ATT_DL3_L; DL_Atten[DET_Alarm_DL4_Index] = bluecell_Currdatastatus.ATT_DL4_H << 8 | bluecell_Currdatastatus.ATT_DL4_L; for(int i = 0 ; i < DET_Alarm_DL_Shutdown_Index_MAX; i++){ // if(i != 0) continue; if( Res_Down_DL_dBm[DET_Alarm_DL1_Index + i] > 0 ){ if(DL_PathStatus[DET_Alarm_DL1_Shutdown_Index + i] == true && (LimitData_DL_Shutdown - 2 >= Res_Up_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i]) && (MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index + i] > 0)){ ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = true; if(DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] > MBIC_OFF_MAINTAIN_SEC){ if(DL_RetryCount[DET_Alarm_DL1_Shutdown_Index + i] > 0){// Nomal Operate DL_RetryCount[DET_Alarm_DL1_Shutdown_Index + i] = 0; // printf("1DL%d_PATH : %d\r\n",i+1,DL_PathStatus[DET_Alarm_DL1_Shutdown_Index + i]); } } }else{ ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = false; } } else{ if(DL_PathStatus[DET_Alarm_DL1_Shutdown_Index + i] == true && (LimitData_DL_Shutdown - 2 >= Res_Down_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i]) && (MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index + i] > 0)){ ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = true; if(DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] > MBIC_OFF_MAINTAIN_SEC){ if(DL_RetryCount[DET_Alarm_DL1_Shutdown_Index + i] > 0){// Nomal Operate DL_RetryCount[DET_Alarm_DL1_Shutdown_Index + i] = 0; // printf("2DL%d_PATH : %d \r\n",i+1,DL_PathStatus[DET_Alarm_DL1_Shutdown_Index + i]); } } }else{ ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = false; } } #if 0 // PYJ.2020.10.23_BEGIN -- printf("=========================Start============================================\r\n"); printf("DL_PathStatus : %d \r\n",DL_PathStatus[DET_Alarm_DL1_Shutdown_Index ]); printf("LimitData_DL_Shutdown : %d \r\n",LimitData_DL_Shutdown); printf("Res_Down_DL_dBm : %d \r\n",Res_Down_DL_dBm[DET_Alarm_DL1_Shutdown_Index ]); printf("MBIC_DL_ShutdownCount : %d \r\n",MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index ]); printf("ADC_Alarm_DL_Normal_Shutdown_Set : %d \r\n",ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index]); printf("=========================End============================================\r\n"); // HAL_Delay(500); #endif // PYJ.2020.10.23_END -- } for(int i = 0 ; i < DET_Alarm_DL_Shutdown_Index_MAX; i++){ // if(i != 0) continue; if( Res_Down_DL_dBm[DET_Alarm_UL1_Index + i] > 0 ){ // if(LimitData_DL_Shutdown <= Res_Down_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i]){ if(LimitData_DL_Shutdown < Res_Down_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i]){ // if(DL_Atten[DET_Alarm_DL1_Index + i] * 0.1 <= -15) // if(i == 0){ // printf("1Res_Down_DL_dBm : %d \r\n",Res_Down_DL_dBm[DET_Alarm_DL1_Shutdown_Index ]); // } ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = true; // if(i == 2){ //// printf("Shutdown On 1\r\n"); // } } else{ if(LimitData_DL_Shutdown - 2 < Res_Down_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i] && MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index + i] > 0 ) { ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = true; // if(i == 2){ //// printf("Shutdown On 1_2\r\n"); // } // if(i == 0){ // printf("2Res_Down_DL_dBm : %d \r\n",Res_Down_DL_dBm[DET_Alarm_DL1_Shutdown_Index ]); // } // printf("Shutdown On 1_1\r\n"); } else if(MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index + i] > 0){ ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = false; // printf("Shutdown Off 1\r\n"); } } } else { // if(LimitData_DL_Shutdown <= Res_Up_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i]){ if(LimitData_DL_Shutdown < Res_Down_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i] && DL_PathStatus[DET_Alarm_DL1_Shutdown_Index + i] == true){ // if(DL_Atten[DET_Alarm_DL1_Index + i] * 0.1 <= -15) ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = true; // if(i == 2){ //// printf("Shutdown On 2_1\r\n"); // } // printf("3Res_Down_DL_dBm : %d \r\n",Res_Down_DL_dBm[DET_Alarm_DL1_Shutdown_Index ]); // printf("Shutdown On 2\r\n"); } else{ if(LimitData_DL_Shutdown - 2 < Res_Up_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i] && MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index + i] > 0 && DL_PathStatus[DET_Alarm_DL1_Shutdown_Index + i] == true){ // printf("4Res_Down_DL_dBm : %d \r\n",Res_Down_DL_dBm[DET_Alarm_DL1_Shutdown_Index ]); ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = true; // printf("Shutdown On 2_2\r\n"); } else if(MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index + i] > 0 && LimitData_DL_Shutdown - 2 < Res_Down_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i] && DL_PathStatus[DET_Alarm_DL1_Shutdown_Index + i] == true){ ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = true; // if(i == 2){ // printf("Shutdown On 2_3\r\n"); // } } else if(MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index + i] > 0){ ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = false; // if(i == 2){ // printf("Shutdown Off 2\r\n"); // } } else if(MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index + i] == 0 && LimitData_DL_Shutdown > Res_Up_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i]){ ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = false; // if(i == 2){ // printf("Shutdown Ofsf 3\r\n"); // } } } } #if 0 // PYJ.2020.10.23_BEGIN -- if(i == 2){ printf("======================================================\r\n"); printf("Res_Down_DL_dBm : %d \r\n",Res_Down_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i ]); printf("Res_Up_DL_dBm : %d \r\n",Res_Up_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i]); printf("LimitData_DL_Shutdown : %d \r\n",LimitData_DL_Shutdown); printf("Res_Up_DL_dBm : %d \r\n",Res_Up_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i]); printf("ALARM RESULT : %d \r\n",ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i]); } #endif // PYJ.2020.10.23_END -- } // printf("======================================================\r\n"); for(int i = 0 ; i < DET_Alarm_DL_Index_MAX; i++){ // if (i != 0)continue; if(PathStatus[DET_Alarm_DL1_Index + i] == false){ ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = false; continue; } if(AlarmStatus[DET_Alarm_DL1_Index + i] == false){ if( Res_Down_DL_dBm[DET_Alarm_DL1_Index + i] > 0 ){ if(LimitData_DL_Low >= Res_Up_DL_dBm[DET_Alarm_DL1_Index + i]) { ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = true; } else if(LimitData_DL_Low < Res_Down_DL_dBm[DET_Alarm_DL1_Index + i]){ ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = false; } }else{ if(LimitData_DL_Low >= Res_Down_DL_dBm[DET_Alarm_DL1_Index + i]) { ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = true; } else if(LimitData_DL_Low < Res_Up_DL_dBm[DET_Alarm_DL1_Index + i]){ ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = false; } } }else{ if(AlarmStatus[DET_Alarm_DL1_Index + i] == true){ if(LimitData_DL_Low + 2 > Res_Up_DL_dBm[DET_Alarm_DL1_Index + i]) { ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = true; } else if(LimitData_DL_Low + 2 <= Res_Up_DL_dBm[DET_Alarm_DL1_Index + i]){ ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = false; } // if(LimitData_DL_Low + 2 <= Res_Up_DL_dBm[DET_Alarm_DL1_Index + i]){ // ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = false; // } }else{ if(LimitData_DL_Low + 1 >= Res_Down_DL_dBm[DET_Alarm_DL1_Index + i]) { ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = true; } if(LimitData_DL_Low + 2 <= Res_Up_DL_dBm[DET_Alarm_DL1_Index + i]){ ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = false; } } } #if 0 // PYJ.2020.06.22_BEGIN -- printf("=========================================================\r\n"); printf("LimitData_DL_Low: %d Res_Up_DL_dBm [%d] : %d Res_Down_DL_dBm [%d] : %d ,Value : %d Real Alamr : %d \r\n", LimitData_DL_Low, DET_Alarm_UL1_Index + i, Res_Up_DL_dBm[DET_Alarm_DL1_Index + i], DET_Alarm_UL1_Index + i, Res_Down_DL_dBm[DET_Alarm_DL1_Index + i], ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i], AlarmStatus[DET_Alarm_DL1_Index + i]); #endif // PYJ.2020.06.22_END -- } /* UL Shutdown Alarm Check Part */ uint8_t* UL_PathStatus = &bluecell_Currdatastatus.ATT_UL1_PATH ; uint8_t* UL_RetryCount = &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1 ; // printf("============================================================================\r\n"); /*UL Shutdown Check */ for(int i = 0 ; i < DET_Alarm_UL_Shutdown_Index_MAX; i++){ // if(i != 0) // continue; // printf("================================================================\r\n"); /*UL Shutdown Cnt plus Condition Check */ if(UL_RetryCount[DET_Alarm_UL1_Shutdown_Index + i] > 0){ // Retry Cnt > 0 if((LimitData_UL_Shutdown <= Res_Up_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i] || LimitData_UL_Shutdown - 2 < Res_Down_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i] ) && UL_PathStatus[DET_Alarm_UL1_Shutdown_Index + i] == true){ ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] = true; ADC_Alarm_UL_Normal_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] = false; // printf("1 Shutdown threas hold : %d \r\n",LimitData_UL_Shutdown); // printf("UL_PathStatus[%d] %d \r\n",i,UL_PathStatus[DET_Alarm_UL1_Shutdown_Index + i]); // printf("Res_Down_UL_dBm : %d \r\n",Res_Down_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i]); // printf("Res_Up_UL_dBm : %d \r\n",Res_Up_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i]); // printf("Shutdown UL %d \r\n ",i + 1); // printf("Alarm ON Count : %d\r\n",UL_RetryCount[DET_Alarm_UL1_Shutdown_Index + i]); } else{ if(UL_PathStatus[DET_Alarm_UL1_Shutdown_Index + i] == true){ ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] = false; ADC_Alarm_UL_Normal_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] = true; if(DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] > MBIC_OFF_MAINTAIN_SEC){ if(UL_RetryCount[DET_Alarm_UL1_Shutdown_Index + i] > 0){// Nomal Operate UL_RetryCount[DET_Alarm_UL1_Shutdown_Index + i] = 0; // printf("UL%d_PATH : %d Retry Count Initialize Start %d \r\n",i+1,UL_PathStatus[DET_Alarm_UL1_Shutdown_Index + i],bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2); } } } else{// Shutdown Off -> ON Recovery ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] = false; ADC_Alarm_UL_Normal_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] = false; } // printf("1 Shutdown threas hold : %d \r\n",LimitData_UL_Shutdown); // printf("UL_PathStatus[%d] %d \r\n",i,UL_PathStatus[DET_Alarm_UL1_Shutdown_Index + i]); // printf("Res_Down_UL_dBm : %d \r\n",Res_Down_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i]); // printf("Res_Up_UL_dBm : %d \r\n",Res_Up_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i]); // printf("Shutdown UL %d \r\n ",i + 1); // printf("Alarm OFF Count : %d\r\n",UL_RetryCount[DET_Alarm_UL1_Shutdown_Index + i]); } } else{ // Retry Cnt == 0 ; if(LimitData_UL_Shutdown <= Res_Up_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i] && UL_PathStatus[DET_Alarm_UL1_Shutdown_Index + i] == true){ ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] = true; ADC_Alarm_UL_Normal_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] = false; // printf("2 Shutdown threas hold : %d \r\n",LimitData_UL_Shutdown); // printf("UL_PathStatus[%d] %d \r\n",i,UL_PathStatus[DET_Alarm_UL1_Shutdown_Index + i]); // printf(" Res_Up_UL_dBm : %d \r\n",Res_Up_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i]); // printf("Shutdown UL %d \r\n ",i + 1); // printf("Alarm ON Count : %d\r\n",UL_RetryCount[DET_Alarm_UL1_Shutdown_Index + i]); }else{ ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] = false; ADC_Alarm_UL_Normal_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] = false; // printf("2 Shutdown threas hold : %d \r\n",LimitData_UL_Shutdown); // printf("UL_PathStatus[%d] %d \r\n",i,UL_PathStatus[DET_Alarm_UL1_Shutdown_Index + i]); // printf(" Res_Up_UL_dBm : %d \r\n",Res_Up_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i]); // printf("Shutdown UL %d \r\n ",i + 1); // printf("Alarm OFF Count : %d\r\n",UL_RetryCount[DET_Alarm_UL1_Shutdown_Index + i]); } } // HAL_Delay(500); } /* UL Level Alarm Check Part */ uint8_t* UL_Alarm_Timer_Status = &bluecell_Currdatastatus.ULO_Level_High_Alarm1; uint8_t* UL_ADC = &bluecell_Currdatastatus.ULO_P1_Level1_H; // LimitData_UL_High = -27; // printf("==========================================================\r\n"); for(int i = 0 ; i < DET_Alarm_UL_Index_MAX; i++){ // if(i != 0) // continue; if(LimitData_UL_High <= Res_Up_UL_dBm[DET_Alarm_UL1_Index + i]){ ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i] = true; // printf("ON _Limit : %d UL%d : %d ADC_Alarm_UL_Set %d ,Value : %d\r\n",LimitData_UL_High,i+1,Res_Up_UL_dBm[DET_Alarm_UL1_Index + i],DET_Alarm_UL1_Index + i,ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i]); } else{ if(LimitData_UL_High - 2 >= Res_Down_UL_dBm[DET_Alarm_UL1_Index + i]) ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i] = false; DET_UL_On_AlarmTimerCnt[DET_Alarm_UL1_Index + i] = 0; // printf("OFF _Limit : %d UL%d : %d ADC_Alarm_UL_Set %d ,Value : %d\r\n",LimitData_UL_High,i+1,Res_Down_UL_dBm[DET_Alarm_UL1_Index + i],DET_Alarm_UL1_Index + i,ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i]); } #if 0 // PYJ.2020.06.22_BEGIN -- printf("ADC : %f LimitData_UL_High: %d Res_UL_dBm [%d] : %d ,Value : %d\r\n", (UL_ADC[i * 2] << 8 | UL_ADC[i * 2 + 1]) * 0.001, LimitData_UL_High, DET_Alarm_UL1_Index + i, Res_UL_dBm[DET_Alarm_UL1_Index + i], ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i]); #endif // PYJ.2020.06.22_END -- } } void Temp_AttenCheck(int8_t Temp){ int8_t CurrentTemp = 0; } volatile uint16_t HFR_ADC1_Array[6] = {0,}; uint8_t HFR_ADC1_SamplingCnt = 0; #if 0 // PYJ.2020.08.07_BEGIN -- #else /* HFR Requset List Total : 50 Sampling */ uint16_t* ArrayMoveBack(uint16_t* array,uint8_t size){ for(int i = 0; i < size; i++){ array[i] = array[i + 1]; } return array; } #define HFR_REQUSET_TOTAL_CNT 6 uint32_t Adc1_ret[ADC1_CNT] = {0,}; uint16_t Adc1_arrange[ADC1_CNT] = {0,}; uint16_t Adc1_HFR_Array[ADC1_CNT][6] = {0,}; uint16_t Adc1_HFR_Desc_Array[ADC1_CNT][6] = {0,}; uint32_t Adc1_HFR_Ret[ADC1_CNT]= {0,}; uint32_t Adc3_ret[ADC3_CNT] = {0,}; uint16_t Adc3_arrange[ADC3_CNT] = {0,}; uint16_t Adc3_HFR_Array[ADC3_CNT][6] = {0,}; uint16_t Adc3_HFR_Desc_Array[ADC3_CNT][6] = {0,}; uint32_t Adc3_HFR_Ret[ADC3_CNT]= {0,}; uint8_t Sampling_Cnt = 0; // 1cbt 100ms uint8_t Total_SamplingCnt = 0; // 6 Cnt - 600ms #if 0 // PYJ.2020.08.12_BEGIN -- #else #define Percent 2 #define Percent100 5 void ADC_Check(void){ #if 1 // PYJ.2020.08.07_BEGIN -- //static uint8_t Cnt = 0; double ADC1DoubleRet[4]; double ADC3DoubleRet[5]; uint32_t ADC1_Average_value[ADC1_CNT]; //static uint32_t HFR_ADC1_Average_value[ADC1_CNT]; uint32_t ADC3_Average_value[ADC3_CNT]; uint16_t MIN_ADC[ADC3_CNT] = {0,}; uint16_t cnt[ADC3_CNT] = {0,}; double temp; if(bluecell_Currdatastatus.SelfTest == true) return; // if(AdcTimerCnt > 10){ // 정렬할 배열, 요소 개수, 요소 크기, 비교 함수를 넣어줌 // if(ADC_100ms_Cnt >= 100){ #if 1 // PYJ.2020.05.25_BEGIN -- for(int i = 0; i < ADC3_CNT; i++){ for(int index = 0; index < 100; index++){ ADC3Desc_valuearray[i][index] = ADC3valuearray[i][index]; } DascendigFunc(&ADC3Desc_valuearray[i][0],ADC_AVERAGECNT); ADC3_Average_value[i] = SumFunc(&ADC3Desc_valuearray[i][0],Percent100); ADC3_Average_value[i] /=Percent100; if(Total_SamplingCnt == HFR_REQUSET_TOTAL_CNT - 1){ ArrayMoveBack(&Adc3_HFR_Array[i][0],HFR_REQUSET_TOTAL_CNT); Adc3_HFR_Array[i][Total_SamplingCnt] = ADC3_Average_value[i]; for(int index = 0; index <6; index++){ Adc3_HFR_Desc_Array[i][index] = Adc3_HFR_Array[i][index] ; // if(i == 4) // printf("%d Adc3_HFR_Desc_Array : %d \r\n",index,Adc3_HFR_Desc_Array[i][index]); } DascendigFunc(&Adc3_HFR_Desc_Array[i][0],6); ADC3_Average_value[i] = 0; for(int index = 0; index > 8); bluecell_Currdatastatus.DLI_P1_Level1_L = ((ADC3Ret[1] & 0x00FF)); bluecell_Currdatastatus.DLI_P2_Level2_H = ((ADC3Ret[2] & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_P2_Level2_L = ((ADC3Ret[2] & 0x00FF) ); bluecell_Currdatastatus.DLI_P3_Level3_H = ((ADC3Ret[3] & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_P3_Level3_L = ((ADC3Ret[3] & 0x00FF) ); bluecell_Currdatastatus.DLI_P4_Level4_H = ((ADC3Ret[4] & 0xFF00) >> 8); bluecell_Currdatastatus.DLI_P4_Level4_L = ((ADC3Ret[4] & 0x00FF) ); bluecell_Currdatastatus.ULO_P4_Level4_H = ((ADC3Ret[0] & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_P4_Level4_L = ((ADC3Ret[0] & 0x00FF) ); #endif // PYJ.2020.05.25_END -- adc3cnt = 0; for(int i = 0; i < ADC1_CNT; i++){ for(int index = 0; index < 100; index++){ ADC1Desc_valuearray[i][index] = ADC1valuearray[i][index]; } DascendigFunc(&ADC1Desc_valuearray[i][0],ADC_AVERAGECNT); ADC1_Average_value[i] = SumFunc(&ADC1Desc_valuearray[i][0],Percent); ADC1_Average_value[i] /=Percent; if(Total_SamplingCnt == HFR_REQUSET_TOTAL_CNT - 1){ ArrayMoveBack(&Adc1_HFR_Array[i][0],HFR_REQUSET_TOTAL_CNT); Adc1_HFR_Array[i][Total_SamplingCnt] = ADC1_Average_value[i]; for(int index = 0; index <6; index++){ Adc1_HFR_Desc_Array[i][index] = Adc1_HFR_Array[i][index] ; } DascendigFunc(&Adc1_HFR_Desc_Array[i][0],6); ADC1_Average_value[i] = 0; for(int index = 0; index <3; index++) ADC1_Average_value[i] += Adc1_HFR_Desc_Array[i][index]; ADC1_Average_value[i] /= 3; } else{ Adc1_HFR_Array[i][Total_SamplingCnt] = ADC1_Average_value[i]; } ADC1DoubleRet[i] = (((ADC1_Average_value[i] ) * 3.3 /4096) * 1000); ADC1Ret[i] = ADC1DoubleRet[i]; ADC1_Average_value[i] = 0; } bluecell_Currdatastatus.ULO_P1_Level1_H = ((ADC1Ret[0] & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_P1_Level1_L = ((ADC1Ret[0] & 0x00FF) ); bluecell_Currdatastatus.ULO_P2_Level2_H = ((ADC1Ret[1] & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_P2_Level2_L = ((ADC1Ret[1] & 0x00FF) ); bluecell_Currdatastatus.ULO_P3_Level3_H = ((ADC1Ret[2] & 0xFF00) >> 8); bluecell_Currdatastatus.ULO_P3_Level3_L = ((ADC1Ret[2] & 0x00FF) ); /* * 온도 소수점 제거 */ temp = (ADC1Ret[3] * 0.001); bluecell_Currdatastatus.DET_TEMP = ((temp - 0.5) * 100); bluecell_Currdatastatus.DET_TEMP += bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET; // printf("bluecell_Currdatastatus.DET_TEMP : %d \r\n",bluecell_Currdatastatus.DET_TEMP); ADC_100ms_Cnt = 0; adc1cnt = 0; Total_SamplingCnt++; // printf("1. Total_SamplingCnt %d\r\n",Total_SamplingCnt); if(Total_SamplingCnt >= 5) Total_SamplingCnt = 5; } #endif// ADC_Sampling_Func(); /* After ADC calculation is completed, start Det Alarm check. */ DET_LevelAlarmCheck();/*DL UL Alarm Check*/ } #endif // PYJ.2020.08.12_END -- #endif // PYJ.2020.08.07_END -- #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) * 0.1; // 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*/ #if 0 // PYJ.2020.06.26_BEGIN -- 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("MInus set : 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); } #else double Bluecell_TestPro(double value ){ bool minusset = false; value *= 0.1; uint8_t temp = 0; // printf("DL1 : %f \r\n", value); #if 0 // PYJ.2020.10.16_BEGIN -- if(value < 0){ value *= -1; minusset = true; } value *= 10; temp = value; if(temp % 10 > 5){ temp = temp - (temp % 10); temp += 10; }else{ temp = temp - (temp % 10); } value = (temp * 0.1); printf("round Ret : %f \r\n",value); if(minusset ==true) value = value * -1; #else if(value < 0){ value -= 0.5; }else{ value += 0.5; } #endif // PYJ.2020.10.16_END -- return value; } int8_t Bluecell_TestPro2(double value ){ bool minusset = false; int8_t remine = 0; double originval = value; uint8_t temp = 0; // printf("value : %f \r\n",value); if(value < 0){ value *= -1; originval *= -1; minusset = true; } value *= 10; // printf("value*10 : %f \r\n",value); temp = (int8_t)value; // printf("temp <-value*10 : %d \r\n",temp ); remine = (temp % 10); // printf("temp <-value*10 % remine : %f \r\n",remine); if(remine >= 5){ // printf("temp : %d remind : %d \r\n",temp,remine); temp = temp - remine; // printf("tempret : %d \r\n",temp); // printf("1.temp : %d \r\n",temp); // if(value >= 10){ temp += 10;//0.5 for // printf("2.temp : %d \r\n",temp); // } }else{ if(originval > 1) temp = (int8_t)originval; else{ temp = (int8_t)originval; } temp *= 10; // printf("originval : %f temp : %d \r\n",originval,temp); } value = (temp * 0.1); // printf("1.round Ret : %f \r\n",value); if(minusset ==true) value = value * -1; // printf("2.round Ret : %f \r\n",value); return value; } #endif // PYJ.2020.06.26_END -- #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,int8_t* RefTable_Data){ double ret = 0xFF,CurrRet = 0,TableAdc,NextTableAdc; double Vitual_array[10] = {0,}; double step = 0; uint8_t LastIndex = 0; uint8_t dot = 0; double Lastdata = 0; // printf("size: %d \r\n",size); for(int i =0; i < size / 2; i++){ TableAdc = CompareAdc[i * 2] << 8; TableAdc += CompareAdc[i * 2 + 1]; if(TableAdc == 0) continue; TableAdc /= 1000; NextTableAdc = CompareAdc[i * 2 + 2] << 8; NextTableAdc += CompareAdc[i * 2 + 3]; NextTableAdc /= 1000; Lastdata = TableAdc; // printf("TableAdc[%d] : %f \r\n",i,TableAdc); // CurrRet = TableAdc - CurrentAdc; step = (TableAdc - NextTableAdc) * 0.1; for(int a = 0; a < 10; a++){ Vitual_array[a] = TableAdc - (step * a); if(Vitual_array[a] >= CurrentAdc){ CurrRet = (Vitual_array[a]) - (CurrentAdc); }else{ CurrRet = (CurrentAdc) - (Vitual_array[a]); } // 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(Lastdata > CurrentAdc) return RefTable_Data[(size / 2) - 1]; if(CurrentAdc < TableAdc){ #if 0 // PYJ.2020.06.26_BEGIN -- for(int i = 0; i < sizeof(ALC_dBm_t); i++) printf("ref Tabe[%d]: %d \r\n",i,RefTable_Data[i]); printf("LastIndex : %d / dot : %d TableAdc : %f \r\n",LastIndex,dot,(RefTable_Data[LastIndex] - (dot * 0.1))); #endif // PYJ.2020.06.26_END -- return (RefTable_Data[LastIndex] - (dot * 0.1)); } else{ // printf("CurrentAdc : %f TableAdc : %f \r\n",CurrentAdc,TableAdc); return (RefTable_Data[0]); } } double AGC_AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size,int8_t* RefTable_Data){ double ret = 3.3,CurrRet = 0,TableAdc,NextTableAdc; double Vitual_array[10] = {0,}; double step = 0; uint8_t LastIndex = 0; uint8_t dot = 0; double Lastdata = 0; double Compare_Data = 0; double first_data = (((CompareAdc[0] << 8) | CompareAdc[1]) * 0.001); for(int i =0; i < size; i++){ TableAdc = (((CompareAdc[i * 2] << 8) | CompareAdc[i * 2 + 1]) * 0.001); Lastdata = TableAdc; NextTableAdc = CompareAdc[i * 2 + 2] << 8; NextTableAdc += CompareAdc[i * 2 + 3]; NextTableAdc /= 1000; // printf("TableAdc[%d] : %f \r\n",i,TableAdc); Vitual_array[0] = TableAdc; // CurrRet = TableAdc - CurrentAdc; if(TableAdc >= NextTableAdc){ step = (TableAdc - NextTableAdc)* 0.1; }else{ step = (NextTableAdc - TableAdc) * 0.1; } for(int a = 0; a < 10; a++){ if(size - 1 != i){ Vitual_array[a] = TableAdc - (step * a); } if(Vitual_array[a] >= CurrentAdc){ CurrRet = Vitual_array[a] - CurrentAdc; }else{ CurrRet = CurrentAdc - Vitual_array[a]; } // CurrRet = (Vitual_array[a]) - (CurrentAdc); // printf("Vitual_array[%d] : %f ERROR RATE : %f \r\n",a,Vitual_array[a],CurrRet); // Compare_Data *= 1000; // if(CurrRet < 0){ // CurrRet = (CurrRet * -2) + CurrRet; // } if(ret > CurrRet){ ret = CurrRet; LastIndex = i; // if(LastIndex == 30 && CurrentAdc != 0 ){ // printf("TableAdc[%d] : %f step : %f x a : %d\r\n",i,TableAdc,step,a); // for(int k = 0; k < 10; k++) // printf("Vitual_array[%d] : %f \r\n",k,Vitual_array[k]); // } // printf("ret : %f CurrRet : %f CurrentAdc : %f %d.Vitual_array[a] : %f dot : %d\r\n",ret,CurrRet,CurrentAdc,i,Vitual_array[a],dot); dot = a; } if(size - 1 == i){ // printf("size - 1 : %d i : %d \r\n",size -1 , i); break; } } } if(Lastdata >= CurrentAdc){ // for(int i = 0; i < size; i++){ // printf("RefTable_Data[%d] : %d \r\n",i,RefTable_Data[i]); // } // printf("RefTable_Data[%d] : %d \r\n",size,RefTable_Data[(LastIndex )]); return RefTable_Data[LastIndex ]; } // 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]); if(first_data <= CurrentAdc){ // printf("(RefTable_Data[0]) : %d \r\n",(RefTable_Data[0])); return (RefTable_Data[0]); }else{ // printf("Nomal _Table Data %f",(RefTable_Data[LastIndex] - (dot * 0.1))); // printf("LastIndex : %d / dot : %d TableAdc : %f \r\n",LastIndex,dot,(RefTable_Data[LastIndex] - (dot * 0.1))); return (RefTable_Data[LastIndex] - (dot * 0.1)); } } #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 -- uint8_t ALC_AlarmSet[ALC_Alarm_UL_Index_MAX] = {0,}; int16_t ALC_Calc(uint8_t num,double CurrAtten ,int8_t threshold,double CurrDet){ double ret = 0; int8_t result = 0; // CurrAtten *= -1; if(CurrDet == threshold){ return 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 0 // PYJ.2020.06.20_BEGIN -- 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",ret); } 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 0 // PYJ.2020.06.20_BEGIN -- if(CurrAtten + ret >= 0){ ret = CurrAtten * -1; printf("3. ret0 : %f \r\n",ret); }else{ ALC_AlarmSet[num] = false; } #endif // PYJ.2020.06.20_END -- ret *= -1; if(CurrAtten < 0){ if(CurrAtten < ret){ ret += CurrAtten; } } #endif // PYJ.2020.06.20_END -- if(threshold < CurrDet){ ret = CurrDet - threshold ; // printf("1. %f : %f - %d\r\n",ret,CurrDet,threshold); // printf("2. %f : %f - %d\r\n",ret,CurrDet,threshold); result = Bluecell_TestPro2(ret /*+( CurrAtten * -1)*/); // printf("2.5. Ret : %d \r\n",result); result *= -1; // printf("3. Ret : %d \r\n",result); // if(CurrAtten <= -20) // ALC_AlarmSet[num] = true; } else if(threshold -2 > CurrDet ){ if(CurrAtten < 0){ ret = (threshold - 2) - CurrDet ;// -27 ///// - 29 // printf("%f = %d - %f\r\n",ret,(threshold - 2),CurrDet); // printf("CurrAtten : %f\r\n",CurrAtten); result = Bluecell_TestPro2(ret); // printf("3.ret : %d\r\n",result); result += CurrAtten; if(CurrAtten < 0){ int8_t tmp = CurrAtten * - 1; } result = CurrAtten + 1; result *= -1; // printf("4.ret : %d\r\n",result); // ALC_AlarmSet[num] = false; } } if(result < -20){ // printf("5. ret1 : %f \r\n",ret); ret = -20; }else{ if(result > 0){ // printf("6. ret1 : %f \r\n",ret); result = 0; } } // printf("ret7 : %f \r\n",ret); return result * 10; } #define UL_DL_DATASEND_MULTIPLE 10 void ALC_Alarm_TimerSet(uint8_t num,int16_t threshold,double CurrDet,int16_t Atten,int16_t MainAtten){ int16_t ret =0; int16_t CurrAtten = 0; int16_t M_Atten = 0; uint8_t* AlarmStatus = &bluecell_Currdatastatus.ULO_ALC_Alarm1; M_Atten = (MainAtten * 0.1); // printf("MainAtten : %d \r\n",MainAtten); CurrAtten = Atten * 0.1; // ALC ATTEN if(CurrAtten + M_Atten >= -18){ ALC_AlarmSet[num] = false; // printf("[%d]CurrDet : %f CurrAtten : %02d M_Atten : %d FALSE\r\n",num,CurrDet,CurrAtten,M_Atten); // printf("Alarm 3 \r\n"); } else if(threshold <= CurrDet){ ret = (int)CurrDet - threshold ; ret = Bluecell_TestPro(ret +( CurrAtten * 0.1 * -1)); ret *= -1; // printf("[%d]CurrDet : %f CurrAtten : %02d M_Atten : %d TRUE\r\n",num,CurrDet,CurrAtten,M_Atten); if(CurrAtten + M_Atten <= -20){ if(AlarmStatus[num] == false){ // if(threshold + 0.6 <= CurrDet){ if(threshold <= CurrDet && threshold + 0.6 <= CurrDet){ ALC_AlarmSet[num] = true; // printf("Alarm 1 ON \r\n"); }else{ ALC_AlarmSet[num] = false; // printf("Alarm 1 OFF \r\n"); } } } #if 0 // PYJ.2020.10.19_BEGIN -- else{ // ALC_AlarmSet[num] = false; // printf("Alarm 1 OFF\r\n"); } #endif // PYJ.2020.10.19_END -- } else { /*NOP*/ // printf("[%d]CurrDet : %f CurrAtten : %02d M_Atten : %d | %d |\r\n",num,CurrDet,CurrAtten,M_Atten,ALC_AlarmSet[num]); } #if 0 // PYJ.2020.11.12_BEGIN -- else if(threshold -2 > CurrDet){ if(CurrAtten < 0){ ret = (threshold - 2) - CurrDet ;// -27 ///// - 29 ret = Bluecell_TestPro(ret); ret += CurrAtten; ALC_AlarmSet[num] = false; // printf("Alarm 2 \r\n"); } } #endif // PYJ.2020.11.12_END -- // printf("threshold : %d \r\n",threshold); // printf("Curr Atten : %d Main Atten : %d Thre : %d CurrDet : %d \r\n", // CurrAtten,MainAtten,threshold,CurrDet); // printf("ALC_AlarmSet[%d] %d \r\n",num,ALC_AlarmSet[num]); } #if 1 // PYJ.2020.10.23_BEGIN -- int HFR_CntUpCalc(double ret){ if(ret > 0) ret += 0.4; else ret -= 0.4; return ret; } #endif // PYJ.2020.10.23_END -- typedef enum{ ULO_ALC_H = 0, ULO_ALC_L, }; bool ALC_DelayCnt_val[ALC_Alarm_UL_Index_MAX] = {false,}; void ALC_DelayCnt_Set(uint8_t index,bool set){ ALC_DelayCnt_val[index] = set; } bool ALC_DelayCnt_Get(uint8_t index){ return ALC_DelayCnt_val[index]; } void ALC_Package_Operate(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st* UL_Table,uint8_t TableIndex,uint8_t* ALC_Atten,uint8_t* UL_Main_Atten,uint8_t* GainOffset,uint8_t* retrycnt ){ /*static int16_t PrevLimitdata[ALC_Alarm_UL_Index_MAX] = {0,}; static int8_t* ALC_Table; int16_t tmpcalc = 0; static int16_t PrevIwillGiveAtten[ALC_Alarm_UL_Index_MAX] ={0,};*/ int16_t Gain_Atten = 0; double ret = 0; double CurrentATTENVALUE = 0; int16_t Limitdata = 0; double ResdBm = 0; double Temp_ResdBm = 0; int16_t ResultData = 0; int16_t IwillGiveAtten = 0; int16_t UL_Atten = 0; int16_t Main_Atten = 0; int16_t GiveAttenPlusULAtten = 0; int16_t Plus_ResultData = 0; static int16_t Prev_IwillGiveAtten[ALC_Alarm_UL_Index_MAX] ={0,}; uint8_t* UL_PathStatus = &bluecell_Currdatastatus.ATT_UL1_PATH ; if(*retrycnt > 0 || UL_PathStatus[TableIndex] == false) return; if(ALC_Delay_Cnt[TableIndex] < 600 && ALC_DelayCnt_Get(TableIndex) == true) return; else ALC_DelayCnt_Set(TableIndex,false); UL_Atten = ALC_Atten[ULO_ALC_H] << 8 | ALC_Atten[ULO_ALC_L]; Main_Atten = UL_Main_Atten[ULO_ALC_H] << 8 | UL_Main_Atten[ULO_ALC_L]; Gain_Atten = GainOffset[ULO_ALC_H] << 8 | GainOffset[ULO_ALC_L]; // printf("Curr Main Atten : %d \r\n",Main_Atten); // printf("Curr Gain Atten : %d \r\n",Gain_Atten); /*Threas Hold Value*/ Limitdata = (( bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8) & 0xFF00) ; Limitdata += bluecell_Currdatastatus.ULO_ALC_Threshold_L ; Limitdata *= 0.1; /*ADC Value*/ ret = ((ULO_ADC_Level[ULO_ALC_H] << 8 | ULO_ADC_Level[ULO_ALC_L]) * 0.001); /*Curr UL Value*/ ResdBm = AutoControl_ADC_Compare(ret,&UL_Table->Table_Det_15_dBm_H,UL_Table->Table_Length * 2,&UL_DET_Table_ref[TableIndex][TABLE_MAX_VALUE]); // ResdBm = (int16_t)(ULO_Level[ULO_ALC_H] << 8 | ULO_Level[ULO_ALC_L]); // ResdBm = (int16_t)Bluecell_TestPro( ResdBm / 10); //ret 현재 Voltage 값 출력 //ret 에 따른 현재 DBM 구현 CurrentATTENVALUE = PE43711_Double(ALC_Atten[ULO_ALC_H],ALC_Atten[ULO_ALC_L]); #if 0 // PYJ.2020.10.19_BEGIN -- printf("=============ALC ON =====START================\r\n"); printf("Current UL ADC VALUE : %f \r\n",ret); printf("ResdBm : UL%d : %f \r\n",TableIndex + 1,ResdBm); // printf("ORIGIN ResdBm : %f %d\r\n",ResdBm,Main_Atten); // printf("After ResdBm : %f \r\n",ResdBm); #endif // PYJ.2020.10.19_END -- ResultData = Bluecell_RoundCalc(ResdBm); Plus_ResultData = HFR_CntUpCalc(ResdBm); int HFR_Dot5 = ((int)(ResdBm * 10) % 10); Temp_ResdBm = ResultData; // printf("HFR CALC RET : %d \r\n",ResultData); ULO_Level[ULO_ALC_H] = (ResultData & 0xFF00) >> 8; ULO_Level[ULO_ALC_L] = (ResultData & 0x00FF); Limitdata += (Main_Atten * 0.1); if(Limitdata < ResultData){ if(HFR_Dot5 == -5){ ResultData--; Temp_ResdBm--; } } // printf("Limitdata : %d | ResultData : %d \r\n",Limitdata,ResultData); ALC_Alarm_TimerSet(TableIndex,Limitdata,ResdBm,UL_Atten,Main_Atten); IwillGiveAtten = ALC_Calc(TableIndex,CurrentATTENVALUE,Limitdata,Temp_ResdBm); // printf("STEP 1 : I WILL GIVE ATTEN %d \r\n",IwillGiveAtten); IwillGiveAtten += UL_Atten; // printf("STEP 2 : I WILL GIVE ATTEN PLUS ALC ATTEN %d \r\n",IwillGiveAtten); // printf("STEP 3 :ResdBm : %f (Limitdata - 1) : %d HFR_Dot5 %d \r\n",ResdBm,(Limitdata - 1),HFR_Dot5); if((Plus_ResultData <= (Limitdata - 2 )) ) { // printf("ResultData : %d \r\n",Plus_ResultData); // printf("(Limitdata - 2 - 0.1) : %f \r\n",(Limitdata - 2)); if(IwillGiveAtten <= -10){ IwillGiveAtten += 10; } // printf("1 I WILL GIVE ATTEN : %d \r\n", IwillGiveAtten); } GiveAttenPlusULAtten = IwillGiveAtten + (Main_Atten ); // printf("1 I WILL GIVE ATTEN : %d \r\n", IwillGiveAtten); if(GiveAttenPlusULAtten <= - 200 ){ IwillGiveAtten = -200 + ((Main_Atten * -1)); // printf("3 I WILL GIVE ATTEN : %d \r\n", IwillGiveAtten); } if(IwillGiveAtten <= -200){ IwillGiveAtten = -200; } if(IwillGiveAtten >= 0){ IwillGiveAtten = 0; } #if 0// PYJ.2020.10.19_BEGIN -- printf(" UL_Atten: %d I WILL GIVE ATTEN : %d \r\n", UL_Atten,IwillGiveAtten); printf("ADC : %f CURR ATT : %f Threas : %d : I WILL GIVE ATTEN : %d \r\n",ret,ResdBm , Limitdata,IwillGiveAtten); printf("==================END================\r\n"); #endif // PYJ.2020.10.19_END -- if(Prev_IwillGiveAtten[TableIndex] != IwillGiveAtten){ Prev_IwillGiveAtten[TableIndex] = IwillGiveAtten; ALC_DelayCnt_Set(TableIndex,true); } // if( (IwillGiveAtten > 0) || (CurrentATTENVALUE >= (IwillGiveAtten))){ // IwillGiveAtten *= 10; ALC_Atten[ULO_ALC_H] = (((uint16_t)((IwillGiveAtten)) & 0xFF00) >> 8); ALC_Atten[ULO_ALC_L] = ((uint16_t)(IwillGiveAtten)) & 0x00FF; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); // } } void UL_Curr_Level(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st* UL_Table,uint8_t TableIndex){ double ret = 0; double ResdBm = 0; int16_t ResultData = 0; ret = ((ULO_ADC_Level[ULO_ALC_H] << 8 | ULO_ADC_Level[ULO_ALC_L]) * 0.001); /*Curr UL Value*/ ResdBm = AutoControl_ADC_Compare(ret,&UL_Table->Table_Det_15_dBm_H,UL_Table->Table_Length * 2,&UL_DET_Table_ref[TableIndex][TABLE_MAX_VALUE]); //ret 현재 Voltage 값 출력 //ret 에 따른 현재 DBM 구현 // ResdBm = HFR_CntUpCalc(ResdBm); ResdBm += Temperature_Offset_Get(&Temp_UL1.Table_1_Temp,bluecell_Currdatastatus.DET_TEMP); ResultData = ResdBm; #if 0 // PYJ.2020.09.10_BEGIN -- if(ResultData < -60) ResultData = -60; else if(ResultData > -15) ResultData = -15; ULO_Level[ULO_ALC_H] = (ResultData & 0xFF00) >> 8; ULO_Level[ULO_ALC_L] = (ResultData & 0x00FF); #else if(ResdBm < UL_Table->Table_Ref - (UL_Table->Table_Length + 1)) ResdBm = UL_Table->Table_Ref - (UL_Table->Table_Length + 1); else if(ResdBm > UL_Table->Table_Ref) ResdBm = UL_Table->Table_Ref; ResultData = ResdBm * 10; ULO_Level[ULO_ALC_H] = (ResultData & 0xFF00) >> 8; ULO_Level[ULO_ALC_L] = (ResultData & 0x00FF); #endif // PYJ.2020.09.10_END -- // printf("HFR CALC RET : %d \r\n",ResultData); // // ResultData = ResdBm; // ULO_Level[ULO_ALC_H] = (ResultData & 0xFF00) >> 8; // ULO_Level[ULO_ALC_L] = (ResultData & 0x00FF); // printf("============ALC_OFF======START================\r\n"); // printf("Current UL ADC VALUE : %f \r\n",ret); // printf("ResdBm : UL1 : %f \r\n",ResdBm); // printf("ResdBm : %x ///// bluecell_Currdatastatus.ULO_Level1_H : %x \r\n",ResultData,ULO_Level[ULO_ALC_H]); // printf("ResdBm : %x ///// bluecell_Currdatastatus.ULO_Level1_L : %x \r\n",ResultData,ULO_Level[ULO_ALC_L]); // printf("==================END================\r\n"); } #define ALC_PRINT 0 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; static int16_t PrevLimitdata[ALC_Alarm_UL_Index_MAX] = {0,}; double ResdBm = 0; int16_t ResultData = 0; int16_t PrevResultData[ALC_Alarm_UL_Index_MAX] = {0,}; int16_t IwillGiveAtten = 0; static int8_t* ALC_Table; int16_t tmpcalc = 0; static int16_t PrevIwillGiveAtten[ALC_Alarm_UL_Index_MAX] ={0,};*/ // uint8_t tempadc[256]; int16_t UL_Atten[ALC_Alarm_UL_Index_MAX] = {0,}; int16_t Main_Atten[ALC_Alarm_UL_Index_MAX] = {0,}; // Bluecell_StructCpy(&AutoControl_Save[0],&UL_DET_Table_ref[TABLE_MAX_VALUE],sizeof(ALC_dBm_t)); // Bluecell_StructCpy(&tempadc[0],&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); if(ALCTimerCnt > 500){ if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true && bluecell_Currdatastatus.SelfTest == false){ UL_Atten[ALC_Alarm_UL1_Index] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L; UL_Atten[ALC_Alarm_UL2_Index] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L; UL_Atten[ALC_Alarm_UL3_Index] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L; UL_Atten[ALC_Alarm_UL4_Index] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L; Main_Atten[ALC_Alarm_UL1_Index] = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L; Main_Atten[ALC_Alarm_UL2_Index] = bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L; Main_Atten[ALC_Alarm_UL3_Index] = bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L; Main_Atten[ALC_Alarm_UL4_Index] = bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L; ALC_Package_Operate(&bluecell_Currdatastatus.ULO_P1_Level1_H, &bluecell_Currdatastatus.ULO_Level1_H, &Det_UL1.Table_Det_15_dBm_H, ALC_Alarm_UL1_Index, &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H, &bluecell_Currdatastatus.ATT_UL1_H, &bluecell_Currdatastatus.bluecell_User_UL1_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1); #if 1 // PYJ.2020.07.16_BEGIN -- ALC_Package_Operate(&bluecell_Currdatastatus.ULO_P2_Level2_H, &bluecell_Currdatastatus.ULO_Level2_H, &Det_UL2.Table_Det_15_dBm_H, ALC_Alarm_UL2_Index, &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H, &bluecell_Currdatastatus.ATT_UL2_H, &bluecell_Currdatastatus.bluecell_User_UL2_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2); ALC_Package_Operate(&bluecell_Currdatastatus.ULO_P3_Level3_H, &bluecell_Currdatastatus.ULO_Level3_H, &Det_UL3.Table_Det_15_dBm_H, ALC_Alarm_UL3_Index, &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H, &bluecell_Currdatastatus.ATT_UL3_H, &bluecell_Currdatastatus.bluecell_User_UL3_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3); ALC_Package_Operate(&bluecell_Currdatastatus.ULO_P4_Level4_H, &bluecell_Currdatastatus.ULO_Level4_H, &Det_UL4.Table_Det_15_dBm_H, ALC_Alarm_UL4_Index, &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H, &bluecell_Currdatastatus.ATT_UL4_H, &bluecell_Currdatastatus.bluecell_User_UL4_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4); #endif // PYJ.2020.07.16_END -- // HAL_Delay(1000); //} ALCTimerCnt = 0; } else{ #if 0 // PYJ.2020.06.21_BEGIN -- printf("=========ALC_OFF=========START================\r\n"); printf("Current UL ADC VALUE : %f \r\n",ret); printf("ResdBm : UL2 : %f \r\n",ResdBm); printf("ResdBm : %x ///// bluecell_Currdatastatus.ULO_Level2_H : %x \r\n",ResultData,bluecell_Currdatastatus.ULO_Level2_H); printf("ResdBm : %x ///// bluecell_Currdatastatus.ULO_Level2_L : %x \r\n",ResultData,bluecell_Currdatastatus.ULO_Level2_L); printf("==================END================\r\n"); #endif // PYJ.2020.06.21_END -- } UL_Curr_Level(&bluecell_Currdatastatus.ULO_P1_Level1_H, &bluecell_Currdatastatus.ULO_Level1_H, &Det_UL1.Table_Det_15_dBm_H, ALC_Alarm_UL1_Index); UL_Curr_Level(&bluecell_Currdatastatus.ULO_P2_Level2_H, &bluecell_Currdatastatus.ULO_Level2_H, &Det_UL2.Table_Det_15_dBm_H, ALC_Alarm_UL2_Index); UL_Curr_Level(&bluecell_Currdatastatus.ULO_P3_Level3_H, &bluecell_Currdatastatus.ULO_Level3_H, &Det_UL3.Table_Det_15_dBm_H, ALC_Alarm_UL3_Index); UL_Curr_Level(&bluecell_Currdatastatus.ULO_P4_Level4_H, &bluecell_Currdatastatus.ULO_Level4_H, &Det_UL4.Table_Det_15_dBm_H, ALC_Alarm_UL4_Index); } } //-15 ~ -5 int8_t AGC_Calc(int8_t threshold,int8_t CurrDet){ int8_t Attenret = 0; if(threshold - CurrDet >= 5){ Attenret = 5; } else if(threshold - CurrDet >= 0){ Attenret = (threshold - CurrDet); } else if(threshold != CurrDet){ Attenret = (threshold - CurrDet) * -1; } // printf("2 %s :threshold : %d CurrDet : %d Ret : %d \r\n",__func__,threshold,CurrDet,Attenret); return Attenret; } int16_t New_AGC_Calc(int16_t threshold,int16_t CurrDet){ int16_t Attenret = 0; if(threshold == CurrDet ) return Attenret; if(threshold != CurrDet){ Attenret = (threshold - CurrDet) * -1; } // printf("Attenret : %d \r\n",Attenret); return Attenret; } int16_t HFR_AGC_Calc(int16_t threshold,double CurrDet){ double Attenret = CurrDet; int16_t ret = 0; if(CurrDet < 0){ ret = CurrDet + 0.6; //current Atten ret = threshold - ret; } // else{ // ret = CurrDet - 0.6; //current Atten // ret = ret + threshold; // } return ret * -1; } //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; // } } } int Bluecell_RoundCalc(double data){ int ret = 0; if(data > 0){ ret = data + 0.5; } else{ ret = data - 0.5; } return ret; } #define AGC_PRINT 0 #if 1 // PYJ.2020.06.27_BEGIN -- void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tableindex,uint8_t* DLI_ADC_Level,uint8_t* DLI_Level,DET_TABLEDL_st* DL_Table,uint8_t* FRBT){ double ret = 0; int Round_ResdBm_Ret =0; int16_t ResdBm = 0; double Temp_ResdBm = 0; int16_t CurrAtten = 0; int16_t Levelret = 0; int i = 0; int16_t Limitdata = 0; int16_t IwillgiveAtten = 0; int16_t ResultData = 0; int8_t* AGC_Table;// = &DL_DET_Table_ref[MBIC_Table_DL1_INDEX][TABLE_MAX_VALUE]; int16_t FRBT_Atten = 0; uint8_t* DL_PathStatus = &bluecell_Currdatastatus.ATT_DL1_PATH ; if(DL_PathStatus[Tableindex] == false) return; //static int16_t RefValue[AGC_Alarm_DL_Index_MAX] = {0,}; //static float Ref_F_Value[AGC_Alarm_DL_Index_MAX] = {0,}; // printf("===================%d =====================\r\n",Tableindex); FRBT_Atten = FRBT[DLI_AGC_H] << 8 | FRBT[DLI_AGC_L]; FRBT_Atten *= 0.1; Limitdata = Threshold[DLI_AGC_H] << 8; Limitdata += Threshold[DLI_AGC_L]; Limitdata *= 0.1; AGC_Table = &DL_DET_Table_ref[Tableindex][TABLE_MAX_VALUE]; ret = DLI_ADC_Level[DLI_AGC_H] << 8; ret += DLI_ADC_Level[DLI_AGC_L]; ret *= 0.001; CurrAtten = (int16_t)(DL_MainAtten[DLI_AGC_H] << 8 | DL_MainAtten[DLI_AGC_L]); CurrAtten *= 0.1; // printf("Apply 1 Curr ATTEN %d \r\n", (int16_t)(DL_MainAtten[DLI_AGC_H] << 8 | DL_MainAtten[DLI_AGC_L])); ResdBm = (int16_t)(DLI_Level[DLI_AGC_H] << 8 | DLI_Level[DLI_AGC_L]) * 10;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&DL_Table->Table_Det5_dBm_H,DL_Table->Table_Length,AGC_Table)); Temp_ResdBm = ResdBm *0.01 ; // printf("ResdBm %d \r\n",ResdBm); ResdBm = (int16_t)Bluecell_TestPro(ResdBm/10); int HFR_Dot5 = ((int)(Temp_ResdBm * 10) % 10); // DLI_Level[DLI_AGC_H] = ((int16_t)ResdBm & 0xFF00) >> 8; // DLI_Level[DLI_AGC_L] = ((int16_t)ResdBm & 0x00FF); for(i = 0; i < sizeof(AGC_dBm_t); i++){ if(AGC_Table[i] == ResdBm) break; } if(bluecell_Currdatastatus.DLI_FRBT_Status != FRBT_IDEL){ IwillgiveAtten = AGC_Calc(Limitdata,ResdBm); if(Limitdata - ResdBm < 0){ IwillgiveAtten *= -1; } } if(bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_IDEL){ int16_t Ref_A = Limitdata - CurrAtten; float Ref_Ret = 0; #if AGC_PRINT // PYJ.2020.10.23_BEGIN -- printf("Ref_A : %d \r\n",Ref_A); printf("CurrAtten : %d \r\n",CurrAtten); #endif if(Ref_A + 0.5 < Temp_ResdBm){ Ref_Ret = Limitdata - Temp_ResdBm; IwillgiveAtten = Bluecell_RoundCalc(Ref_Ret); #if AGC_PRINT // PYJ.2020.10.23_BEGIN -- printf("True 2.1 IwillgiveAtten : %d \r\n",IwillgiveAtten); #endif }else{ if(Ref_A - 1.5 > Temp_ResdBm){ IwillgiveAtten = CurrAtten + 1; #if AGC_PRINT // PYJ.2020.10.23_BEGIN -- printf("True 3 IwillgiveAtten : %d \r\n",IwillgiveAtten); #endif }else{ IwillgiveAtten = CurrAtten; #if AGC_PRINT // PYJ.2020.10.23_BEGIN -- printf("false 4 IwillgiveAtten : %d \r\n",IwillgiveAtten); #endif } } if(IwillgiveAtten >= 5){ IwillgiveAtten = 5; } } #if AGC_PRINT // PYJ.2020.10.23_BEGIN -- printf("Result Curr ATTEN %d \r\n",CurrAtten ); printf("ResdBm : %d\r\n",ResdBm); printf("Current DL% ADC VALUE : %f \r\n",Tableindex+1,ret); printf("Temp_ResdBm : DL%d : %f \r\n",Tableindex+1,Temp_ResdBm); printf("I WILL GIVE YOU ATTEN : %d\r\n",IwillgiveAtten); printf("AGC : %d\r\n",Limitdata); #endif // PYJ.2020.10.23_END -- if(bluecell_Currdatastatus.DLI_FRBT_Status != FRBT_IDEL && (CurrAtten) < IwillgiveAtten){ IwillgiveAtten = (CurrAtten ); } if(IwillgiveAtten < -15) IwillgiveAtten = -15; if(bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_IDEL && bluecell_Currdatastatus.DLI_FRBT_ON_OFF == false){ DL_MainAtten[DLI_AGC_H] = ((((IwillgiveAtten) * 10) & 0xFF00) >> 8) ; DL_MainAtten[DLI_AGC_L] = ((((IwillgiveAtten) * 10) & 0x00FF)); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); #if AGC_PRINT // PYJ.2020.10.23_BEGIN -- printf("FRBT_IDEL \r\n"); #endif } else if(bluecell_Currdatastatus.DLI_FRBT_Status != FRBT_IDEL //Tracking && (ResdBm + CurrAtten) > Limitdata // - 8 + 5 > -10 // && (DL_PrevIwillgiveAtten[Tableindex] > IwillgiveAtten || )){ && CurrAtten > IwillgiveAtten){ // printf("IwillgiveAtten : %d \r\n",IwillgiveAtten); DL_PrevIwillgiveAtten[Tableindex] = IwillgiveAtten; // IwillgiveAtten = (DL_AGC_StartAtten[Tableindex]*0.1) + IwillgiveAtten; // printf("WILLATTEN RET : %d \r\n",IwillgiveAtten); AGC_Alarm_Check(AGC_Alarm_DL1_Index + Tableindex,ret,&DL_Table->Table_Det5_dBm_H,IwillgiveAtten); DL_MainAtten[DLI_AGC_H] = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ; DL_MainAtten[DLI_AGC_L] = (((IwillgiveAtten * 10) & 0x00FF)); // printf("Apply 1 Curr ATTEN %d \r\n", (int16_t)(DL_MainAtten[DLI_AGC_H] << 8 | DL_MainAtten[DLI_AGC_L])); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); #if AGC_PRINT // PYJ.2020.10.23_BEGIN -- printf("FRBT TRACKING \r\n"); printf("Curr Atten %d ==== Prev Giveattne : %d ==== Give Atten %d \r\n",CurrAtten,DL_PrevIwillgiveAtten[Tableindex],IwillgiveAtten); #endif } else if(bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_RUNNING){ if(CurrAtten == FRBT_Atten) return; if(CurrAtten + ResdBm <= Limitdata - 1){ // -1 -17 <= -10 -1 IwillgiveAtten = ((CurrAtten) + 1); if(IwillgiveAtten > 5){ IwillgiveAtten = 5; } DL_PrevIwillgiveAtten[Tableindex] = IwillgiveAtten; DL_MainAtten[DLI_AGC_H] = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ; DL_MainAtten[DLI_AGC_L] = (((IwillgiveAtten * 10) & 0x00FF)); // printf("Apply 2 Curr ATTEN %d \r\n", (int16_t)(DL_MainAtten[DLI_AGC_H] << 8 | DL_MainAtten[DLI_AGC_L])); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); } #if AGC_PRINT // PYJ.2020.10.23_BEGIN -- printf("FRBT Runngin \r\n"); #endif }else{ #if AGC_PRINT // PYJ.2020.10.23_BEGIN -- // DL_PrevIwillgiveAtten[Tableindex] > IwillgiveAttsen printf("Prev Giveattne : %d //// Give Atten %d \r\n",DL_PrevIwillgiveAtten[Tableindex],IwillgiveAtten); printf("FRBT Tracking \r\n"); #endif } } #endif // PYJ.2020.06.27_END -- /* bluecell_Currdatastatus.DET_TEMP */ int16_t Temperature_Offset_Get(int8_t* Temp_Table,int8_t CurrTemp){ int8_t Ref_Temperature = -10; int16_t Curr_Level_Offset_ret = 0; uint8_t index = 0; for(int i = Ref_Temperature; i < 60; i += 5){ // printf("about Temp : %d \r\n",i); if(CurrTemp >= i && CurrTemp < i + 5){ // printf("Origin Temp : %d Aboud Temp : %d,index : %d \r\n",CurrTemp,i,index); Curr_Level_Offset_ret = (int8_t)(Temp_Table[index]/ 4);// (Temp_Table[(index * 2)] << 8 | Temp_Table[(index * 2) + 1]) / 4; } index++; } // printf("Curr_Level_Offset_ret : %x \r\n",Curr_Level_Offset_ret); return Curr_Level_Offset_ret; // printf("Curr Temperature : %d \r\n",CurrTemp); // printf(",Temp_Table[0] : %x \r\n",Temp_Table[0]); // printf(",Temp_Table[1] : %x \r\n",Temp_Table[1]); // printf("Temp Table : %x \r\n",Temp_Table[0] << 8 | Temp_Table[1]); } void DL_Det_Function(uint8_t Table_Num,uint8_t* CurrADC_Level,DET_TABLEDL_st* DL_Table,uint8_t* Level){ double ret = 0;// uint8_t* AGC_Table; int16_t Levelret = 0; AGC_Table = &DL_DET_Table_ref[Table_Num][TABLE_MAX_VALUE]; ret = (((CurrADC_Level[DL_Level_H] << 8) | CurrADC_Level[DL_Level_L]) * 0.001); // printf("DL_Table->Table_Length : %d \r\n",DL_Table->Table_Length); #if 0 // PYJ.2020.09.10_BEGIN -- Levelret = (int16_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&DL_Table->Table_Det5_dBm_H,DL_Table->Table_Length,AGC_Table)); Levelret += Temperature_Offset_Get(&Temp_DL1.Table_1_Temp,bluecell_Currdatastatus.DET_TEMP); if(Levelret < -25) Levelret = -25; else if(Levelret > 7) Levelret = 7; // printf("Levelret %d : %d \r\n",Table_Num + 1,Levelret); Level[DL_Level_H] = (Levelret & 0xFF00) >> 8; Level[DL_Level_L] = (Levelret & 0x00FF); #else ret = AGC_AutoControl_ADC_Compare(ret,&DL_Table->Table_Det5_dBm_H,DL_Table->Table_Length,AGC_Table); // ret += Temperature_Offset_Get(&Temp_DL1.Table_1_Temp,bluecell_Currdatastatus.DET_TEMP); if(ret < DL_Table->Table_Ref - (DL_Table->Table_Length-1)) ret = DL_Table->Table_Ref - (DL_Table->Table_Length-1); else if(ret > DL_Table->Table_Ref) ret = DL_Table->Table_Ref; // printf("Levelret %d : %d \r\n",Table_Num + 1,Levelret); // printf("ret : %f \r\n",ret); ret *= 10; Levelret = ret; // printf("Levelret : %d \r\n",Levelret); Level[DL_Level_H] = (Levelret & 0xFF00) >> 8; Level[DL_Level_L] = (Levelret & 0x00FF); #endif // PYJ.2020.09.10_END -- } void AGC_Function(){//DL /*double ret = 0; int8_t ResdBm = 0; int16_t Levelret = 0; int i = 0; int16_t IwillgiveAtten = 0; int16_t ResultData = 0; static int8_t* AGC_Table;// = &DL_DET_Table_ref[MBIC_Table_DL1_INDEX][TABLE_MAX_VALUE];*/ int16_t Limitdata = 0; uint8_t* AGC_AlarmStatus = &bluecell_Currdatastatus.DLI_AGC_Alarm1; int16_t DL_Curr_Atten[AGC_Alarm_DL_Index_MAX] = { bluecell_Currdatastatus.ATT_DL1_H << 8 | bluecell_Currdatastatus.ATT_DL1_L, bluecell_Currdatastatus.ATT_DL2_H << 8 | bluecell_Currdatastatus.ATT_DL2_L, bluecell_Currdatastatus.ATT_DL3_H << 8 | bluecell_Currdatastatus.ATT_DL3_L, bluecell_Currdatastatus.ATT_DL4_H << 8 | bluecell_Currdatastatus.ATT_DL4_L, }; if(AGCTimerCnt > 500){ if(bluecell_Currdatastatus.DLI_AGC_ON_OFF == true && bluecell_Currdatastatus.SelfTest == false){ Limitdata = (( bluecell_Currdatastatus.DLI_AGC_Threshold_H << 8) & 0xFF00) ; Limitdata += bluecell_Currdatastatus.DLI_AGC_Threshold_L ; Limitdata /= 10; DL_Curr_Atten[AGC_Alarm_DL1_Index] = bluecell_Currdatastatus.ATT_DL1_H << 8 | bluecell_Currdatastatus.ATT_DL1_L; DL_Curr_Atten[AGC_Alarm_DL2_Index] = bluecell_Currdatastatus.ATT_DL2_H << 8 | bluecell_Currdatastatus.ATT_DL2_L; DL_Curr_Atten[AGC_Alarm_DL3_Index] = bluecell_Currdatastatus.ATT_DL3_H << 8 | bluecell_Currdatastatus.ATT_DL3_L; DL_Curr_Atten[AGC_Alarm_DL4_Index] = bluecell_Currdatastatus.ATT_DL4_H << 8 | bluecell_Currdatastatus.ATT_DL4_L; uint8_t* DLI_Level = &bluecell_Currdatastatus.DLI_Level1_H; int16_t ResdBm = 0; for(int k = 0; k < AGC_Alarm_DL_Index_MAX; k++){ // if(k != 0) continue; ResdBm = (int16_t)(DLI_Level[DLI_AGC_H + (k * 2)] << 8 | DLI_Level[DLI_AGC_L + ((k * 2))]) * 10; // printf("============================================\r\n"); // printf("%d : Limitdata : %d ResdBm : %d \r\n",k,Limitdata * 100,ResdBm); if(DL_Curr_Atten[AGC_Alarm_DL1_Index+k] <= -150) DL_Curr_Atten[AGC_Alarm_DL1_Index+k] = -150; // printf("DL_Curr_Atten%d : %d \r\n",k+1,DL_Curr_Atten[AGC_Alarm_DL1_Index+k] * 0.1); if(((DL_Curr_Atten[AGC_Alarm_DL1_Index+k] * 0.1) <= -15) && ((Limitdata * 100) + 50 < ResdBm - 1500) ){ // printf("DL_Curr_Atten%d : %d Alarm True\r\n",k+1,DL_Curr_Atten[AGC_Alarm_DL1_Index+k]); // printf("Limitdata : %d \r\n",Limitdata * 100); // printf("ResdBm : %d \r\n",ResdBm); AGC_AlarmSet[AGC_Alarm_DL1_Index+k] = true; }else{ if(AGC_AlarmStatus[AGC_Alarm_DL1_Index+k] == true){ if((DL_Curr_Atten[AGC_Alarm_DL1_Index+k] * 0.1) >= -13 ){ AGC_AlarmSet[AGC_Alarm_DL1_Index+k] = false; // printf("AGC FALSE 1 DL_Curr_Atten %f \r\n",(DL_Curr_Atten[AGC_Alarm_DL1_Index+k] * 0.1)); }else{ AGC_AlarmSet[AGC_Alarm_DL1_Index+k] = true; // printf("AGC TRUE 2\r\n"); } }else{ AGC_AlarmSet[AGC_Alarm_DL1_Index+k] = false; // printf("AGC FALSE 3\r\n"); } } // printf("AGC_AlarmSet : %d \r\n",AGC_AlarmSet[AGC_Alarm_DL1_Index+k]); } AGC_Package_Operate(&bluecell_Currdatastatus.DLI_AGC_Threshold_H, &bluecell_Currdatastatus.ATT_DL3_H, AGC_Alarm_DL3_Index, &bluecell_Currdatastatus.DLI_P3_Level3_H, &bluecell_Currdatastatus.DLI_Level3_H, &Det_DL3.Table_Det5_dBm_H , &bluecell_Currdatastatus.DLI_FRBT_Atten3_H); #if (AGC_PRINT == 0)// PYJ.2020.09.15_BEGIN -- AGC_Package_Operate(&bluecell_Currdatastatus.DLI_AGC_Threshold_H, &bluecell_Currdatastatus.ATT_DL1_H, AGC_Alarm_DL1_Index, &bluecell_Currdatastatus.DLI_P1_Level1_H, &bluecell_Currdatastatus.DLI_Level1_H, &Det_DL1.Table_Det5_dBm_H , &bluecell_Currdatastatus.DLI_FRBT_Atten1_H); AGC_Package_Operate(&bluecell_Currdatastatus.DLI_AGC_Threshold_H, &bluecell_Currdatastatus.ATT_DL2_H, AGC_Alarm_DL2_Index, &bluecell_Currdatastatus.DLI_P2_Level2_H, &bluecell_Currdatastatus.DLI_Level2_H, &Det_DL2.Table_Det5_dBm_H , &bluecell_Currdatastatus.DLI_FRBT_Atten2_H); AGC_Package_Operate(&bluecell_Currdatastatus.DLI_AGC_Threshold_H, &bluecell_Currdatastatus.ATT_DL4_H, AGC_Alarm_DL4_Index, &bluecell_Currdatastatus.DLI_P4_Level4_H, &bluecell_Currdatastatus.DLI_Level4_H, &Det_DL4.Table_Det5_dBm_H, &bluecell_Currdatastatus.DLI_FRBT_Atten4_H); #endif // PYJ.2020.09.15_END -- } DL_Det_Function(MBIC_Table_DL1_INDEX,&bluecell_Currdatastatus.DLI_P1_Level1_H,&Det_DL1.Table_Det5_dBm_H,&bluecell_Currdatastatus.DLI_Level1_H); DL_Det_Function(MBIC_Table_DL2_INDEX,&bluecell_Currdatastatus.DLI_P2_Level2_H,&Det_DL2.Table_Det5_dBm_H,&bluecell_Currdatastatus.DLI_Level2_H); DL_Det_Function(MBIC_Table_DL3_INDEX,&bluecell_Currdatastatus.DLI_P3_Level3_H,&Det_DL3.Table_Det5_dBm_H,&bluecell_Currdatastatus.DLI_Level3_H); DL_Det_Function(MBIC_Table_DL4_INDEX,&bluecell_Currdatastatus.DLI_P4_Level4_H,&Det_DL4.Table_Det5_dBm_H,&bluecell_Currdatastatus.DLI_Level4_H); AGCTimerCnt = 0; } } void DLI_LevelAlarmCheck(){ //double temp = 0; //double ret = 0; //int8_t ResdBm[4] = {0,}; /*********************DL LEVEL LOW START****************************/ if(DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL1_Index] >= MBIC_ON_MAINTAIN_SEC &&ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index] == true){ bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_LOW; bluecell_Currdatastatus.DLI_Level_Low_Alarm1 = true; }else{/**/ if(DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL1_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P1_LEVEL_LOW; bluecell_Currdatastatus.DLI_Level_Low_Alarm1 = false; } } if(DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL2_Index] >= MBIC_ON_MAINTAIN_SEC &&ADC_Alarm_DL_Low_Set[DET_Alarm_DL2_Index] == true){ bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_LOW; bluecell_Currdatastatus.DLI_Level_Low_Alarm2 = true; }else{ if(DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL2_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P2_LEVEL_LOW; bluecell_Currdatastatus.DLI_Level_Low_Alarm2 = false; } } if(DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL3_Index] >= MBIC_ON_MAINTAIN_SEC &&ADC_Alarm_DL_Low_Set[DET_Alarm_DL3_Index] == true){ bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_LOW; bluecell_Currdatastatus.DLI_Level_Low_Alarm3 = true; }else{ if(DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL3_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P3_LEVEL_LOW; bluecell_Currdatastatus.DLI_Level_Low_Alarm3 = false; } } if(DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL4_Index] >= MBIC_ON_MAINTAIN_SEC &&ADC_Alarm_DL_Low_Set[DET_Alarm_DL4_Index] == true){ bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_LOW; bluecell_Currdatastatus.DLI_Level_Low_Alarm4 = true; }else{ if(DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL4_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P4_LEVEL_LOW; bluecell_Currdatastatus.DLI_Level_Low_Alarm4 = false; } } /*********************DL LEVEL HIGH START***************************/ if(DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL1_Index] >= MBIC_ON_MAINTAIN_SEC &&ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index] == true){ bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm1 = true; }else{/**/ if(DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL1_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P1_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm1 = false; } } if(DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL2_Index] >= MBIC_ON_MAINTAIN_SEC &&ADC_Alarm_DL_High_Set[DET_Alarm_DL2_Index] == true){ bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm2 = true; }else{ if(DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL2_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P2_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm2 = false; } } if(DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL3_Index] >= MBIC_ON_MAINTAIN_SEC &&ADC_Alarm_DL_High_Set[DET_Alarm_DL3_Index] == true){ bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm3 = true; }else{ if(DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL3_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P3_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm3 = false; } } if(DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL4_Index] >= MBIC_ON_MAINTAIN_SEC &&ADC_Alarm_DL_High_Set[DET_Alarm_DL4_Index] == true){ bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm4 = true; }else{ if(DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL4_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P4_LEVEL_HIGH; bluecell_Currdatastatus.DLI_Level_High_Alarm4 = false; } } } void ULO_LevelAlarmCheck(){ //double temp = 0; //double ret = 0; //int8_t ResdBm[4] = {0,}; if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL1_Index] >= MBIC_ON_MAINTAIN_SEC &&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{/**/ if(DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL1_Index] >= MBIC_OFF_MAINTAIN_SEC){ 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] >= MBIC_ON_MAINTAIN_SEC &&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{ if(DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL2_Index] >= MBIC_OFF_MAINTAIN_SEC){ 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] >= MBIC_ON_MAINTAIN_SEC &&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{ if(DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL3_Index] >= MBIC_OFF_MAINTAIN_SEC){ 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] >= MBIC_ON_MAINTAIN_SEC &&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{ if(DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL4_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P4_LEVEL_HIGH; bluecell_Currdatastatus.ULO_Level_High_Alarm4 = false; } } } typedef enum{ DL_Shutdown_H = 0, DL_Shutdown_L, }; #define DL_SHUTDOWN_DEBUG 1 void DL_Shutdown_Operate(uint8_t index,uint8_t* path,uint8_t* retrycnt,uint8_t* ShutdownAlarm,uint8_t* MainAtten){ GPIO_TypeDef *Port = 0; uint16_t Pin = 0; uint8_t AlarmFlag = 0; switch(index){ case DET_Alarm_DL1_Shutdown_Index: Port = PATH_EN_DL1_GPIO_Port; Pin = PATH_EN_DL1_Pin; AlarmFlag = ALARM_DLI_SHUTDOWN_P1; break; case DET_Alarm_DL2_Shutdown_Index: Port = PATH_EN_DL2_GPIO_Port; Pin = PATH_EN_DL2_Pin; AlarmFlag = ALARM_DLI_SHUTDOWN_P2; break; case DET_Alarm_DL3_Shutdown_Index: Port = PATH_EN_DL3_GPIO_Port; Pin = PATH_EN_DL3_Pin; AlarmFlag = ALARM_DLI_SHUTDOWN_P3; break; case DET_Alarm_DL4_Shutdown_Index: Port = PATH_EN_DL4_GPIO_Port; Pin = PATH_EN_DL4_Pin; AlarmFlag = ALARM_DLI_SHUTDOWN_P4; // printf("Timer : %d | Retry Cnt : %d | PrevMBIC_DL_ShutdownCount[%d] %d | MBIC_DL_ShutdownCount[%d] %d | DL_PathUserHandl[index] %d \r\n",DET_DL_Shutdown_Off_AlarmTimerCnt[index],(*retrycnt),index + 1,PrevMBIC_DL_ShutdownCount[index],index + 1,MBIC_DL_ShutdownCount[index],DL_PathUserHandl[index]); break; } if((*retrycnt) < 3 /*&& (PrevMBIC_DL_ShutdownCount[index] != MBIC_DL_ShutdownCount[index])*/ && DET_DL_Shutdown_Off_AlarmTimerCnt[index] >= MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC && DL_PathUserHandl[index] == false && (*retrycnt) > 0){ HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK *path = true; MainAtten[DL_Shutdown_H] = 0xFF; MainAtten[DL_Shutdown_L] = 0xFF; PrevMBIC_DL_ShutdownCount[index] = MBIC_DL_ShutdownCount[index]; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); } else if(MBIC_DL_ShutdownCount[index] == 3 && DET_DL_Shutdown_Off_AlarmTimerCnt[index] >= MBIC_RECOVERY_LAST_SHUTDOWN_MAINTAIN_SEC && DL_PathUserHandl[index] == false){ HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK *path = true; MainAtten[DL_Shutdown_H] = 0xFF; MainAtten[DL_Shutdown_L] = 0xFF; PrevMBIC_DL_ShutdownCount[index] = MBIC_DL_ShutdownCount[index]; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); } if(DET_DL_Shutdown_On_AlarmTimerCnt[index] >= MBIC_ON_SHUTDOWN_MAINTAIN_SEC) { /*Shutdown 5sec Alarm*/ HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_RESET);//CLOCK // printf("SHUTDOWN ON DL %d\r\n",index + 1); *path = false; (*retrycnt)++; DET_DL_Shutdown_On_AlarmTimerCnt[index] = 0; #if 1 // PYJ.2020.09.17_BEGIN -- if((*retrycnt) >= RETRYCNT_MAX){ (*retrycnt) = RETRYCNT_MAX; // bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= AlarmFlag; // *ShutdownAlarm = true; } #else /*HFR Request list */ if((*retrycnt) >= 1){ // (*retrycnt) = 1; bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= AlarmFlag; *ShutdownAlarm = true; } #endif // PYJ.2020.09.17_END -- } else{ if(DET_DL_Shutdown_Off_AlarmTimerCnt[index] >= MBIC_OFF_MAINTAIN_SEC && (*retrycnt) != RETRYCNT_MAX){ bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~AlarmFlag; *ShutdownAlarm = false; } } if((*retrycnt) >= 1){ // (*retrycnt) = 1; bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= AlarmFlag; *ShutdownAlarm = true; } } void DLI_ShutdownAlarmCheck() { if(bluecell_Currdatastatus.DLI_Shutdown_ON_OFF == true){ /***************************************************************************************************************/ /* SHUTDOWN DL1 */ /***************************************************************************************************************/ DL_Shutdown_Operate(DET_Alarm_DL1_Shutdown_Index, &bluecell_Currdatastatus.ATT_DL1_PATH, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1, &bluecell_Currdatastatus.DLI_Shutdown_Alarm1, &bluecell_Prevdatastatus.ATT_DL1_H); DL_Shutdown_Operate(DET_Alarm_DL2_Shutdown_Index, &bluecell_Currdatastatus.ATT_DL2_PATH, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2, &bluecell_Currdatastatus.DLI_Shutdown_Alarm2, &bluecell_Prevdatastatus.ATT_DL2_H); DL_Shutdown_Operate(DET_Alarm_DL3_Shutdown_Index, &bluecell_Currdatastatus.ATT_DL3_PATH, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3, &bluecell_Currdatastatus.DLI_Shutdown_Alarm3, &bluecell_Prevdatastatus.ATT_DL3_H); DL_Shutdown_Operate(DET_Alarm_DL4_Shutdown_Index, &bluecell_Currdatastatus.ATT_DL4_PATH, &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4, &bluecell_Currdatastatus.DLI_Shutdown_Alarm4, &bluecell_Prevdatastatus.ATT_DL4_H); } else{ bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN = 0; bluecell_Currdatastatus.DLI_Shutdown_Alarm1 = false; bluecell_Currdatastatus.DLI_Shutdown_Alarm2 = false; bluecell_Currdatastatus.DLI_Shutdown_Alarm3 = false; bluecell_Currdatastatus.DLI_Shutdown_Alarm4 = false; } } typedef enum{ UL_Shutdown_H, UL_Shutdown_L, }; void UL_Shutdown_Operate(uint8_t Index,uint8_t* Path,uint8_t* PrevATT,uint8_t* RetryCnt,uint8_t* ShutdownAlarm,uint8_t AlarmFlag){ GPIO_TypeDef *Port = 0; uint16_t Pin = 0; switch(Index){ case DET_Alarm_UL1_Shutdown_Index: Port = PATH_EN_UL1_GPIO_Port; Pin = PATH_EN_UL1_Pin; break; case DET_Alarm_UL2_Shutdown_Index: Port = PATH_EN_UL2_GPIO_Port; Pin = PATH_EN_UL2_Pin; break; case DET_Alarm_UL3_Shutdown_Index: Port = PATH_EN_UL3_GPIO_Port; Pin = PATH_EN_UL3_Pin; break; case DET_Alarm_UL4_Shutdown_Index: Port = PATH_EN_UL4_GPIO_Port; Pin = PATH_EN_UL4_Pin; // printf("Timer : %d | Retry Cnt : %d | \r\n",DET_UL_Shutdown_Off_AlarmTimerCnt[Index],(*RetryCnt),Index + 1,PrevMBIC_UL_ShutdownCount[Index],Index + 1,MBIC_UL_ShutdownCount[Index]); break; } if((*RetryCnt) < 3 // && (PrevMBIC_UL_ShutdownCount[Index] != MBIC_UL_ShutdownCount[Index]) && DET_UL_Shutdown_Off_AlarmTimerCnt[Index] >= MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC && (*RetryCnt) > 0 && (*Path) == false){ HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK // printf(); *Path = true; PrevATT[UL_Shutdown_H] = 0xFF; PrevATT[UL_Shutdown_L] = 0xFF; PrevMBIC_UL_ShutdownCount[Index] = MBIC_UL_ShutdownCount[Index]; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); } else if((*RetryCnt) == 3 && DET_UL_Shutdown_Off_AlarmTimerCnt[Index] >= MBIC_RECOVERY_LAST_SHUTDOWN_MAINTAIN_SEC){ HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK *Path = true; PrevATT[UL_Shutdown_H] = 0xFF; PrevATT[UL_Shutdown_L] = 0xFF; CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); } if(DET_UL_Shutdown_On_AlarmTimerCnt[Index] >= MBIC_ON_SHUTDOWN_MAINTAIN_SEC && (*Path) == true) { /*Shutdown 5sec Alarm*/ HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_RESET);//CLOCK *Path = false; (*RetryCnt)++; if((*RetryCnt) >= RETRYCNT_MAX){ (*RetryCnt) = RETRYCNT_MAX; } } else{ if(DET_UL_Shutdown_Off_AlarmTimerCnt[Index] >= MBIC_OFF_MAINTAIN_SEC && (*RetryCnt) != RETRYCNT_MAX){ bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~AlarmFlag; *ShutdownAlarm = false; } } if((*RetryCnt) >= 1){ bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN |= AlarmFlag; *ShutdownAlarm = true; } // printf("DET_UL_Shutdown_Off_AlarmTimerCnt[%d] : %d\r\n",Index,DET_UL_Shutdown_Off_AlarmTimerCnt[Index]); // printf("ADC_Alarm_UL_Shutdown_Set[%d] : %d\r\n",Index,ADC_Alarm_UL_Shutdown_Set[Index]); // } void ULO_ShutdownAlarmCheck(){ // double temp = 0; //double ret = 0; // int8_t ResdBm[4] = {0,}; // if(ALC_AlarmSet[ALC_Alarm_UL1_Index] == true // &&ALC_On_AlarmTimerCnt[ALC_Alarm_UL1_Index] >= MBIC_ON_MAINTAIN_SEC){ // printf("ALARM_ALC_P1 OCCUR\r\n"); // bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P1; // bluecell_Currdatastatus.ULO_ALC_Alarm1 = true; // }else{ // if(ALC_On_AlarmTimerCnt[ALC_Alarm_UL1_Index] >= MBIC_OFF_MAINTAIN_SEC){ // bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm &= ~ALARM_ALC_P1; // bluecell_Currdatastatus.ULO_ALC_Alarm1 = false; // } // } if(bluecell_Currdatastatus.ULO_Shutdown_ON_OFF == true){ #if 1 // PYJ.2020.06.19_BEGIN -- #if 1 // PYJ.2020.07.01_BEGIN -- UL_Shutdown_Operate(DET_Alarm_UL1_Shutdown_Index, &bluecell_Currdatastatus.ATT_UL1_PATH, &bluecell_Prevdatastatus.ATT_UL1_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1, &bluecell_Currdatastatus.ULO_Shutdown_Alarm1, ALARM_ULO_SHUTDOWN_P1); #if 1 // PYJ.2020.09.23_BEGIN -- UL_Shutdown_Operate(DET_Alarm_UL2_Shutdown_Index, &bluecell_Currdatastatus.ATT_UL2_PATH, &bluecell_Prevdatastatus.ATT_UL2_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2, &bluecell_Currdatastatus.ULO_Shutdown_Alarm2, ALARM_ULO_SHUTDOWN_P2); UL_Shutdown_Operate(DET_Alarm_UL3_Shutdown_Index, &bluecell_Currdatastatus.ATT_UL3_PATH, &bluecell_Prevdatastatus.ATT_UL3_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3, &bluecell_Currdatastatus.ULO_Shutdown_Alarm3, ALARM_ULO_SHUTDOWN_P3); UL_Shutdown_Operate(DET_Alarm_UL4_Shutdown_Index, &bluecell_Currdatastatus.ATT_UL4_PATH, &bluecell_Prevdatastatus.ATT_UL4_H, &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4, &bluecell_Currdatastatus.ULO_Shutdown_Alarm4, ALARM_ULO_SHUTDOWN_P4); #endif // PYJ.2020.09.23_END -- #else #endif // PYJ.2020.07.01_END -- #if 0 // PYJ.2020.06.21_BEGIN -- #endif // PYJ.2020.06.21_END -- #endif // PYJ.2020.06.19_END -- } else{ bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN = 0; bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1 = 0; bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2 = 0; bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3 = 0; bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 = 0; bluecell_Currdatastatus.ULO_Shutdown_Alarm1 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm2 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm3 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm4 = false; } } void ULO_ALCAlarmCheck(){ //double temp = 0; //double ret = 0; //int8_t ResdBm[4] = {0,}; if(bluecell_Currdatastatus.Carrier_ON_OFF == false) return; if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){ if(ALC_AlarmSet[ALC_Alarm_UL1_Index] == true &&ALC_On_AlarmTimerCnt[ALC_Alarm_UL1_Index] >= MBIC_ON_MAINTAIN_SEC){ // printf("ALARM_ALC_P1 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P1; bluecell_Currdatastatus.ULO_ALC_Alarm1 = true; }else{ if(ALC_Off_AlarmTimerCnt[ALC_Alarm_UL1_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm &= ~ALARM_ALC_P1; bluecell_Currdatastatus.ULO_ALC_Alarm1 = false; } } if(ALC_AlarmSet[ALC_Alarm_UL2_Index] == true &&ALC_On_AlarmTimerCnt[ALC_Alarm_UL2_Index] >= MBIC_ON_MAINTAIN_SEC){ // printf("ALARM_ALC_P2 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P2; bluecell_Currdatastatus.ULO_ALC_Alarm2 = true; }else{ if(ALC_Off_AlarmTimerCnt[ALC_Alarm_UL2_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm &= ~ALARM_ALC_P2; bluecell_Currdatastatus.ULO_ALC_Alarm2 = false; } } if(ALC_AlarmSet[ALC_Alarm_UL3_Index] == true &&ALC_On_AlarmTimerCnt[ALC_Alarm_UL3_Index] >= MBIC_ON_MAINTAIN_SEC){ // printf("ALARM_ALC_P3 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P3; bluecell_Currdatastatus.ULO_ALC_Alarm3 = true; }else{ if(ALC_Off_AlarmTimerCnt[ALC_Alarm_UL3_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm &= ~ALARM_ALC_P3; bluecell_Currdatastatus.ULO_ALC_Alarm3 = false; } } if(ALC_AlarmSet[ALC_Alarm_UL4_Index] == true &&ALC_On_AlarmTimerCnt[ALC_Alarm_UL4_Index] >= MBIC_ON_MAINTAIN_SEC){ // printf("ALARM_ALC_P4 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P4; bluecell_Currdatastatus.ULO_ALC_Alarm4 = true; }else{ if(ALC_Off_AlarmTimerCnt[ALC_Alarm_UL4_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm &= ~ALARM_ALC_P4; bluecell_Currdatastatus.ULO_ALC_Alarm4 = false; } } } } void DLI_AGCAlarmCheck(){ //double temp = 0; //double ret = 0; //int8_t ResdBm[4] = {0,}; if(bluecell_Currdatastatus.Carrier_ON_OFF == false) return; // if(DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL1_Index] >= MBIC_ON_MAINTAIN_SEC // &&ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index] == true){ // bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_LOW; // bluecell_Currdatastatus.DLI_Level_Low_Alarm1 = true; // // }else{/**/ // if(DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL1_Index] >= MBIC_OFF_MAINTAIN_SEC){ // bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P1_LEVEL_LOW; // bluecell_Currdatastatus.DLI_Level_Low_Alarm1 = false; // } // } if(bluecell_Currdatastatus.DLI_AGC_ON_OFF == true){ // printf("bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm : %x \r\n",bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm); if(AGC_AlarmSet[AGC_Alarm_DL1_Index] == true &&AGC_On_AlarmTimerCnt[AGC_Alarm_DL1_Index] >= MBIC_ON_MAINTAIN_SEC){ // printf("ALARM_AGC_P1 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm |= ALARM_AGC_P1; bluecell_Currdatastatus.DLI_AGC_Alarm1 = true; }else{ if(AGC_Off_AlarmTimerCnt[AGC_Alarm_DL1_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm &= ~ALARM_AGC_P1; bluecell_Currdatastatus.DLI_AGC_Alarm1 = false; } } if(AGC_AlarmSet[AGC_Alarm_DL2_Index] == true &&AGC_On_AlarmTimerCnt[AGC_Alarm_DL2_Index] >= MBIC_ON_MAINTAIN_SEC){ // printf("ALARM_AGC_P2 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm |= ALARM_AGC_P2; bluecell_Currdatastatus.DLI_AGC_Alarm2 = true; }else{ if(AGC_Off_AlarmTimerCnt[AGC_Alarm_DL2_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm &= ~ALARM_AGC_P2; bluecell_Currdatastatus.DLI_AGC_Alarm2 = false; } } if(AGC_AlarmSet[AGC_Alarm_DL3_Index] == true &&AGC_On_AlarmTimerCnt[AGC_Alarm_DL3_Index] >= MBIC_ON_MAINTAIN_SEC){ // printf("ALARM_AGC_P3 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm |= ALARM_AGC_P3; bluecell_Currdatastatus.DLI_AGC_Alarm3 = true; }else{ if(AGC_Off_AlarmTimerCnt[AGC_Alarm_DL3_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm &= ~ALARM_AGC_P3; bluecell_Currdatastatus.DLI_AGC_Alarm3 = false; } } if(AGC_AlarmSet[AGC_Alarm_DL4_Index] == true &&AGC_On_AlarmTimerCnt[AGC_Alarm_DL4_Index] >= MBIC_ON_MAINTAIN_SEC){ // printf("ALARM_AGC_P4 OCCUR\r\n"); bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm |= ALARM_AGC_P4; bluecell_Currdatastatus.DLI_AGC_Alarm4 = true; }else{ if(AGC_Off_AlarmTimerCnt[AGC_Alarm_DL4_Index] >= MBIC_OFF_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm &= ~ALARM_AGC_P4; bluecell_Currdatastatus.DLI_AGC_Alarm4 = false; } } } else{ bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm = 0; bluecell_Currdatastatus.DLI_AGC_Alarm4 = false; } } void Temp_HighAlarmCheck(){ //double temp = 0; //double ret = 0; //int8_t ResdBm[4] = {0,}; if(bluecell_Currdatastatus.Carrier_ON_OFF == false) return; if(bluecell_Currdatastatus.Temp_High_Threshold <= (bluecell_Currdatastatus.DET_TEMP )){ bluecell_Currdatastatus.Temp_High_Alarm = true; if(Alarm_Temp_TimerOnCnt > MBIC_ON_MAINTAIN_SEC){ bluecell_Currdatastatus.ALARM_TEMP_HIGH |= ENVIRONMENT_TEMPHIGH; } }else{ if(bluecell_Currdatastatus.ALARM_TEMP_HIGH == ENVIRONMENT_TEMPHIGH){ if(bluecell_Currdatastatus.Temp_High_Threshold - 2 >= (bluecell_Currdatastatus.DET_TEMP )){ bluecell_Currdatastatus.Temp_High_Alarm = false; if( Alarm_Temp_TimerOffCnt > MBIC_OFF_MAINTAIN_SEC){ // printf("1 Alarm TEMP OFF Curr : %d Limit : %d \r\n",(bluecell_Currdatastatus.DET_TEMP ),bluecell_Currdatastatus.Temp_High_Threshold); bluecell_Currdatastatus.ALARM_TEMP_HIGH &= ~ENVIRONMENT_TEMPHIGH; } } } } } #if 0 // PYJ.2020.06.28_BEGIN -- #endif // PYJ.2020.06.28_END -- typedef enum{ FRBT_H = 0, FRBT_L, }; /* uint8_t DLI_FRBT_D_Day; uint8_t DLI_FRBT_Status; */ void FRBT_Tracking_Package(uint8_t Index, uint8_t* FRBT,uint8_t* DL_MainAtten,uint8_t path){ int16_t DL_Atten = 0; int16_t FRBT_Atten = 0; FRBT_Atten = FRBT[FRBT_H] << 8 | FRBT[FRBT_L]; DL_Atten = DL_MainAtten[FRBT_H] << 8 | DL_MainAtten[FRBT_L]; if(path == false || DL_Atten > 0 || FRBT_Atten <= DL_Atten) return; if(FRBT_Atten == DL_Atten){ // printf("Tracking Return %d \r\n "); // printf("FRBT_Atten : %d DL_Atten : %d \r\n",FRBT_Atten,DL_Atten); return; } // printf("FRBT_Atten : %d DL_Atten : %d \r\n",FRBT_Atten,DL_Atten); FRBT[FRBT_H] = DL_MainAtten[FRBT_H]; FRBT[FRBT_L] = DL_MainAtten[FRBT_L]; } void SelfTest_TimerOff(uint8_t num,uint8_t* selftest){ GPIO_TypeDef *Port = 0; uint16_t Pin = 0; GPIO_TypeDef *_Port = 0; uint16_t _Pin = 0; switch(num){ case SelfTest1: _Port = _PATH_SW1_GPIO_Port; _Pin = _PATH_SW1_Pin; Port = PATH_SW1_GPIO_Port; Pin = PATH_SW1_Pin; break; case SelfTest2: _Port = _PATH_SW2_GPIO_Port; _Pin = _PATH_SW2_Pin; Port = PATH_SW2_GPIO_Port; Pin = PATH_SW2_Pin; break; case SelfTest3: _Port = _PATH_SW3_GPIO_Port; _Pin = _PATH_SW3_Pin; Port = PATH_SW3_GPIO_Port; Pin = PATH_SW3_Pin; break; case SelfTest4: _Port = _PATH_SW4_GPIO_Port; _Pin = _PATH_SW4_Pin; Port = PATH_SW4_GPIO_Port; Pin = PATH_SW4_Pin; break; } *selftest = false; HAL_GPIO_WritePin(_Port,_Pin,GPIO_PIN_RESET);//CLOCK HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK } void SelfTest_Ctrl(uint8_t num,uint8_t val,uint8_t* selftest,uint8_t* DL_Atten,uint8_t* UL_Atten,uint8_t* Prev_DL_Atten,uint8_t* Prev_UL_Atten,uint8_t* ALC_Atten,uint8_t* Prev_ALC_Atten){ GPIO_TypeDef *Port = 0; uint16_t Pin = 0; GPIO_TypeDef *_Port = 0; uint16_t _Pin = 0; switch(num){ case SelfTest1: _Port = _PATH_SW1_GPIO_Port; _Pin = _PATH_SW1_Pin; Port = PATH_SW1_GPIO_Port; Pin = PATH_SW1_Pin; break; case SelfTest2: _Port = _PATH_SW2_GPIO_Port; _Pin = _PATH_SW2_Pin; Port = PATH_SW2_GPIO_Port; Pin = PATH_SW2_Pin; break; case SelfTest3: _Port = _PATH_SW3_GPIO_Port; _Pin = _PATH_SW3_Pin; Port = PATH_SW3_GPIO_Port; Pin = PATH_SW3_Pin; break; case SelfTest4: _Port = _PATH_SW4_GPIO_Port; _Pin = _PATH_SW4_Pin; Port = PATH_SW4_GPIO_Port; Pin = PATH_SW4_Pin; break; } // if(*selftest == val) // return; if(val == true){ // Selftest_DL_PrevAttenSave[num * 2] = DL_Atten[Atten_H]; // Selftest_DL_PrevAttenSave[((num * 2) + 1)] = DL_Atten[Atten_L]; // Selftest_UL_PrevAttenSave[num * 2] = UL_Atten[Atten_H]; // Selftest_UL_PrevAttenSave[((num * 2) + 1)] = UL_Atten[Atten_L]; Prev_DL_Atten[Atten_H] = DL_Atten[Atten_H]; Prev_DL_Atten[Atten_L] = DL_Atten[Atten_L]; Prev_UL_Atten[Atten_H] = UL_Atten[Atten_H]; Prev_UL_Atten[Atten_L] = UL_Atten[Atten_L]; Prev_ALC_Atten[Atten_H] = ALC_Atten[Atten_H]; Prev_ALC_Atten[Atten_L] = ALC_Atten[Atten_L]; // for(int i =0; i< 8; i++) // printf("Selftest_UL_PrevAttenSave[%d] : %x \r\n",i,Selftest_UL_PrevAttenSave[i]); DL_Atten[Atten_H] = 0; DL_Atten[Atten_L] = 0; UL_Atten[Atten_H] = 0; UL_Atten[Atten_L] = 0; ALC_Atten[Atten_H] = 0; ALC_Atten[Atten_L] = 0; HAL_GPIO_WritePin(_Port,_Pin,GPIO_PIN_SET);//CLOCK HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_RESET);//CLOCK }else{ #if 0 // PYJ.2020.09.03_BEGIN -- DL_Atten[Atten_H] = Selftest_DL_PrevAttenSave[num * 2]; DL_Atten[Atten_L] = Selftest_DL_PrevAttenSave[((num * 2) + 1)]; UL_Atten[Atten_H] = Selftest_UL_PrevAttenSave[num * 2]; UL_Atten[Atten_L] = Selftest_UL_PrevAttenSave[((num * 2) + 1)]; #else DL_Atten[Atten_H] = Prev_DL_Atten[Atten_H]; DL_Atten[Atten_L] = Prev_DL_Atten[Atten_L]; UL_Atten[Atten_H] = Prev_UL_Atten[Atten_H]; UL_Atten[Atten_L] = Prev_UL_Atten[Atten_L]; ALC_Atten[Atten_H] = Prev_ALC_Atten[Atten_H]; ALC_Atten[Atten_L] = Prev_ALC_Atten[Atten_L]; #endif // PYJ.2020.09.03_END -- // for(int i =0; i< 8; i++) // printf("Selftest_UL_PrevAttenSave[%d] : %x \r\n",i,Selftest_UL_PrevAttenSave[i]); HAL_GPIO_WritePin(_Port,_Pin,GPIO_PIN_RESET);//CLOCK HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK } CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); *selftest = val; } void SelfTestTimer_Operate() { if(bluecell_Currdatastatus.SelfTest == false || SelfTestLifeCnt < MBIC_RECOVERY_SELFTEST_TIMER_SEC){ return; } SelfTest_TimerOff(SelfTest1,&bluecell_Currdatastatus.SelfTest); SelfTest_TimerOff(SelfTest2,&bluecell_Currdatastatus.SelfTest); SelfTest_TimerOff(SelfTest3,&bluecell_Currdatastatus.SelfTest); SelfTest_TimerOff(SelfTest4,&bluecell_Currdatastatus.SelfTest); } void FRBT_Operate(){ if(bluecell_Currdatastatus.DLI_FRBT_ON_OFF == false){ bluecell_Currdatastatus.DLI_FRBT_Status = FRBT_IDEL; return; } if(bluecell_Currdatastatus.DLI_FRBT_D_Day == 0 ){ bluecell_Currdatastatus.DLI_FRBT_Status = FRBT_RUNNING; } /*Time Calc*/ if(bluecell_Currdatastatus.DLI_FRBT_D_Day > 0) { bluecell_Currdatastatus.DLI_FRBT_Status = FRBT_TRACKING; // printf("FRBT Running Start \r\n"); } if(bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_TRACKING){ FRBT_Tracking_Package(DET_Alarm_DL1_Index,&bluecell_Currdatastatus.DLI_FRBT_Atten1_H,&bluecell_Currdatastatus.ATT_DL1_H,bluecell_Currdatastatus.ATT_DL1_PATH); FRBT_Tracking_Package(DET_Alarm_DL2_Index,&bluecell_Currdatastatus.DLI_FRBT_Atten2_H,&bluecell_Currdatastatus.ATT_DL2_H,bluecell_Currdatastatus.ATT_DL2_PATH); FRBT_Tracking_Package(DET_Alarm_DL3_Index,&bluecell_Currdatastatus.DLI_FRBT_Atten3_H,&bluecell_Currdatastatus.ATT_DL3_H,bluecell_Currdatastatus.ATT_DL3_PATH); FRBT_Tracking_Package(DET_Alarm_DL4_Index,&bluecell_Currdatastatus.DLI_FRBT_Atten4_H,&bluecell_Currdatastatus.ATT_DL4_H,bluecell_Currdatastatus.ATT_DL4_PATH); // printf("Tracking ... \r\n"); } } void LED_Alarm_Check(){ if(bluecell_Currdatastatus.ALARM_TESTMODE == false){ if(bluecell_Currdatastatus.SelfTest == true){ Alarm_LED_OnSet = false; // printf("%d\r\n",__LINE__); } #if 0 // PYJ.2020.09.23_BEGIN -- else if( (bluecell_Currdatastatus.ALARM_TEMP_HIGH > 0 && bluecell_Currdatastatus.ALARM_MASK1 != false) || (bluecell_Currdatastatus.ALARM_DLI_Level > 0 && bluecell_Currdatastatus.ALARM_MASK2 != false) || (bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN > 0 && bluecell_Currdatastatus.ALARM_MASK3 != false) || (bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm > 0 && bluecell_Currdatastatus.ALARM_MASK3 != false) || (bluecell_Currdatastatus.ALARM_ULO_Level > 0 && bluecell_Currdatastatus.ALARM_MASK4 != false) || (bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm > 0 && bluecell_Currdatastatus.ALARM_MASK5 != false) || (bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN > 0 && bluecell_Currdatastatus.ALARM_MASK5 != false)) { Alarm_LED_OnSet = true; // printf("%d ::: bluecell_Currdatastatus.ALARM_MASK2 : %x \r\n",__LINE__,bluecell_Currdatastatus.ALARM_MASK2); }else{ Alarm_LED_OnSet = false; printf("%d ::: bluecell_Currdatastatus.ALARM_MASK2 : %x \r\n",__LINE__,bluecell_Currdatastatus.ALARM_MASK2); } #else else if( ((bluecell_Currdatastatus.ALARM_TEMP_HIGH & bluecell_Currdatastatus.ALARM_MASK1)> 0) || ((bluecell_Currdatastatus.ALARM_DLI_Level & bluecell_Currdatastatus.ALARM_MASK2)> 0) || ((bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & bluecell_Currdatastatus.ALARM_MASK3)> 0) || ((bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & bluecell_Currdatastatus.ALARM_MASK3)> 0) || ((bluecell_Currdatastatus.ALARM_ULO_Level & bluecell_Currdatastatus.ALARM_MASK4)> 0) || ((bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & bluecell_Currdatastatus.ALARM_MASK5)> 0) || ((bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & bluecell_Currdatastatus.ALARM_MASK5)> 0)) { Alarm_LED_OnSet = true; // printf("%d ::: bluecell_Currdatastatus.ALARM_MASK2 : %x \r\n",__LINE__,bluecell_Currdatastatus.ALARM_MASK2); }else{ Alarm_LED_OnSet = false; // printf ("bluecell_Currdatastatus.ALARM_MASK1 : %x \r\n",bluecell_Currdatastatus.ALARM_TEMP_HIGH & bluecell_Currdatastatus.ALARM_MASK1) ; // printf ("bluecell_Currdatastatus.ALARM_MASK2 : %x \r\n",bluecell_Currdatastatus.ALARM_DLI_Level & bluecell_Currdatastatus.ALARM_MASK2); // printf ("bluecell_Currdatastatus.ALARM_MASK3 : %x \r\n",bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & bluecell_Currdatastatus.ALARM_MASK3); // printf ("bluecell_Currdatastatus.ALARM_MASK3 : %x \r\n",bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & bluecell_Currdatastatus.ALARM_MASK3); // printf ("bluecell_Currdatastatus.ALARM_MASK4 : %x \r\n",bluecell_Currdatastatus.ALARM_ULO_Level & bluecell_Currdatastatus.ALARM_MASK4); // printf ("bluecell_Currdatastatus.ALARM_MASK5 : %x \r\n",bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & bluecell_Currdatastatus.ALARM_MASK5); // printf ("bluecell_Currdatastatus.ALARM_MASK5 : %x \r\n",bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & bluecell_Currdatastatus.ALARM_MASK5); } #endif // PYJ.2020.09.23_END -- } else{ if(bluecell_Currdatastatus.ALARM_Test_Dummy1 > 0 || bluecell_Currdatastatus.ALARM_Test_Dummy2 > 0 || bluecell_Currdatastatus.ALARM_Test_Dummy3 > 0 || bluecell_Currdatastatus.ALARM_Test_Dummy4 > 0 || bluecell_Currdatastatus.ALARM_Test_Dummy5 > 0) { Alarm_LED_OnSet = true; // printf("%d\r\n",__LINE__); } else{ Alarm_LED_OnSet = false; // printf("%d\r\n",__LINE__); } } } void AlarmCheck_Exception(){ if(bluecell_Currdatastatus.SelfTest == true){ bluecell_Currdatastatus.ALARM_TEMP_HIGH = 0; bluecell_Currdatastatus.ALARM_DLI_Level = 0; bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN = 0; bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm = 0; bluecell_Currdatastatus.ALARM_ULO_Level = 0; bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm = 0; bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN = 0; bluecell_Currdatastatus.Temp_High_Alarm = false; bluecell_Currdatastatus.DLI_AGC_Alarm1 = false; bluecell_Currdatastatus.DLI_AGC_Alarm2 = false; bluecell_Currdatastatus.DLI_AGC_Alarm3 = false; bluecell_Currdatastatus.DLI_AGC_Alarm4 = false; bluecell_Currdatastatus.ULO_ALC_Alarm1 = false; bluecell_Currdatastatus.ULO_ALC_Alarm2 = false; bluecell_Currdatastatus.ULO_ALC_Alarm3 = false; bluecell_Currdatastatus.ULO_ALC_Alarm4 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm1 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm2 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm3 = false; bluecell_Currdatastatus.ULO_Shutdown_Alarm4 = false; bluecell_Currdatastatus.DLI_Shutdown_Alarm1 = false; bluecell_Currdatastatus.DLI_Shutdown_Alarm2 = false; bluecell_Currdatastatus.DLI_Shutdown_Alarm3 = false; bluecell_Currdatastatus.DLI_Shutdown_Alarm4 = false; bluecell_Currdatastatus.DLI_Level_Low_Alarm1 = false; bluecell_Currdatastatus.DLI_Level_Low_Alarm2 = false; bluecell_Currdatastatus.DLI_Level_Low_Alarm3 = false; bluecell_Currdatastatus.DLI_Level_Low_Alarm4 = false; bluecell_Currdatastatus.DLI_Level_High_Alarm1 = false; bluecell_Currdatastatus.DLI_Level_High_Alarm2 = false; bluecell_Currdatastatus.DLI_Level_High_Alarm3 = false; bluecell_Currdatastatus.DLI_Level_High_Alarm4 = false; bluecell_Currdatastatus.ULO_Level_High_Alarm1 = false; bluecell_Currdatastatus.ULO_Level_High_Alarm2 = false; bluecell_Currdatastatus.ULO_Level_High_Alarm3 = false; bluecell_Currdatastatus.ULO_Level_High_Alarm4 = false; } } void Alarm_Check(){ // double temp = 0; // double ret = 0; // int8_t ResdBm[4] = {0,}; LED_Alarm_Check(); Temp_HighAlarmCheck(); DLI_AGCAlarmCheck(); ULO_ALCAlarmCheck(); ULO_ShutdownAlarmCheck(); DLI_ShutdownAlarmCheck(); DLI_LevelAlarmCheck(); ULO_LevelAlarmCheck(); AlarmCheck_Exception(); } typedef struct{ uint8_t Temperature_Status ; uint8_t DLI_Path4_Low ; uint8_t DLI_Path3_Low ; uint8_t DLI_Path2_Low ; uint8_t DLI_Path1_Low ; uint8_t DLI_Path4_High ; uint8_t DLI_Path3_High ; uint8_t DLI_Path2_High ; uint8_t DLI_Path1_High ; uint8_t DLI_Path1_AGC ; uint8_t DLI_Path2_AGC ; uint8_t DLI_Path3_AGC ; uint8_t DLI_Path4_AGC ; uint8_t DLI_Path1_Shutdown ; uint8_t DLI_Path2_Shutdown ; uint8_t DLI_Path3_Shutdown ; uint8_t DLI_Path4_Shutdown ; uint8_t ULO_Path4_High ; uint8_t ULO_Path3_High ; uint8_t ULO_Path2_High ; uint8_t ULO_Path1_High ; uint8_t ULO_Path1_ALC ; uint8_t ULO_Path2_ALC ; uint8_t ULO_Path3_ALC ; uint8_t ULO_Path4_ALC ; uint8_t ULO_Path1_Shutdown ; uint8_t ULO_Path2_Shutdown ; uint8_t ULO_Path3_Shutdown ; uint8_t ULO_Path4_Shutdown ; }Alarm_Report_t; Alarm_Report_t Curr_Alarm_Status_Save; void Alarm_Compare(uint8_t* Prev_Data,uint8_t* Curr_data,uint16_t mode,uint8_t flag){ if(*Prev_Data != *Curr_data){ // printf("Data Report Occur !!\r\n"); if(*Curr_data & flag){ Alarm_Report_Send(mode,true); } else{ Alarm_Report_Send(mode,false); } *Prev_Data = *Curr_data; } } void AlarmLog_Report(){ if(AlarmReport_TimerCnt < 100) return; else AlarmReport_TimerCnt = 0; Alarm_Compare(&Curr_Alarm_Status_Save.Temperature_Status,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x80); #if 1 // PYJ.2020.08.18_BEGIN -- Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_Low,&bluecell_Currdatastatus.ALARM_DLI_Level,DLI_P4_Level_Low,0x80); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path3_Low,&bluecell_Currdatastatus.ALARM_DLI_Level,DLI_P3_Level_Low,0x40); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path2_Low,&bluecell_Currdatastatus.ALARM_DLI_Level,DLI_P2_Level_Low,0x20); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path1_Low,&bluecell_Currdatastatus.ALARM_DLI_Level,DLI_P1_Level_Low,0x10); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_High,&bluecell_Currdatastatus.ALARM_DLI_Level,DLI_P4_Level_High,0x08); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_High,&bluecell_Currdatastatus.ALARM_DLI_Level,DLI_P3_Level_High,0x04); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_High,&bluecell_Currdatastatus.ALARM_DLI_Level,DLI_P2_Level_High,0x02); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_High,&bluecell_Currdatastatus.ALARM_DLI_Level,DLI_P1_Level_High,0x01); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path1_AGC,&bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm,DLI_P4_AGC_Alarm,0x80); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path2_AGC,&bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm,DLI_P3_AGC_Alarm,0x40); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path3_AGC,&bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm,DLI_P2_AGC_Alarm,0x20); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_AGC,&bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm,DLI_P1_AGC_Alarm,0x10); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path1_Shutdown,&bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN,DLI_P4_Shutdown_Alarm,0x08); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path2_Shutdown,&bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN,DLI_P3_Shutdown_Alarm,0x04); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path3_Shutdown,&bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN,DLI_P2_Shutdown_Alarm,0x02); Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_Shutdown,&bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN,DLI_P1_Shutdown_Alarm,0x01); Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path1_High,&bluecell_Currdatastatus.ALARM_ULO_Level,ULO_P4_Level_High,0x08); Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path2_High,&bluecell_Currdatastatus.ALARM_ULO_Level,ULO_P3_Level_High,0x04); Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path3_High,&bluecell_Currdatastatus.ALARM_ULO_Level,ULO_P2_Level_High,0x02); Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path4_High,&bluecell_Currdatastatus.ALARM_ULO_Level,ULO_P1_Level_High,0x01); Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path1_ALC,&bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm,ULO_P4_ALC_Alarm,0x80); Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path2_ALC,&bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm,ULO_P3_ALC_Alarm,0x40); Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path3_ALC,&bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm,ULO_P2_ALC_Alarm,0x20); Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path4_ALC,&bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm,ULO_P1_ALC_Alarm,0x10); Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path1_Shutdown,&bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN,ULO_P4_Shutdown,0x08); Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path2_Shutdown,&bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN,ULO_P3_Shutdown,0x04); Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path3_Shutdown,&bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN,ULO_P2_Shutdown,0x02); Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path4_Shutdown,&bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN,ULO_P1_Shutdown,0x01); #endif // PYJ.2020.08.18_END -- }