Version 01.17

1. DL Atten 동작이 기존과 동일합니다. (수정안됨)
-동작 확인 후 수정 완료 하였습니다.
2. UL ALC 동작하지 않습니다. 출력이 계속 올라감
-사이드 이펙트로 다른 증상 해결 후 증상이 해결 되었습니다.
3. UL High Alarm 해제 조건이 High Level -2dB가 아니라, -1.1dB입니다.
-동작 확인 후 수정 완료 하였습니다.

Bluecell_Src/Bluecell_operate.c

@@ -6085,8 +6085,10 @@ void DET_LevelAlarmCheck(){
     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,};    
+    int16_t Res_Up_DL_dBm[DET_Alarm_DL_Index_MAX] = {0,};
+    int16_t Res_Down_DL_dBm[DET_Alarm_DL_Index_MAX] = {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;
@@ -6100,19 +6102,19 @@ void DET_LevelAlarmCheck(){
     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] 
+    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_DL_dBm[DET_Alarm_DL2_Index] 
+    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_DL_dBm[DET_Alarm_DL3_Index] 
+    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)));
 
 
@@ -6120,50 +6122,35 @@ void DET_LevelAlarmCheck(){
     ret += bluecell_Currdatastatus.DLI_P4_Level4_L;   
     ret *= 0.001;  
 
-    Res_DL_dBm[DET_Alarm_DL4_Index] 
+    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.15_BEGIN -- 
-        if(Res_DL_dBm[DET_Alarm_DL1_Index + i] % 10 != 0){
-            Res_DL_dBm[DET_Alarm_DL1_Index + i] *= 0.1;
-            if(Res_DL_dBm[DET_Alarm_DL1_Index + i] < 0)
-                Res_DL_dBm[DET_Alarm_DL1_Index + i]--;
-            else
-                Res_DL_dBm[DET_Alarm_DL1_Index + i]++;
-        }else{
-            Res_DL_dBm[DET_Alarm_DL1_Index + i] *= 0.1;
-        }
-#else
-    if(Res_DL_dBm[DET_Alarm_DL1_Index + i] > 0){
-        
-        if(Res_DL_dBm[DET_Alarm_DL1_Index + i] % 10 != 0){
-            if(Res_DL_dBm[DET_Alarm_DL1_Index + i] % 10 >= 5){
-                Res_DL_dBm[DET_Alarm_DL1_Index + i] *= 0.1;
-                Res_DL_dBm[DET_Alarm_DL1_Index + i]++;
-            }else{
-                Res_DL_dBm[DET_Alarm_DL1_Index + i] *= 0.1;
-            }
-        }
-        else{
-            Res_DL_dBm[DET_Alarm_DL1_Index + i] *= 0.1;
-        }
-        
-    }else{
-    
-        if(Res_DL_dBm[DET_Alarm_DL1_Index + i] % 10 != 0){
-            if(Res_DL_dBm[DET_Alarm_DL1_Index + i] % 10 <= -5){
-                Res_DL_dBm[DET_Alarm_DL1_Index + i] *= 0.1;
-                Res_DL_dBm[DET_Alarm_DL1_Index + i]--;
-            }else{
-                Res_DL_dBm[DET_Alarm_DL1_Index + i] *= 0.1;
+#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{
-            Res_DL_dBm[DET_Alarm_DL1_Index + i] *= 0.1;
+            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
+        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]);    
@@ -6176,7 +6163,7 @@ void DET_LevelAlarmCheck(){
     ret += bluecell_Currdatastatus.ULO_P1_Level1_L;   
     ret *= 0.001;
 
-    Res_UL_dBm[DET_Alarm_UL1_Index] 
+    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));
 
 
@@ -6184,14 +6171,14 @@ void DET_LevelAlarmCheck(){
     ret += bluecell_Currdatastatus.ULO_P2_Level2_L;   
     ret *= 0.001;
 
-    Res_UL_dBm[DET_Alarm_UL2_Index] 
+    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_UL_dBm[DET_Alarm_UL3_Index] 
+    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));
 
 
@@ -6199,13 +6186,13 @@ void DET_LevelAlarmCheck(){
     ret += bluecell_Currdatastatus.ULO_P4_Level4_L;   
     ret *= 0.001;
 
-    Res_UL_dBm[DET_Alarm_UL4_Index] 
+    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;
@@ -6218,22 +6205,72 @@ void DET_LevelAlarmCheck(){
         }
 
     }
