Det 통합 ,Alarm index 추가

UL Alarm Set Val 추가

Bluecell_Inc/Bluecell_operate.h

@@ -635,22 +635,22 @@ typedef struct{
     uint8_t ATT_UL3_L;
     uint8_t ATT_UL4_H;
     uint8_t ATT_UL4_L;
-    uint8_t DET_DL1_IN_H;//ADC3   5
-    uint8_t DET_DL1_IN_L;//ADC3   5
-    uint8_t DET_DL2_IN_H;//ADC3   6 
-    uint8_t DET_DL2_IN_L;//ADC3   6
-    uint8_t DET_DL3_IN_H;//ADC3   7
-    uint8_t DET_DL3_IN_L;//ADC3   7
-    uint8_t DET_DL4_IN_H;//ADC3   8   
-    uint8_t DET_DL4_IN_L;//ADC3   8
-    uint8_t DET_UL1_IN_H;//ADC1   4  
-    uint8_t DET_UL1_IN_L;//ADC1   4 
-    uint8_t DET_UL2_IN_H;//ADC1   5 
-    uint8_t DET_UL2_IN_L;//ADC1   5
-    uint8_t DET_UL3_IN_H;//ADC1   6
-    uint8_t DET_UL3_IN_L;//ADC1   6
-    uint8_t DET_UL4_IN_H;//ADC3   4
-    uint8_t DET_UL4_IN_L;//ADC3   4
+    uint8_t ULO_Level1_H;
+    uint8_t ULO_Level1_L;
+    uint8_t ULO_Level2_H;
+    uint8_t ULO_Level2_L;
+    uint8_t ULO_Level3_H;
+    uint8_t ULO_Level3_L;
+    uint8_t ULO_Level4_H;
+    uint8_t ULO_Level4_L;
+    uint8_t DLI_Level1_H;
+    uint8_t DLI_Level1_L;
+    uint8_t DLI_Level2_H;
+    uint8_t DLI_Level2_L;
+    uint8_t DLI_Level3_H;
+    uint8_t DLI_Level3_L;
+    uint8_t DLI_Level4_H;
+    uint8_t DLI_Level4_L;    
     uint8_t BLUECELL_RESERVE1;
     uint8_t DET_TEMP;
     uint8_t DLI_AGC_ON_OFF;
@@ -793,22 +793,22 @@ typedef struct{
     uint8_t ULO_Level_High_Threshold_H;
     uint8_t ULO_Level_High_Threshold_L;
     uint8_t ULO_Level_High_Threshold_default;
-    uint8_t ULO_Level1_H;
-    uint8_t ULO_Level1_L;
-    uint8_t ULO_Level2_H;
-    uint8_t ULO_Level2_L;
-    uint8_t ULO_Level3_H;
-    uint8_t ULO_Level3_L;
-    uint8_t ULO_Level4_H;
-    uint8_t ULO_Level4_L;
-    uint8_t DLI_Level1_H;
-    uint8_t DLI_Level1_L;
-    uint8_t DLI_Level2_H;
-    uint8_t DLI_Level2_L;
-    uint8_t DLI_Level3_H;
-    uint8_t DLI_Level3_L;
-    uint8_t DLI_Level4_H;
-    uint8_t DLI_Level4_L;
+    uint8_t BLUECELL_RESERVE22;//ADC3   5
+    uint8_t BLUECELL_RESERVE23;//ADC3   5
+    uint8_t BLUECELL_RESERVE24;//ADC3   6 
+    uint8_t BLUECELL_RESERVE25;//ADC3   6
+    uint8_t BLUECELL_RESERVE26;//ADC3   7
+    uint8_t BLUECELL_RESERVE27;//ADC3   7
+    uint8_t BLUECELL_RESERVE28;//ADC3   8   
+    uint8_t BLUECELL_RESERVE29;//ADC3   8
+    uint8_t BLUECELL_RESERVE30;//ADC1   4  
+    uint8_t BLUECELL_RESERVE31;//ADC1   4 
+    uint8_t BLUECELL_RESERVE32;//ADC1   5 
+    uint8_t BLUECELL_RESERVE33;//ADC1   5
+    uint8_t BLUECELL_RESERVE34;//ADC1   6
+    uint8_t BLUECELL_RESERVE35;//ADC1   6
+    uint8_t BLUECELL_RESERVE36;//ADC3   4
+    uint8_t BLUECELL_RESERVE37;//ADC3   4
     uint8_t ULO_Level_High_Alarm1;
     uint8_t ULO_Level_High_Alarm2;
     uint8_t ULO_Level_High_Alarm3;
@@ -1104,6 +1104,20 @@ typedef enum{
   Bluecell_DET_DL4_ADC_INDEX_L,
   Bluecell_ADC3_MaxLength,
 }Bluecell_ADC3_Index;
+  typedef enum{
+    DET_Alarm_DL1_Index = 0,
+    DET_Alarm_DL2_Index,
+    DET_Alarm_DL3_Index,
+    DET_Alarm_DL4_Index,
+    DET_Alarm_DL_Index_MAX,
+};
+typedef enum{
+    DET_Alarm_UL1_Index = 0,
+    DET_Alarm_UL2_Index,
+    DET_Alarm_UL3_Index,
+    DET_Alarm_UL4_Index,
+    DET_Alarm_UL_Index_MAX,
+};
 #define ADC1_EA Bluecell_ADC1_MaxLength /2
 #define ADC3_EA Bluecell_ADC3_MaxLength /2
 

Bluecell_Src/Bluecell_operate.c

@@ -7,8 +7,6 @@
 #include "PE43711.h"
 #include "eeprom.h"
 
-extern volatile uint32_t LedTimerCnt;
-extern volatile uint32_t AdcTimerCnt;
 
 /***************************************************************************************/
 /*                                  Extern Function                                    */
@@ -30,6 +28,13 @@ extern ALL_PE43711_st ALL_ATT;
 extern volatile uint16_t ADC1valuearray[4][ADC_AVERAGECNT];
 extern volatile uint16_t ADC3valuearray[5][ADC_AVERAGECNT];
 
+extern volatile uint32_t LedTimerCnt;
+extern volatile uint32_t AdcTimerCnt;
+extern volatile uint32_t DET_UL_On_AlarmTimerCnt[DET_Alarm_UL_Index_MAX];
+extern volatile uint32_t DET_DL_On_AlarmTimerCnt[DET_Alarm_DL_Index_MAX];
+extern volatile uint32_t DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL_Index_MAX];
+extern volatile uint32_t DET_DL_Off_AlarmTimerCnt[DET_Alarm_DL_Index_MAX];
+
 /***************************************************************************************/
 /*                                  Function                                           */
 /***************************************************************************************/
@@ -43,6 +48,8 @@ uint8_t PE43711_Calc(uint8_t* Table,uint8_t high_bit,uint8_t low_bit,uint8_t off
 uint8_t PE43711_Calc_NoTable(uint8_t high_bit,uint8_t low_bit);
 double PE43711_Double(uint8_t high_bit,uint8_t low_bit);
 void Booting_LED_Check(void);
+double Bluecell_TestPro(double value );
+double AGC_AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size);
 
 
 
@@ -51,7 +58,7 @@ void Booting_LED_Check(void);
 /*                                  Valuable                                           */
 /***************************************************************************************/
 
-
+bool Alarm_LED_OnSet = false;
 uint8_t DataWrite[sizeof(BLUESTATUS_st)] = {0,};
 uint8_t Txdata[512];
 int8_t AutoControl_Save[sizeof(ALC_dBm_t)];
@@ -142,13 +149,14 @@ void Boot_LED_Toggle(void){
   if(LedTimerCnt > 1000){
     HAL_GPIO_TogglePin(BOOT_LED_GPIO_Port,BOOT_LED_Pin);
     HAL_GPIO_TogglePin(LED_FAIL_GPIO_Port,LED_FAIL_Pin);
-    if(AlarmTimerOnCnt > 3000){
+//    if(AlarmTimerOnCnt > 3000){
+    if(Alarm_LED_OnSet == true){
         HAL_GPIO_WritePin(LED_ACT_GPIO_Port,LED_ACT_Pin,GPIO_PIN_SET);
     }else{
         HAL_GPIO_WritePin(LED_ACT_GPIO_Port,LED_ACT_Pin,GPIO_PIN_RESET);
     }
+    printf("Alarm_LED_OnSet : %d\r\n",Alarm_LED_OnSet);
     LedTimerCnt = 0;
-//    printf("LED OF OFF\r\n");
   }
   
 }
@@ -891,8 +899,8 @@ void Bluecell_StructCpy(uint8_t* dst,uint8_t* src,uint16_t size){
 }
 
 
-uint16_t ConvertTo2byte(uint8_t highbit, uint8_t lowbit){
-    uint16_t ret = 0;
+int16_t ConvertTo2byte(uint8_t highbit, uint8_t lowbit){
+    int16_t ret = 0;
     ret += ((highbit << 8) & 0xFF00);
     ret += (lowbit & 0x00FF);
 
@@ -1587,7 +1595,7 @@ bool Bluecell_Operate(uint8_t* data){
         tempdata = (( bluecell_Currdatastatus.DLI_Level_High_Threshold_H << 8) & 0xFF00) ;
         tempdata +=  bluecell_Currdatastatus.DLI_Level_High_Threshold_L ;
         tempdata /= 10;
-        printf("tempdata : %d\r\n",tempdata);
+        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;
@@ -1596,8 +1604,8 @@ bool Bluecell_Operate(uint8_t* data){
         bluecell_Currdatastatus.DLI_Level_Low_Threshold_L = data[BLUECELL_DATA + i++];
         tempdata = (( bluecell_Currdatastatus.DLI_Level_Low_Threshold_H << 8) & 0xFF00) ;
         tempdata +=  bluecell_Currdatastatus.DLI_Level_Low_Threshold_L ;
-//        tempdata /= 10;
-//         printf("tempdata : %d\r\n",tempdata);
+        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);    
 
@@ -1636,8 +1644,8 @@ bool Bluecell_Operate(uint8_t* data){
         bluecell_Currdatastatus.ULO_Level_High_Threshold_L = data[BLUECELL_DATA + i++];
         tempdata = (( bluecell_Currdatastatus.ULO_Level_High_Threshold_H << 8) & 0xFF00) ;
         tempdata +=  bluecell_Currdatastatus.ULO_Level_High_Threshold_L ;
-//        tempdata /= 10;
-//         printf("tempdata : %d\r\n",tempdata);
+        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);   
 
@@ -1657,7 +1665,7 @@ bool Bluecell_Operate(uint8_t* data){
         tempdata = (( bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8) & 0xFF00) ;
         tempdata +=  bluecell_Currdatastatus.ULO_ALC_Threshold_L ;
         tempdata /= 10;
-        printf("tempdata : %d\r\n",tempdata);
+        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);
 
@@ -1945,25 +1953,25 @@ bool MBIC_Operate(uint8_t* data){
         
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Carrier_ON_OFF;
 
-        Temp_ADC = ((bluecell_Currdatastatus.DET_DL1_IN_H << 8) & 0xFF00 
-                   |(bluecell_Currdatastatus.DET_DL1_IN_L));
+        Temp_ADC = ((bluecell_Currdatastatus.DLI_Level1_H << 8) & 0xFF00 
+                   |(bluecell_Currdatastatus.DLI_Level1_L));
         data[MBIC_PAYLOADSTART + i++] = ((Temp_ADC & 0xFF00) >> 8);
         data[MBIC_PAYLOADSTART + i++] = (Temp_ADC & 0x00FF);
         
-        Temp_ADC = ((bluecell_Currdatastatus.DET_DL2_IN_H << 8) & 0xFF00 
-                   |(bluecell_Currdatastatus.DET_DL2_IN_L));
+        Temp_ADC = ((bluecell_Currdatastatus.DLI_Level2_H << 8) & 0xFF00 
+                   |(bluecell_Currdatastatus.DLI_Level2_L));
         data[MBIC_PAYLOADSTART + i++] = ((Temp_ADC & 0xFF00) >> 8);
         data[MBIC_PAYLOADSTART + i++] = (Temp_ADC & 0x00FF);
 
 
-        Temp_ADC = ((bluecell_Currdatastatus.DET_DL3_IN_H << 8) & 0xFF00 
-                   |(bluecell_Currdatastatus.DET_DL3_IN_L));
+        Temp_ADC = ((bluecell_Currdatastatus.DLI_Level3_H << 8) & 0xFF00 
+                   |(bluecell_Currdatastatus.DLI_Level3_L));
 
         data[MBIC_PAYLOADSTART + i++] = ((Temp_ADC & 0xFF00) >> 8);
         data[MBIC_PAYLOADSTART + i++] = (Temp_ADC & 0x00FF);
 
-        Temp_ADC = ((bluecell_Currdatastatus.DET_DL4_IN_H << 8) & 0xFF00 
-                   |(bluecell_Currdatastatus.DET_DL4_IN_L));
+        Temp_ADC = ((bluecell_Currdatastatus.DLI_Level4_H << 8) & 0xFF00 
+                   |(bluecell_Currdatastatus.DLI_Level4_L));
         data[MBIC_PAYLOADSTART + i++] = ((Temp_ADC & 0xFF00) >> 8);
         data[MBIC_PAYLOADSTART + i++] = (Temp_ADC & 0x00FF);
 
@@ -1973,14 +1981,14 @@ bool MBIC_Operate(uint8_t* data){
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_DL3_PATH;
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ATT_DL4_PATH;
 
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL1_IN_H;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL1_IN_L;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL2_IN_H;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL2_IN_L;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL3_IN_H;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL3_IN_L;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL4_IN_H;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_DL4_IN_L;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level1_H;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level1_L;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level2_H;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level2_L;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level3_H;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level3_L;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level4_H;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level4_L;
         /*USER == OFFSET */
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_DL1_H;
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_DL1_L;
@@ -2002,28 +2010,28 @@ bool MBIC_Operate(uint8_t* data){
 
         /*DLI LEVEL QUESTION START ???? */
 
-        temp  = (bluecell_Currdatastatus.DET_DL1_IN_H << 8 
-              | bluecell_Currdatastatus.DET_DL1_IN_L) * 3.3/4095; 
+        temp  = (bluecell_Currdatastatus.DLI_Level1_H << 8 
+              | bluecell_Currdatastatus.DLI_Level1_L) * 3.3/4095; 
         Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
         Level *= 10;
         bluecell_Currdatastatus.DLI_Level1_H = ((Level & 0xFF00) >> 8);
         bluecell_Currdatastatus.DLI_Level1_L = ((Level & 0xFF00) >> 8);
-        temp  = (bluecell_Currdatastatus.DET_DL2_IN_H << 8 
-              | bluecell_Currdatastatus.DET_DL2_IN_L) * 3.3/4095; 
+        temp  = (bluecell_Currdatastatus.DLI_Level2_H << 8 
+              | bluecell_Currdatastatus.DLI_Level2_L) * 3.3/4095; 
         Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
         Level *= 10;
         bluecell_Currdatastatus.DLI_Level1_H = ((Level & 0xFF00) >> 8);
         bluecell_Currdatastatus.DLI_Level1_L = ((Level & 0xFF00) >> 8);
         
-        temp  = (bluecell_Currdatastatus.DET_DL3_IN_H << 8 
-              | bluecell_Currdatastatus.DET_DL3_IN_L) * 3.3/4095; 
+        temp  = (bluecell_Currdatastatus.DLI_Level3_H << 8 
+              | bluecell_Currdatastatus.DLI_Level3_L) * 3.3/4095; 
         Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
         Level *= 10;
         bluecell_Currdatastatus.DLI_Level1_H = ((Level & 0xFF00) >> 8);
         bluecell_Currdatastatus.DLI_Level1_L = ((Level & 0xFF00) >> 8);
         
-        temp  = (bluecell_Currdatastatus.DET_DL4_IN_H << 8 
-              | bluecell_Currdatastatus.DET_DL4_IN_L) * 3.3/4095; 
+        temp  = (bluecell_Currdatastatus.DLI_Level4_H << 8 
+              | bluecell_Currdatastatus.DLI_Level4_L) * 3.3/4095; 
         Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
         Level *= 10;
         bluecell_Currdatastatus.DLI_Level1_H = ((Level & 0xFF00) >> 8);
@@ -2116,28 +2124,28 @@ bool MBIC_Operate(uint8_t* data){
         /*ULO LEVEL QUESTION START ???? */
 
 
-        temp  = (bluecell_Currdatastatus.DET_UL1_IN_H << 8 
-              | bluecell_Currdatastatus.DET_UL1_IN_L) * 3.3/4095; 
+        temp  = (bluecell_Currdatastatus.ULO_Level1_H << 8 
+              | bluecell_Currdatastatus.ULO_Level1_L) * 3.3/4095; 
         Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
         Level *= 10;
         bluecell_Currdatastatus.ULO_Level1_H = ((Level & 0xFF00) >> 8);
         bluecell_Currdatastatus.ULO_Level1_L = ((Level & 0xFF00) >> 8);
-        temp  = (bluecell_Currdatastatus.DET_UL2_IN_H << 8 
-              | bluecell_Currdatastatus.DET_UL2_IN_L) * 3.3/4095; 
+        temp  = (bluecell_Currdatastatus.ULO_Level2_H << 8 
+              | bluecell_Currdatastatus.ULO_Level2_L) * 3.3/4095; 
         Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
         Level *= 10;
         bluecell_Currdatastatus.ULO_Level2_H = ((Level & 0xFF00) >> 8);
         bluecell_Currdatastatus.ULO_Level2_L = ((Level & 0xFF00) >> 8);
         
-        temp  = (bluecell_Currdatastatus.DET_UL3_IN_H << 8 
-              | bluecell_Currdatastatus.DET_UL3_IN_L) * 3.3/4095; 
+        temp  = (bluecell_Currdatastatus.ULO_Level3_H << 8 
+              | bluecell_Currdatastatus.ULO_Level3_L) * 3.3/4095; 
         Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
         Level *= 10;
         bluecell_Currdatastatus.ULO_Level3_H = ((Level & 0xFF00) >> 8);
         bluecell_Currdatastatus.ULO_Level3_L = ((Level & 0xFF00) >> 8);
         
-        temp  = (bluecell_Currdatastatus.DET_UL4_IN_H << 8 
-              | bluecell_Currdatastatus.DET_UL4_IN_L) * 3.3/4095; 
+        temp  = (bluecell_Currdatastatus.ULO_Level4_H << 8 
+              | bluecell_Currdatastatus.ULO_Level4_L) * 3.3/4095; 
         Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
         Level *= 10;
         bluecell_Currdatastatus.ULO_Level4_H = ((Level & 0xFF00) >> 8);
@@ -2750,6 +2758,119 @@ uint32_t SumFunc(uint16_t* data,uint16_t size){
     return ret;
 }
 
+
+
+
+bool ADC_Alarm_DL_Set[DET_Alarm_DL_Index_MAX] = {false,} ;
+bool ADC_Alarm_UL_Set[DET_Alarm_UL_Index_MAX] = {false,} ;
+void DET_LevelAlarmCheck(){
+    int16_t DL[DET_Alarm_DL_Index_MAX] = {0,};
+    int16_t UL[DET_Alarm_UL_Index_MAX] = {0,};
+    int16_t LimitData_UL_High = 0;
+    
+    int16_t LimitData_DL_High = 0;    
+    int16_t LimitData_DL_Low = 0;    
+    double ret = 0;
+    int8_t Res_DL_dBm[DET_Alarm_DL_Index_MAX] = {0,};
+    int8_t Res_UL_dBm[DET_Alarm_UL_Index_MAX] = {0,};    
+    
+
+    LimitData_UL_High = ConvertTo2byte(bluecell_Currdatastatus.ULO_Level_High_Threshold_H,bluecell_Currdatastatus.ULO_Level_High_Threshold_L) / 10;
+    LimitData_DL_High = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level_High_Threshold_H,bluecell_Currdatastatus.DLI_Level_High_Threshold_L)/ 10;
+    LimitData_DL_Low = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level_Low_Threshold_H,bluecell_Currdatastatus.DLI_Level_Low_Threshold_L)/ 10;
+    DL[DET_Alarm_DL1_Index] = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level1_H,bluecell_Currdatastatus.DLI_Level1_L);
+    DL[DET_Alarm_DL2_Index] = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level2_H,bluecell_Currdatastatus.DLI_Level2_L);
+    DL[DET_Alarm_DL3_Index] = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level3_H,bluecell_Currdatastatus.DLI_Level3_L);
+    DL[DET_Alarm_DL4_Index] = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level4_H,bluecell_Currdatastatus.DLI_Level4_L);
+    UL[DET_Alarm_UL1_Index] = ConvertTo2byte(bluecell_Currdatastatus.ULO_Level1_H,bluecell_Currdatastatus.ULO_Level1_L);
+    UL[DET_Alarm_UL2_Index] = ConvertTo2byte(bluecell_Currdatastatus.ULO_Level2_H,bluecell_Currdatastatus.ULO_Level2_L);
+    UL[DET_Alarm_UL3_Index] = ConvertTo2byte(bluecell_Currdatastatus.ULO_Level3_H,bluecell_Currdatastatus.ULO_Level3_L);
+    UL[DET_Alarm_UL4_Index] = ConvertTo2byte(bluecell_Currdatastatus.ULO_Level4_H,bluecell_Currdatastatus.ULO_Level4_L);
+
+    ret  = bluecell_Currdatastatus.DLI_Level1_H << 8;
+    ret += bluecell_Currdatastatus.DLI_Level1_L;   
+    ret *= 0.001;    
+    Res_DL_dBm[DET_Alarm_DL1_Index] 
+        = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)));
+    ret  = bluecell_Currdatastatus.DLI_Level2_H << 8;
+    ret += bluecell_Currdatastatus.DLI_Level2_L;   
+    ret *= 0.001;  
+
+    Res_DL_dBm[DET_Alarm_DL2_Index] 
+        = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)));
+    ret  = bluecell_Currdatastatus.DLI_Level3_H << 8;
+    ret += bluecell_Currdatastatus.DLI_Level3_L;   
+    ret *= 0.001;  
+
+    Res_DL_dBm[DET_Alarm_DL3_Index] 
+        = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)));
+
+
+    ret  = bluecell_Currdatastatus.DLI_Level4_H << 8;
+    ret += bluecell_Currdatastatus.DLI_Level4_L;   
+    ret *= 0.001;  
+
+    Res_DL_dBm[DET_Alarm_DL4_Index] 
+        = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)));
+
+
+
+    ret  = bluecell_Currdatastatus.ULO_Level1_H << 8;
+    ret += bluecell_Currdatastatus.ULO_Level1_L;   
+    ret *= 0.001;
+
+    Res_UL_dBm[DET_Alarm_UL1_Index] 
+        = (int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)));
+
+//    printf("LimitData_UL_High : %d \r\n",LimitData_UL_High);
+//    printf("DET_High : %d \r\n",Res_UL_dBm[DET_Alarm_UL1_Index] );
+
+    ret  = bluecell_Currdatastatus.ULO_Level2_H << 8;
+    ret += bluecell_Currdatastatus.ULO_Level2_L;   
+    ret *= 0.001;
+
+    Res_UL_dBm[DET_Alarm_UL2_Index] 
+        = (int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)));
+
+    ret  = bluecell_Currdatastatus.ULO_Level3_H << 8;
+    ret += bluecell_Currdatastatus.ULO_Level3_L;   
+    ret *= 0.001;
+
+    Res_UL_dBm[DET_Alarm_UL3_Index] 
+        = (int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)));
+
+
+    ret  = bluecell_Currdatastatus.ULO_Level4_H << 8;
+    ret += bluecell_Currdatastatus.ULO_Level4_L;   
+    ret *= 0.001;
+
+    Res_UL_dBm[DET_Alarm_UL4_Index] 
+        = (int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)));
+
+
+//    printf("LimitData_DL_High : %d \r\n",LimitData_DL_High);    
+//    printf("LimitData_DL_Low : %d \r\n",LimitData_DL_Low);   
+    for(int i = 0 ; i < DET_Alarm_UL_Index_MAX; i++){
+        if(LimitData_UL_High > Res_UL_dBm[DET_Alarm_UL1_Index + i]){
+            ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i] = true;
+//            printf("ADC_Alarm_UL_Set %d ,Value : %d\r\n",DET_Alarm_UL1_Index + i,ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i]);
+        }
+        else{
+            ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i] = false;
+//            printf("ADC_Alarm_UL_Set %d ,Value : %d\r\n",DET_Alarm_UL1_Index + i,ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i] );            
+        }
+    }
+#if 1 // PYJ.2020.05.27_BEGIN -- 
+    for(int i = 0 ; i < DET_Alarm_DL_Index_MAX; i++){
+        if(LimitData_DL_High > Res_DL_dBm[DET_Alarm_DL1_Index + i]
+         &&LimitData_DL_Low < Res_DL_dBm[DET_Alarm_DL1_Index + i])
+            ADC_Alarm_DL_Set[DET_Alarm_DL1_Index + i] = true;
+        else
+            ADC_Alarm_DL_Set[DET_Alarm_DL1_Index + i] = false;
+    }    
+//    HAL_Delay(1000);
+#endif // PYJ.2020.05.27_END -- 
+}
 void ADC_Check(void){
     //static uint8_t Cnt = 0;
    double ADC1DoubleRet[4];
@@ -2792,33 +2913,33 @@ void ADC_Check(void){
                 ADC3_Average_value[i] = 0;
             }
             
-            bluecell_Currdatastatus.DET_DL1_IN_H 
+            bluecell_Currdatastatus.DLI_Level1_H 
                 = ((ADC3Ret[1] & 0xFF00) >> 8);
-            bluecell_Currdatastatus.DET_DL1_IN_L 
+            bluecell_Currdatastatus.DLI_Level1_L 
                 = ((ADC3Ret[1] & 0x00FF));
             
 
-            bluecell_Currdatastatus.DET_DL2_IN_H 
+            bluecell_Currdatastatus.DLI_Level2_H 
                 = ((ADC3Ret[2] & 0xFF00) >> 8);
-            bluecell_Currdatastatus.DET_DL2_IN_L 
+            bluecell_Currdatastatus.DLI_Level2_L 
                 = ((ADC3Ret[2] & 0x00FF) );
 
                 
-            bluecell_Currdatastatus.DET_DL3_IN_H 
+            bluecell_Currdatastatus.DLI_Level3_H 
                 = ((ADC3Ret[3] & 0xFF00) >> 8);
-            bluecell_Currdatastatus.DET_DL3_IN_L 
+            bluecell_Currdatastatus.DLI_Level3_L 
                 = ((ADC3Ret[3] & 0x00FF) );
 
                 
-            bluecell_Currdatastatus.DET_DL4_IN_H 
+            bluecell_Currdatastatus.DLI_Level4_H 
                 = ((ADC3Ret[4] & 0xFF00) >> 8);
-            bluecell_Currdatastatus.DET_DL4_IN_L 
+            bluecell_Currdatastatus.DLI_Level4_L 
                 = ((ADC3Ret[4] & 0x00FF) );
 
                 
-            bluecell_Currdatastatus.DET_UL4_IN_H 
+            bluecell_Currdatastatus.ULO_Level4_H 
                 = ((ADC3Ret[0] & 0xFF00) >> 8);
-            bluecell_Currdatastatus.DET_UL4_IN_L 
+            bluecell_Currdatastatus.ULO_Level4_L 
                 = ((ADC3Ret[0] & 0x00FF) );
 #endif // PYJ.2020.05.25_END -- 
 #if 0 // PYJ.2020.04.26_BEGIN -- 
@@ -2864,21 +2985,21 @@ void ADC_Check(void){
             ADC1_Average_value[i] = 0;
         }
        
-        bluecell_Currdatastatus.DET_UL1_IN_H 
+        bluecell_Currdatastatus.ULO_Level1_H 
             = ((ADC1Ret[0] & 0xFF00) >> 8);
-        bluecell_Currdatastatus.DET_UL1_IN_L 
+        bluecell_Currdatastatus.ULO_Level1_L 
             = ((ADC1Ret[0] & 0x00FF) );
 
             
-        bluecell_Currdatastatus.DET_UL2_IN_H 
+        bluecell_Currdatastatus.ULO_Level2_H 
             = ((ADC1Ret[1] & 0xFF00) >> 8);
-        bluecell_Currdatastatus.DET_UL2_IN_L 
+        bluecell_Currdatastatus.ULO_Level2_L 
             = ((ADC1Ret[1] & 0x00FF) );
 
             
-        bluecell_Currdatastatus.DET_UL3_IN_H 
+        bluecell_Currdatastatus.ULO_Level3_H 
             = ((ADC1Ret[2] & 0xFF00) >> 8);
-        bluecell_Currdatastatus.DET_UL3_IN_L 
+        bluecell_Currdatastatus.ULO_Level3_L 
             = ((ADC1Ret[2] & 0x00FF) );
 
 //            printf("ADC1_Average_value[%d] : %d / %f \r\n",i,ADC1_Average_value[i],ADC1_Average_value[i]/cnt[i] * Volt_Calc_val);            
@@ -3312,8 +3433,8 @@ void ALC_Function(){ //DL
             //ret 현재 Voltage 값 출력 
             //ret 에 따른 현재 DBM 구현 
             
-            ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
-            ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
+            ret  = bluecell_Currdatastatus.ULO_Level1_H << 8;
+            ret += bluecell_Currdatastatus.ULO_Level1_L;   
             ret *= 0.001;
 
             
@@ -3340,7 +3461,7 @@ void ALC_Function(){ //DL
     //                        printf("ResdBm : UL1 : %f \r\n",ResdBm);
      
 
-                //CurrnALC_MIN_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL1_IN_H,CurrnALC_MIN_SettingValue);
+                //CurrnALC_MIN_SettingValue = MinusConvert(bluecell_Currdatastatus.ULO_Level1_H,CurrnALC_MIN_SettingValue);
     //            Limitdata = (( bluecell_Currdatastatus.ATT_UL1_H << 8) & 0xFF00) ;
     //            Limitdata +=  bluecell_Currdatastatus.ATT_UL1_L ;
     //
@@ -3385,8 +3506,8 @@ void ALC_Function(){ //DL
             //ret 현재 Voltage 값 출력 
             //ret 에 따른 현재 DBM 구현 
             
-            ret  = bluecell_Currdatastatus.DET_UL2_IN_H << 8;
-            ret += bluecell_Currdatastatus.DET_UL2_IN_L;   
+            ret  = bluecell_Currdatastatus.ULO_Level2_H << 8;
+            ret += bluecell_Currdatastatus.ULO_Level2_L;   
             ret *= 0.001;
             
             
@@ -3417,8 +3538,8 @@ void ALC_Function(){ //DL
             //ret 현재 Voltage 값 출력 
             //ret 에 따른 현재 DBM 구현 
             
-            ret  = bluecell_Currdatastatus.DET_UL3_IN_H << 8;
-            ret += bluecell_Currdatastatus.DET_UL3_IN_L;   
+            ret  = bluecell_Currdatastatus.ULO_Level3_H << 8;
+            ret += bluecell_Currdatastatus.ULO_Level3_L;   
             ret *= 0.001;
             
             
@@ -3452,8 +3573,8 @@ void ALC_Function(){ //DL
             //ret 현재 Voltage 값 출력 
             //ret 에 따른 현재 DBM 구현 
             
-            ret  = bluecell_Currdatastatus.DET_UL4_IN_H << 8;
-            ret += bluecell_Currdatastatus.DET_UL4_IN_L;   
+            ret  = bluecell_Currdatastatus.ULO_Level4_H << 8;
+            ret += bluecell_Currdatastatus.ULO_Level4_L;   
             ret *= 0.001;
             
             
@@ -3516,19 +3637,19 @@ void AGC_Alarm_Check(uint8_t Path_Index,double AGC_Det,uint8_t* AGC_Table,uint16
 
     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);
+//        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){
+//        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;
-        }
+//        }
     }
 
 }
@@ -3558,8 +3679,8 @@ void AGC_Function(){//DL
 #if 1 // PYJ.2020.05.25_BEGIN -- 
                         //ret 현재 Voltage 값 출력 
             //ret 에 따른 현재 DBM 구현 
-            ret  = bluecell_Currdatastatus.DET_DL1_IN_H << 8;
-            ret += bluecell_Currdatastatus.DET_DL1_IN_L;   
+            ret  = bluecell_Currdatastatus.DLI_Level1_H << 8;
+            ret += bluecell_Currdatastatus.DLI_Level1_L;   
             ret *= 0.001;
             
             
@@ -3593,8 +3714,8 @@ void AGC_Function(){//DL
 
 
 
-       ret  = bluecell_Currdatastatus.DET_DL2_IN_H << 8;
-       ret += bluecell_Currdatastatus.DET_DL2_IN_L;   
+       ret  = bluecell_Currdatastatus.DLI_Level2_H << 8;
+       ret += bluecell_Currdatastatus.DLI_Level2_L;   
        ret *= 0.001;
       
        ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)));
@@ -3624,8 +3745,8 @@ void AGC_Function(){//DL
 
 
 
-        ret  = bluecell_Currdatastatus.DET_DL3_IN_H << 8;
-        ret += bluecell_Currdatastatus.DET_DL3_IN_L;   
+        ret  = bluecell_Currdatastatus.DLI_Level3_H << 8;
+        ret += bluecell_Currdatastatus.DLI_Level3_L;   
         ret *= 0.001;
         
         ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)));
