DL Shutdown / DL Shutdown Alarm / UL ALC 어텐 제어 가능 하도록 수정 / DL Atten AGC ON 할 떄 Shutdown 은 AGC 어텐 동작 후 적용한다. Det Table 수정 /

AGC 동작 하도록 수정 / 첫 부팅시 retry Count 초기화 하도록 수정 Level Alarm 도 초기화 하도록 수정

Bluecell_Src/Bluecell_operate.c

@@ -20,7 +20,7 @@
 #define ANSI_COLOR_BLUE    "\x1b[34m"
 #define ANSI_COLOR_MAGENTA "\x1b[35m"
 #define ANSI_COLOR_CYAN    "\x1b[36m"
-#define ANSI_COLOR_RESET   "\x1b[0m"
+#define ANSI_COLOR_RESET   "\x1b[0m" "\r\n"    
 
 
 
@@ -143,6 +143,8 @@ 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,};
 
 
 #if 0 // PYJ.2020.05.21_BEGIN -- 
@@ -3646,6 +3648,18 @@ bool MBIC_Operate(uint8_t* data){
             case  DLI_AGC_ON_OFF                   :
                 /*AGC multi apply*/
                 bluecell_Currdatastatus.DLI_AGC_ON_OFF = data[MBIC_PAYLOADSTART + 3];
+                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                       :
                 bluecell_Currdatastatus.DLI_AGC_Threshold_H = data[MBIC_PAYLOADSTART + 3]; 
@@ -3657,7 +3671,15 @@ bool MBIC_Operate(uint8_t* data){
                 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                  :
                 bluecell_Currdatastatus.DLI_Shutdown_Threshold_H = data[MBIC_PAYLOADSTART + 3]; 
@@ -3794,6 +3816,7 @@ bool MBIC_Operate(uint8_t* data){
             case  ULO_ALC_ON_OFF                   :
                 bluecell_Currdatastatus.ULO_ALC_ON_OFF = data[MBIC_PAYLOADSTART + 3]; 
 
+
                 break;
             case  ULO_ALC_Threshold                       :
                 bluecell_Currdatastatus.ULO_ALC_Threshold_H = data[MBIC_PAYLOADSTART + 3];
@@ -3816,7 +3839,18 @@ bool MBIC_Operate(uint8_t* data){
             case  ULO_Shutdown_Threshold_Default          :
                 bluecell_Currdatastatus.ULO_Shutdown_Threshold_Default = data[MBIC_PAYLOADSTART + 3]; 
 
-
+            
+                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;
         }
         if(data[MBIC_PAYLOADSTART + data[MBIC_PAYLOADSTART + 2] + 3 ] == 0xE0 && occurlen > 0){
@@ -4167,6 +4201,7 @@ void DET_LevelAlarmCheck(){
     */
     uint8_t* DL_PathStatus = &bluecell_Currdatastatus.ATT_DL1_PATH ;
     uint8_t* DL_RetryCount = &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 ;
+#if 0 // PYJ.2020.06.23_BEGIN -- 
     for(int i = 0 ; i < DET_Alarm_DL_Shutdown_Index_MAX; i++){
         if(DL_PathStatus[DET_Alarm_DL1_Shutdown_Index + i] == true){
             ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = true;
@@ -4187,7 +4222,45 @@ void DET_LevelAlarmCheck(){
                 ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = false;
         }
     }
+#else
+    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(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);
+                }
+            }
+        }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] / 10 <= -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;
+        }
+    }
+
+#endif // PYJ.2020.06.23_END -- 
 //    printf("======================================================\r\n");