+#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(LimitData_DL_High <= Res_DL_dBm[DET_Alarm_DL1_Index + i]){
-            ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i] = true;
-//            printf("DL High Threadhold : %d |||| DL Det : %d \r\n",LimitData_DL_High,Res_DL_dBm[DET_Alarm_DL1_Index + i]);
-//            printf("ADC_Alarm_DL_High_Set %d ,Value : %d\r\n",DET_Alarm_UL1_Index + i,ADC_Alarm_DL_High_Set[DET_Alarm_UL1_Index + 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 - 2 >= Res_DL_dBm[DET_Alarm_DL1_Index + i])
-                ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i] = false;
-//            printf("ADC_Alarm_DL_High_Set %d ,Value : %d\r\n",DET_Alarm_UL1_Index + i,ADC_Alarm_DL_High_Set[DET_Alarm_UL1_Index + i]);            
+            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",
@@ -6242,11 +6279,6 @@ void DET_LevelAlarmCheck(){
         Res_DL_dBm[DET_Alarm_DL1_Index + i],
         ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i]);            
 #endif // PYJ.2020.06.22_END -- 
-
-//        LimitData_DL_Low,
-//        DET_Alarm_UL1_Index + i,
-//        Res_DL_dBm[DET_Alarm_DL1_Index + i],
-//        ADC_Alarm_DL_High_Set[LimitData_DL_High + i]);            
     }    
     
     /*
@@ -6263,55 +6295,111 @@ void DET_LevelAlarmCheck(){
 
 
     for(int i = 0 ; i < DET_Alarm_DL_Shutdown_Index_MAX; i++){
-        if(DL_PathStatus[DET_Alarm_DL1_Shutdown_Index + i] == true
-            && (LimitData_DL_Shutdown - 2 >= Res_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("DL%d_PATH : %d Retry Count Initialize Start %d \r\n",i+1,DL_PathStatus[DET_Alarm_DL1_Shutdown_Index + i],bluecell_Currdatastatus.DLO_Shutdown_Retry_Count2);
+        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("DL%d_PATH : %d Retry Count Initialize Start %d \r\n",i+1,DL_PathStatus[DET_Alarm_DL1_Shutdown_Index + i],bluecell_Currdatastatus.DLO_Shutdown_Retry_Count2);
+                    }
                 }
+            }else{
+                ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = false;
             }
-        }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("DL%d_PATH : %d Retry Count Initialize Start %d \r\n",i+1,DL_PathStatus[DET_Alarm_DL1_Shutdown_Index + i],bluecell_Currdatastatus.DLO_Shutdown_Retry_Count2);
+                    }
+                }
+            }else{
+                ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = false;
+            }
+
         }
     }
     for(int i = 0 ; i < DET_Alarm_DL_Shutdown_Index_MAX; i++){
-        if(LimitData_DL_Shutdown <= Res_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i]){
-//            if(DL_Atten[DET_Alarm_DL1_Index + i] * 0.1 <= -15)
-                ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = true;
-        }
-        else{
-//             if(LimitData_DL_Shutdown - 2 >= Res_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i])
-              if(MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index + i] > 0)
-                ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = false;
+        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(DL_Atten[DET_Alarm_DL1_Index + i] * 0.1 <= -15)
+                    ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = true;
+            }
+            else{
+    //             if(LimitData_DL_Shutdown - 2 >= Res_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i])
+                  if(MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index + i] > 0)
+                    ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = false;
+            }
+        }else{
+            if(LimitData_DL_Shutdown <= Res_Up_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i]){
+    //            if(DL_Atten[DET_Alarm_DL1_Index + i] * 0.1 <= -15)
+                    ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = true;
+            }
+            else{
+    //             if(LimitData_DL_Shutdown - 2 >= Res_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i])
+                  if(MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index + i] > 0)
+                    ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = false;
+            }
+
         }
     }
 
 //    printf("======================================================\r\n");
-        uint8_t* AlarmStatus = &bluecell_Currdatastatus.DLI_Level_Low_Alarm1;
-        uint8_t* PathStatus = &bluecell_Currdatastatus.ATT_DL1_PATH;
+        
         for(int i = 0 ; i < DET_Alarm_DL_Index_MAX; i++){
-            if(PathStatus[DET_Alarm_DL1_Index + i] == false){
+//            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(LimitData_DL_Low >= Res_DL_dBm[DET_Alarm_DL1_Index + i])
-                {
-                    ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = true;
-                }
-                if(LimitData_DL_Low + 2 <= Res_DL_dBm[DET_Alarm_DL1_Index + i]){
-                    ADC_Alarm_DL_Low_Set[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(LimitData_DL_Low + 1 >= Res_DL_dBm[DET_Alarm_DL1_Index + i])
-                {
-                    ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = true;
-                }
-                if(LimitData_DL_Low + 2 <= Res_DL_dBm[DET_Alarm_DL1_Index + i]){
-                    ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = false;
+                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;
+                    }
                 }
             }
 
@@ -6319,10 +6407,12 @@ void DET_LevelAlarmCheck(){
         
 #if 0 // PYJ.2020.06.22_BEGIN -- 
         printf("=========================================================\r\n");
-        printf("LimitData_DL_Low: %d Res_DL_dBm [%d] : %d ,Value : %d Real Alamr : %d \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_DL_dBm[DET_Alarm_DL1_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 -- 
@@ -6341,7 +6431,7 @@ void DET_LevelAlarmCheck(){
 //          if(i != 0)
 //                continue;
         /*UL Shutdown Cnt plus Condition Check */