@@ -3657,8 +3778,8 @@ void AGC_Function(){//DL
 #endif // PYJ.2020.05.25_END -- 
 
 
-            ret  = bluecell_Currdatastatus.DET_DL4_IN_H << 8;
-            ret += bluecell_Currdatastatus.DET_DL4_IN_L;   
+            ret  = bluecell_Currdatastatus.DLI_Level4_H << 8;
+            ret += bluecell_Currdatastatus.DLI_Level4_L;   
             ret *= 0.001;
             ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)));
             for(i = 0; i < sizeof(AGC_dBm_t); i++){
@@ -3702,10 +3823,15 @@ void Alarm_Check(){
     || bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN     > 0){
         AlarmTimerOnSet = true;
         AlarmTimerOffSet = false;
+        if(AlarmTimerOnCnt > 3000){
+            Alarm_LED_OnSet  = true;
+        }
     }else{
         AlarmTimerOffSet = true;// False 
         if(AlarmTimerOffCnt > 10000){
             AlarmTimerOnSet = false;
+            Alarm_LED_OnSet = false;
+//            printf("=================AlarmTimerOffCnt=================\r\n");
         }
     }
 
@@ -3719,191 +3845,9 @@ void Alarm_Check(){
     }
     /******************************TEMP END*******************************************/ 
 
-    /******************************ULO LEVEL START*******************************************/ 
-    
-    if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){ // ALC ON 
-#if 0 // PYJ.2020.05.23_BEGIN -- 
-        temp = ((bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8) & 0xFF00);
-        temp += (bluecell_Currdatastatus.ULO_ALC_Threshold_L & 0x00FF);
-        temp /= 10;
-        
-        ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
-        ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
-        ret *= 0.001;
-        ResdBm[0] = AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-        ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
-        ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
-        ret *= 0.001;
-        ResdBm[1] = AutoControl_ADC_Compare(ret,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-
-        ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
-        ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
-        ret *= 0.001;
-        ResdBm[2] = AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-        ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
-        ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
-        ret *= 0.001;
-        ResdBm[3] = AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-        
-#endif // PYJ.2020.05.23_END -- 
-     /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */
-        if(ALC_AlarmSet[ALC_Alarm_UL1_Index] == true){
-             printf("ULO_ALC_Alarm1 OCCUR\r\n");
-            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P1_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm1  = true;
-        }else{
-            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P1_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm1  = false;
-        }
-
-        if(ALC_AlarmSet[ALC_Alarm_UL2_Index] == true){
-             printf("ULO_ALC_Alarm2 OCCUR\r\n");
-            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P2_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm2  = true;
-        }else{
-            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P2_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm2  = false;
-        }        
-        if(ALC_AlarmSet[ALC_Alarm_UL3_Index] == true){
-             printf("ULO_ALC_Alarm3 OCCUR\r\n");
-            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P3_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm3  = true;
-        }else{
-            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P3_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm3  = false;
-        }        
-        if(ALC_AlarmSet[ALC_Alarm_UL4_Index] == true){
-             printf("ULO_ALC_Alarm4 OCCUR\r\n");
-            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P4_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm4  = true;
-        }else{
-            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P4_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm4  = false;
-        }                
-#if 0 // PYJ.2020.05.23_BEGIN -- 
-        if( temp > ResdBm[1]){
-            printf("ULO_ALC_Alarm2 OCCUR\r\n");
-            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P2_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm2  = true;        
-        }else{
-            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P2_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm2  = false;        
-
-        }
-        if(temp > ResdBm[2]){
-            printf("ULO_ALC_Alarm3 OCCUR\r\n");
-            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P3_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm3  = true;        
-        }else{
-            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P3_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm3  = false;        
 
-        }
-        if(temp > ResdBm[3]){
-            printf("ULO_ALC_Alarm4 OCCUR\r\n");
-            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P4_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm4  = true;        
-        }else{
-            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P4_LEVEL_HIGH;
-            bluecell_Currdatastatus.ULO_ALC_Alarm4  = false;        
-        }
-#endif // PYJ.2020.05.23_END -- 
-#if 0 // PYJ.2020.05.23_BEGIN -- 
-        /******************************ULO LEVEL END*******************************************/ 
-        /******************************ULO ALC Start*******************************************/ 
-        temp = ((bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8) & 0xFF00);
-        temp += (bluecell_Currdatastatus.ULO_ALC_Threshold_L & 0x00FF);
-        if(temp > ResdBm[0]){
-            bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P1;
-        }
-        if( temp > ResdBm[1]){
-            bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P2;
-        }
-        if(temp > ResdBm[2]){
-            bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P3;
-        }
-        if(temp > ResdBm[3]){
-            bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P4;
-        }
-        /******************************ULO ALC END*******************************************/ 
-        temp = ((bluecell_Currdatastatus.ULO_Shutdown_Threshold_H << 8) & 0xFF00);
-        temp += (bluecell_Currdatastatus.ULO_Shutdown_Threshold_L & 0x00FF);    
-        if(temp > ResdBm[0]){
-            bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P1;
-        }
-        if( temp > ResdBm[1]){
-            bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P2;
-        }
-        if(temp > ResdBm[2]){
-            bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P3;
-        }
-        if(temp > ResdBm[3]){
-            bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P4;
-        }
-#endif // PYJ.2020.05.23_END -- 
-    }
-    /******************************DLI LEVEL START*******************************************/ 
+    /******************************DLI AGC START******************************************/     
     if(bluecell_Currdatastatus.DLI_AGC_ON_OFF == true){
-#if 0 // PYJ.2020.05.25_BEGIN -- 
-        ret  = bluecell_Currdatastatus.DET_DL1_IN_H << 8;
-        ret += bluecell_Currdatastatus.DET_DL1_IN_L;   
-        ret *= 0.001;
-        ResdBm[0] = AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
-
-        ret  = bluecell_Currdatastatus.DET_DL2_IN_H << 8;
-        ret += bluecell_Currdatastatus.DET_DL2_IN_L;   
-        ret *= 0.001;
-        ResdBm[1] = AutoControl_ADC_Compare(ret,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
-
-        ret  = bluecell_Currdatastatus.DET_DL3_IN_H << 8;
-        ret += bluecell_Currdatastatus.DET_DL3_IN_L;   
-        ret *= 0.001;
-        ResdBm[2] = AutoControl_ADC_Compare(ret,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
-
-        ret  = bluecell_Currdatastatus.DET_DL4_IN_H << 8;
-        ret += bluecell_Currdatastatus.DET_DL4_IN_L;   
-        ret *= 0.001;
-        ResdBm[3] = AutoControl_ADC_Compare(ret,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
-
-        temp = ((bluecell_Currdatastatus.DLI_Level_High_Threshold_H << 8) & 0xFF00);
-        temp += (bluecell_Currdatastatus.DLI_Level_High_Threshold_L & 0x00FF);
-        /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */
-        if(temp < ResdBm[0]){
-            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_HIGH;
-        }
-        if( temp < ResdBm[1]){
-            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_HIGH;
-        }
-        if(temp < ResdBm[2]){
-            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_HIGH;
-        }
-        if(temp < ResdBm[3]){
-            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_HIGH;
-        }
-#endif // PYJ.2020.05.25_END -- 
-
-#if 0 // PYJ.2020.05.20_BEGIN -- 
-        temp = ((bluecell_Currdatastatus.DLI_Level_Low_Threshold_H << 8) & 0xFF00);
-        temp += (bluecell_Currdatastatus.DLI_Level_Low_Threshold_L & 0x00FF);
-        /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */
-        if(temp > ResdBm[0]){
-            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_HIGH;
-        }
-        if( temp > ResdBm[1]){
-            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_HIGH;
-        }
-        if(temp > ResdBm[2]){
-            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_HIGH;
-        }
-        if(temp > ResdBm[3]){
-            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_HIGH;
-        }    
-#endif // PYJ.2020.05.20_END -- 
-        /******************************DLI LEVEL END*******************************************/     
-        /******************************DLI AGC START******************************************/     
-        
-
-        
         temp = ((bluecell_Currdatastatus.ATT_DL1_H << 8) & 0xFF00);
         temp += (bluecell_Currdatastatus.ATT_DL1_L & 0x00FF);
         temp /= 10;
@@ -3943,27 +3887,160 @@ void Alarm_Check(){
         }
     }
     /******************************DLI AGC END******************************************/     
-    /******************************DLI ShutDown Start******************************************/     
-#if 0 // PYJ.2020.05.23_BEGIN -- 
-    temp = ((bluecell_Currdatastatus.DLI_Shutdown_Threshold_H << 8) & 0xFF00);
-    temp += (bluecell_Currdatastatus.DLI_Shutdown_Threshold_L & 0x00FF);
+    /******************************DLI ALC START******************************************/     
+    if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){ // ALC ON 
+     /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */
+        if(ALC_AlarmSet[ALC_Alarm_UL1_Index] == true){
+             printf("ULO_ALC_Alarm1 OCCUR\r\n");
+            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ALC_P1;
+            bluecell_Currdatastatus.ULO_ALC_Alarm1  = true;
+        }else{
+            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ALC_P1;
+            bluecell_Currdatastatus.ULO_ALC_Alarm1  = false;
+        }
 
+        if(ALC_AlarmSet[ALC_Alarm_UL2_Index] == true){
+             printf("ULO_ALC_Alarm2 OCCUR\r\n");
+            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ALC_P2;
+            bluecell_Currdatastatus.ULO_ALC_Alarm2  = true;
+        }else{
+            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ALC_P2;
+            bluecell_Currdatastatus.ULO_ALC_Alarm2  = false;
+        }        
+        if(ALC_AlarmSet[ALC_Alarm_UL3_Index] == true){
+             printf("ULO_ALC_Alarm3 OCCUR\r\n");
+            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ALC_P3;
+            bluecell_Currdatastatus.ULO_ALC_Alarm3  = true;
+        }else{
+            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ALC_P3;
+            bluecell_Currdatastatus.ULO_ALC_Alarm3  = false;
+        }        
+        if(ALC_AlarmSet[ALC_Alarm_UL4_Index] == true){
+             printf("ULO_ALC_Alarm4 OCCUR\r\n");
+            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ALC_P4;
+            bluecell_Currdatastatus.ULO_ALC_Alarm4  = true;
+        }else{
+            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ALC_P4;
+            bluecell_Currdatastatus.ULO_ALC_Alarm4  = false;
+        }                
+    }
+    /******************************DLI ALC END******************************************/
+    /******************************ULO LEVEL START*******************************************/   
+#if 0 // PYJ.2020.05.27_BEGIN -- 
+    if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL1_Index] >= 3000){
+        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P1_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm1 = true;
+//        printf("ULO_Level_High_Alarm1 OCCUR\r\n");
+    }else if(DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL1_Index] >= 10000){
+        bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P1_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm1 = false;
+    }
+    if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL2_Index] >= 3000){
+        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P2_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm2 = true;
+//        printf("ULO_Level_High_Alarm2 OCCUR\r\n");
+
+    }else{
+        bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P2_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm2 = false;
+    }
+    if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL3_Index] >= 3000){
+        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P3_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm3 = true;
+//        printf("ULO_Level_High_Alarm3 OCCUR\r\n");
+    }else{
+        bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P3_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm3 = false;
+    }
+    if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL4_Index] >= 3000){
+        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P4_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm4 = true;
+//        printf("ULO_Level_High_Alarm4 OCCUR\r\n");
+    }else{
+        bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P4_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm4 = false;
+    }    
+#else
+    if(ADC_Alarm_UL_Set[DET_Alarm_UL1_Index] == true){
+        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P1_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm1 = true;
+
+    }else{
+        bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P1_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm1 = false;
+    }
+
+    if(ADC_Alarm_UL_Set[DET_Alarm_UL2_Index] == true){
+        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P2_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm2 = true;
+
+    }else{
+        bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P2_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm2 = false;
+    }
+
+    if(ADC_Alarm_UL_Set[DET_Alarm_UL3_Index] == true){
+        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P3_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm3 = true;
+
+    }else{
+        bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P3_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm3 = false;
+    }
+
+    if(ADC_Alarm_UL_Set[DET_Alarm_UL4_Index] == true){
+        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P4_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm4 = true;
+
+    }else{
+        bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P4_LEVEL_HIGH;
+        bluecell_Currdatastatus.ULO_Level_High_Alarm4 = false;
+    }
+
+#endif // PYJ.2020.05.27_END -- 
+    /******************************ULO LEVEL END*******************************************/ 
     