+#if 0 // PYJ.2020.06.23_BEGIN -- 
     for(int i = 0 ; i < DET_Alarm_DL_Index_MAX; i++){
         if(LimitData_DL_Low >= Res_DL_dBm[DET_Alarm_DL1_Index + i]){
             ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = true;
@@ -4197,6 +4270,20 @@ void DET_LevelAlarmCheck(){
                 ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = false;
 
         }
+#else
+
+        for(int i = 0 ; i < DET_Alarm_DL_Index_MAX; i++){
+            if(LimitData_DL_Low >= Res_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_DL_dBm[DET_Alarm_DL1_Index + i])
+                    ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = false;
+        
+            }
+
+
+#endif // PYJ.2020.06.23_END -- 
         
 #if 0 // PYJ.2020.06.22_BEGIN -- 
         printf("LimitData_DL_Low: %d Res_DL_dBm [%d] : %d ,Value : %d\r\n",
@@ -4243,6 +4330,7 @@ void DET_LevelAlarmCheck(){
     */
     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++){
@@ -4632,6 +4720,7 @@ double AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t siz
     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;
@@ -4643,17 +4732,22 @@ double AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t siz
         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;
+//        CurrRet = TableAdc - CurrentAdc;
 
         step = (TableAdc - NextTableAdc) / 10;
         for(int a = 0; a < 10; a++){
             Vitual_array[a] = TableAdc - (step * a);
-            CurrRet = (Vitual_array[a]) - (CurrentAdc);
-//            printf("Vitual_array[%d] : %f \r\n",a,Vitual_array[a]);
-            if(CurrRet < 0){
-                CurrRet = (CurrRet * -2) + CurrRet;
+            if(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;
@@ -4666,6 +4760,10 @@ double AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t siz
     TableAdc = CompareAdc[0] << 8;
     TableAdc += CompareAdc[1];
     TableAdc /= 1000;    
+
+    if(Lastdata > CurrentAdc)
+        return RefTable_Data[(size / 2) - 1]; 
+    
     if(CurrentAdc < TableAdc){
         for(int i = 0; i < sizeof(ALC_dBm_t); i++)
 //            printf("ref Tabe: %d \r\n",RefTable_Data[i]);
@@ -4679,53 +4777,73 @@ double AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t siz
 }
 
 double AGC_AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size,int8_t* RefTable_Data){
-    double ret = 0xFF,CurrRet = 0,TableAdc,NextTableAdc; 
+    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];
     for(int i =0; i < size / 2; i++){
         TableAdc = CompareAdc[i * 2] << 8;
         TableAdc += CompareAdc[i * 2 + 1];
         TableAdc /= 1000;
-
+        Lastdata = TableAdc;
+        
         NextTableAdc = CompareAdc[i * 2 + 2] << 8;
         NextTableAdc += CompareAdc[i * 2 + 3];
         NextTableAdc /= 1000;        
 //        printf("TableAdc[%d] : %f \r\n",i,TableAdc);
-        CurrRet = TableAdc - CurrentAdc;
-
-        step = (TableAdc - NextTableAdc) / 10;
+//        CurrRet = TableAdc - CurrentAdc;
+        if(TableAdc >= NextTableAdc){
+            step = (TableAdc - NextTableAdc)/10;
+        }else{
+            step = (NextTableAdc - TableAdc) / 10;
+        }
         for(int a = 0; a < 10; a++){
             Vitual_array[a] = TableAdc - (step * a);
-            CurrRet = (Vitual_array[a]) - (CurrentAdc);
-//            printf("Vitual_array[%d] : %f \r\n",a,Vitual_array[a]);
-            if(CurrRet < 0){
-                CurrRet = (CurrRet * -2) + CurrRet;
+            if(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 \r\n",a,Vitual_array[a]);
+//            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;
             }
         }
         
     }
-    TableAdc = CompareAdc[0] << 8;
-    TableAdc += CompareAdc[1];
-    TableAdc /= 1000;    
-    if(CurrentAdc < TableAdc){
-//        printf("LastIndex : %d  / dot : %d  TableAdc : %f \r\n",LastIndex,dot,(RefTable_Data[LastIndex] - (dot * 0.1)));
-        return (RefTable_Data[LastIndex] - (dot * 0.1));
+    if(Lastdata > CurrentAdc){
+//        printf("RefTable_Data[(size / 2) - 1] : %d \r\n",RefTable_Data[(size / 2) - 1]);
+        return RefTable_Data[(size / 2) - 1];
     }
-    else{
 //        printf("CurrentAdc : %f     TableAdc : %f \r\n",CurrentAdc,TableAdc);
 //        for(int a = 0; a < sizeof(AGC_dBm_t); a++)
 //            printf("AutoControl_Save[%d] : %d \r\n",a,AutoControl_Save[a]);
-            
+    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));
     }
 }
 
@@ -4811,24 +4929,24 @@ int16_t ALC_Calc(uint8_t num,double CurrAtten ,int8_t threshold,double CurrDet){
 #endif // PYJ.2020.06.20_END -- 
     if(threshold < CurrDet){
         ret = CurrDet - threshold ;
-        printf("1. %f : %f - %d\r\n",ret,CurrDet,threshold);
+//        printf("1. %f : %f - %d\r\n",ret,CurrDet,threshold);
 
         
-        printf("2. %f : %f - %d\r\n",ret,CurrDet,threshold);
+//        printf("2. %f : %f - %d\r\n",ret,CurrDet,threshold);
         ret = Bluecell_TestPro(ret +( CurrAtten * -1));
         ret *= -1;        
     }
     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);
+//            printf("%f  =  %d - %f\r\n",ret,(threshold - 2),CurrDet);
+//            printf("CurrAtten : %f\r\n",CurrAtten);
             ret = Bluecell_TestPro(ret);
-            printf("3.ret : %f\r\n",ret);
+//            printf("3.ret : %f\r\n",ret);
             ret += CurrAtten;
 //             ret *= -1;     
              
-            printf("4.ret : %f\r\n",ret);
+//            printf("4.ret : %f\r\n",ret);
         }
          
     }
@@ -4836,17 +4954,17 @@ int16_t ALC_Calc(uint8_t num,double CurrAtten ,int8_t threshold,double CurrDet){
 
     
     if(ret < -20){
-        printf("5. ret1 : %f \r\n",ret);
+//        printf("5. ret1 : %f \r\n",ret);
         ret = -20;
         ALC_AlarmSet[num] = true;
     }else{
         if(ret > 0){
-            printf("6. ret1 : %f \r\n",ret);
+//            printf("6. ret1 : %f \r\n",ret);
             ret = 0;
         }
         ALC_AlarmSet[num] = false; 
     }
-    printf("ret7 : %f \r\n",ret);
+//    printf("ret7 : %f \r\n",ret);
     return ret * 10;
 }
 #define UL_DL_DATASEND_MULTIPLE 10
@@ -5246,6 +5364,7 @@ void AGC_Alarm_Check(uint8_t Path_Index,double AGC_Det,uint8_t* AGC_Table,uint16
 }
 
 
+
 void AGC_Function(){//DL
     double ret = 0;
     int8_t ResdBm = 0;
@@ -5256,16 +5375,30 @@ void AGC_Function(){//DL
     int16_t IwillgiveAtten = 0;
     int16_t ResultData = 0;
     static int8_t* AGC_Table;// = &AGC_Table_ref[MBIC_Table_DL1_INDEX].DET_DL_0;
-
+    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 > 100){
         
 
         if(bluecell_Currdatastatus.DLI_AGC_ON_OFF == true){
-            
-#if 1 // PYJ.2020.05.25_BEGIN -- 
+            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;            
+#if 0 // PYJ.2020.06.23_BEGIN -- 
             AGC_Table = &AGC_Table_ref[MBIC_Table_DL1_INDEX].DET_DL_0;
-
             ret  = bluecell_Currdatastatus.DLI_P1_Level1_H << 8;
             ret += bluecell_Currdatastatus.DLI_P1_Level1_L;   
             ret *= 0.001;
@@ -5273,43 +5406,25 @@ void AGC_Function(){//DL
             ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,Det_DL1.Table_Length * 2,AGC_Table));
              bluecell_Currdatastatus.DLI_Level1_H = ((int16_t)ResdBm & 0xFF00) >> 8;
              bluecell_Currdatastatus.DLI_Level1_L = ((int16_t)ResdBm & 0x00FF);
-
-                        //ret 현재 Voltage 값 출력
-            //ret 에 따른 현재 DBM 구현
-          
             for(i = 0; i < sizeof(AGC_dBm_t); i++){
                 if(AGC_Table[i] == ResdBm)
                     break;
             }
-            Limitdata = (( bluecell_Currdatastatus.DLI_AGC_Threshold_H << 8) & 0xFF00) ;
-            Limitdata +=  bluecell_Currdatastatus.DLI_AGC_Threshold_L ;
-            Limitdata /= 10;
-
-#if 0 // PYJ.2020.06.22_BEGIN -- 
-            printf(ANSI_COLOR_YELLOW     "=================AGC ON =================\r\n"ANSI_COLOR_RESET "\n");
-            printf(ANSI_COLOR_YELLOW     "Current DL1 ADC VALUE : %f \r\n"ANSI_COLOR_RESET "\n",ret);
-            printf(ANSI_COLOR_YELLOW     "ResdBm : DL1 : %d \r\n"ANSI_COLOR_RESET "\n",ResdBm);
-            printf(ANSI_COLOR_YELLOW     "AGC_Table[%d] : %d\r\n"ANSI_COLOR_RESET "\n",i,AGC_Table[i]);
-            printf(ANSI_COLOR_YELLOW     "I WILL GIVE YOU ATTEN  : %d\r\n"ANSI_COLOR_RESET "\n",AGC_Calc(Limitdata,ResdBm));            
-            printf(ANSI_COLOR_YELLOW     "AGC  : %d\r\n"ANSI_COLOR_RESET "\n",Limitdata);            
-#endif // PYJ.2020.06.22_END -- 
-//            HAL_Delay(1000);
-
             IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
             IwillgiveAtten *= -1; 
-
             AGC_Alarm_Check(AGC_Alarm_DL1_Index,ret,&Det_DL1.Table_Det5_dBm_H,IwillgiveAtten);
             bluecell_Currdatastatus.ATT_DL1_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
             bluecell_Currdatastatus.ATT_DL1_L = (((IwillgiveAtten * 10) & 0x00FF));     
             CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+#endif // PYJ.2020.06.23_END -- 
 
 
 
 
+#if 1 // PYJ.2020.05.25_BEGIN -- 
 #if 1// PYJ.2020.06.22_BEGIN -- 
-        AGC_Table = &AGC_Table_ref[MBIC_Table_DL2_INDEX].DET_DL_0;
-
-
+#if 0 // PYJ.2020.06.23_BEGIN -- 
+       AGC_Table = &AGC_Table_ref[MBIC_Table_DL2_INDEX].DET_DL_0;
        ret  = bluecell_Currdatastatus.DLI_P2_Level2_H << 8;
        ret += bluecell_Currdatastatus.DLI_P2_Level2_L;   
        ret *= 0.001;
@@ -5321,19 +5436,7 @@ void AGC_Function(){//DL
            if(AGC_Table[i] == ResdBm)
                break;
        }
-       Limitdata = (( bluecell_Currdatastatus.DLI_AGC_Threshold_H << 8) & 0xFF00) ;
-       Limitdata +=  bluecell_Currdatastatus.DLI_AGC_Threshold_L ;
-       Limitdata /= 10;
    
-#if 0 // PYJ.2020.06.21_BEGIN -- 
-        printf("========AGC ON==========START================\r\n");
-        printf("Current DL2 ADC VALUE : %f \r\n",ret);
-        printf("ResdBm : DL2 : %d \r\n",ResdBm);
-        printf("AGC_Table[%d] : %d\r\n",i,AGC_Table[i]);
-        printf("I WILL GIVE YOU ATTEN  : %d\r\n",AGC_Calc(Limitdata,ResdBm));            
-        printf("AGC  : %d\r\n",Limitdata);            
-#endif // PYJ.2020.06.21_END -- 
-//        HAL_Delay(1000);
 
        IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
        AGC_Alarm_Check(AGC_Alarm_DL2_Index,ret,&Det_DL2.Table_Det5_dBm_H,IwillgiveAtten);
@@ -5341,15 +5444,73 @@ void AGC_Function(){//DL
        bluecell_Currdatastatus.ATT_DL2_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
        bluecell_Currdatastatus.ATT_DL2_L = (((IwillgiveAtten * 10) & 0x00FF));     
        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+#endif // PYJ.2020.06.23_END -- 
+        AGC_Table = &AGC_Table_ref[MBIC_Table_DL1_INDEX].DET_DL_0;
+        ret  = bluecell_Currdatastatus.DLI_P1_Level1_H << 8;
+        ret += bluecell_Currdatastatus.DLI_P1_Level1_L;   
+        ret *= 0.001;
+        ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,Det_DL1.Table_Length * 2,AGC_Table));
+        bluecell_Currdatastatus.DLI_Level1_H = ((int16_t)ResdBm & 0xFF00) >> 8;
+        bluecell_Currdatastatus.DLI_Level1_L = ((int16_t)ResdBm & 0x00FF);
+        for(i = 0; i < sizeof(AGC_dBm_t); i++){
+            if(AGC_Table[i] == ResdBm)
+                break;
+        }
+        IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
+        IwillgiveAtten *= -1;
+//        printf("==================================\r\n");
+//        printf("Current DL1 ADC VALUE : %f \r\n",ret);
+//        printf("ResdBm : DL1 : %d \r\n",ResdBm);
+//        printf("I WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten);            
+//        printf("AGC  : %d\r\n",Limitdata);            
+
+
+        if(ResdBm > Limitdata &&  DL_PrevIwillgiveAtten[AGC_Alarm_DL1_Index] > IwillgiveAtten){
+//            printf("IwillgiveAtten : %d \r\n",IwillgiveAtten);
+            DL_PrevIwillgiveAtten[AGC_Alarm_DL1_Index] = IwillgiveAtten;
+            IwillgiveAtten = (DL_AGC_StartAtten[AGC_Alarm_DL1_Index]/10) + IwillgiveAtten;
+//            printf("WILLATTEN RET : %d \r\n",IwillgiveAtten);
+            AGC_Alarm_Check(AGC_Alarm_DL1_Index,ret,&Det_DL1.Table_Det5_dBm_H,IwillgiveAtten);
+            bluecell_Currdatastatus.ATT_DL1_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
+            bluecell_Currdatastatus.ATT_DL1_L = (((IwillgiveAtten * 10) & 0x00FF));     
+            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        }
+        AGC_Table = &AGC_Table_ref[MBIC_Table_DL2_INDEX].DET_DL_0;
+        ret  = bluecell_Currdatastatus.DLI_P2_Level2_H << 8;
+        ret += bluecell_Currdatastatus.DLI_P2_Level2_L;   
+        ret *= 0.001;
+        ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL2.Table_Det5_dBm_H,Det_DL2.Table_Length * 2,AGC_Table));
+        bluecell_Currdatastatus.DLI_Level2_H = ((int16_t)ResdBm & 0xFF00) >> 8;
+        bluecell_Currdatastatus.DLI_Level2_L = ((int16_t)ResdBm & 0x00FF);
+        for(i = 0; i < sizeof(AGC_dBm_t); i++){
+            if(AGC_Table[i] == ResdBm)
+                break;
+        }
+        IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
+        IwillgiveAtten *= -1;
+//        printf("==================================\r\n");
+//        printf("Current DL2 ADC VALUE : %f \r\n",ret);
+//        printf("ResdBm : DL2 : %d \r\n",ResdBm);
+//        printf("I WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten);            
+//        printf("AGC  : %d\r\n",Limitdata);            
+
+
+        if(ResdBm > Limitdata &&  DL_PrevIwillgiveAtten[AGC_Alarm_DL2_Index] > IwillgiveAtten){
+//            printf("IwillgiveAtten : %d \r\n",IwillgiveAtten);
+            DL_PrevIwillgiveAtten[AGC_Alarm_DL2_Index] = IwillgiveAtten;
+            IwillgiveAtten = (DL_AGC_StartAtten[AGC_Alarm_DL2_Index]/10) + IwillgiveAtten;
+//            printf("WILLATTEN RET : %d \r\n",IwillgiveAtten);
+            AGC_Alarm_Check(AGC_Alarm_DL2_Index,ret,&Det_DL2.Table_Det5_dBm_H,IwillgiveAtten);
+            bluecell_Currdatastatus.ATT_DL2_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
+            bluecell_Currdatastatus.ATT_DL2_L = (((IwillgiveAtten * 10) & 0x00FF));     
+            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        }
 
 
         AGC_Table = &AGC_Table_ref[MBIC_Table_DL3_INDEX].DET_DL_0;
-
-
         ret  = bluecell_Currdatastatus.DLI_P3_Level3_H << 8;
         ret += bluecell_Currdatastatus.DLI_P3_Level3_L;   
         ret *= 0.001;
-        
         ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL3.Table_Det5_dBm_H,Det_DL3.Table_Length * 2,AGC_Table));
         bluecell_Currdatastatus.DLI_Level3_H = ((int16_t)ResdBm & 0xFF00) >> 8;
         bluecell_Currdatastatus.DLI_Level3_L = ((int16_t)ResdBm & 0x00FF);