-        if(LimitData_UL_Shutdown <= Res_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i] 
+        if(LimitData_UL_Shutdown <= Res_Up_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i] 
             && UL_PathStatus[DET_Alarm_UL1_Shutdown_Index + i] == true){
           
 //            printf("UL_PathStatus[%d] %d \r\n",i,UL_PathStatus[DET_Alarm_UL1_Shutdown_Index + i]);
@@ -6352,7 +6442,7 @@ void DET_LevelAlarmCheck(){
 //            if(i != 0)
 //                continue;  
             /*UL Shutdown Minus Condition Check */            
-            if(LimitData_UL_Shutdown - 2 >= Res_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i] || UL_PathStatus[DET_Alarm_UL1_Shutdown_Index + i] == false)
+            if(LimitData_UL_Shutdown - 2 >= Res_Down_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i] || UL_PathStatus[DET_Alarm_UL1_Shutdown_Index + i] == false)
                 ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] = false;
 //                printf("ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] =  %d \r\n ",ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index ]);
 //            printf("2 Shutdown threas hold : %d | Curr Meas : %d Shutdown UL %d | Alarm OFF Count : %d\r\n",LimitData_UL_Shutdown,Res_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i],i + 1,UL_RetryCount[DET_Alarm_UL1_Shutdown_Index + i] );
@@ -6381,15 +6471,17 @@ void DET_LevelAlarmCheck(){
 //    LimitData_UL_High = -27;
 //    printf("==========================================================\r\n");
     for(int i = 0 ; i < DET_Alarm_UL_Index_MAX; i++){
-        if(LimitData_UL_High <= Res_UL_dBm[DET_Alarm_UL1_Index + 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_UL_dBm[DET_Alarm_UL1_Index + i],DET_Alarm_UL1_Index + i,ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i]);
+//            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_UL_dBm[DET_Alarm_UL1_Index + i])
+            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_UL_dBm[DET_Alarm_UL1_Index + i],DET_Alarm_UL1_Index + i,ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i]);            
+//            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 1 // PYJ.2020.06.22_BEGIN -- 
 #if 0 // PYJ.2020.06.22_BEGIN --