-    if(temp > ResdBm[0]){
-        bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P1;
+    /******************************DLI LEVEL START*******************************************/ 
+
+    if(ADC_Alarm_DL_Set[DET_Alarm_DL1_Index] == true){
+        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_HIGH;
+        bluecell_Currdatastatus.DLI_Level_High_Alarm1 = true;
+
+    }else{
+        bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P1_LEVEL_HIGH;
+        bluecell_Currdatastatus.DLI_Level_High_Alarm1 = false;
     }
-    if( temp > ResdBm[1]){
-        bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P2;
+
+    if(ADC_Alarm_DL_Set[DET_Alarm_DL2_Index] == true){
+        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_HIGH;
+        bluecell_Currdatastatus.DLI_Level_High_Alarm2 = true;
+
+    }else{
+        bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P2_LEVEL_HIGH;
+        bluecell_Currdatastatus.DLI_Level_High_Alarm2 = false;
     }
-    if(temp > ResdBm[2]){
-        bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P3;
+
+    if(ADC_Alarm_DL_Set[DET_Alarm_DL3_Index] == true){
+        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_HIGH;
+        bluecell_Currdatastatus.DLI_Level_High_Alarm3 = true;
+
+    }else{
+        bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P3_LEVEL_HIGH;
+        bluecell_Currdatastatus.DLI_Level_High_Alarm3 = false;
     }
-    if(temp > ResdBm[3]){
-        bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P4;
-    }  
 
+    if(ADC_Alarm_DL_Set[DET_Alarm_DL4_Index] == true){
+        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_HIGH;
+        bluecell_Currdatastatus.DLI_Level_High_Alarm4 = true;
+
+    }else{
+        bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P4_LEVEL_HIGH;
+        bluecell_Currdatastatus.DLI_Level_High_Alarm4 = false;
+    }     
+    /******************************DLI LEVEL END*******************************************/     
+    
+    /******************************DLI ShutDown Start******************************************/     
     /******************************DLI ShutDown END******************************************/     
-#endif // PYJ.2020.05.23_END -- 
 
     
 }

Inc/main.h

@@ -172,6 +172,9 @@ extern I2C_HandleTypeDef hi2c2;
 #define ATT_EN_DL1_Pin GPIO_PIN_9
 #define ATT_EN_DL1_GPIO_Port GPIOB
 /* USER CODE BEGIN Private defines */
+#define MBIC_ON_MAINTAIN_SEC 3000
+#define MBIC_OFF_MAINTAIN_SEC 10000
+
 #define ADC_AVERAGECNT 500
 #define ADC1_CNT 4
 #define ADC3_CNT 5
@@ -185,3 +188,4 @@ extern I2C_HandleTypeDef hi2c2;
 #endif /* __MAIN_H */
 
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+

Src/main.c

@@ -75,13 +75,22 @@ volatile uint32_t LDTimerCnt = 0;
 volatile uint32_t ALCTimerCnt = 0;
 volatile uint32_t AGCTimerCnt = 0;
 volatile uint32_t AGCAlarmTimerCnt[AGC_Alarm_DL_Index_MAX] = {0,};
+volatile uint32_t DET_UL_On_AlarmTimerCnt[DET_Alarm_UL_Index_MAX] = {0,};
+volatile uint32_t DET_DL_On_AlarmTimerCnt[DET_Alarm_DL_Index_MAX] = {0,};
+volatile uint32_t DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL_Index_MAX] = {0,};
+volatile uint32_t DET_DL_Off_AlarmTimerCnt[DET_Alarm_DL_Index_MAX] = {0,};
+
+
 
 volatile bool     AlarmTimerOnSet = 0;
 volatile bool     AlarmTimerOffSet = 0;
-volatile uint32_t AlarmTimerOnCnt = 0;
 volatile uint32_t AlarmTimerOffCnt = 0;
+volatile uint32_t AlarmTimerOnCnt = 0;
+
 
 extern bool AGC_AlarmTimerSet[AGC_Alarm_DL_Index_MAX];
+extern bool ADC_Alarm_DL_Set[DET_Alarm_DL_Index_MAX];
+extern bool ADC_Alarm_UL_Set[DET_Alarm_UL_Index_MAX];
 
 
 
@@ -101,6 +110,7 @@ static void MX_NVIC_Init(void);
 /* USER CODE BEGIN PFP */
 extern void Booting_LedInit(void);
 extern void Bluecell_AttenInitialize();
+extern void DET_LevelAlarmCheck();
 
 /* USER CODE END PFP */
 
@@ -264,6 +274,8 @@ void eepromtest_j1(){
     printf("\r\n");
 
 }
+extern void DET_LevelAlarmCheck();
+
 #endif // PYJ.2020.04.23_END -- 
 
 extern void ALC_Function();
@@ -364,6 +376,7 @@ int main(void)
     ALC_Function();
     AGC_Function();
     Alarm_Check();
+    DET_LevelAlarmCheck();
     /* USER CODE END WHILE */
 
     /* USER CODE BEGIN 3 */
@@ -864,21 +877,113 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
       LDTimerCnt++;
       ALCTimerCnt++;
       AGCTimerCnt++;
-      if(AGC_AlarmTimerSet[AGC_Alarm_DL1_Index] == true)
+      if(AGC_AlarmTimerSet[AGC_Alarm_DL1_Index] == true){
           AGCAlarmTimerCnt[AGC_Alarm_DL1_Index]++;
-      if(AGC_AlarmTimerSet[AGC_Alarm_DL2_Index] == true)
+          if(AGCAlarmTimerCnt[AGC_Alarm_DL1_Index] == 0xFFFFFFFF){
+            AGCAlarmTimerCnt[AGC_Alarm_DL1_Index] = MBIC_ON_MAINTAIN_SEC;
+          }
+      }
+      if(AGC_AlarmTimerSet[AGC_Alarm_DL2_Index] == true){
           AGCAlarmTimerCnt[AGC_Alarm_DL2_Index]++;
-      if(AGC_AlarmTimerSet[AGC_Alarm_DL3_Index] == true)
+          if(AGCAlarmTimerCnt[AGC_Alarm_DL2_Index] == 0xFFFFFFFF){
+            AGCAlarmTimerCnt[AGC_Alarm_DL2_Index] = MBIC_ON_MAINTAIN_SEC;
+          }
+          
+      }
+      if(AGC_AlarmTimerSet[AGC_Alarm_DL3_Index] == true){
           AGCAlarmTimerCnt[AGC_Alarm_DL3_Index]++;
-      if(AGC_AlarmTimerSet[AGC_Alarm_DL4_Index] == true)
-          AGCAlarmTimerCnt[AGC_Alarm_DL4_Index]++;      
+          if(AGCAlarmTimerCnt[AGC_Alarm_DL3_Index] == 0xFFFFFFFF){
+            AGCAlarmTimerCnt[AGC_Alarm_DL3_Index] = MBIC_ON_MAINTAIN_SEC;
+          }          
+      }
+      if(AGC_AlarmTimerSet[AGC_Alarm_DL4_Index] == true){
+          AGCAlarmTimerCnt[AGC_Alarm_DL4_Index]++;  
+          if(AGCAlarmTimerCnt[AGC_Alarm_DL4_Index] == 0xFFFFFFFF){
+            AGCAlarmTimerCnt[AGC_Alarm_DL4_Index] = MBIC_ON_MAINTAIN_SEC;
+          }          
+      }
+
+
+    if(ADC_Alarm_UL_Set[DET_Alarm_UL1_Index ] == true){
+        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL1_Index]++;
+        DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL1_Index] = 0;
+
+        if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL1_Index] == 0xFFFFFFFF){
+            DET_UL_On_AlarmTimerCnt[DET_Alarm_UL1_Index] = MBIC_ON_MAINTAIN_SEC;
+        }   
+        
+    }
+    else{
+        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL1_Index] = 0;
+        DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL1_Index]++;
+
+        if(DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL1_Index] == 0xFFFFFFFF){
+            DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL1_Index] = MBIC_OFF_MAINTAIN_SEC;
+        }           
+    }
+#if 0 // PYJ.2020.05.27_BEGIN -- 
+
+    if(ADC_Alarm_UL_Set[DET_Alarm_UL2_Index ] == true){
+        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL2_Index]++;
+    }
+    else{
+        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL2_Index] = 0;
+    }
+
+    if(ADC_Alarm_UL_Set[DET_Alarm_UL3_Index ] == true){
+        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL3_Index]++;
+    }
+    else{
+        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL3_Index] = 0;
+    }
+
+    if(ADC_Alarm_UL_Set[DET_Alarm_UL4_Index ] == true){
+        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL4_Index]++;
+    }
+    else{
+        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL4_Index] = 0;
+    }
+
+
+
+
+    if(ADC_Alarm_DL_Set[DET_Alarm_DL1_Index ] == true){
+        DET_DL_On_AlarmTimerCnt[DET_Alarm_DL1_Index]++;
+    }
+    else{
+        DET_DL_On_AlarmTimerCnt[DET_Alarm_DL1_Index] = 0;
+    }
+
+    if(ADC_Alarm_DL_Set[DET_Alarm_DL2_Index ] == true){
+        DET_DL_On_AlarmTimerCnt[DET_Alarm_DL2_Index]++;
+    }
+    else{
+        DET_DL_On_AlarmTimerCnt[DET_Alarm_DL2_Index] = 0;
+    }
+
+    if(ADC_Alarm_DL_Set[DET_Alarm_DL3_Index ] == true){
+        DET_DL_On_AlarmTimerCnt[DET_Alarm_DL3_Index]++;
+    }
+    else{
+        DET_DL_On_AlarmTimerCnt[DET_Alarm_DL3_Index] = 0;
+    }
 