@@ -5357,28 +5518,63 @@ void AGC_Function(){//DL
             if(AGC_Table[i] == ResdBm)
                 break;
         }
-        Limitdata = (( bluecell_Currdatastatus.DLI_AGC_Threshold_H << 8) & 0xFF00) ;
-        Limitdata +=  bluecell_Currdatastatus.DLI_AGC_Threshold_L ;
-        Limitdata /= 10;
-    
-//            printf("==================================\r\n");
-//            printf("Current DL3 ADC VALUE : %f \r\n",ret);
-//            printf("ResdBm : DL3 : %d \r\n",ResdBm);
-//            printf("AGC_Table[%d] : %d\r\n",i,AGC_Table[i]);
-//            printf("I WILL GIVE YOU ATTEN  : %d\r\n",AGC_Calc(Limitdata,ResdBm));            
-//            printf("AGC  : %d\r\n",Limitdata);            
-//            HAL_Delay(1000);
-
         IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
-        AGC_Alarm_Check(AGC_Alarm_DL3_Index,ret,&Det_DL3.Table_Det5_dBm_H,IwillgiveAtten);
-
-        bluecell_Currdatastatus.ATT_DL3_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
-        bluecell_Currdatastatus.ATT_DL3_L = (((IwillgiveAtten * 10) & 0x00FF));     
-        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        IwillgiveAtten *= -1;
+//        printf("==================================\r\n");
+//        printf("Current DL3 ADC VALUE : %f \r\n",ret);
+//        printf("ResdBm : DL3 : %d \r\n",ResdBm);
+//        printf("I WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten);            
+//        printf("AGC  : %d\r\n",Limitdata);            
+
+
+        if(ResdBm > Limitdata &&  DL_PrevIwillgiveAtten[AGC_Alarm_DL3_Index] > IwillgiveAtten){
+//            printf("IwillgiveAtten : %d \r\n",IwillgiveAtten);
+            DL_PrevIwillgiveAtten[AGC_Alarm_DL3_Index] = IwillgiveAtten;
+            IwillgiveAtten = (DL_AGC_StartAtten[AGC_Alarm_DL3_Index]/10) + IwillgiveAtten;
+//            printf("WILLATTEN RET : %d \r\n",IwillgiveAtten);
+            AGC_Alarm_Check(AGC_Alarm_DL3_Index,ret,&Det_DL3.Table_Det5_dBm_H,IwillgiveAtten);
+            bluecell_Currdatastatus.ATT_DL3_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
+            bluecell_Currdatastatus.ATT_DL3_L = (((IwillgiveAtten * 10) & 0x00FF));     
+            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        }
+//        printf("DL_Curr_Atten[AGC_Alarm_DL3_Index] : %d  \r\n",DL_Curr_Atten[AGC_Alarm_DL3_Index]);
+//            IwillgiveAtten < DL_Curr_Atten[AGC_Alarm_DL3_Index];
+        
+        AGC_Table = &AGC_Table_ref[MBIC_Table_DL4_INDEX].DET_DL_0;
+        ret  = bluecell_Currdatastatus.DLI_P4_Level4_H << 8;
+        ret += bluecell_Currdatastatus.DLI_P4_Level4_L;   
+        ret *= 0.001;
+        ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL4.Table_Det5_dBm_H,Det_DL4.Table_Length * 2,AGC_Table));
+        bluecell_Currdatastatus.DLI_Level4_H = ((int16_t)ResdBm & 0xFF00) >> 8;
+        bluecell_Currdatastatus.DLI_Level4_L = ((int16_t)ResdBm & 0x00FF);
+        for(i = 0; i < sizeof(AGC_dBm_t); i++){
+            if(AGC_Table[i] == ResdBm)
+                break;
+        }
+        IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
+        IwillgiveAtten *= -1;
+//        printf("==================================\r\n");
+//        printf("Current DL4 ADC VALUE : %f \r\n",ret);
+//        printf("ResdBm : DL4 : %d \r\n",ResdBm);
+//        printf("I WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten);            
+//        printf("AGC  : %d\r\n",Limitdata);            
+
+
+        if(ResdBm > Limitdata &&  DL_PrevIwillgiveAtten[AGC_Alarm_DL4_Index] > IwillgiveAtten){
+//            printf("IwillgiveAtten : %d \r\n",IwillgiveAtten);
+            DL_PrevIwillgiveAtten[AGC_Alarm_DL4_Index] = IwillgiveAtten;
+            IwillgiveAtten = (DL_AGC_StartAtten[AGC_Alarm_DL4_Index]/10) + IwillgiveAtten;
+//            printf("WILLATTEN RET : %d \r\n",IwillgiveAtten);
+            AGC_Alarm_Check(AGC_Alarm_DL4_Index,ret,&Det_DL4.Table_Det5_dBm_H,IwillgiveAtten);
+            bluecell_Currdatastatus.ATT_DL4_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
+            bluecell_Currdatastatus.ATT_DL4_L = (((IwillgiveAtten * 10) & 0x00FF));     
+            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        }
 
 
 
 
+#if 0 // PYJ.2020.06.23_BEGIN -- 
             AGC_Table = &AGC_Table_ref[MBIC_Table_DL4_INDEX].DET_DL_0;
 
             ret  = bluecell_Currdatastatus.DLI_P4_Level4_H << 8;