@@ -7672,8 +7764,10 @@ double Bluecell_TestPro(double 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;
@@ -7690,10 +7784,17 @@ double Bluecell_TestPro(double value ){
     }
 
     value = (temp * 0.1);
-//    printf("round Ret : %f \r\n",value);
+    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;
 
 }
@@ -8492,6 +8593,7 @@ void AGC_Alarm_Check(uint8_t Path_Index,double AGC_Det,uint8_t* AGC_Table,uint16
 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;
         int16_t ResdBm = 0;
+        
         int16_t CurrAtten = 0;
         int16_t Levelret = 0;
         int i = 0;
@@ -8517,7 +8619,7 @@ void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tablei
 
         CurrAtten = (int16_t)(DL_MainAtten[DLI_AGC_H] << 8 |  DL_MainAtten[DLI_AGC_L]);
         CurrAtten *= 0.1;
-        ResdBm = (int16_t)(DLI_Level[DLI_AGC_H] << 8 |  DLI_Level[DLI_AGC_L]);//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&DL_Table->Table_Det5_dBm_H,DL_Table->Table_Length,AGC_Table));
+        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));
         ResdBm = (int16_t)Bluecell_TestPro( ResdBm / 10);
 //        DLI_Level[DLI_AGC_H] = ((int16_t)ResdBm & 0xFF00) >> 8;
 //        DLI_Level[DLI_AGC_L] = ((int16_t)ResdBm & 0x00FF);
@@ -8525,12 +8627,20 @@ void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tablei
             if(AGC_Table[i] == ResdBm)
                 break;
         }
-        if(bluecell_Currdatastatus.DLI_FRBT_Status != FRBT_IDEL)
+        if(bluecell_Currdatastatus.DLI_FRBT_Status != FRBT_IDEL){
             IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
+
+
+
+        }
         if(bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_IDEL){
             IwillgiveAtten = New_AGC_Calc(Limitdata,ResdBm);
+            if(Limitdata == ResdBm){
+                IwillgiveAtten = CurrAtten;
+            }
             if(IwillgiveAtten == CurrAtten)
                 IwillgiveAtten = 0;
+            
         }
         
         IwillgiveAtten *= -1;
@@ -8542,8 +8652,10 @@ void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tablei
         printf("I WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten);
         printf("AGC  : %d\r\n",Limitdata);
 #endif // PYJ.2020.09.14_END -- 
-        if(bluecell_Currdatastatus.DLI_FRBT_Status != FRBT_IDEL && (CurrAtten) < IwillgiveAtten)
+        if(bluecell_Currdatastatus.DLI_FRBT_Status != FRBT_IDEL && (CurrAtten) < IwillgiveAtten){
             IwillgiveAtten = (CurrAtten );
+
+        }
         if(IwillgiveAtten < -15)
             IwillgiveAtten = -15;
 
@@ -8562,6 +8674,15 @@ void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tablei
                 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);            
+            }else{
+                if(Limitdata == ResdBm){
+                    IwillgiveAtten = 0;
+                    DL_MainAtten[DLI_AGC_H] = ((((IwillgiveAtten)  * 10) & 0xFF00) >> 8) ;
+                    DL_MainAtten[DLI_AGC_L] = ((((IwillgiveAtten) * 10) & 0x00FF));      
+                    CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);                       
+                }            
+                
+
             }
         }
         else if(bluecell_Currdatastatus.DLI_FRBT_Status != FRBT_IDEL && (ResdBm + CurrAtten) > Limitdata &&  DL_PrevIwillgiveAtten[Tableindex] > IwillgiveAtten){

Src/main.c

@@ -274,7 +274,7 @@ uint8_t MBICTest_Firmdata[8]  = {1,2,3,4,5,6,7,8};
   * @retval int
   */
 int main(void)
-  {
+{
   /* USER CODE BEGIN 1 */