HFR 7월 1일 검수 직전

1.Shutdown 기능 AGC -15db 먹은 후 동작 -> Shutdown 기능 HFR 요청 사항 적용 ( AGC와 Shutdown 따로따로 각각 동작하도록 수정)
2.EEPROM INIT 에서 Table Initialize 하도록 수정
3. UL 4 번 Atten printf 주석
4. Bluecell Data Request 시 Data 전송 시 Txdata 변수 사용
5.MBIC SW Reset 에서 Table LengSet 하도록 수정
6.Shutdown 종료시 Retry cont 무조건 0으로 Clear 하도록 수정
7.Check Sum 에서 No Error 시 Data 적용하도록 수정
8.Timer 기능 UL DL Package 로 변경

Bluecell_Src/Bluecell_operate.c

@@ -431,16 +431,21 @@ ATT_TABLE_st Atten_Table_ref[Table_ATT_Ref_Index_MAX] = {
 #define TableDataSetting_ATT_UL_LEVEL_STEP -1 
 #define TableDataSetting_ATT_DL_TEMP_STEP -5 
 #define TableDataSetting_ATT_UL_TEMP_STEP -5 
+void Table_LengthSetting(){
+
+
+}
 
 void Table_DataSetting(int8_t* pdata,int8_t RefData,double step,uint8_t size){
 //    step /= 10;
     for(int i =0; i < size; i++){
         pdata[i] = RefData;
-        printf("pdata[%d] %d \r\n",i,pdata[i]);
+//        printf("pdata[%d] %d \r\n",i,pdata[i]);
         RefData += step; 
     }
 }
 void Table_Init(){
+    printf("Table Initialize\r\n");
     Table_DataSetting(&DL_DET_Table_ref[AGC_Table_DL1_Ref_Index][TABLE_MAX_VALUE],Det_DL1.Table_Ref,TableDataSetting_ATT_DL_LEVEL_STEP,Det_DL1.Table_Length);
     Table_DataSetting(&DL_DET_Table_ref[AGC_Table_DL2_Ref_Index][TABLE_MAX_VALUE],Det_DL2.Table_Ref,TableDataSetting_ATT_DL_LEVEL_STEP,Det_DL2.Table_Length);
     Table_DataSetting(&DL_DET_Table_ref[AGC_Table_DL3_Ref_Index][TABLE_MAX_VALUE],Det_DL3.Table_Ref,TableDataSetting_ATT_DL_LEVEL_STEP,Det_DL3.Table_Length);
@@ -451,11 +456,24 @@ void Table_Init(){
     Table_DataSetting(&UL_DET_Table_ref[ALC_Table_UL4_Ref_Index][TABLE_MAX_VALUE],Det_UL4.Table_Ref,TableDataSetting_ATT_UL_LEVEL_STEP,Det_UL4.Table_Length);
 
 
+//    EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_UL4_TABLE_ADDRESDS,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
+//    EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL1_TABLE_ADDRESDS,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
+//    EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL2_TABLE_ADDRESDS,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
+//    EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL3_TABLE_ADDRESDS,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
+//
+//
+//    EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_DL4_TABLE_ADDRESDS,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
+//    EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL1_TABLE_ADDRESDS,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
+//    EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL2_TABLE_ADDRESDS,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
+//    EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_DET_UL3_TABLE_ADDRESDS,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
+
+
+
 }
 void Bluecell_AttenInitialize(){
     uint8_t val = 0;
     int16_t MBIC_ALC_Val = 0,MBIC_Val = 0,MBIC_UserVal = 0;
-    Table_Init();
+
 //    Bluecell_StructCpy(&AutoControl_Save[MBIC_Table_DL1_INDEX],&DL_DET_Table_ref[AGC_Table_DL1_Ref_Index][TABLE_MAX_VALUE],sizeof(AGC_dBm_t));
 //    Bluecell_StructCpy(&AutoControl_Save[MBIC_Table_DL2_INDEX],&DL_DET_Table_ref[AGC_Table_DL2_Ref_Index][TABLE_MAX_VALUE],sizeof(AGC_dBm_t));
 //    Bluecell_StructCpy(&AutoControl_Save[MBIC_Table_DL3_INDEX],&DL_DET_Table_ref[AGC_Table_DL3_Ref_Index][TABLE_MAX_VALUE],sizeof(AGC_dBm_t));
@@ -683,13 +701,42 @@ void Atten_UL_Ctrl_Function(uint8_t index,ATT_TABLE_st* Table,uint8_t* CurrAtten
     }
 
 }
+typedef enum{
+    DL_ATTEN_H,
+    DL_ATTEN_L,        
+};
+void DL_AttenOperate(uint8_t* Atten,uint8_t* PrevAtten,uint8_t* UserAtten,uint8_t* PrevUserAtten,PE43711_st ATT){
+     uint8_t val = 0;
+     uint16_t MBIC_Val = 0;
+     uint16_t MBIC_ALC_Val = 0;
+     uint16_t MBIC_UserVal = 0;    
+        if((Atten[DL_ATTEN_H] != PrevAtten[DL_ATTEN_H])
+         ||(Atten[DL_ATTEN_L] != PrevAtten[DL_ATTEN_L])
+         ||(UserAtten[DL_ATTEN_H] != PrevUserAtten[DL_ATTEN_H])
+         ||(UserAtten[DL_ATTEN_L] != PrevUserAtten[DL_ATTEN_L])){
+    //         printf("%s : %d \r\n",__func__,__LINE__);   
+                Atten[DL_ATTEN_H] = PrevAtten[DL_ATTEN_H];
+                Atten[DL_ATTEN_L] = PrevAtten[DL_ATTEN_L];
+                UserAtten[DL_ATTEN_H] = PrevUserAtten[DL_ATTEN_H];
+                UserAtten[DL_ATTEN_L] = PrevUserAtten[DL_ATTEN_L];
+                MBIC_Val =Atten[DL_ATTEN_H] << 8 |Atten[DL_ATTEN_L];
+                MBIC_UserVal = UserAtten[DL_ATTEN_H] << 8 | UserAtten[DL_ATTEN_L];
+                val = MBIC_DL_PE43711_Calc(&Att_DL1.Table_0_0_dBm, // Table Offset
+                                    MBIC_Val,
+                                   MBIC_UserVal);// User Atten Low Bit
+                printf("%s : %d \r\n",__func__,__LINE__);   
+                printf("%d val = %x \r\n",__LINE__,val);
+                PE43711_atten_ctrl(ATT,val);
+        }
+
 
+}
 void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      uint8_t val = 0;
      uint16_t MBIC_Val = 0;
      uint16_t MBIC_ALC_Val = 0;
      uint16_t MBIC_UserVal = 0;
-
+#if 1 // PYJ.2020.07.01_BEGIN -- 
     if((Curr.ATT_DL1_H != Prev.ATT_DL1_H)
      ||(Curr.ATT_DL1_L != Prev.ATT_DL1_L)
      ||(Curr.bluecell_User_DL1_H != Prev.bluecell_User_DL1_H)
@@ -766,6 +813,17 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
             printf("%d val = %x \r\n",__LINE__,val);
             PE43711_atten_ctrl(ALL_ATT.ATT_DL4,val);
     }
+#else
+    DL_AttenOperate(&bluecell_Currdatastatus.ATT_DL1_H,&bluecell_Prevdatastatus.ATT_DL1_L,
+                    &bluecell_Currdatastatus.bluecell_User_DL1_H,&bluecell_Prevdatastatus.bluecell_User_DL1_L,ALL_ATT.ATT_DL1);
+    DL_AttenOperate(&bluecell_Currdatastatus.ATT_DL2_H,&bluecell_Prevdatastatus.ATT_DL2_L,
+                    &bluecell_Currdatastatus.bluecell_User_DL2_H,&bluecell_Prevdatastatus.bluecell_User_DL2_L,ALL_ATT.ATT_DL2);
+    DL_AttenOperate(&bluecell_Currdatastatus.ATT_DL3_H,&bluecell_Prevdatastatus.ATT_DL3_L,
+                    &bluecell_Currdatastatus.bluecell_User_DL3_H,&bluecell_Prevdatastatus.bluecell_User_DL3_L,ALL_ATT.ATT_DL3);    
+    DL_AttenOperate(&bluecell_Currdatastatus.ATT_DL4_H,&bluecell_Prevdatastatus.ATT_DL4_L,
+                    &bluecell_Currdatastatus.bluecell_User_DL4_H,&bluecell_Prevdatastatus.bluecell_User_DL4_L,ALL_ATT.ATT_DL4);
+
+#endif // PYJ.2020.07.01_END -- 
 
     if(bluecell_Prevdatastatus.bluecell_User_UL1_H != 0xFF)
         bluecell_Prevdatastatus.bluecell_User_UL1_H =0xFF;
@@ -874,19 +932,19 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      ||(Curr.MBIC_ULO_ALC_Atten4_H != Prev.MBIC_ULO_ALC_Atten4_H)
      ||(Curr.MBIC_ULO_ALC_Atten4_L != Prev.MBIC_ULO_ALC_Atten4_L))
      {
-            printf("bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_H : %02x \r\n",bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_H);
-            printf("bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_L : %02x \r\n",bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_L);
-            printf("bluecell_Prevdatastatus.ATT_UL4_H : %02x \r\n",bluecell_Prevdatastatus.ATT_UL4_H);
-            printf("bluecell_Prevdatastatus.ATT_UL4_L : %02x \r\n",bluecell_Prevdatastatus.ATT_UL4_L);
-            printf("bluecell_Prevdatastatus.bluecell_User_UL4_H : %02x \r\n",bluecell_Prevdatastatus.bluecell_User_UL4_H);
-            printf("bluecell_Prevdatastatus.bluecell_User_UL4_L : %02x \r\n",bluecell_Prevdatastatus.bluecell_User_UL4_L);        
-            printf("============================================================\r\n");
-            printf("bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H : %02x \r\n",bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H);
-            printf("bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L : %02x \r\n",bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L);
-            printf("bluecell_Currdatastatus.ATT_UL4_H : %02x \r\n",bluecell_Currdatastatus.ATT_UL4_H);
-            printf("bluecell_Currdatastatus.ATT_UL4_L : %02x \r\n",bluecell_Currdatastatus.ATT_UL4_L);
-            printf("bluecell_Currdatastatus.bluecell_User_UL4_H : %02x \r\n",bluecell_Currdatastatus.bluecell_User_UL4_H);
-            printf("bluecell_Currdatastatus.bluecell_User_UL4_L : %02x \r\n",bluecell_Currdatastatus.bluecell_User_UL4_L);        
+//            printf("bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_H : %02x \r\n",bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_H);
+//            printf("bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_L : %02x \r\n",bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_L);
+//            printf("bluecell_Prevdatastatus.ATT_UL4_H : %02x \r\n",bluecell_Prevdatastatus.ATT_UL4_H);
+//            printf("bluecell_Prevdatastatus.ATT_UL4_L : %02x \r\n",bluecell_Prevdatastatus.ATT_UL4_L);
+//            printf("bluecell_Prevdatastatus.bluecell_User_UL4_H : %02x \r\n",bluecell_Prevdatastatus.bluecell_User_UL4_H);
+//            printf("bluecell_Prevdatastatus.bluecell_User_UL4_L : %02x \r\n",bluecell_Prevdatastatus.bluecell_User_UL4_L);        
+//            printf("============================================================\r\n");
+//            printf("bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H : %02x \r\n",bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H);
+//            printf("bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L : %02x \r\n",bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L);
+//            printf("bluecell_Currdatastatus.ATT_UL4_H : %02x \r\n",bluecell_Currdatastatus.ATT_UL4_H);
+//            printf("bluecell_Currdatastatus.ATT_UL4_L : %02x \r\n",bluecell_Currdatastatus.ATT_UL4_L);
+//            printf("bluecell_Currdatastatus.bluecell_User_UL4_H : %02x \r\n",bluecell_Currdatastatus.bluecell_User_UL4_H);
+//            printf("bluecell_Currdatastatus.bluecell_User_UL4_L : %02x \r\n",bluecell_Currdatastatus.bluecell_User_UL4_L);        
             bluecell_Prevdatastatus.ATT_UL4_H = bluecell_Currdatastatus.ATT_UL4_H;
             bluecell_Prevdatastatus.ATT_UL4_L = bluecell_Currdatastatus.ATT_UL4_L;
             bluecell_Prevdatastatus.bluecell_User_UL4_H = bluecell_Currdatastatus.bluecell_User_UL4_H;
@@ -2195,12 +2253,16 @@ bool Bluecell_Operate(uint8_t* data){
   int16_t CurrAtten = 0;
   int16_t ALC_TEMP[4] ={0,};
   int16_t Tmpdata = 0 ,Tmpdata2 = 0;
+  double tmpedata2 = 0;
   uint8_t i = 0;
   uint16_t Crcret = 0;
+  uint16_t Length = 0;
   switch(datatype){
     case BLUECELL_SOFTWARERESET:
         printf("Bluecell Reset \r\n");
+//        Table_Init();
         Table_LengSet();
+//        Table_LengSet();
         NVIC_SystemReset();
         break;
 	case Bluecell_ATT_DL1 				 :
@@ -2641,8 +2703,12 @@ bool Bluecell_Operate(uint8_t* data){
         Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
         Txdata[BLUECELL_LENGTH_L] = sizeof(BLUESTATUS_st) - 3;//sizeof(BLUESTATUS_st) - 3;
 //        Txdata[sizeof(BLUESTATUS_st) - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH_L]);
-        Txdata[sizeof(BLUESTATUS_st) - 3] = ((CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH_L]) & 0xFF00) >> 8);
-        Txdata[sizeof(BLUESTATUS_st) - 2] = CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH_L]) & 0x00FF;        
+        Length = sizeof(BLUESTATUS_st) - 4;
+        Txdata[BLUECELL_LENGTH_H] = ((Length & 0xFF00) >> 8);
+        Txdata[BLUECELL_LENGTH_L] = ((Length & 0x00FF));
+        Crcret = ((CRC16_Generate(&Txdata[BLUECELL_TYPE], Length) ));
+        Txdata[sizeof(BLUESTATUS_st) - 3] = ((Crcret & 0xFF00) >> 8 );
+        Txdata[sizeof(BLUESTATUS_st) - 2] = ((Crcret & 0x00FF));
         
 #endif // PYJ.2020.05.28_END -- 
 #if 0 // PYJ.2020.04.22_BEGIN -- 
@@ -2651,24 +2717,18 @@ bool Bluecell_Operate(uint8_t* data){
         }
         printf("\r\n");
 #endif // PYJ.2020.04.22_END --   
-#if 0 // PYJ.2020.07.01_BEGIN -- 
+#if 1 // PYJ.2020.07.01_BEGIN -- 
         printf("===================START=======================\r\n");
-        printf("ALC ON %d  \r\n",bluecell_Currdatastatus.ULO_ALC_ON_OFF);
-        printf("AGC ON %d  \r\n",bluecell_Currdatastatus.DLI_AGC_ON_OFF);
-        printf("Shutdown DL ON OFF %d  \r\n",bluecell_Currdatastatus.DLI_Shutdown_ON_OFF);
-        printf("Shutdown UL ON OFF %d  \r\n",bluecell_Currdatastatus.ULO_Shutdown_ON_OFF);
-
-
-        printf("Shutdown DL1 CNT %d  \r\n",bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1);
-        printf("Shutdown DL2 CNT %d  \r\n",bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2);
-        printf("Shutdown DL3 CNT %d  \r\n",bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3);
-        printf("Shutdown DL4 CNT %d  \r\n",bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4);
-        
-        printf("Shutdown UL1 CNT %d  \r\n",bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1);
-        printf("Shutdown UL2 CNT %d  \r\n",bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2);
-        printf("Shutdown UL3 CNT %d  \r\n",bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3);
-        printf("Shutdown UL4 CNT %d  \r\n",bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4);
-
+        printf("ALC ON %d                     | AGC ON %d\r\n",bluecell_Currdatastatus.ULO_ALC_ON_OFF,bluecell_Currdatastatus.DLI_AGC_ON_OFF);
+        printf("Shutdown DL ON OFF %d         | Shutdown UL ON OFF %d \r\n",bluecell_Currdatastatus.DLI_Shutdown_ON_OFF,bluecell_Currdatastatus.ULO_Shutdown_ON_OFF);
+        printf("PATH1 %d|Shutdown DL1 CNT %d  | PATH1 %d|Shutdown UL1 CNT %d\r\n",bluecell_Currdatastatus.ATT_DL1_PATH,bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1,bluecell_Currdatastatus.ATT_DL1_PATH,bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1);
+        printf("PATH2 %d|Shutdown DL2 CNT %d  | PATH2 %d|Shutdown UL2 CNT %d\r\n",bluecell_Currdatastatus.ATT_DL2_PATH,bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2,bluecell_Currdatastatus.ATT_UL2_PATH,bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2);
+        printf("PATH3 %d|Shutdown DL3 CNT %d  | PATH3 %d|Shutdown UL3 CNT %d\r\n",bluecell_Currdatastatus.ATT_DL3_PATH,bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3,bluecell_Currdatastatus.ATT_UL3_PATH,bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3);
+        printf("PATH4 %d|Shutdown DL4 CNT %d  | PATH4 %d|Shutdown UL4 CNT %d\r\n",bluecell_Currdatastatus.ATT_DL4_PATH,bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4,bluecell_Currdatastatus.ATT_UL4_PATH,bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4);
+        tempdata = (( bluecell_Currdatastatus.DLI_Shutdown_Threshold_H << 8) & 0xFF00) ;
+        tempdata +=  bluecell_Currdatastatus.DLI_Shutdown_Threshold_L ;
+        tempdata /= 10;
+        printf("DL Shutdown Threas : %d \r\n",tempdata);
 //        printf("Temp Alarm %d \r\n");
         printf("ALC  Alarm 1: %d 2:  %d 3: %d 4: %d\r\n",
             bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & ALARM_ALC_P1,
@@ -2739,6 +2799,7 @@ bool Bluecell_Operate(uint8_t* data){
 //        Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st));        
         EEPROM_M24C08_Zerowrite(EEPROM_M24C08_ID ,(EEPROM_ATT_BASE));
 //        printf("ZERO WRITE COMPLETE");
+
          NVIC_SystemReset();
 
         break;
@@ -2838,12 +2899,12 @@ bool Bluecell_Operate(uint8_t* data){
 //        bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET_L = data[BLUECELL_DATA + i++];
         break;
     case Bluecell_DLI_AGC_ON_OFF:                             
-        bluecell_Currdatastatus.DLI_AGC_ON_OFF = data[BLUECELL_DATA + i];
         printf("AGC ON OFF SET : %d \r\n",bluecell_Currdatastatus.DLI_AGC_ON_OFF);
+        bluecell_Currdatastatus.DLI_AGC_ON_OFF = data[BLUECELL_DATA + i];
         break;
     case Bluecell_ULO_ALC_ON_OFF:                             
+        printf("ALC ON OFF SET : %d \r\n",bluecell_Currdatastatus.ULO_ALC_ON_OFF);
         bluecell_Currdatastatus.ULO_ALC_ON_OFF = data[BLUECELL_DATA + i];
-        printf("ALC ON OFF SET : %d \r\n",bluecell_Currdatastatus.DLI_AGC_ON_OFF);
         break;
     case Bluecell_DLI_AGC_Threshold:                          
         bluecell_Currdatastatus.DLI_AGC_Threshold_H = data[BLUECELL_DATA + i++];
@@ -2866,8 +2927,8 @@ bool Bluecell_Operate(uint8_t* data){
         }
         break;
     case Bluecell_DLI_Shutdown_ON_OFF:                        
-        bluecell_Currdatastatus.DLI_Shutdown_ON_OFF = data[BLUECELL_DATA + i++];
         printf("%s : %d  DLI_Shutdown_ON_OFF : %d \r\n",__func__,__LINE__,bluecell_Currdatastatus.DLI_Shutdown_ON_OFF);
+        bluecell_Currdatastatus.DLI_Shutdown_ON_OFF = data[BLUECELL_DATA + i++];
         
         break;
     case Bluecell_DLI_Shutdown_Threshold:                     
@@ -2991,8 +3052,8 @@ bool Bluecell_Operate(uint8_t* data){
 
         break;
     case Bluecell_ULO_Shutdown_ON_OFF                     :   
+        printf("%s Bluecell_ULO_Shutdown_ON_OFF : %d \r\n",__func__,bluecell_Currdatastatus.ULO_Shutdown_ON_OFF );
         bluecell_Currdatastatus.ULO_Shutdown_ON_OFF = data[BLUECELL_DATA + i++];
-         printf("%s Bluecell_ULO_Shutdown_ON_OFF : %d \r\n",__func__,bluecell_Currdatastatus.ULO_Shutdown_ON_OFF );
 
         break;
     case Bluecell_ULO_Shutdown_Threshold                  :   
@@ -4117,7 +4178,7 @@ bool MBIC_Operate(uint8_t* data){
                 NVIC_SystemReset();
                 break;
             case  SW_Reset                                :
-                Table_LengSet();
+//                Table_LengSet();
                 printf("SoftWare Reset Start \r\n");
                 bluecell_Currdatastatus.S_W_Reset = data[MBIC_PAYLOADSTART + 3]; 
                 NVIC_SystemReset();
@@ -6552,7 +6613,7 @@ typedef enum{
 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){
         double ret = 0;
         int8_t ResdBm = 0;
-        
+        int16_t CurrAtten = 0;
         int16_t Levelret = 0;
         int i = 0;
         int16_t Limitdata = 0;
@@ -6567,7 +6628,9 @@ void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tablei
         ret  = DLI_ADC_Level[DLI_AGC_H] << 8;
         ret += DLI_ADC_Level[DLI_AGC_L];
         ret *= 0.001;
-        ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&DL_Table->Table_Det5_dBm_H,DL_Table->Table_Length * 2,AGC_Table));
+
+        CurrAtten = (int16_t)(DL_MainAtten[DLI_AGC_H] << 8 |  DL_MainAtten[DLI_AGC_L]);
+        ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&DL_Table->Table_Det5_dBm_H,DL_Table->Table_Length,AGC_Table));
         DLI_Level[DLI_AGC_H] = ((int16_t)ResdBm & 0xFF00) >> 8;
         DLI_Level[DLI_AGC_L] = ((int16_t)ResdBm & 0x00FF);
         for(i = 0; i < sizeof(AGC_dBm_t); i++){
@@ -6577,18 +6640,20 @@ void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tablei
         IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
         IwillgiveAtten *= -1;
 //        printf("==================================\r\n");
+//        printf("Curr ATTEN %d \r\n",CurrAtten );
 //        printf("Current DL% ADC VALUE : %f \r\n",Tableindex+1,ret);
 //        printf("ResdBm : DL% : %d \r\n",Tableindex+1,ResdBm);
 //        printf("I WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten);
 //        printf("AGC  : %d\r\n",Limitdata);
-
+        if((CurrAtten / 10) < IwillgiveAtten)
+            IwillgiveAtten = (CurrAtten / 10);
 
         if(ResdBm > Limitdata &&  DL_PrevIwillgiveAtten[Tableindex] > IwillgiveAtten){
 //            printf("IwillgiveAtten : %d \r\n",IwillgiveAtten);
             DL_PrevIwillgiveAtten[Tableindex] = IwillgiveAtten;
             IwillgiveAtten = (DL_AGC_StartAtten[Tableindex]*0.1) + IwillgiveAtten;
 //            printf("WILLATTEN RET : %d \r\n",IwillgiveAtten);
-            AGC_Alarm_Check(AGC_Alarm_DL1_Index,ret,&DL_Table->Table_Det5_dBm_H,IwillgiveAtten);
+            AGC_Alarm_Check(AGC_Alarm_DL1_Index + Tableindex,ret,&DL_Table->Table_Det5_dBm_H,IwillgiveAtten);
             DL_MainAtten[DLI_AGC_H] = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
             DL_MainAtten[DLI_AGC_L] = (((IwillgiveAtten * 10) & 0x00FF));     
             CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
@@ -6606,7 +6671,7 @@ void DL_Det_Function(uint8_t Table_Num,uint8_t* CurrADC_Level,DET_TABLEDL_st* DL
     int16_t Levelret = 0;    
     AGC_Table = &DL_DET_Table_ref[Table_Num][TABLE_MAX_VALUE];
     ret = (((CurrADC_Level[DL_Level_H] << 8) | CurrADC_Level[DL_Level_L]) * 0.001);
-                
+//    printf("DL_Table->Table_Length : %d \r\n",DL_Table->Table_Length);                
     Levelret = (int16_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&DL_Table->Table_Det5_dBm_H,DL_Table->Table_Length,AGC_Table));
     Level[DL_Level_H] = (Levelret & 0xFF00) >> 8;
     Level[DL_Level_L] = (Levelret & 0x00FF);
@@ -7374,11 +7439,12 @@ void DL_Shutdown_Operate(uint8_t index,uint8_t* path,uint8_t* retrycnt,uint8_t*
     if(MBIC_DL_ShutdownCount[index] < 3
         && (PrevMBIC_DL_ShutdownCount[index] != MBIC_DL_ShutdownCount[index])
         && DET_DL_Shutdown_Off_AlarmTimerCnt[index] >= MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC
-        && DL_PathUserHandl[index] == false){
+        && DL_PathUserHandl[index] == false
+        && (*retrycnt) > 0){
         HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK
         *path = true;            
-        bluecell_Prevdatastatus.ATT_DL1_H = 0xFF;
-        bluecell_Prevdatastatus.ATT_DL1_L = 0xFF;
+        MainAtten[DL_Shutdown_H] = 0xFF;
+        MainAtten[DL_Shutdown_L] = 0xFF;
         PrevMBIC_DL_ShutdownCount[index] = MBIC_DL_ShutdownCount[index];
         CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); 
     }
@@ -8082,6 +8148,10 @@ void ULO_ShutdownAlarmCheck(){
     }
     else{
             bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN = 0;
+            bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1 = 0;
+            bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2 = 0;
+            bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3 = 0;
+            bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 = 0;            
             bluecell_Currdatastatus.ULO_Shutdown_Alarm1 = false;            
             bluecell_Currdatastatus.ULO_Shutdown_Alarm2 = false;            
             bluecell_Currdatastatus.ULO_Shutdown_Alarm3 = false;            

Bluecell_Src/CRC.c

@@ -203,10 +203,14 @@ uint8_t Chksum_Create(uint8_t *data)
 etError CRC16_Check(uint8_t* buf_ptr, int len,uint16_t checksum)
 {
     uint16_t crc = 0;
+    etError ret = CHECKSUM_ERROR;
     for (uint32_t counter = 0; counter < len; counter++)
         crc = (uint16_t)((crc << 8) ^ crc16_tab[(uint32_t)(((crc >> 8) ^ buf_ptr[counter]) & 0x00FF)]);
     printf("REAL CRC %x / IN CRC : %x \r\n",crc,checksum);
-    return (crc == checksum ? CHECKSUM_ERROR : NO_ERROR);
+    if(crc == checksum)
+        ret = NO_ERROR;
+        
+    return ret;
 }
 
 

Bluecell_Src/eeprom.c

@@ -14,7 +14,7 @@
 
 /* Includes ------------------------------------------------------------------*/   
 HAL_StatusTypeDef EEPROM_M24C08_ByteRead(uint16_t devid,uint16_t Address,uint8_t* data,uint8_t size);
-
+extern void Table_Init();
 
 extern BLUESTATUS_st bluecell_Currdatastatus;
 
@@ -117,24 +117,24 @@ void EEPROM_M24C08_Init(void){
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL1_TABLE_ADDRESDS,&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st) );
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL2_TABLE_ADDRESDS,&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL3_TABLE_ADDRESDS,&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );
-
-//    printf("TableDL 1_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_DL1.Table_Length,Att_DL1.Table_Ref);
-//    printf("TableDL 2_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_DL2.Table_Length,Att_DL2.Table_Ref);
-//    printf("TableDL 3_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_DL3.Table_Length,Att_DL3.Table_Ref);    
-//    printf("TableDL 4_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_DL4.Table_Length,Att_DL4.Table_Ref);
-//    printf("TableUL 1_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_UL1.Table_Length,Att_UL1.Table_Ref);
-//    printf("TableUL 2_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_UL2.Table_Length,Att_UL2.Table_Ref);
-//    printf("TableUL 3_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_UL3.Table_Length,Att_UL3.Table_Ref);    
-//    printf("TableUL 4_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_UL4.Table_Length,Att_UL4.Table_Ref);    
-//
-//    printf("TableDL 1_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL1.Table_Length,Det_DL1.Table_Ref);
-//    printf("TableDL 2_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL2.Table_Length,Det_DL2.Table_Ref);
-//    printf("TableDL 3_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL3.Table_Length,Det_DL3.Table_Ref);    
-//    printf("TableDL 4_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL4.Table_Length,Det_DL4.Table_Ref);
-//    printf("TableUL 1_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL1.Table_Length,Det_DL1.Table_Ref);
-//    printf("TableUL 2_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL2.Table_Length,Det_DL2.Table_Ref);
-//    printf("TableUL 3_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL3.Table_Length,Det_DL3.Table_Ref);    
-//    printf("TableUL 4_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL4.Table_Length,Det_DL4.Table_Ref);    
+    Table_Init();
+    printf("ATT TableDL 1_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_DL1.Table_Length,Att_DL1.Table_Ref);
+    printf("ATT TableDL 2_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_DL2.Table_Length,Att_DL2.Table_Ref);
+    printf("ATT TableDL 3_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_DL3.Table_Length,Att_DL3.Table_Ref);    
+    printf("ATT TableDL 4_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_DL4.Table_Length,Att_DL4.Table_Ref);
+    printf("ATT TableUL 1_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_UL1.Table_Length,Att_UL1.Table_Ref);
+    printf("ATT TableUL 2_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_UL2.Table_Length,Att_UL2.Table_Ref);
+    printf("ATT TableUL 3_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_UL3.Table_Length,Att_UL3.Table_Ref);    
+    printf("ATT TableUL 4_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Att_UL4.Table_Length,Att_UL4.Table_Ref);    
+
+    printf("DET TableDL 1_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL1.Table_Length,Det_DL1.Table_Ref);
+    printf("DET TableDL 2_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL2.Table_Length,Det_DL2.Table_Ref);
+    printf("DET TableDL 3_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL3.Table_Length,Det_DL3.Table_Ref);    
+    printf("DET TableDL 4_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_DL4.Table_Length,Det_DL4.Table_Ref);
+    printf("DET TableUL 1_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_UL1.Table_Length,Det_UL1.Table_Ref);
+    printf("DET TableUL 2_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_UL2.Table_Length,Det_UL2.Table_Ref);
+    printf("DET TableUL 3_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_UL3.Table_Length,Det_UL3.Table_Ref);    
+    printf("DET TableUL 4_Init START ORIGIN TABLE LENGTH  %d / Ref : %d \r\n",Det_UL4.Table_Length,Det_UL4.Table_Ref);    
 //    printf("DL1\r\n");    Table_DET_DataSetting(&DL_Table_ref[AGC_Table_DL1_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_DL1.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_DL1.Table_Length);
 //    printf("DL2\r\n");    Table_DET_DataSetting(&DL_Table_ref[AGC_Table_DL2_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_DL2.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_DL2.Table_Length);
 //    printf("DL3\r\n");    Table_DET_DataSetting(&DL_Table_ref[AGC_Table_DL3_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_DL3.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_DL3.Table_Length);

Bluecell_Src/uart.c

@@ -100,7 +100,7 @@ void GetDataFromUartQueue(UART_HandleTypeDef *huart)
 //        printf("data cnt zero !!!  \r\n");
         //RF_Ctrl_Main(&uart_buf[Header]);
 //        HAL_UART_Transmit(dst, &temp_buf[BLUECELL_HEADER00], 11, 3000);
-#if 0// PYJ.2019.07.15_BEGIN --
+#if 1// PYJ.2019.07.15_BEGIN --
             printf("\r\n[RX]");
             for(int i = 0; i < cnt; i++){
                 printf("%02x ",uart_buf[i]);
@@ -110,7 +110,7 @@ void GetDataFromUartQueue(UART_HandleTypeDef *huart)
             if(uart_buf[0] == 0xbe){
                 Length = uart_buf[BLUECELL_LENGTH_H] << 8  |  uart_buf[BLUECELL_LENGTH_L] ;
                 CrcChk = uart_buf[Length + 1] << 8 | uart_buf[Length  + 2] ;
-                if(CRC16_Check(&uart_buf[BLUECELL_TYPE], Length,CrcChk))
+         //       if(CRC16_Check(&uart_buf[BLUECELL_TYPE], Length,CrcChk))
             	Bluecell_Operate(uart_buf);
             }else if(uart_buf[0] == MBIC_PREAMBLE0
                    &&uart_buf[1] == MBIC_PREAMBLE1

Src/main.c

@@ -237,6 +237,7 @@ uint8_t MBICTest_Firmdata[8]  = {1,2,3,4,5,6,7,8};
 extern const uint16_t crc16_tab[256];
 
 
+
 main(void)  {
   /* USER CODE BEGIN 1 */
 
@@ -865,6 +866,56 @@ static void MX_GPIO_Init(void)
 }
 
 /* USER CODE BEGIN 4 */
+void DL_Shutdown_Timer(uint8_t* pdata,uint8_t Table_num){
+    if(bluecell_Currdatastatus.DLI_Shutdown_ON_OFF == true){
+          if(ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + Table_num] == true){
+              DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + Table_num] = 0; // OFF CNT = 0;
+              DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + Table_num]++;
+              if(DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + Table_num] == 0xFFFFFFFF){
+                  DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + Table_num] = MBIC_ON_SHUTDOWN_MAINTAIN_SEC;
+              }
+          }else{
+              DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + Table_num] = 0;
+              DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + Table_num]++;
+              if(DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + Table_num] == 0xFFFFFFFF){
+                  DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + Table_num] = MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC;
+              }
+          }
+          if(ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + Table_num] == true){
+              DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + Table_num]++;
+              if(DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + Table_num] == 0xFFFFFFFF){
+                  DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + Table_num] = MBIC_OFF_MAINTAIN_SEC;
+              }                
+          }else{
+              DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + Table_num] = 0;
+          }
+  }
+}
+void UL_Shutdown_Timer(uint8_t* pdata,uint8_t Table_num){
+    if(bluecell_Currdatastatus.ULO_Shutdown_ON_OFF == true){
+          if(ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + Table_num] == true){
+              DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + Table_num] = 0; // OFF CNT = 0;
+              DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + Table_num]++;
+              if(DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + Table_num] == 0xFFFFFFFF){
+                  DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + Table_num] = MBIC_ON_SHUTDOWN_MAINTAIN_SEC;
+              }
+          }else{
+              DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + Table_num] = 0;
+              DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + Table_num]++;
+              if(DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + Table_num] == 0xFFFFFFFF){
+                  DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + Table_num] = MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC;
+              }
+          }
+          if(ADC_Alarm_UL_Normal_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + Table_num] == true){
+              DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + Table_num]++;
+              if(DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + Table_num] == 0xFFFFFFFF){
+                  DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + Table_num] = MBIC_OFF_MAINTAIN_SEC;
+              }                
+          }else{
+              DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + Table_num] = 0;
+          }
+  }
+}
 
 /* USER CODE END 4 */
 