@@ -5408,6 +5604,7 @@ void AGC_Function(){//DL
             bluecell_Currdatastatus.ATT_DL4_H = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
             bluecell_Currdatastatus.ATT_DL4_L = (((IwillgiveAtten * 10) & 0x00FF));     
             CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+#endif // PYJ.2020.06.23_END -- 
 #endif // PYJ.2020.05.25_END --             
 #endif // PYJ.2020.06.22_END -- 
         }else{
@@ -5420,11 +5617,11 @@ void AGC_Function(){//DL
             Levelret = (int16_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,Det_DL2.Table_Length * 2,AGC_Table));
             bluecell_Currdatastatus.DLI_Level1_H = (Levelret & 0xFF00) >> 8;
             bluecell_Currdatastatus.DLI_Level1_L = (Levelret & 0x00FF);
-#if 0 // PYJ.2020.06.20_BEGIN -- 
+#if 1 // PYJ.2020.06.20_BEGIN -- 
             printf("========AGC OFF==========START================\r\n");
-            printf("Current DL1 ADC VALUE : %f \r\n",ret);
+            printf(ANSI_COLOR_YELLOW"Current DL1 ADC VALUE : %f \r\n"ANSI_COLOR_RESET,ret);
             printf("AGC_Table[%d] : %d\r\n",i,AGC_Table[i]);
-            printf("Levelret : DL1 : %d \r\n",Levelret);
+            printf(ANSI_COLOR_YELLOW "Levelret : DL1 : %d \r\n"ANSI_COLOR_RESET ,Levelret);
             printf("Levelret  : %x /////  bluecell_Currdatastatus.DLI_Level1_H : %x \r\n",Levelret,bluecell_Currdatastatus.DLI_Level1_H);
             printf("Levelret  : %x /////  bluecell_Currdatastatus.DLI_Level1_L : %x \r\n",Levelret,bluecell_Currdatastatus.DLI_Level1_L);            
             printf("==================END================\r\n");        
@@ -5435,6 +5632,7 @@ void AGC_Function(){//DL
 //              printf("ResdBm : DL1 : %d \r\n",ResdBm);
 //            HAL_Delay(1000);
 
+#if 1 // PYJ.2020.06.23_BEGIN -- 
             AGC_Table = &AGC_Table_ref[MBIC_Table_DL2_INDEX].DET_DL_0;
             ret  = bluecell_Currdatastatus.DLI_P2_Level2_H << 8;
             ret += bluecell_Currdatastatus.DLI_P2_Level2_L;   
@@ -5464,6 +5662,7 @@ void AGC_Function(){//DL
             AGC_Table = &AGC_Table_ref[MBIC_Table_DL4_INDEX].DET_DL_0;
             bluecell_Currdatastatus.DLI_Level4_H = (Levelret & 0xFF00) >> 8;
             bluecell_Currdatastatus.DLI_Level4_L = (Levelret & 0x00FF);
+#endif // PYJ.2020.06.23_END -- 
 
 
         }
@@ -5843,20 +6042,21 @@ void DLI_ShutdownAlarmCheck()
 {
 
 
-        
-    if(bluecell_Currdatastatus.DLI_Shutdown_ON_OFF == true){
 
+    
+    if(bluecell_Currdatastatus.DLI_Shutdown_ON_OFF == true){
+         
         /***************************************************************************************************************/
         /*                                             SHUTDOWN DL1                                                    */
         /***************************************************************************************************************/  
         if(MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index] < 3
-            && (PrevMBIC_DL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index] != MBIC_UL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index])
+            && (PrevMBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index] != MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index])
             && DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index] >= MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC){
             HAL_GPIO_WritePin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin,GPIO_PIN_SET);//CLOCK
             bluecell_Currdatastatus.ATT_DL1_PATH = true;            
             bluecell_Prevdatastatus.ATT_DL1_H = 0xFF;
             bluecell_Prevdatastatus.ATT_DL1_L = 0xFF;
