Alarm 오류수정

Bluecell_Src/Bluecell_operate.c

@@ -88,7 +88,7 @@ double PE43711_Double(uint8_t high_bit,uint8_t low_bit);
 void Booting_LED_Check(void);
 double Bluecell_TestPro(double value );
 double AGC_AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size,int8_t* RefTable_Data);
-void ALC_Alarm_TimerSet(uint8_t num,int16_t threshold,int16_t CurrDet,int16_t CurrAtten);
+void ALC_Alarm_TimerSet(uint8_t num,int16_t threshold,int16_t CurrDet,int16_t CurrAtten,int16_t MainAtten);
 
 
 
@@ -1393,7 +1393,7 @@ void Bluecell_TableLoad(uint8_t* data,uint8_t type){
         case DLI_P1_ATT_Accuracy_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,EEPROM_ATT_BASE              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-            printf("Table_Length : %d , Table_Ref : %d ",Att_DL1.Table_Length,Att_DL1.Table_Ref);
+//            printf("Table_Length : %d , Table_Ref : %d ",Att_DL1.Table_Length,Att_DL1.Table_Ref);
 //            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             data[BLUECELL_LENGTH_H] = 0;
             data[BLUECELL_LENGTH_L] = (sizeof(ATT_TABLE_st)) + 7 - 3;;
@@ -1436,12 +1436,15 @@ void Bluecell_TableLoad(uint8_t* data,uint8_t type){
         case DLI_P1_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL4_TABLE_ADDRESDS),&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
-            printf("Table_Length : %d , Table_Ref : %d ",Det_DL1.Table_Length,Det_DL1.Table_Ref);
+//            printf("Table_Length : %d , Table_Ref : %d ",Det_DL1.Table_Length,Det_DL1.Table_Ref);
             data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
             break;
         case DLI_P2_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL1_TABLE_ADDRESDS),&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
+//            for(int i = 0 ; i < sizeof(DET_TABLEDL_st);i++)
+//                printf("[%d Dbm] : %f \r\n",ALC_Table_ref[i],((data[BLUECELL_DATA + 1 + (i * 2)] << 8)| data[BLUECELL_DATA + 1 + (i * 2)+ 1]) * 0.001 );
+        
             data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
             break;
         case DLI_P3_Level_Table_Number: 
@@ -1457,22 +1460,33 @@ void Bluecell_TableLoad(uint8_t* data,uint8_t type){
         case ULO_P1_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL4_TABLE_ADDRESDS),&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+//            for(int i = 0 ; i < sizeof(DET_TABLEUL_st);i++)
+//                printf("[%d Dbm] : %f \r\n",ALC_Table_ref[i],((data[BLUECELL_DATA + 1 + (i * 2)] << 8)| data[BLUECELL_DATA + 1 + (i * 2)+ 1]) * 0.001 );
             data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
             break;
         case ULO_P2_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL1_TABLE_ADDRESDS),&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+//            for(int i = 0 ; i < sizeof(DET_TABLEUL_st);i++)
+//                printf("[%d Dbm] : %f \r\n",ALC_Table_ref[i],((data[BLUECELL_DATA + 1 + (i * 2)] << 8)| data[BLUECELL_DATA + 1 + (i * 2)+ 1]) * 0.001 );
+        
             data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
         
             break;
         case ULO_P3_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL2_TABLE_ADDRESDS),&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+//            for(int i = 0 ; i < sizeof(DET_TABLEUL_st);i++)
+//                printf("[%d Dbm] : %f \r\n",ALC_Table_ref[i],((data[BLUECELL_DATA + 1 + (i * 2)] << 8)| data[BLUECELL_DATA + 1 + (i * 2)+ 1]) * 0.001 );
+        
             data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
             break;
         case ULO_P4_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL3_TABLE_ADDRESDS),&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+//            for(int i = 0 ; i < sizeof(DET_TABLEUL_st);i++)
+//                printf("[%d Dbm] : %f \r\n",ALC_Table_ref[i],((data[BLUECELL_DATA + 1 + (i * 2)] << 8)| data[BLUECELL_DATA + 1 + (i * 2)+ 1]) * 0.001 );
+        
             data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
 
             break;