+    if(ADC_Alarm_DL_Set[DET_Alarm_DL4_Index ] == true){
+        DET_DL_On_AlarmTimerCnt[DET_Alarm_DL4_Index]++;
+    }
+    else{
+        DET_DL_On_AlarmTimerCnt[DET_Alarm_DL4_Index] = 0;
+    }
+#endif // PYJ.2020.05.27_END -- 
+
+    
       /*3 Sec Time Cnt */
       if(AlarmTimerOnSet == true){
         if(AlarmTimerOnCnt == 0xFFFFFFFF)
-            AlarmTimerOnCnt = 3000;
-        else
+            AlarmTimerOnCnt = MBIC_ON_MAINTAIN_SEC;
+        else{
             AlarmTimerOnCnt++;
+        }
       }
       else{
         AlarmTimerOnCnt = 0;
@@ -888,9 +993,10 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
       /*10 Sec Time Cnt*/
       if(AlarmTimerOffSet == true){
         if(AlarmTimerOffCnt == 0xFFFFFFFF)
-            AlarmTimerOffCnt = 10000;
-        else
+            AlarmTimerOffCnt = MBIC_OFF_MAINTAIN_SEC;
+        else{
             AlarmTimerOffCnt++;
+        }
       }
       else{
         AlarmTimerOffCnt = 0;