-            PrevMBIC_UL_ShutdownCount[DET_Alarm_DL2_Shutdown_Index] = MBIC_UL_ShutdownCount[DET_Alarm_DL2_Shutdown_Index];
+            PrevMBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index] = MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index];
             CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); 
         }
         else if(MBIC_DL_ShutdownCount[DET_Alarm_DL1_Shutdown_Index] == 3
@@ -5876,14 +6076,14 @@ void DLI_ShutdownAlarmCheck()
             DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index] = 0;
             
             if(bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 >= RETRYCNT_MAX){
+                bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 = RETRYCNT_MAX;
                 bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P1;
                 bluecell_Currdatastatus.DLI_Shutdown_Alarm1       = true;
-            }else{
             }
-
         }
         else{
-            if(DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC){
+            if(DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC
+                && bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 != RETRYCNT_MAX){
                 bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P1;
                 bluecell_Currdatastatus.DLI_Shutdown_Alarm1       = false;            
             }
@@ -5893,13 +6093,13 @@ void DLI_ShutdownAlarmCheck()
         /*                                             SHUTDOWN DL2                                                    */
         /***************************************************************************************************************/  
         if(MBIC_DL_ShutdownCount[DET_Alarm_DL2_Shutdown_Index] < 3
-            && (PrevMBIC_DL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index] != MBIC_UL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index])
+            && (PrevMBIC_DL_ShutdownCount[DET_Alarm_DL2_Shutdown_Index] != MBIC_DL_ShutdownCount[DET_Alarm_DL2_Shutdown_Index])
             && DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL2_Shutdown_Index] >= MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC){
             HAL_GPIO_WritePin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin,GPIO_PIN_SET);//CLOCK
             bluecell_Currdatastatus.ATT_DL2_PATH = true;            
             bluecell_Prevdatastatus.ATT_DL2_H = 0xFF;
             bluecell_Prevdatastatus.ATT_DL2_L = 0xFF;