@@ -2057,6 +2071,8 @@ bool Bluecell_Operate(uint8_t* data){
   //double ret = 0 ,tmp = 0.1;
   int16_t tempdata = 0;
   int16_t CurrAtten = 0;
+  int16_t ALC_TEMP[4] ={0,};
+  int16_t Tmpdata = 0 ,Tmpdata2 = 0;
   uint8_t i = 0;
   uint16_t Crcret = 0;
   switch(datatype){
@@ -2119,12 +2135,22 @@ bool Bluecell_Operate(uint8_t* data){
     case Bluecell_ATT_UL1                :
 
         bluecell_Currdatastatus.ATT_UL1_H = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_UL1_L = data[BLUECELL_DATA + i++];
-        CurrAtten = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
-        if(CurrAtten <= -200){
-            bluecell_Currdatastatus.ATT_UL1_H = (CurrAtten & 0xFF00) >> 8;
-            bluecell_Currdatastatus.ATT_UL1_L = (CurrAtten & 0x00FF);
+        bluecell_Currdatastatus.ATT_UL1_L =data[BLUECELL_DATA + i++];
+        if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+            Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
+            Tmpdata2 = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
+            if(Tmpdata + Tmpdata2 <= -200){
+                Tmpdata2 = -200 + (Tmpdata * -1);
+                bluecell_Currdatastatus.ATT_UL1_H = ((Tmpdata2 & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ATT_UL1_L = Tmpdata2 & 0x00FF;                    
+            }
+            UL_ALC_GainAttenSet[ALC_Alarm_UL1_Index] = true;
+            ALC_Level_Save[ALC_Alarm_UL1_Index] = bluecell_Currdatastatus.ULO_Level1_H << 8 | bluecell_Currdatastatus.ULO_Level1_L;
         }
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+
+        
         printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
     
         /*
@@ -2138,12 +2164,19 @@ bool Bluecell_Operate(uint8_t* data){
     case Bluecell_ATT_UL2                :        
         bluecell_Currdatastatus.ATT_UL2_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_UL2_L = data[BLUECELL_DATA + i++];
-        CurrAtten = bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L;
-        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
-        if(CurrAtten <= -200){
-            bluecell_Currdatastatus.ATT_UL2_H = (CurrAtten & 0xFF00) >> 8;
-            bluecell_Currdatastatus.ATT_UL2_L = (CurrAtten & 0x00FF);
+        if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+            Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L;
+            Tmpdata2 = bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L;
+            if(Tmpdata + Tmpdata2 <= -200){
+                Tmpdata2 = -200 + (Tmpdata * -1);
+                bluecell_Currdatastatus.ATT_UL2_H = ((Tmpdata2 & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ATT_UL2_L = Tmpdata2 & 0x00FF;                    
+            }
+            UL_ALC_GainAttenSet[ALC_Alarm_UL2_Index] = true;
+            ALC_Level_Save[ALC_Alarm_UL2_Index] = bluecell_Currdatastatus.ULO_Level2_H << 8 | bluecell_Currdatastatus.ULO_Level2_L;
         }
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
 
         /*
             Atten Ctrl Function
@@ -2154,12 +2187,18 @@ bool Bluecell_Operate(uint8_t* data){
     case Bluecell_ATT_UL3                :    
         bluecell_Currdatastatus.ATT_UL3_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_UL3_L = data[BLUECELL_DATA + i++];
-        CurrAtten = bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L;
-        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
-        if(CurrAtten <= -200){
-            bluecell_Currdatastatus.ATT_UL3_H = (CurrAtten & 0xFF00) >> 8;
-            bluecell_Currdatastatus.ATT_UL3_L = (CurrAtten & 0x00FF);
+        if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+            Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L;
+            Tmpdata2 = bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L;
+            if(Tmpdata + Tmpdata2 <= -200){
+                Tmpdata2 = -200 + (Tmpdata * -2);
+                bluecell_Currdatastatus.ATT_UL3_H = ((Tmpdata2 & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ATT_UL3_L = Tmpdata2 & 0x00FF;                    
+            }
+            UL_ALC_GainAttenSet[ALC_Alarm_UL3_Index] = true;
+            ALC_Level_Save[ALC_Alarm_UL3_Index] = bluecell_Currdatastatus.ULO_Level3_H << 8 | bluecell_Currdatastatus.ULO_Level3_L;
         }
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
         /*
             Atten Ctrl Function
@@ -2170,12 +2209,19 @@ bool Bluecell_Operate(uint8_t* data){
     case Bluecell_ATT_UL4                :        
         bluecell_Currdatastatus.ATT_UL4_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_UL4_L = data[BLUECELL_DATA + i++];
-        CurrAtten = bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L;
-        if(CurrAtten <= -200){
-            bluecell_Currdatastatus.ATT_UL4_H = (CurrAtten & 0xFF00) >> 8;
-            bluecell_Currdatastatus.ATT_UL4_L = (CurrAtten & 0x00FF);
-        }        
-        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
+        if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+            Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
+            Tmpdata2 = bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L;
+            if(Tmpdata + Tmpdata2 <= -200){
+                Tmpdata2 = -200 + (Tmpdata * -2);
+                bluecell_Currdatastatus.ATT_UL4_H = ((Tmpdata2 & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ATT_UL4_L = Tmpdata2 & 0x00FF;                    
+            }
+            UL_ALC_GainAttenSet[ALC_Alarm_UL4_Index] = true;
+            ALC_Level_Save[ALC_Alarm_UL4_Index] = bluecell_Currdatastatus.ULO_Level4_H << 8 | bluecell_Currdatastatus.ULO_Level4_L;
+        }
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
         ALCTimerCnt = 0;
 
 
@@ -2470,7 +2516,63 @@ bool Bluecell_Operate(uint8_t* data){
             printf("%x ",Txdata[i]);
         }
         printf("\r\n");
-#endif // PYJ.2020.04.22_END --    
+#endif // PYJ.2020.04.22_END --   
+        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("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,
+            bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & ALARM_ALC_P2,
+            bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & ALARM_ALC_P3,
+            bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & ALARM_ALC_P4);
+            ALC_TEMP[0] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
+            ALC_TEMP[1] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L;
+            ALC_TEMP[2] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L;
+            ALC_TEMP[3] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
+            printf("ALC%d ATTEN : %d \r\n",1,ALC_TEMP[0]);
+            printf("ALC%d ATTEN : %d \r\n",2,ALC_TEMP[1]);
+            printf("ALC%d ATTEN : %d \r\n",3,ALC_TEMP[2]);
+            printf("ALC%d ATTEN : %d \r\n",4,ALC_TEMP[3]);
+            printf("AGC  Alarm 1: %d 2:  %d 3: %d 4: %d\r\n",
+            bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & ALARM_AGC_P1,
+            bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & ALARM_AGC_P2,
+            bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & ALARM_AGC_P3,
+            bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & ALARM_AGC_P4
+            );
+
+        printf("Shutdown DL Alarm 1: %d 2:  %d 3: %d 4: %d\r\n",
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & ALARM_DLI_SHUTDOWN_P1,
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & ALARM_DLI_SHUTDOWN_P2,
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & ALARM_DLI_SHUTDOWN_P3,
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & ALARM_DLI_SHUTDOWN_P4
+            );
+        printf("Shutdown UL Alarm 1: %d 2:  %d 3: %d 4: %d\r\n",
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & ALARM_ULO_SHUTDOWN_P1,
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & ALARM_ULO_SHUTDOWN_P2,
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & ALARM_ULO_SHUTDOWN_P3,
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & ALARM_ULO_SHUTDOWN_P4
+        );
+        printf("===================END=======================\r\n");
+
+//        printf("Level DL Alarm %d \r\n");
+//        printf("Level DL Alarm %d \r\n");
+
+
         Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st));
         break;
     case Bluecell_StatusSave:
@@ -3760,7 +3862,8 @@ bool MBIC_Operate(uint8_t* data){
 	uint8_t datatype = data[MBIC_PAYLOADSTART + 1];
    // uint8_t Length = (data[MBIC_PROT_SUB_DATA_INDEX + 2]);
     uint8_t cmd = data[MBIC_PROT_CMD_INDEX];
-
+    int16_t Tmpdata = 0;
+    int16_t Tmpdata2 = 0;    
     //uint16_t Temp_ADC = 0;
     //uint16_t i = 0;
     //double temp = 0;
@@ -3946,6 +4049,7 @@ bool MBIC_Operate(uint8_t* data){
             case  DLI_Gain_Atten1                         :
                 bluecell_Currdatastatus.ATT_DL1_H = data[MBIC_PAYLOADSTART + 3]; 
                 bluecell_Currdatastatus.ATT_DL1_L = data[MBIC_PAYLOADSTART + 4]; 
+
                 DL_PrevIwillgiveAtten[AGC_Alarm_DL1_Index] = 0;
                 printf("bluecell_Currdatastatus.ATT_DL1_H : %x\r\n",bluecell_Currdatastatus.ATT_DL1_H);
                 printf("bluecell_Currdatastatus.ATT_DL1_L : %x\r\n",bluecell_Currdatastatus.ATT_DL1_L);              
@@ -4136,6 +4240,13 @@ bool MBIC_Operate(uint8_t* data){
                 bluecell_Currdatastatus.ATT_UL1_H = data[MBIC_PAYLOADSTART + 3]; 
                 bluecell_Currdatastatus.ATT_UL1_L = data[MBIC_PAYLOADSTART + 4]; 
                 if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+                    Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
+                    Tmpdata2 = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
+                    if(Tmpdata + Tmpdata2 <= -200){
+                        Tmpdata2 = -200 + (Tmpdata * -1);
+                        bluecell_Currdatastatus.ATT_UL1_H = ((Tmpdata2 & 0xFF00) >> 8);
+                        bluecell_Currdatastatus.ATT_UL1_L = Tmpdata2 & 0x00FF;                    
+                    }
                     UL_ALC_GainAttenSet[ALC_Alarm_UL1_Index] = true;
                     ALC_Level_Save[ALC_Alarm_UL1_Index] = bluecell_Currdatastatus.ULO_Level1_H << 8 | bluecell_Currdatastatus.ULO_Level1_L;
                 }
@@ -4146,6 +4257,13 @@ bool MBIC_Operate(uint8_t* data){
                 bluecell_Currdatastatus.ATT_UL2_H = data[MBIC_PAYLOADSTART + 3]; 
                 bluecell_Currdatastatus.ATT_UL2_L = data[MBIC_PAYLOADSTART + 4]; 
                 if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+                    Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
+                    Tmpdata2 = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
+                    if(Tmpdata + Tmpdata2 <= -200){
+                        Tmpdata2 = -200 + (Tmpdata * -1);
+                        bluecell_Currdatastatus.ATT_UL1_H = ((Tmpdata2 & 0xFF00) >> 8);
+                        bluecell_Currdatastatus.ATT_UL1_L = Tmpdata2 & 0x00FF;                    
+                    }                    
                     UL_ALC_GainAttenSet[ALC_Alarm_UL2_Index] = true;
                     ALC_Level_Save[ALC_Alarm_UL2_Index] = bluecell_Currdatastatus.ULO_Level2_H << 8 | bluecell_Currdatastatus.ULO_Level2_L;
                 }
@@ -4157,6 +4275,13 @@ bool MBIC_Operate(uint8_t* data){
                 bluecell_Currdatastatus.ATT_UL3_H = data[MBIC_PAYLOADSTART + 3]; 
                 bluecell_Currdatastatus.ATT_UL3_L = data[MBIC_PAYLOADSTART + 4]; 
                 if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+                    Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
+                    Tmpdata2 = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
+                    if(Tmpdata + Tmpdata2 <= -200){
+                        Tmpdata2 = -200 + (Tmpdata * -1);
+                        bluecell_Currdatastatus.ATT_UL1_H = ((Tmpdata2 & 0xFF00) >> 8);
+                        bluecell_Currdatastatus.ATT_UL1_L = Tmpdata2 & 0x00FF;                    
+                    }                    
                     UL_ALC_GainAttenSet[ALC_Alarm_UL3_Index] = true;
                     ALC_Level_Save[ALC_Alarm_UL3_Index] = bluecell_Currdatastatus.ULO_Level3_H << 8 | bluecell_Currdatastatus.ULO_Level3_L;
                 }
@@ -4168,6 +4293,13 @@ bool MBIC_Operate(uint8_t* data){
                 bluecell_Currdatastatus.ATT_UL4_H = data[MBIC_PAYLOADSTART + 3]; 
                 bluecell_Currdatastatus.ATT_UL4_L = data[MBIC_PAYLOADSTART + 4]; 
                 if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+                    Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
+                    Tmpdata2 = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
+                    if(Tmpdata + Tmpdata2 <= -200){
+                        Tmpdata2 = -200 + (Tmpdata * -1);
+                        bluecell_Currdatastatus.ATT_UL1_H = ((Tmpdata2 & 0xFF00) >> 8);
+                        bluecell_Currdatastatus.ATT_UL1_L = Tmpdata2 & 0x00FF;                    
+                    }                    
                     UL_ALC_GainAttenSet[ALC_Alarm_UL4_Index] = true;
                     ALC_Level_Save[ALC_Alarm_UL4_Index] = bluecell_Currdatastatus.ULO_Level4_H << 8 | bluecell_Currdatastatus.ULO_Level4_L  ;                      
                 }
@@ -5455,7 +5587,7 @@ int16_t ALC_Calc(uint8_t num,double CurrAtten ,int8_t threshold,double CurrDet){
     return result * 10;
 }
 #define UL_DL_DATASEND_MULTIPLE 10
-void ALC_Alarm_TimerSet(uint8_t num,int16_t threshold,int16_t CurrDet,int16_t Atten){
+void ALC_Alarm_TimerSet(uint8_t num,int16_t threshold,int16_t CurrDet,int16_t Atten,int16_t MainAtten){
     int16_t ret =0;
     int16_t CurrAtten = 0;
     CurrAtten = Atten * 0.1;
@@ -5463,7 +5595,7 @@ void ALC_Alarm_TimerSet(uint8_t num,int16_t threshold,int16_t CurrDet,int16_t At
             ret = CurrDet - threshold ;
             ret = Bluecell_TestPro(ret +( CurrAtten * 0.1 * -1));
             ret *= -1;  
-            if(CurrAtten <= -20)
+            if(CurrAtten + (MainAtten*0.1) <= -20)
                 ALC_AlarmSet[num] = true;
         }
         else if(threshold -2 > CurrDet){
@@ -5515,13 +5647,13 @@ void ALC_Package_Operate(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st
     CurrentATTENVALUE = PE43711_Double(ALC_Atten[ULO_ALC_H],ALC_Atten[ULO_ALC_L]);
     ULO_Level[ULO_ALC_H] = (ResultData & 0xFF00) >> 8;
     ULO_Level[ULO_ALC_L] = (ResultData & 0x00FF);
-//    printf("=============ALC ON =====START================\r\n");
+    printf("=============ALC ON =====START================\r\n");
 //    printf("Current UL ADC VALUE : %f \r\n",ret);
-//    printf("ResdBm : UL%d : %f \r\n",TableIndex,ResdBm);    
+    printf("ResdBm : UL%d : %f \r\n",TableIndex + 1,ResdBm);    
 //    printf("ORIGIN ResdBm : %f  %d\r\n",ResdBm,Main_Atten);
 //    printf("After ResdBm : %f \r\n",ResdBm);
     Limitdata += (Main_Atten * 0.1);
-    ALC_Alarm_TimerSet(TableIndex,Limitdata,ResdBm,UL_Atten);
+    ALC_Alarm_TimerSet(TableIndex,Limitdata,ResdBm,UL_Atten,Main_Atten);
     IwillGiveAtten = ALC_Calc(TableIndex,CurrentATTENVALUE,Limitdata,ResdBm);
 //    printf("STEP 1 : I WILL GIVE ATTEN  %d \r\n",IwillGiveAtten);
     IwillGiveAtten += UL_Atten;
@@ -7008,6 +7140,78 @@ void DLI_ShutdownAlarmCheck(){
 
 }
 #else
+//DL_Shutdown_Operate(DET_Alarm_DL1_Shutdown_Index,
+//                        &bluecell_Currdatastatus.ATT_DL1_PATH,
+//                        &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1);
+
+void DL_Shutdown_Operate(uint8_t index,uint8_t* path,uint8_t* retrycnt){
+    GPIO_TypeDef *Port;
+    uint16_t Pin;
+
+
+    switch(index){
+        case DET_Alarm_DL1_Shutdown_Index:
+            Port = PATH_EN_DL1_GPIO_Port;
+            Pin = PATH_EN_DL1_Pin;
+            break;
+        case DET_Alarm_DL2_Shutdown_Index:
+            Port = PATH_EN_DL2_GPIO_Port;
+            Pin = PATH_EN_DL2_Pin;            
+            break;
+        case DET_Alarm_DL3_Shutdown_Index:
+            Port = PATH_EN_DL3_GPIO_Port;
+            Pin = PATH_EN_DL3_Pin;             
+            break;
+        case DET_Alarm_DL4_Shutdown_Index:            
+            Port = PATH_EN_DL4_GPIO_Port;
+            Pin = PATH_EN_DL4_Pin;             
+            break;
+    }
+    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){
+        HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK
+        *path = true;            
+        bluecell_Prevdatastatus.ATT_DL1_H = 0xFF;
+        bluecell_Prevdatastatus.ATT_DL1_L = 0xFF;
+        PrevMBIC_DL_ShutdownCount[index] = MBIC_DL_ShutdownCount[index];
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); 
+    }
+    else if(MBIC_DL_ShutdownCount[index] == 3
+        && DET_DL_Shutdown_Off_AlarmTimerCnt[index] >= MBIC_RECOVERY_LAST_SHUTDOWN_MAINTAIN_SEC
+        && DL_PathUserHandl[index] == false){
+        HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK
+        *path = true;            
+        bluecell_Prevdatastatus.ATT_DL1_H = 0xFF;
+        bluecell_Prevdatastatus.ATT_DL1_L = 0xFF;
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); 
+    }                  
+    if(DET_DL_Shutdown_On_AlarmTimerCnt[index] >= MBIC_ON_SHUTDOWN_MAINTAIN_SEC)
+    {
+        /*Shutdown 5sec Alarm*/
+        HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_RESET);//CLOCK      
+        printf("SHUTDOWN ON DL %d\r\n",index + 1);
+        *path = false;
+        (*retrycnt)++;
+        DET_DL_Shutdown_On_AlarmTimerCnt[index] = 0;
+        
+        if((*retrycnt) >= RETRYCNT_MAX){
+            (*retrycnt) = RETRYCNT_MAX;
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P1;
+            bluecell_Currdatastatus.DLI_Shutdown_Alarm1       = true;
+        }
+    }
+    else{
+        if(DET_DL_Shutdown_Off_AlarmTimerCnt[index] >= MBIC_OFF_MAINTAIN_SEC
+            && (*retrycnt) != RETRYCNT_MAX){
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P1;
+            bluecell_Currdatastatus.DLI_Shutdown_Alarm1       = false;            
+        }
+    } 
+
+
+}
 void DLI_ShutdownAlarmCheck()
 {
 
@@ -7217,7 +7421,84 @@ void DLI_ShutdownAlarmCheck()
 }
 
 #endif // PYJ.2020.06.21_END -- 
+typedef enum{
+    UL_Shutdown_H,
+    UL_Shutdown_L,        
+};
+#if 0 // PYJ.2020.06.28_BEGIN -- 
+UL_Shutdown_Operate(DET_Alarm_UL1_Shutdown_Index,
+                        &bluecell_Currdatastatus.ATT_UL1_PATH,
+                        &bluecell_Prevdatastatus.ATT_UL1_H,
+                        &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1,
+                        &bluecell_Currdatastatus.ULO_Shutdown_Alarm1);
+#endif // PYJ.2020.06.28_END -- 
+
+void UL_Shutdown_Operate(uint8_t Index,uint8_t* Path,uint8_t* PrevATT,uint8_t* RetryCnt,uint8_t* ShutdownAlarm){
+    GPIO_TypeDef *Port;
+    uint16_t Pin;
+
+
+    switch(Index){
+        case DET_Alarm_UL1_Shutdown_Index: 
+        Port = PATH_EN_UL1_GPIO_Port;
+        Pin = PATH_EN_UL1_Pin;  
+        break;
+        case DET_Alarm_UL2_Shutdown_Index: 
+        Port = PATH_EN_UL2_GPIO_Port;
+        Pin = PATH_EN_UL2_Pin;  
+        break;
+        case DET_Alarm_UL3_Shutdown_Index: 
+        Port = PATH_EN_UL3_GPIO_Port;
+        Pin = PATH_EN_UL3_Pin;  
+        break;            
+        case DET_Alarm_UL4_Shutdown_Index: 
+        Port = PATH_EN_UL4_GPIO_Port;
+        Pin = PATH_EN_UL4_Pin;  
+        break;
 
+    }
+    if(MBIC_UL_ShutdownCount[Index] < 3
+        && (PrevMBIC_UL_ShutdownCount[Index] != MBIC_UL_ShutdownCount[Index])
+        && DET_UL_Shutdown_Off_AlarmTimerCnt[Index] >= MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC){
+        HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK
+        *Path = true;            
+        PrevATT[UL_Shutdown_H] = 0xFF;
+        PrevATT[UL_Shutdown_L] = 0xFF;
+        PrevMBIC_UL_ShutdownCount[Index] = MBIC_UL_ShutdownCount[Index];
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); 
+    }
+    else if(MBIC_UL_ShutdownCount[Index] == 3
+        && DET_UL_Shutdown_Off_AlarmTimerCnt[Index] >= MBIC_RECOVERY_LAST_SHUTDOWN_MAINTAIN_SEC){
+        HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK
+        *Path = true;            
+        PrevATT[UL_Shutdown_H] = 0xFF;
+        PrevATT[UL_Shutdown_L] = 0xFF;
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); 
+    }                  
+    if(DET_UL_Shutdown_On_AlarmTimerCnt[Index] >= MBIC_ON_SHUTDOWN_MAINTAIN_SEC)
+    {
+        /*Shutdown 5sec Alarm*/
+        HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_RESET);//CLOCK      
+        *Path = false;
+        (*RetryCnt)++;
+        DET_UL_Shutdown_On_AlarmTimerCnt[Index] = 0;
+        
+        if((*RetryCnt) >= RETRYCNT_MAX){
+            (*RetryCnt) = RETRYCNT_MAX;
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P1;
+            *ShutdownAlarm       = true;
+        }else{
+        }
+
+    }
+    else{
+        if(DET_UL_Shutdown_Off_AlarmTimerCnt[Index] >= MBIC_OFF_MAINTAIN_SEC
+            && (*RetryCnt) != RETRYCNT_MAX){
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~ALARM_ULO_SHUTDOWN_P1;
+            *ShutdownAlarm       = false;            
+        }
+    } 
+}
 
 void ULO_ShutdownAlarmCheck(){
    // double temp = 0;
@@ -7378,10 +7659,10 @@ void ULO_ShutdownAlarmCheck(){
             /*Shutdown 5sec Alarm*/
             HAL_GPIO_WritePin(PATH_EN_UL2_GPIO_Port,PATH_EN_UL2_Pin,GPIO_PIN_RESET);//CLOCK      
             bluecell_Currdatastatus.ATT_UL2_PATH = false;
-             printf("UL SHUTDOWN RECOVERY OPERATE PATH OFF\r\n");
+//             printf("UL SHUTDOWN RECOVERY OPERATE PATH OFF\r\n");
             bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2++;
             DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL2_Shutdown_Index] = 0;
-            printf("Shutdown Operate UL2 ============== bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2 : %d \r\n",bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2);
+//            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;
@@ -7619,13 +7900,13 @@ void ULO_ALCAlarmCheck(){
                 bluecell_Currdatastatus.ULO_ALC_Alarm3       = false;            
             }
         }