@@ -879,7 +930,7 @@ static void MX_GPIO_Init(void)
 void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
 {
   /* USER CODE BEGIN Callback 0 */
-
+    uint8_t* pdata;
   /* USER CODE END Callback 0 */
   if (htim->Instance == TIM2) {
     HAL_IncTick();
@@ -892,58 +943,25 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
       LDTimerCnt++;
       ALCTimerCnt++;
       AGCTimerCnt++;
-    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;
-                }
-            }
-            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(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;
-                }
-            }
-            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;
-            }
-        }  
-    }
+      
+//    pdata = &bluecell_Currdatastatus.ATT_UL1_PATH;
+    UL_Shutdown_Timer(pdata,DET_Alarm_UL1_Shutdown_Index);
+//    pdata = &bluecell_Currdatastatus.ATT_UL2_PATH;
+    UL_Shutdown_Timer(pdata,DET_Alarm_UL2_Shutdown_Index);
+//    pdata = &bluecell_Currdatastatus.ATT_UL3_PATH;
+    UL_Shutdown_Timer(pdata,DET_Alarm_UL3_Shutdown_Index);
+//    pdata = &bluecell_Currdatastatus.ATT_UL4_PATH;
+    UL_Shutdown_Timer(pdata,DET_Alarm_UL4_Shutdown_Index);
+
+//    pdata = &bluecell_Currdatastatus.ATT_DL1_PATH;
+    DL_Shutdown_Timer(pdata,DET_Alarm_DL1_Shutdown_Index);
+//    pdata = &bluecell_Currdatastatus.ATT_DL2_PATH;
+    DL_Shutdown_Timer(pdata,DET_Alarm_DL2_Shutdown_Index);
+//    pdata = &bluecell_Currdatastatus.ATT_DL3_PATH;
+    DL_Shutdown_Timer(pdata,DET_Alarm_DL3_Shutdown_Index);
+//    pdata = &bluecell_Currdatastatus.ATT_DL4_PATH;
+    DL_Shutdown_Timer(pdata,DET_Alarm_DL4_Shutdown_Index);
+  
       /*ALC Alarm timer start*/
       if(ALC_AlarmSet[ALC_Alarm_UL1_Index] == true){
           ALC_Off_AlarmTimerCnt[ALC_Alarm_UL1_Index] = 0;