-            PrevMBIC_UL_ShutdownCount[DET_Alarm_DL2_Shutdown_Index] = MBIC_UL_ShutdownCount[DET_Alarm_DL2_Shutdown_Index];
+            PrevMBIC_DL_ShutdownCount[DET_Alarm_DL2_Shutdown_Index] = MBIC_DL_ShutdownCount[DET_Alarm_DL2_Shutdown_Index];
             CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); 
             printf("DL SHUTDOWN RECOVERY OPERATE PATH ON\r\n");
         }
@@ -5924,12 +6124,14 @@ void DLI_ShutdownAlarmCheck()
             printf("Shutdown Operate DL2 ============== bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 : %d \r\n",bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2);
             
             if(bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 >= RETRYCNT_MAX){
+                bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 = RETRYCNT_MAX;
                 bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P2;
                 bluecell_Currdatastatus.DLI_Shutdown_Alarm2       = true;
             }
         }
         else{
-            if(DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL2_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC){
+            if(DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL2_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC
+                && bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 != RETRYCNT_MAX){
                 bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P2;
                 bluecell_Currdatastatus.DLI_Shutdown_Alarm2       = false;            
             }
@@ -5938,13 +6140,13 @@ void DLI_ShutdownAlarmCheck()
         /*                                             SHUTDOWN DL3                                                    */
         /***************************************************************************************************************/  
         if(MBIC_DL_ShutdownCount[DET_Alarm_DL3_Shutdown_Index] < 3
-            && (PrevMBIC_DL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index] != MBIC_UL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index])
+            && (PrevMBIC_DL_ShutdownCount[DET_Alarm_DL3_Shutdown_Index] != MBIC_DL_ShutdownCount[DET_Alarm_DL3_Shutdown_Index])
             && DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL3_Shutdown_Index] >= MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC){
             HAL_GPIO_WritePin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin,GPIO_PIN_SET);//CLOCK
             bluecell_Currdatastatus.ATT_DL3_PATH = true;            
             bluecell_Prevdatastatus.ATT_DL3_H = 0xFF;
             bluecell_Prevdatastatus.ATT_DL3_L = 0xFF;