-        if(ALC_AlarmSet[ALC_Alarm_UL3_Index] == true
-         &&ALC_On_AlarmTimerCnt[ALC_Alarm_UL3_Index] >= MBIC_ON_MAINTAIN_SEC){
+        if(ALC_AlarmSet[ALC_Alarm_UL4_Index] == true
+         &&ALC_On_AlarmTimerCnt[ALC_Alarm_UL4_Index] >= MBIC_ON_MAINTAIN_SEC){
 //            printf("ALARM_ALC_P4 OCCUR\r\n");
             bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P4;
             bluecell_Currdatastatus.ULO_ALC_Alarm4       = true;
         }else{
-            if(ALC_Off_AlarmTimerCnt[ALC_Alarm_UL3_Index] >= MBIC_OFF_MAINTAIN_SEC){
+            if(ALC_Off_AlarmTimerCnt[ALC_Alarm_UL4_Index] >= MBIC_OFF_MAINTAIN_SEC){
                 bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm &= ~ALARM_ALC_P4;
                 bluecell_Currdatastatus.ULO_ALC_Alarm4       = false;            
             }

STM32F103ZE_FLASH.ld

@@ -62,7 +62,7 @@ _Min_Stack_Size = 0x400; /* required amount of stack */
 MEMORY
 {
 RAM (xrw)      : ORIGIN = 0x20002800, LENGTH = 54K
-FLASH (rx)      : ORIGIN = 0x8008000, LENGTH = 512K - 20K
+FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 512K - 20K
 }
 
 /* Define output sections */

Src/system_stm32f1xx.c

@@ -92,7 +92,7 @@
 /*!< Uncomment the following line if you need to relocate your vector Table in
      Internal SRAM. */ 
 /* #define VECT_TAB_SRAM */
-#define VECT_TAB_OFFSET  0x8000 /* Original Value : 0x00000000U*/ /*!< Vector Table base offset field.
+#define VECT_TAB_OFFSET  0x0000 /* Original Value : 0x00000000U*/ /*!< Vector Table base offset field.
                                   This value must be a multiple of 0x200. */