-            PrevMBIC_UL_ShutdownCount[DET_Alarm_DL3_Shutdown_Index] = MBIC_UL_ShutdownCount[DET_Alarm_DL3_Shutdown_Index];
+            PrevMBIC_DL_ShutdownCount[DET_Alarm_DL3_Shutdown_Index] = MBIC_DL_ShutdownCount[DET_Alarm_DL3_Shutdown_Index];
             CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); 
         }
         else if(MBIC_DL_ShutdownCount[DET_Alarm_DL3_Shutdown_Index] == 3
@@ -5964,6 +6166,7 @@ void DLI_ShutdownAlarmCheck()
             DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL3_Shutdown_Index] = 0;
             
             if(bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 >= RETRYCNT_MAX){
+                bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = RETRYCNT_MAX;
                 bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P3;
                 bluecell_Currdatastatus.DLI_Shutdown_Alarm3       = true;
             }else{
@@ -5971,7 +6174,8 @@ void DLI_ShutdownAlarmCheck()
 
         }
         else{
-            if(DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL3_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC){
+            if(DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL3_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC
+                && bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 != RETRYCNT_MAX){
                 bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P3;
                 bluecell_Currdatastatus.DLI_Shutdown_Alarm3       = false;            
             }
@@ -5980,13 +6184,13 @@ void DLI_ShutdownAlarmCheck()
         /*                                             SHUTDOWN DL4                                                    */
         /***************************************************************************************************************/  
         if(MBIC_DL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index] < 3
-            && (PrevMBIC_DL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index] != MBIC_UL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index])
+            && (PrevMBIC_DL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index] != MBIC_DL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index])
             && DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL4_Shutdown_Index] >= MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC){
             HAL_GPIO_WritePin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin,GPIO_PIN_SET);//CLOCK
             bluecell_Currdatastatus.ATT_DL4_PATH = true;            
             bluecell_Prevdatastatus.ATT_DL4_H = 0xFF;
             bluecell_Prevdatastatus.ATT_DL4_L = 0xFF;
-            PrevMBIC_UL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index] = MBIC_UL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index];
+            PrevMBIC_DL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index] = MBIC_DL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index];
             CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); 
         }
         else if(MBIC_DL_ShutdownCount[DET_Alarm_DL4_Shutdown_Index] == 3
@@ -6006,6 +6210,7 @@ void DLI_ShutdownAlarmCheck()
             DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL4_Shutdown_Index] = 0;
             
             if(bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 >= RETRYCNT_MAX){
+                bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 = RETRYCNT_MAX;
                 bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P4;
                 bluecell_Currdatastatus.DLI_Shutdown_Alarm4       = true;
             }else{
@@ -6013,7 +6218,8 @@ void DLI_ShutdownAlarmCheck()
 
         }
         else{
-            if(DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL4_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC){
+            if(DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL4_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC
+                && bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 != RETRYCNT_MAX){
                 bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P4;
                 bluecell_Currdatastatus.DLI_Shutdown_Alarm4       = false;            
             }
@@ -6119,6 +6325,7 @@ void ULO_ShutdownAlarmCheck(){
             DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index] = 0;
             
             if(bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1 >= RETRYCNT_MAX){
+                bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1 = RETRYCNT_MAX;
                 bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P1;
                 bluecell_Currdatastatus.ULO_Shutdown_Alarm1       = true;
             }else{
@@ -6194,6 +6401,7 @@ void ULO_ShutdownAlarmCheck(){
             printf("Shutdown Operate UL2 ============== bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2 : %d \r\n",bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2);
             
             if(bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2 >= RETRYCNT_MAX){
+                bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2 = RETRYCNT_MAX;
                 bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P2;
                 bluecell_Currdatastatus.ULO_Shutdown_Alarm2       = true;
             }
@@ -6236,6 +6444,7 @@ void ULO_ShutdownAlarmCheck(){
             DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL3_Shutdown_Index] = 0;
             
             if(bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3 >= RETRYCNT_MAX){
+                bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3 = RETRYCNT_MAX;
                 bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P3;
                 bluecell_Currdatastatus.ULO_Shutdown_Alarm3       = true;
             }else{
@@ -6281,6 +6490,7 @@ void ULO_ShutdownAlarmCheck(){
             DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL4_Shutdown_Index] = 0;
             
             if(bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 >= RETRYCNT_MAX){
+                bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 = RETRYCNT_MAX;
                 bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P4;
                 bluecell_Currdatastatus.ULO_Shutdown_Alarm4       = true;
             }
@@ -6391,7 +6601,7 @@ void ULO_ALCAlarmCheck(){
     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");
+//            printf("ALARM_ALC_P1 OCCUR\r\n");
 
                 bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P1;
                 bluecell_Currdatastatus.ULO_ALC_Alarm1       = true;
@@ -6403,7 +6613,7 @@ void ULO_ALCAlarmCheck(){
         }
         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");
+//            printf("ALARM_ALC_P2 OCCUR\r\n");
             bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P2;
             bluecell_Currdatastatus.ULO_ALC_Alarm2       = true;
         }else{
@@ -6414,7 +6624,7 @@ void ULO_ALCAlarmCheck(){
         }
         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");
+//            printf("ALARM_ALC_P3 OCCUR\r\n");
             bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P3;
             bluecell_Currdatastatus.ULO_ALC_Alarm3       = true;
         }else{
@@ -6425,7 +6635,7 @@ void ULO_ALCAlarmCheck(){
         }
         if(ALC_AlarmSet[ALC_Alarm_UL3_Index] == true
          &&ALC_On_AlarmTimerCnt[ALC_Alarm_UL3_Index] >= MBIC_ON_MAINTAIN_SEC){
-            printf("ALARM_ALC_P4 OCCUR\r\n");
+//            printf("ALARM_ALC_P4 OCCUR\r\n");
             bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P4;
             bluecell_Currdatastatus.ULO_ALC_Alarm4       = true;
         }else{

Bluecell_Src/eeprom.c

@@ -72,11 +72,29 @@ void EEPROM_M24C08_Init(void){
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL3_TABLE_ADDRESDS,&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );
     
     /*Table Initial Length Setting */
+#if 0 // PYJ.2020.06.23_BEGIN -- 
         printf("Init Temp_UL3 Length : %d \r\n",Temp_UL3.Table_Length);
         Bluecell_DataCopy(testdata, &Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
         for(int i = 0; i < sizeof(TEMP_TABLE_st); i++){
             printf("\r\n testdata[%d] : %x ",i,testdata[i]);
         }
+#endif // PYJ.2020.06.23_END -- 
+    bluecell_Currdatastatus.ALARM_TEMP_HIGH = 0; //bit
+    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_Retry_Count1 = 0;    
+    bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 = 0;    
+    bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = 0;    
+    bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 = 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;        
+
     Att_DL1.Table_Length  = ATTENTABLEDLUL_LENGTH;
     Att_DL2.Table_Length  = ATTENTABLEDLUL_LENGTH;
     Att_DL3.Table_Length  = ATTENTABLEDLUL_LENGTH;

Inc/main.h

@@ -185,7 +185,7 @@ extern I2C_HandleTypeDef hi2c2;
 #define MBIC_ON_MAINTAIN_SEC 3000
 #define MBIC_ON_SHUTDOWN_MAINTAIN_SEC 5000//5
 #define MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC 30000//30
-#define MBIC_RECOVERY_LAST_SHUTDOWN_MAINTAIN_SEC 60000 * 5 //5min
+#define MBIC_RECOVERY_LAST_SHUTDOWN_MAINTAIN_SEC 60000//60000 * 5 //5min
 
 
 #define MBIC_OFF_MAINTAIN_SEC 10000

Src/main.c

@@ -430,7 +430,7 @@ int main(void)  {
 //  Bluecell_AttenInitialize();
 #if 1 // PYJ.2020.05.06_BEGIN -- 
       printf("****************************************\r\n");
-      printf("MBIC Project\r\n");
+      printf("MBIC Project _ COPY _\r\n");
       printf("Build at %s %s\r\n", __DATE__, __TIME__);
       printf("Copyright (c) 2020. BLUECELL\r\n");
       printf("****************************************\r\n");
@@ -948,53 +948,58 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
       LDTimerCnt++;
       ALCTimerCnt++;
       AGCTimerCnt++;
-
-    for(int i = 0; i < DET_Alarm_UL_Shutdown_Index_MAX; i++){
-        if(ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] == true){
-            DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = 0; // OFF CNT = 0;
-            DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i]++;
-            if(DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] == 0xFFFFFFFF){
-                DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = MBIC_ON_MAINTAIN_SEC;
+    if(bluecell_Currdatastatus.ULO_Shutdown_ON_OFF == true){
+        for(int i = 0; i < DET_Alarm_UL_Shutdown_Index_MAX; i++){
+            if(ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] == true){
+                DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = 0; // OFF CNT = 0;
+                DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i]++;
+                if(DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] == 0xFFFFFFFF){
+                    DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = MBIC_ON_SHUTDOWN_MAINTAIN_SEC;
+                }
+            }else{
+                DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = 0;
+                DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i]++;
+                if(DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] == 0xFFFFFFFF){
+                    DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC;
+                }
             }
-        }else{
-            DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = 0;
-            DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i]++;
-            if(DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] == 0xFFFFFFFF){
-                DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC;
+            if(ADC_Alarm_UL_Normal_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] == true){
+                DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i]++;
+                if(DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] == 0xFFFFFFFF){
+                    DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = MBIC_OFF_MAINTAIN_SEC;
+                }                
+            }else{
+                DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = 0;
             }
         }
-        if(ADC_Alarm_UL_Normal_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] == true){
-            DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i]++;
-            if(DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] == 0xFFFFFFFF){
-                DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = MBIC_OFF_MAINTAIN_SEC;
-            }                
-        }else{
-            DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = 0;
-        }
     }
-    for(int i = 0; i < DET_Alarm_DL_Shutdown_Index_MAX; i++){
-        if(ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] == true){
-            DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = 0; // OFF CNT = 0;
-            DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i]++;
-            if(DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] == 0xFFFFFFFF){
-                DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = MBIC_ON_MAINTAIN_SEC;
+
+
+    if(bluecell_Currdatastatus.DLI_Shutdown_ON_OFF == true){
+        for(int i = 0; i < DET_Alarm_DL_Shutdown_Index_MAX; i++){
+            if(ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] == true){
+                DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = 0; // OFF CNT = 0;
+                DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i]++;
+                if(DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] == 0xFFFFFFFF){
+                    DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = MBIC_ON_SHUTDOWN_MAINTAIN_SEC;
+                }
+            }else{
+                DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = 0;
+                DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i]++;
+                if(DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] == 0xFFFFFFFF){
+                    DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC;
+                }
             }
-        }else{
-            DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = 0;
-            DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i]++;
-            if(DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] == 0xFFFFFFFF){
-                DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC;
+            if(ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] == true){
+                DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i]++;
+                if(DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] == 0xFFFFFFFF){
+                    DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = MBIC_OFF_MAINTAIN_SEC;
+                }                
+            }else{
+                DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = 0;
             }
-        }
-        if(ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] == true){
-            DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i]++;
-            if(DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] == 0xFFFFFFFF){
-                DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = MBIC_OFF_MAINTAIN_SEC;
-            }                
-        }else{
-            DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = 0;
-        }
-    }    
+        }  
+    }
       /*ALC Alarm timer start*/
       if(ALC_AlarmSet[ALC_Alarm_UL1_Index] == true){
           ALC_Off_AlarmTimerCnt[ALC_Alarm_UL1_Index] = 0;