수정 내역

1.Atten Data Set 할 때 통합 으로 설정 하도록 수정
2.구조체에서 쓸모없는 구조체 제거
3.구조체 EEPROM Write를 위해 32byte 배수로 맞춤
4.DataWrite Tx 할 때 사용하는 변수 Size 변경
5.LED Timer HFR 업체에서 요청하는 대로 0.5초에서 1초로 변경
6.Fail LED 와 ACT LED 회로상 색상 잘못기입 Firmware로 수정
7.Alarm Data 있을 때 LED 동작하도록 수정
8.ALC/AGC 동작 계산공식 추가
9. Alarm Check 하는 함수 추가
10.Alarm Timer Cnt와 Alarm Timer Cnt On 시키는 변수 추가
11.최초 Booting 시 LED 3회 점멸 후 동작하도록 수정
12. Timer CallBack 함수 에서 AlarmTimerSet 함수가 True 일 때만 AlarmTimerCnt 가 증가하도록 수정
13.CubeMX에서 LED 회로 오타 수정
 사유 :
 ACT != 빨강  -> ACT == 초록
Fail != 초록    -> Fail == 빨강
으로 변경

Bluecell_Inc/Bluecell_operate.h

@@ -252,7 +252,6 @@ ULO_Shutdown_Alarm4,
 enum DATATYPE
 {
     BLUECELL_SOFTWARERESET = 0,
-	ATTSET  = 0x11,
 	ATT_DL1_PATH = 0x12,
 	ATT_UL1_PATH = 0x16,
 	ATT_SelfTest1 = 0x18,
@@ -309,7 +308,23 @@ enum DATATYPE
     Bluecell_ULO_Shutdown_Threshold                  ,
     Bluecell_ULO_Shutdown_Threshold_Default          ,
     Bluecell_ULO_Shutdown_Retry_Count                ,
-    Bluecell_Reset,
+    Bluecell_Alarm_Mask,
+    Bluecell_ATT_DL1,
+    Bluecell_ATT_DL2,
+    Bluecell_ATT_DL3,
+    Bluecell_ATT_DL4,
+    Bluecell_ATT_UL1,
+    Bluecell_ATT_UL2,
+    Bluecell_ATT_UL3,
+    Bluecell_ATT_UL4,
+    Bluecell_ATT_DL1_USER,
+    Bluecell_ATT_DL2_USER,
+    Bluecell_ATT_DL3_USER,
+    Bluecell_ATT_DL4_USER,
+    Bluecell_ATT_UL1_USER,
+    Bluecell_ATT_UL2_USER,
+    Bluecell_ATT_UL3_USER,
+    Bluecell_ATT_UL4_USER,    
 
 };
 typedef enum{    
@@ -473,7 +488,7 @@ typedef struct{
     uint8_t BLUECELL_RESERVE1;
     uint8_t DET_TEMP;
     uint8_t DLI_AGC_ON_OFF;
-    uint8_t ATT_ALC1_ONOFF;
+    uint8_t ULO_ALC_ON_OFF;
     uint8_t ATT_AGC2_ONOFF;
     uint8_t ATT_ALC2_ONOFF;
     uint8_t ATT_AGC3_ONOFF;
@@ -525,6 +540,8 @@ typedef struct{
     uint8_t ALARM_TEMP_HIGH; //bit
     uint8_t ALARM_DLI_Level;
     uint8_t ALARM_DLI_AGC_SHTUTDOWN;
+    uint8_t ALARM_DLI_AGC_Alarm;
+    uint8_t ALARM_ULO_ALC_Alarm;    
     uint8_t ALARM_ULO_Level;
     uint8_t ALARM_ULO_ALC_SHTUTDOWN;
     uint8_t ALARM_MASK1;
@@ -559,11 +576,8 @@ typedef struct{
     uint8_t CPU_Bank2_Image_Name[32];
     uint8_t S_W_Reset;
     uint8_t Factory_Set_Initialization;
-    
     uint8_t Temp_High_Alarm;
-    
     uint8_t LED_TEST;
-    
     uint8_t NODE;
     uint8_t Type;
     uint8_t PCB_Version[2];
@@ -573,7 +587,6 @@ typedef struct{
     uint8_t Freq_ID;
     uint8_t Carrier_ID;
     uint8_t Carrier_ON_OFF;
-    
     uint8_t DLI_Level_High_Alarm1;
     uint8_t DLI_Level_High_Alarm2;
     uint8_t DLI_Level_High_Alarm3;
@@ -582,23 +595,16 @@ typedef struct{
     uint8_t DLI_Level_Low_Alarm2;
     uint8_t DLI_Level_Low_Alarm3;
     uint8_t DLI_Level_Low_Alarm4;
-    
     uint8_t DLI_FRBT_Atten1_H;
     uint8_t DLI_FRBT_Atten1_L;    
-
     uint8_t DLI_FRBT_Atten2_H;
     uint8_t DLI_FRBT_Atten2_L;    
-    
     uint8_t DLI_FRBT_Atten3_H;
     uint8_t DLI_FRBT_Atten3_L;    
-    
     uint8_t DLI_FRBT_Atten4_H;
     uint8_t DLI_FRBT_Atten4_L;    
-
     uint8_t DLI_FRBT_D_Day;
-    
     uint8_t DLI_FRBT_Status;
-    
     uint8_t DLI_AGC_Threshold_H;
     uint8_t DLI_AGC_Threshold_L;
     uint8_t DLI_AGC_Threshold_default;
@@ -618,13 +624,8 @@ typedef struct{
     uint8_t DLI_Shutdown_Alarm2;
     uint8_t DLI_Shutdown_Alarm3;
     uint8_t DLI_Shutdown_Alarm4;
-
-    
-
-    
     uint8_t ULO_Level_High_Threshold_H;
     uint8_t ULO_Level_High_Threshold_L;
-    
     uint8_t ULO_Level_High_Threshold_default;
     uint8_t ULO_Level1_H;
     uint8_t ULO_Level1_L;
@@ -646,7 +647,6 @@ typedef struct{
     uint8_t ULO_Level_High_Alarm2;
     uint8_t ULO_Level_High_Alarm3;
     uint8_t ULO_Level_High_Alarm4;
-    uint8_t ULO_ALC_ON_OFF;
     uint8_t ULO_ALC_Threshold_Default;
     uint8_t ULO_Shutdown_ON_OFF;
     uint8_t ULO_Shutdown_Threshold_H;
@@ -664,7 +664,6 @@ typedef struct{
     uint8_t ULO_Shutdown_Alarm2;
     uint8_t ULO_Shutdown_Alarm3;
     uint8_t ULO_Shutdown_Alarm4;
-
     uint8_t Reserve0;
     uint8_t Reserve1;
     uint8_t Reserve2;
@@ -672,10 +671,6 @@ typedef struct{
     uint8_t Reserve4;
     uint8_t Reserve5;
     uint8_t Reserve6;
-    uint8_t Reserve7;    
-    uint8_t Reserve8;
-    uint8_t Reserve9;
-
     uint8_t bluecell_crc;
     uint8_t bluecell_etx;
 

Bluecell_Src/Bluecell_operate.c

@@ -19,8 +19,10 @@ void Alarm_Check();
 uint8_t Alarm_Status[MAX_ALARM_Len] = {0,};
 //uint8_t data123[10000];
 uint8_t ResultData[1024] = {0,};
-uint8_t DataWrite[512] = {0,};
+uint8_t DataWrite[sizeof(BLUESTATUS_st)] = {0,};
 uint8_t DataRead[512] = {0,};
+extern volatile bool     AlarmTimerSet;
+extern volatile uint32_t AlarmTimerCnt;
 
 
 typedef enum{
@@ -258,19 +260,41 @@ double TableAtteGuarantee(uint8_t* Table,double AttenValue);
 uint8_t PE43711_Calc(uint8_t* Table,uint8_t high_bit,uint8_t low_bit,uint8_t offset_h,uint8_t offset_l);
 uint8_t PE43711_Calc_NoTable(uint8_t high_bit,uint8_t low_bit);
 double PE43711_Double(uint8_t high_bit,uint8_t low_bit);
+void Booting_LED_Check(void);
+
 int8_t AutoControl_Save[sizeof(ALC_dBm_t)];
 
 uint8_t MBIC_TxDataArray[256] = {0,};
+void Booting_LED_Check(void){
+    for(int i = 0; i < 6; i ++){
+        HAL_GPIO_TogglePin(BOOT_LED_GPIO_Port,BOOT_LED_Pin);
+        HAL_GPIO_TogglePin(LED_ACT_GPIO_Port,LED_ACT_Pin);
+        HAL_GPIO_TogglePin(LED_FAIL_GPIO_Port,LED_FAIL_Pin);
+        HAL_Delay(1000);
+    }
+}
 
 
 void Boot_LED_Toggle(void){
-  if(LedTimerCnt > 500){
+  if(LedTimerCnt > 1000){
     HAL_GPIO_TogglePin(BOOT_LED_GPIO_Port,BOOT_LED_Pin);
     HAL_GPIO_TogglePin(LED_ACT_GPIO_Port,LED_ACT_Pin);
-    HAL_GPIO_TogglePin(LED_FAIL_GPIO_Port,LED_FAIL_Pin);  
+    if((bluecell_Currdatastatus.ALARM_TEMP_HIGH             > 0 
+    || bluecell_Currdatastatus.ALARM_DLI_Level             > 0
+    || bluecell_Currdatastatus.ALARM_DLI_AGC_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_ALC_SHTUTDOWN     > 0) 
+    && bluecell_Currdatastatus.ALARM_MASK1                 > 0){
+        HAL_GPIO_WritePin(LED_FAIL_GPIO_Port,LED_FAIL_Pin,GPIO_PIN_SET);
+    }else{
+        HAL_GPIO_WritePin(LED_FAIL_GPIO_Port,LED_FAIL_Pin,GPIO_PIN_RESET);
+    }
     LedTimerCnt = 0;
 //    printf("LED OF OFF\r\n");
   }
+  
 }
 
 
@@ -705,7 +729,6 @@ void Bluecell_TableLoad(uint8_t* data,uint8_t type){
     switch(tabletype){
         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) );
-//            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,EEPROM_WINDOW_STATUS_ADDRESDS              ,&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));
 //            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
@@ -849,9 +872,6 @@ void Bluecell_TableSave(uint8_t* data,uint8_t type){
         case DLI_P1_ATT_Accuracy_Table_Number: 
             Bluecell_DataCopy(&Att_DL1.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_BASE)              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
-//            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-//            printf("ADDRESS : %d \r\n",EEPROM_WINDOW_STATUS_ADDRESDS );
-//            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             break;
         case DLI_P2_ATT_Accuracy_Table_Number: 
             Bluecell_DataCopy(&Att_DL2.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
@@ -972,55 +992,82 @@ bool Bluecell_Operate(uint8_t* data){
     case BLUECELL_SOFTWARERESET:
         NVIC_SystemReset();
         break;
-	case ATTSET 				 :
+	case Bluecell_ATT_DL1 				 :
 //		printf("Function : %s Line %d \r\n",__func__,__LINE__);
         bluecell_Currdatastatus.ATT_DL1_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_DL1_L = data[BLUECELL_DATA + i++];
 //        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);        
+        /*
+            Atten Ctrl Function
+        */
+		CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        break;
+    case Bluecell_ATT_DL2                :
         bluecell_Currdatastatus.ATT_DL2_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_DL2_L = data[BLUECELL_DATA + i++];
+    
+        /*
+            Atten Ctrl Function
+        */
+		CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        break;
+	case Bluecell_ATT_DL3 				 :        
         bluecell_Currdatastatus.ATT_DL3_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_DL3_L = data[BLUECELL_DATA + i++];
+    
+        /*
+            Atten Ctrl Function
+        */
+		CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        break;
+	case Bluecell_ATT_DL4 				 :    
         bluecell_Currdatastatus.ATT_DL4_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_DL4_L = data[BLUECELL_DATA + i++];
+    
+        /*
+            Atten Ctrl Function
+        */
+		CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        break;
+    case Bluecell_ATT_UL1                :
 
         bluecell_Currdatastatus.ATT_UL1_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_UL1_L = data[BLUECELL_DATA + i++];
+    
+        /*
+            Atten Ctrl Function
+        */
+		CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        //        printf("bluecell_Currdatastatus.ATT_UL1_H : %x\r\n",bluecell_Currdatastatus.ATT_UL1_H);
+        //        printf("bluecell_Currdatastatus.ATT_UL1_L : %x\r\n",bluecell_Currdatastatus.ATT_UL1_L);        
+        break;
+    case Bluecell_ATT_UL2                :        
         bluecell_Currdatastatus.ATT_UL2_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_UL2_L = data[BLUECELL_DATA + i++];
+    
+        /*
+            Atten Ctrl Function
+        */
+		CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        break;    
+    case Bluecell_ATT_UL3                :    
         bluecell_Currdatastatus.ATT_UL3_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_UL3_L = data[BLUECELL_DATA + i++];
+    
+        /*
+            Atten Ctrl Function
+        */
+		CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        break;    
+    case Bluecell_ATT_UL4                :        
         bluecell_Currdatastatus.ATT_UL4_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_UL4_L = data[BLUECELL_DATA + i++];
-
-        bluecell_Currdatastatus.ATT_ALC1_MAX_H = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC1_MAX_L = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC2_MAX_H = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC2_MAX_L = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC3_MAX_H = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC3_MAX_L = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC4_MAX_H = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC4_MAX_L = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC_Threshold_H = data[BLUECELL_DATA + i++]; // 20
-        bluecell_Currdatastatus.ATT_ALC_Threshold_L = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC2_MIN_H = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC2_MIN_L = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC3_MIN_H = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC3_MIN_L = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC4_MIN_H = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC4_MIN_L = data[BLUECELL_DATA + i++];
-//        printf("ALC 1 H: %x \r\n",        bluecell_Currdatastatus.ATT_ALC1_MAX_H);
-//        printf("ALC 1 L: %x \r\n",        bluecell_Currdatastatus.ATT_ALC1_MAX_L);
-//        printf("bluecell_Currdatastatus.ATT_ALC4_MAX_H : %x \r\nbluecell_Currdatastatus.ATT_ALC4_MAX_L : %x\r\n",
-            //bluecell_Currdatastatus.ATT_ALC4_MAX_H,bluecell_Currdatastatus.ATT_ALC4_MAX_L);
-     //   memcpy(&bluecell_Currdatastatus.ATT_DL1_H,&data[BLUECELL_DATA],32);
-//		bluecell_Currdatastatus.ATT_DL1_H =  data[BLUECELL_DATA + i++];
-//		bluecell_Currdatastatus.ATT_DL1_L =  data[BLUECELL_DATA + 1];
         /*
             Atten Ctrl Function
         */
 		CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        break;
 //		printf("ret : %f ,tmp %f \r\n",ret,tmp );
 		break;
 	case ATT_DL1_PATH 		 :
@@ -1180,10 +1227,10 @@ bool Bluecell_Operate(uint8_t* data){
 		break;
     case ALC1_EN :
         if(data[BLUECELL_DATA]==0){
-            bluecell_Currdatastatus.ATT_ALC1_ONOFF = false;
+            bluecell_Currdatastatus.ULO_ALC_ON_OFF = false;
         }
         else{
-            bluecell_Currdatastatus.ATT_ALC1_ONOFF = true;
+            bluecell_Currdatastatus.ULO_ALC_ON_OFF = true;
         }
     break;
     case ALC2_EN :
@@ -1264,7 +1311,7 @@ bool Bluecell_Operate(uint8_t* data){
         break;
     case Bluecell_StatusReq:
         DataStatusSet();
-        Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
+        Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,94);
         Txdata[BLUECELL_LENGTH] = 94 - 3;//sizeof(BLUESTATUS_st) - 3;
         Txdata[94 - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]);
 #if 0 // PYJ.2020.04.22_BEGIN -- 
@@ -1347,7 +1394,7 @@ bool Bluecell_Operate(uint8_t* data){
 
         break;
     case Bluecell_ULO_ALC_ON_OFF:                             
-        bluecell_Currdatastatus.ATT_ALC1_ONOFF = data[BLUECELL_DATA + i];
+        bluecell_Currdatastatus.ULO_ALC_ON_OFF = data[BLUECELL_DATA + i];
         break;
     case Bluecell_DLI_AGC_Threshold:                          
         bluecell_Currdatastatus.DLI_AGC_Threshold_H = data[BLUECELL_DATA + i++];
@@ -1403,8 +1450,8 @@ bool Bluecell_Operate(uint8_t* data){
         bluecell_Currdatastatus.DLI_Level_High_Threshold_L = data[BLUECELL_DATA + i++];
         tempdata = (( bluecell_Currdatastatus.DLI_Level_High_Threshold_H << 8) & 0xFF00) ;
         tempdata +=  bluecell_Currdatastatus.DLI_Level_High_Threshold_L ;
-//        tempdata /= 10;
-//        printf("tempdata : %d\r\n",tempdata);
+        tempdata /= 10;
+        printf("tempdata : %d\r\n",tempdata);
 //        bluecell_Currdatastatus.DLI_Level_High_Threshold_H = ((tempdata & 0xFF00) >> 8);
 //        bluecell_Currdatastatus.DLI_Level_High_Threshold_L = (tempdata & 0x00FF);
         break;
@@ -1473,8 +1520,8 @@ bool Bluecell_Operate(uint8_t* data){
         bluecell_Currdatastatus.ATT_ALC_Threshold_L = data[BLUECELL_DATA + i++];
         tempdata = (( bluecell_Currdatastatus.ATT_ALC_Threshold_H << 8) & 0xFF00) ;
         tempdata +=  bluecell_Currdatastatus.ATT_ALC_Threshold_L ;
-//        tempdata /= 10;
-//        printf("tempdata : %d\r\n",tempdata);
+        tempdata /= 10;
+        printf("tempdata : %d\r\n",tempdata);
 //        bluecell_Currdatastatus.ATT_ALC_Threshold_H = ((tempdata & 0xFF00) >> 8);
 //        bluecell_Currdatastatus.ATT_ALC_Threshold_L = (tempdata & 0x00FF);
 
@@ -1514,10 +1561,15 @@ bool Bluecell_Operate(uint8_t* data){
         break;
     case Bluecell_ULO_Shutdown_Retry_Count                :   
         break;
+    case Bluecell_Alarm_Mask:
+        bluecell_Currdatastatus.ALARM_MASK1 = data[BLUECELL_DATA + i+ 1];
+         printf("%s : %d   ALARM_MASK1 : %d \r\n",__func__,__LINE__,bluecell_Currdatastatus.ALARM_MASK1);
+        break;
   }
   if(datatype != Bluecell_StatusReq){
       Bluecell_StructCpy(&DataWrite[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
       EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS),&DataWrite[0],sizeof(BLUESTATUS_st));
+//      EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_WINDOW_STATUS_ADDRESDS,&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st) );
 //      Bluecell_StructCpy(&Txdata[0],&DataWrite[0],sizeof(BLUESTATUS_st));
 //      Txdata[sizeof(BLUESTATUS_st) - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], sizeof(BLUESTATUS_st) - 3);
 //      Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st));        
@@ -2543,7 +2595,6 @@ uint16_t Descendingcompare(const void *a, const void *b)    // 내림차순 비
     return 0;           // a와 b가 같을 때는 0 반환
 }
 void DascendigFunc(uint16_t* data,uint32_t size ){
-
   int temp;
   for(int i = 0 ; i < size - 1 ; i ++) {
       for(int j = i+1 ; j < size ; j ++) {
@@ -2914,7 +2965,11 @@ int32_t MinusConvert(uint8_t Temp_h, int32_t Value){
      
     return ret;
 }
-
+int8_t ALC_Calc(int8_t threshold,double CurrDet){
+    int8_t ret = 0;
+    ret = CurrDet - threshold;
+    return ret;
+}
 void ALC_Function(){ //DL 
     double Volt_Calc_val = 3.3 / 4095;
     double ret = 0;
@@ -2923,13 +2978,17 @@ void ALC_Function(){ //DL
     int32_t CurrnALC_MAX_SettingValue = 0;    
     int32_t CurrnALC_MIN_SettingValue = 0;        
     int32_t ALC_Result = 0;
+    int16_t Limitdata = 0;
     double ResdBm = 0;
+    uint16_t IwillGiveAtten = 0;
     uint8_t tempadc[100];
     Bluecell_StructCpy(&AutoControl_Save[0],&ALC_Table_ref.DET_UL_0,sizeof(ALC_dBm_t));
     Bluecell_StructCpy(&tempadc[0],&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
     if(ALCTimerCnt > 100){
-        if(bluecell_Currdatastatus.ATT_ALC1_ONOFF == true){
-#if 1 // PYJ.2020.04.29_BEGIN -- 
+        if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+            /***************************************************************************************************************/
+            /*                                             ALC 1                                                           */
+            /***************************************************************************************************************/            
             //ret 현재 Voltage 값 출력 
             //ret 에 따른 현재 DBM 구현 
             ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
@@ -2938,178 +2997,100 @@ void ALC_Function(){ //DL
             ResdBm = AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
 //            printf("db %f \r\n",ResdBm);
 //            HAL_Delay(1000);
-#if 0 // PYJ.2020.05.14_BEGIN -- 
-            //            printf("==================================\r\n");
+//                        printf("==================================\r\n");
             //            printf("Current UL ADC VALUE : %f \r\n",ret);
-            //            printf("ResdBm : UL1 : %f \r\n",ResdBm);
-            //            HAL_Delay(1000);
-            CurrnALC_MAX_SettingValue = bluecell_Currdatastatus.ATT_ALC1_MAX_H << 8;
-            CurrnALC_MAX_SettingValue += bluecell_Currdatastatus.ATT_ALC1_MAX_L;
-            CurrnALC_MAX_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL1_IN_H,CurrnALC_MAX_SettingValue);
-            
-            CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC1_MIN_H << 8;
-            CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC1_MIN_L;
-            CurrnALC_MIN_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL1_IN_H,CurrnALC_MIN_SettingValue);
-
-//            printf("CurrnALC_MAX_SettingValue : %d \r\n",CurrnALC_MAX_SettingValue);      
-//            printf("CurrnALC_MIN_SettingValue : %d \r\n",CurrnALC_MIN_SettingValue);                  
-//            printf("I WILL GIVE YOU ATTEN MAX : %d \r\n",ResdBm - CurrnALC_MAX_SettingValue);
-//            printf("I WILL GIVE YOU ATTEN MIN : %d \r\n",ResdBm - CurrnALC_MIN_SettingValue);
-//            printf("==================================\r\n");            
-            ALC_Result  = ResdBm - CurrnALC_MAX_SettingValue;
-            if(ALC_Result > 0){
-                ALC_Result *= 100;
-                ALC_Result +=  bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
-                bluecell_Currdatastatus.ATT_UL1_H =  ((ALC_Result & 0xFF00) >> 8);
-                bluecell_Currdatastatus.ATT_UL1_L =  ALC_Result & 0x00FF;               
-                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
-            }else{
-            }
-#endif // PYJ.2020.05.14_END -- 
-            CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC_Threshold_H << 8;
-            CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC_Threshold_L;
-            CurrnALC_MIN_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL1_IN_H,CurrnALC_MIN_SettingValue);
+//                        printf("ResdBm : UL1 : %f \r\n",ResdBm);
+            Limitdata = (( bluecell_Currdatastatus.DLI_Level_High_Threshold_H << 8) & 0xFF00) ;
+            Limitdata +=  bluecell_Currdatastatus.DLI_Level_High_Threshold_L ;
+
+            Limitdata /= 10;
+
+            //CurrnALC_MIN_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL1_IN_H,CurrnALC_MIN_SettingValue);
+//            Limitdata = (( bluecell_Currdatastatus.ATT_UL1_H << 8) & 0xFF00) ;
+//            Limitdata +=  bluecell_Currdatastatus.ATT_UL1_L ;
+//
+//            Limitdata /= 10;
 
             CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL1_H,bluecell_Currdatastatus.ATT_UL1_L);
-            uint16_t tempValue = 0;
-            if(CurrnALC_MIN_SettingValue > ResdBm && CurrentATTENVALUE > 0){
-                tempValue = (CurrentATTENVALUE*10);
-                tempValue %= 10;
-                if(tempValue > 0){
-                    ALC_Result = CurrentATTENVALUE *10 -50;
-                }else{
-                    ALC_Result = CurrentATTENVALUE *10 -100;
-                }
-                 bluecell_Currdatastatus.ATT_UL1_H = ((ALC_Result & 0xFF00) >> 8);
-                 bluecell_Currdatastatus.ATT_UL1_L = ALC_Result & 0x00FF;
+            IwillGiveAtten = ALC_Calc(Limitdata,ResdBm);
+//            printf("%f  %d : I WILL GIVE ATTEN  : %d \r\n",ResdBm , Limitdata,IwillGiveAtten);            
+            
+//            printf("CurrentATTENVALUE %f \r\n",CurrentATTENVALUE);
+            IwillGiveAtten *=10;
 
+            if((ResdBm > (Limitdata + 0.5)) || (ResdBm < (Limitdata - 0.5))){
+                bluecell_Currdatastatus.ATT_UL1_H = ((IwillGiveAtten & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ATT_UL1_L = IwillGiveAtten & 0x00FF;
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
-                
-            }else{
             }
-#else
+             /***************************************************************************************************************/
+             /*                                             ALC 2                                                           */
+             /***************************************************************************************************************/  
 
-#endif // PYJ.2020.04.29_END -- 
-        }
-        if(bluecell_Currdatastatus.ATT_ALC2_ONOFF == true){
             ret  = bluecell_Currdatastatus.DET_UL2_IN_H << 8;
             ret += bluecell_Currdatastatus.DET_UL2_IN_L;   
             ret *= Volt_Calc_val;
             ResdBm = AutoControl_ADC_Compare(ret,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-//            printf("db %f \r\n",ResdBm);
+            Limitdata = (( bluecell_Currdatastatus.DLI_Level_High_Threshold_H << 8) & 0xFF00) ;
+            Limitdata +=  bluecell_Currdatastatus.DLI_Level_High_Threshold_L ;
+            Limitdata /= 10;
 
-#if 0 // PYJ.2020.05.14_BEGIN -- 
-            CurrnALC_MAX_SettingValue = bluecell_Currdatastatus.ATT_ALC2_MAX_H << 8;
-            CurrnALC_MAX_SettingValue += bluecell_Currdatastatus.ATT_ALC2_MAX_L;
-            CurrnALC_MAX_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL2_IN_H,CurrnALC_MAX_SettingValue);
-            ALC_Result  = ResdBm - CurrnALC_MAX_SettingValue;
-            
-            if(ALC_Result > 0){
-                ALC_Result *= 100;
-                ALC_Result +=  bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L;
-                bluecell_Currdatastatus.ATT_UL2_H =  ((ALC_Result & 0xFF00) >> 8);
-                bluecell_Currdatastatus.ATT_UL2_L =  ALC_Result & 0x00FF;               
+            CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL2_H,bluecell_Currdatastatus.ATT_UL2_L);
+            IwillGiveAtten = ALC_Calc(Limitdata,ResdBm);
+            IwillGiveAtten *=10;
+            if((ResdBm > (Limitdata + 0.5)) || (ResdBm < (Limitdata - 0.5))){
+                bluecell_Currdatastatus.ATT_UL2_H = ((IwillGiveAtten & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ATT_UL2_L = IwillGiveAtten & 0x00FF;
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
             }
-#endif // PYJ.2020.05.14_END -- 
-            CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC_Threshold_H << 8;
-            CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC_Threshold_L;
-            CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL2_H,bluecell_Currdatastatus.ATT_UL2_L);
-            uint16_t tempValue = 0;
-            if(CurrnALC_MIN_SettingValue > ResdBm && CurrentATTENVALUE > 0){
-                tempValue = (CurrentATTENVALUE*10);
-                tempValue %= 10;
-                if(tempValue > 0){
-                    ALC_Result = CurrentATTENVALUE *10 -50;
-                }else{
-                    ALC_Result = CurrentATTENVALUE *10 -100;
-                }
-                 bluecell_Currdatastatus.ATT_UL2_H = ((ALC_Result & 0xFF00) >> 8);
-                 bluecell_Currdatastatus.ATT_UL2_L = ALC_Result & 0x00FF;
+                
+            /***************************************************************************************************************/
+            /*                                             ALC 3                                                           */
+            /***************************************************************************************************************/              
+            ret  = bluecell_Currdatastatus.DET_UL3_IN_H << 8;
+            ret += bluecell_Currdatastatus.DET_UL3_IN_L;   
+            ret *= Volt_Calc_val;
+            ResdBm = AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+            Limitdata = (( bluecell_Currdatastatus.DLI_Level_High_Threshold_H << 8) & 0xFF00) ;
+            Limitdata +=  bluecell_Currdatastatus.DLI_Level_High_Threshold_L ;
 
+            Limitdata /= 10;
+
+
+            CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL3_H,bluecell_Currdatastatus.ATT_UL3_L);
+            IwillGiveAtten = ALC_Calc(Limitdata,ResdBm);
+            IwillGiveAtten *=10;
+
+            if((ResdBm > (Limitdata + 0.5)) || (ResdBm < (Limitdata - 0.5))){
+                bluecell_Currdatastatus.ATT_UL3_H = ((IwillGiveAtten & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ATT_UL3_L = IwillGiveAtten & 0x00FF;
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
-                
-           }
-        }
-        if(bluecell_Currdatastatus.ATT_ALC3_ONOFF == true){
-             ret  = bluecell_Currdatastatus.DET_UL3_IN_H << 8;
-             ret += bluecell_Currdatastatus.DET_UL3_IN_L;   
-             ret *= Volt_Calc_val;
-             ResdBm = AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-#if 0 // PYJ.2020.05.14_BEGIN -- 
-             CurrnALC_MAX_SettingValue = bluecell_Currdatastatus.ATT_ALC3_MAX_H << 8;
-             CurrnALC_MAX_SettingValue += bluecell_Currdatastatus.ATT_ALC3_MAX_L;
-             CurrnALC_MAX_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL3_IN_H,CurrnALC_MAX_SettingValue);
-             ALC_Result  = ResdBm - CurrnALC_MAX_SettingValue;
-             
-             if(ALC_Result > 0){
-                 ALC_Result *= 100;
-                 ALC_Result +=  bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L;
-                 bluecell_Currdatastatus.ATT_UL3_H =  ((ALC_Result & 0xFF00) >> 8);
-                 bluecell_Currdatastatus.ATT_UL3_L =  ALC_Result & 0x00FF;               
-                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
-             }
-#endif // PYJ.2020.05.14_END -- 
-             CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC_Threshold_H << 8;
-             CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC_Threshold_L;
-             CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL3_H,bluecell_Currdatastatus.ATT_UL3_L);
-             uint16_t tempValue = 0;
-             if(CurrnALC_MIN_SettingValue > ResdBm && CurrentATTENVALUE > 0){
-                 tempValue = (CurrentATTENVALUE*10);
-                 tempValue %= 10;
-                 if(tempValue > 0){
-                     ALC_Result = CurrentATTENVALUE *10 -50;
-                 }else{
-                     ALC_Result = CurrentATTENVALUE *10 -100;
-                 }
-                  bluecell_Currdatastatus.ATT_UL3_H = ((ALC_Result & 0xFF00) >> 8);
-                  bluecell_Currdatastatus.ATT_UL3_L = ALC_Result & 0x00FF;
-            
-                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
-                 
             }
+            /***************************************************************************************************************/
+            /*                                             ALC 4                                                           */
+            /***************************************************************************************************************/  
 
-        }
-        if(bluecell_Currdatastatus.ATT_ALC4_ONOFF == true){
-             ret  = bluecell_Currdatastatus.DET_UL4_IN_H << 8;
-             ret += bluecell_Currdatastatus.DET_UL4_IN_L;   
-             ret *= Volt_Calc_val;
-             ResdBm = AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-#if 0 // PYJ.2020.05.14_BEGIN -- 
-             CurrnALC_MAX_SettingValue = bluecell_Currdatastatus.ATT_ALC4_MAX_H << 8;
-             CurrnALC_MAX_SettingValue += bluecell_Currdatastatus.ATT_ALC4_MAX_L;
-             CurrnALC_MAX_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL4_IN_H,CurrnALC_MAX_SettingValue);
-             ALC_Result  = ResdBm - CurrnALC_MAX_SettingValue;
-             if(ALC_Result > 0){
-                 ALC_Result *= 100;
-                 ALC_Result +=  bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L;
-                 bluecell_Currdatastatus.ATT_UL4_H =  ((ALC_Result & 0xFF00) >> 8);
-                 bluecell_Currdatastatus.ATT_UL4_L =  ALC_Result & 0x00FF;               
-                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
-             }
-#endif // PYJ.2020.05.14_END -- 
-             
-             CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC4_MIN_H << 8;
-             CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC4_MIN_L;
-             CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL4_H,bluecell_Currdatastatus.ATT_UL4_L);
-             uint16_t tempValue = 0;
-             if(CurrnALC_MIN_SettingValue > ResdBm && CurrentATTENVALUE > 0){
-                 tempValue = (CurrentATTENVALUE*10);
-                 tempValue %= 10;
-                 if(tempValue > 0){
-                     ALC_Result = CurrentATTENVALUE *10 -50;
-                 }else{
-                     ALC_Result = CurrentATTENVALUE *10 -100;
-                 }
-                  bluecell_Currdatastatus.ATT_UL4_H = ((ALC_Result & 0xFF00) >> 8);
-                  bluecell_Currdatastatus.ATT_UL4_L = ALC_Result & 0x00FF;
-            
-                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
-                 
-            }
+            ret  = bluecell_Currdatastatus.DET_UL4_IN_H << 8;
+            ret += bluecell_Currdatastatus.DET_UL4_IN_L;   
+            ret *= Volt_Calc_val;
+            ResdBm = AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+            Limitdata = (( bluecell_Currdatastatus.DLI_Level_High_Threshold_H << 8) & 0xFF00) ;
+            Limitdata +=  bluecell_Currdatastatus.DLI_Level_High_Threshold_L ;
 
-        }
+            Limitdata /= 10;
+
+
+            CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL4_H,bluecell_Currdatastatus.ATT_UL4_L);
+            IwillGiveAtten = ALC_Calc(Limitdata,ResdBm);
+            IwillGiveAtten *=10;
+
+            if((ResdBm > (Limitdata + 0.5)) || (ResdBm < (Limitdata - 0.5))){
+                bluecell_Currdatastatus.ATT_UL4_H = ((IwillGiveAtten & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ATT_UL4_L = IwillGiveAtten & 0x00FF;
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+            }
         ALCTimerCnt = 0;
+        }
     }
 }
 //-15 ~ -5
@@ -3240,163 +3221,223 @@ void Alarm_Check(){
     double Volt_Calc_val = 3.3 / 4095;
     double ret = 0;
     int8_t ResdBm[4] = {0,};
-#if 0 // PYJ.2020.05.18_BEGIN -- 
-    if(bluecell_Currdatastatus.ALARM_MASK1 != true)
+    if(bluecell_Currdatastatus.ALARM_MASK1 == false)
         return;
-#endif // PYJ.2020.05.18_END -- 
+
+    if(bluecell_Currdatastatus.ALARM_TEMP_HIGH             > 0 
+    || bluecell_Currdatastatus.ALARM_DLI_Level             > 0
+    || bluecell_Currdatastatus.ALARM_DLI_AGC_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_ALC_SHTUTDOWN     > 0){
+        AlarmTimerSet = true;
+    }else{
+        AlarmTimerSet = false;
+    }
 
     /******************************TEMP START*******************************************/ 
-    if(bluecell_Currdatastatus.Temp_High_Threshold > bluecell_Currdatastatus.DET_TEMP){
-        bluecell_Currdatastatus.ALARM_TEMP_HIGH == ENVIRONMENT_TEMPHIGH;
+    if(bluecell_Currdatastatus.Temp_High_Threshold < (bluecell_Currdatastatus.DET_TEMP )){
+        bluecell_Currdatastatus.ALARM_TEMP_HIGH |= ENVIRONMENT_TEMPHIGH;
+        
+    }else{
+        bluecell_Currdatastatus.ALARM_TEMP_HIGH &= ~ENVIRONMENT_TEMPHIGH;
+        
     }
     /******************************TEMP END*******************************************/ 
 
     /******************************ULO LEVEL START*******************************************/ 
 
-    temp = ((bluecell_Currdatastatus.ULO_Level_High_Threshold_H << 8) & 0xFF00);
-    temp += (bluecell_Currdatastatus.ULO_Level_High_Threshold_L & 0x00FF);
-    
-    ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
-    ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
-    ret *= Volt_Calc_val;
-    ResdBm[0] = AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-    ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
-    ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
-    ret *= Volt_Calc_val;
-    ResdBm[1] = AutoControl_ADC_Compare(ret,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-
-    ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
-    ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
-    ret *= Volt_Calc_val;
-    ResdBm[2] = AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-    ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
-    ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
-    ret *= Volt_Calc_val;
-    ResdBm[3] = AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-    
-    /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */
-    if(temp > ResdBm[0]){
-        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P1_LEVEL_HIGH;
-    }
-    if( temp > ResdBm[1]){
-        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P2_LEVEL_HIGH;
-    }
-    if(temp > ResdBm[2]){
-        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P3_LEVEL_HIGH;
-    }
-    if(temp > ResdBm[3]){
-        bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P4_LEVEL_HIGH;
-    }
-    /******************************ULO LEVEL END*******************************************/ 
-    /******************************ULO ALC Start*******************************************/ 
-    temp = ((bluecell_Currdatastatus.ATT_ALC_Threshold_H << 8) & 0xFF00);
-    temp += (bluecell_Currdatastatus.ATT_ALC_Threshold_L & 0x00FF);
-    if(temp > ResdBm[0]){
-        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ALC_P1;
-    }
-    if( temp > ResdBm[1]){
-        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ALC_P2;
-    }
-    if(temp > ResdBm[2]){
-        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ALC_P3;
-    }
-    if(temp > ResdBm[3]){
-        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ALC_P4;
-    }
-    /******************************ULO ALC END*******************************************/ 
-    temp = ((bluecell_Currdatastatus.ULO_Shutdown_Threshold_H << 8) & 0xFF00);
-    temp += (bluecell_Currdatastatus.ULO_Shutdown_Threshold_L & 0x00FF);    
-    if(temp > ResdBm[0]){
-        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P1;
-    }
-    if( temp > ResdBm[1]){
-        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P2;
-    }
-    if(temp > ResdBm[2]){
-        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P3;
-    }
-    if(temp > ResdBm[3]){
-        bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P4;
-    }
+    if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+        temp = ((bluecell_Currdatastatus.ULO_Level_High_Threshold_H << 8) & 0xFF00);
+        temp += (bluecell_Currdatastatus.ULO_Level_High_Threshold_L & 0x00FF);
+        
+        ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
+        ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
+        ret *= Volt_Calc_val;
+        ResdBm[0] = AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+        ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
+        ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
+        ret *= Volt_Calc_val;
+        ResdBm[1] = AutoControl_ADC_Compare(ret,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+
+        ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
+        ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
+        ret *= Volt_Calc_val;
+        ResdBm[2] = AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+        ret  = bluecell_Currdatastatus.DET_UL1_IN_H << 8;
+        ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
+        ret *= Volt_Calc_val;
+        ResdBm[3] = AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+        
+     /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */
+        if(temp > ResdBm[0]){
+             printf("ULO_ALC_Alarm1 OCCUR\r\n");
+            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P1_LEVEL_HIGH;
+            bluecell_Currdatastatus.ULO_ALC_Alarm1  = true;
+        }else{
+            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P1_LEVEL_HIGH;
+            bluecell_Currdatastatus.ULO_ALC_Alarm1  = false;
 
-    /******************************DLI LEVEL START*******************************************/ 
+        }
+        if( temp > ResdBm[1]){
+            printf("ULO_ALC_Alarm2 OCCUR\r\n");
+            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P2_LEVEL_HIGH;
+            bluecell_Currdatastatus.ULO_ALC_Alarm2  = true;        
+        }else{
+            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P2_LEVEL_HIGH;
+            bluecell_Currdatastatus.ULO_ALC_Alarm2  = false;        
 
-    ret  = bluecell_Currdatastatus.DET_DL1_IN_H << 8;
-    ret += bluecell_Currdatastatus.DET_DL1_IN_L;   
-    ret *= Volt_Calc_val;
-    ResdBm[0] = AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
-
-    ret  = bluecell_Currdatastatus.DET_DL2_IN_H << 8;
-    ret += bluecell_Currdatastatus.DET_DL2_IN_L;   
-    ret *= Volt_Calc_val;
-    ResdBm[1] = AutoControl_ADC_Compare(ret,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
-
-    ret  = bluecell_Currdatastatus.DET_DL3_IN_H << 8;
-    ret += bluecell_Currdatastatus.DET_DL3_IN_L;   
-    ret *= Volt_Calc_val;
-    ResdBm[2] = AutoControl_ADC_Compare(ret,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
-
-    ret  = bluecell_Currdatastatus.DET_DL4_IN_H << 8;
-    ret += bluecell_Currdatastatus.DET_DL4_IN_L;   
-    ret *= Volt_Calc_val;
-    ResdBm[3] = AutoControl_ADC_Compare(ret,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
-
-    temp = ((bluecell_Currdatastatus.DLI_Level_High_Threshold_H << 8) & 0xFF00);
-    temp += (bluecell_Currdatastatus.DLI_Level_High_Threshold_L & 0x00FF);
-    /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */
-    if(temp < ResdBm[0]){
-        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_HIGH;
-    }
-    if( temp < ResdBm[1]){
-        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_HIGH;
-    }
-    if(temp < ResdBm[2]){
-        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_HIGH;
-    }
-    if(temp < ResdBm[3]){
-        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_HIGH;
-    }
+        }
+        if(temp > ResdBm[2]){
+            printf("ULO_ALC_Alarm3 OCCUR\r\n");
+            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P3_LEVEL_HIGH;
+            bluecell_Currdatastatus.ULO_ALC_Alarm3  = true;        
+        }else{
+            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P3_LEVEL_HIGH;
+            bluecell_Currdatastatus.ULO_ALC_Alarm3  = false;        
 
-    temp = ((bluecell_Currdatastatus.DLI_Level_Low_Threshold_H << 8) & 0xFF00);
-    temp += (bluecell_Currdatastatus.DLI_Level_Low_Threshold_L & 0x00FF);
-    /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */
-    if(temp > ResdBm[0]){
-        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_HIGH;
-    }
-    if( temp > ResdBm[1]){
-        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_HIGH;
-    }
-    if(temp > ResdBm[2]){
-        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_HIGH;
+        }
+        if(temp > ResdBm[3]){
+            printf("ULO_ALC_Alarm4 OCCUR\r\n");
+            bluecell_Currdatastatus.ALARM_ULO_Level |= ALARM_ULO_P4_LEVEL_HIGH;
+            bluecell_Currdatastatus.ULO_ALC_Alarm4  = true;        
+        }else{
+            bluecell_Currdatastatus.ALARM_ULO_Level &= ~ALARM_ULO_P4_LEVEL_HIGH;
+            bluecell_Currdatastatus.ULO_ALC_Alarm4  = false;        
+        }
+        /******************************ULO LEVEL END*******************************************/ 
+        /******************************ULO ALC Start*******************************************/ 
+        temp = ((bluecell_Currdatastatus.ATT_ALC_Threshold_H << 8) & 0xFF00);
+        temp += (bluecell_Currdatastatus.ATT_ALC_Threshold_L & 0x00FF);
+        if(temp > ResdBm[0]){
+            bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P1;
+        }
+        if( temp > ResdBm[1]){
+            bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P2;
+        }
+        if(temp > ResdBm[2]){
+            bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P3;
+        }
+        if(temp > ResdBm[3]){
+            bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm |= ALARM_ALC_P4;
+        }
+        /******************************ULO ALC END*******************************************/ 
+        temp = ((bluecell_Currdatastatus.ULO_Shutdown_Threshold_H << 8) & 0xFF00);
+        temp += (bluecell_Currdatastatus.ULO_Shutdown_Threshold_L & 0x00FF);    
+        if(temp > ResdBm[0]){
+            bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P1;
+        }
+        if( temp > ResdBm[1]){
+            bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P2;
+        }
+        if(temp > ResdBm[2]){
+            bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P3;
+        }
+        if(temp > ResdBm[3]){
+            bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P4;
+        }
     }
-    if(temp > ResdBm[3]){
-        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_HIGH;
-    }    
-    /******************************DLI LEVEL END*******************************************/     
-    /******************************DLI AGC START******************************************/     
-    
+    /******************************DLI LEVEL START*******************************************/ 
+    if(bluecell_Currdatastatus.DLI_AGC_ON_OFF == true){
+        ret  = bluecell_Currdatastatus.DET_DL1_IN_H << 8;
+        ret += bluecell_Currdatastatus.DET_DL1_IN_L;   
+        ret *= Volt_Calc_val;
+        ResdBm[0] = AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
+
+        ret  = bluecell_Currdatastatus.DET_DL2_IN_H << 8;
+        ret += bluecell_Currdatastatus.DET_DL2_IN_L;   
+        ret *= Volt_Calc_val;
+        ResdBm[1] = AutoControl_ADC_Compare(ret,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
+
+        ret  = bluecell_Currdatastatus.DET_DL3_IN_H << 8;
+        ret += bluecell_Currdatastatus.DET_DL3_IN_L;   
+        ret *= Volt_Calc_val;
+        ResdBm[2] = AutoControl_ADC_Compare(ret,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
+
+        ret  = bluecell_Currdatastatus.DET_DL4_IN_H << 8;
+        ret += bluecell_Currdatastatus.DET_DL4_IN_L;   
+        ret *= Volt_Calc_val;
+        ResdBm[3] = AutoControl_ADC_Compare(ret,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEUL_st));
+
+        temp = ((bluecell_Currdatastatus.DLI_Level_High_Threshold_H << 8) & 0xFF00);
+        temp += (bluecell_Currdatastatus.DLI_Level_High_Threshold_L & 0x00FF);
+        /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */
+        if(temp < ResdBm[0]){
+            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_HIGH;
+        }
+        if( temp < ResdBm[1]){
+            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_HIGH;
+        }
+        if(temp < ResdBm[2]){
+            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_HIGH;
+        }
+        if(temp < ResdBm[3]){
+            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_HIGH;
+        }
+
+#if 0 // PYJ.2020.05.20_BEGIN -- 
+        temp = ((bluecell_Currdatastatus.DLI_Level_Low_Threshold_H << 8) & 0xFF00);
+        temp += (bluecell_Currdatastatus.DLI_Level_Low_Threshold_L & 0x00FF);
+        /*4개의 디텍 중에 한개라도 상한치를 넘었을 경우 알림 */
+        if(temp > ResdBm[0]){
+            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_HIGH;
+        }
+        if( temp > ResdBm[1]){
+            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_HIGH;
+        }
+        if(temp > ResdBm[2]){
+            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_HIGH;
+        }
+        if(temp > ResdBm[3]){
+            bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_HIGH;
+        }    
+#endif // PYJ.2020.05.20_END -- 
+        /******************************DLI LEVEL END*******************************************/     
+        /******************************DLI AGC START******************************************/     
+        
 
-    
-    temp = ((bluecell_Currdatastatus.ATT_DL1_H << 8) & 0xFF00);
-    temp += (bluecell_Currdatastatus.ATT_DL1_L & 0x00FF);
-    temp /= 10;
-    if(temp >= 15){
-        printf("ALARM_AGC_P1 OCCUR\r\n");
-        bluecell_Currdatastatus.DLI_AGC_Alarm1 |= ALARM_AGC_P1;
-    }
-    if( temp < ResdBm[1]){
-        bluecell_Currdatastatus.DLI_AGC_Alarm2 |= ALARM_AGC_P2;
-    }
-    if(temp < ResdBm[2]){
-        bluecell_Currdatastatus.DLI_AGC_Alarm3 |= ALARM_AGC_P3;
+        
+        temp = ((bluecell_Currdatastatus.ATT_DL1_H << 8) & 0xFF00);
+        temp += (bluecell_Currdatastatus.ATT_DL1_L & 0x00FF);
+        temp /= 10;
+        if(temp >= 15){
+            printf("ALARM_AGC_P1 OCCUR\r\n");
+            bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm |= ALARM_AGC_P1;
+            bluecell_Currdatastatus.DLI_AGC_Alarm1       = true;
+        }else{
+            bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm &= ~ALARM_AGC_P1;
+        }
+        if( temp < ResdBm[1]){
+            printf("ALARM_AGC_P2 OCCUR\r\n");
+            bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm |= ALARM_AGC_P2;
+            bluecell_Currdatastatus.DLI_AGC_Alarm2       = true;
+        }else{
+            bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm &= ~ALARM_AGC_P2;
+            bluecell_Currdatastatus.DLI_AGC_Alarm2       = false;
+
+        }
+        if(temp < ResdBm[2]){
+            printf("ALARM_AGC_P3 OCCUR\r\n");
+            bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm |= ALARM_AGC_P3;
+            bluecell_Currdatastatus.DLI_AGC_Alarm3       = true;    
+        }else{
+            bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm &= ~ALARM_AGC_P3;
+            bluecell_Currdatastatus.DLI_AGC_Alarm3       = false;
+
+        }
+        if(temp < ResdBm[3]){
+            printf("ALARM_AGC_P4 OCCUR\r\n");
+            bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm |= ALARM_AGC_P4;
+            bluecell_Currdatastatus.DLI_AGC_Alarm4       = true;    
+        }else{
+            bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm &= ~ALARM_AGC_P4;
+            bluecell_Currdatastatus.DLI_AGC_Alarm4       = false;
+
+        }
     }
-    if(temp < ResdBm[3]){
-        bluecell_Currdatastatus.DLI_AGC_Alarm4 |= ALARM_AGC_P4;
-    }   
     /******************************DLI AGC END******************************************/     
     /******************************DLI ShutDown Start******************************************/     
-
-
     temp = ((bluecell_Currdatastatus.DLI_Shutdown_Threshold_H << 8) & 0xFF00);
     temp += (bluecell_Currdatastatus.DLI_Shutdown_Threshold_L & 0x00FF);
 

Inc/main.h

@@ -71,8 +71,8 @@ extern I2C_HandleTypeDef hi2c2;
 /* USER CODE END EFP */
 
 /* Private defines -----------------------------------------------------------*/
-#define LED_FAIL_Pin GPIO_PIN_3
-#define LED_FAIL_GPIO_Port GPIOE
+#define LED_ACT_Pin GPIO_PIN_3
+#define LED_ACT_GPIO_Port GPIOE
 #define FAIL_MBIC_Pin GPIO_PIN_4
 #define FAIL_MBIC_GPIO_Port GPIOE
 #define BOOT_LED_Pin GPIO_PIN_15
@@ -127,8 +127,8 @@ extern I2C_HandleTypeDef hi2c2;
 #define PATH_EN_DL2_GPIO_Port GPIOD
 #define PATH_EN_UL2_Pin GPIO_PIN_11
 #define PATH_EN_UL2_GPIO_Port GPIOD
-#define LED_ACT_Pin GPIO_PIN_14
-#define LED_ACT_GPIO_Port GPIOD
+#define LED_FAIL_Pin GPIO_PIN_14
+#define LED_FAIL_GPIO_Port GPIOD
 #define ATT_EN_DL3_Pin GPIO_PIN_2
 #define ATT_EN_DL3_GPIO_Port GPIOG
 #define ATT_EN_UL3_Pin GPIO_PIN_3

STM32F103ZET_JDASMBIC.ioc

@@ -284,7 +284,7 @@ PD11.GPIO_Label=PATH_EN_UL2
 PD11.Locked=true
 PD11.Signal=GPIO_Output
 PD14.GPIOParameters=GPIO_Label
-PD14.GPIO_Label=LED_ACT
+PD14.GPIO_Label=LED_FAIL
 PD14.Locked=true
 PD14.Signal=GPIO_Output
 PD15.Locked=true
@@ -330,7 +330,7 @@ PE15.GPIO_Label=PATH_EN_UL4
 PE15.Locked=true
 PE15.Signal=GPIO_Output
 PE3.GPIOParameters=GPIO_Label
-PE3.GPIO_Label=LED_FAIL
+PE3.GPIO_Label=LED_ACT
 PE3.Locked=true
 PE3.Signal=GPIO_Output
 PE4.GPIOParameters=GPIO_Label

Src/main.c

@@ -75,6 +75,9 @@ volatile uint32_t UartRxTimerCnt = 0;
 volatile uint32_t LDTimerCnt = 0;
 volatile uint32_t ALCTimerCnt = 0;
 volatile uint32_t AGCTimerCnt = 0;
+volatile bool     AlarmTimerSet = 0;
+volatile uint32_t AlarmTimerCnt = 0;
+
 
 
 /* USER CODE END PV */
@@ -118,7 +121,7 @@ uint16_t adc3cnt = 0 ;
 void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
 {
 //?��?��?�� 코드 ?��?��
-//諤嵸烄 ?嚙踝蕭?嚙踝蕭 adc?嚙踝蕭嚙?????????? 嚙???????????嚙踝蕭?嚙踝蕭 ?嚙踝蕭 ?嚙踝蕭?嚙踝蕭嚙?????????? ?嚙踝蕭?嚙踝蕭嚙?????????? ?嚙踝蕭?嚙踝蕭?? 穈軤𦚯 魽國探嚙?????????? ?嚙踝蕭?嚙踝蕭
+//만약 ?��?�� adc?���?????????? �???????????��?�� ?�� ?��?���?????????? ?��?���?????????? ?��?��?? 같이 조건�?????????? ?��?��
 
     if(hadc->Instance == hadc1.Instance)
     {
@@ -261,6 +264,8 @@ void eepromtest_j1(){
 extern void ALC_Function();
 extern void Boot_LED_Toggle(void);
 extern void ADC_Check(void);
+extern void Booting_LED_Check(void);
+
 /* USER CODE END 0 */
 
 /**
@@ -312,6 +317,14 @@ int main(void)
   PE43711_PinInit();
   EEPROM_M24C08_Init();
   Bluecell_DataInit();
+#if 1 // PYJ.2020.05.06_BEGIN -- 
+    printf("****************************************\r\n");
+    printf("MBIC Project\r\n");
+    printf("Build at %s %s\r\n", __DATE__, __TIME__);
+    printf("Copyright (c) 2020. BLUECELL\r\n");
+    printf("****************************************\r\n");
+#endif // PYJ.2020.05.06_END --   
+  Booting_LED_Check();
 #if 0 // PYJ.2020.04.22_BEGIN -- 
   EEPROM_M24C08_write(0xA0,0,i2cTestData,1);
   printf("i2c Test Data1 %d\r\n",i2ctest[0]);
@@ -328,13 +341,7 @@ int main(void)
 //    EEPROMTEST_J();
 //    eepromtest_j1();
 //        eepromtest_j1();
-#if 1 // PYJ.2020.05.06_BEGIN -- 
-    printf("****************************************\r\n");
-    printf("MBIC Project\r\n");
-    printf("Build at %s %s\r\n", __DATE__, __TIME__);
-    printf("Copyright (c) 2020. BLUECELL\r\n");
-    printf("****************************************\r\n");
-#endif // PYJ.2020.05.06_END -- 
+
 
   while (1)
   {
@@ -750,7 +757,7 @@ static void MX_GPIO_Init(void)
   __HAL_RCC_GPIOD_CLK_ENABLE();
 
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(GPIOE, LED_FAIL_Pin|FAIL_MBIC_Pin|ATT_CLOCK4_Pin|ATT_DATA4_Pin 
+  HAL_GPIO_WritePin(GPIOE, LED_ACT_Pin|FAIL_MBIC_Pin|ATT_CLOCK4_Pin|ATT_DATA4_Pin 
                           |ATT_EN_DL4_Pin|ATT_EN_UL4_Pin|PATH_EN_DL4_Pin|PATH_EN_UL4_Pin, GPIO_PIN_RESET);
 
   /*Configure GPIO pin Output Level */
@@ -767,12 +774,12 @@ static void MX_GPIO_Init(void)
                           |ATT_EN_DL1_Pin, GPIO_PIN_RESET);
 
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(GPIOD, PATH_EN_DL2_Pin|PATH_EN_UL2_Pin|LED_ACT_Pin|GPIO_PIN_15 
+  HAL_GPIO_WritePin(GPIOD, PATH_EN_DL2_Pin|PATH_EN_UL2_Pin|LED_FAIL_Pin|GPIO_PIN_15 
                           |ATT_CLOCK2_Pin|ATT_DATA2_Pin|ATT_EN_DL2_Pin|ATT_EN_UL2_Pin, GPIO_PIN_RESET);
 
-  /*Configure GPIO pins : LED_FAIL_Pin FAIL_MBIC_Pin ATT_CLOCK4_Pin ATT_DATA4_Pin 
+  /*Configure GPIO pins : LED_ACT_Pin FAIL_MBIC_Pin ATT_CLOCK4_Pin ATT_DATA4_Pin 
                            ATT_EN_DL4_Pin ATT_EN_UL4_Pin PATH_EN_DL4_Pin PATH_EN_UL4_Pin */
-  GPIO_InitStruct.Pin = LED_FAIL_Pin|FAIL_MBIC_Pin|ATT_CLOCK4_Pin|ATT_DATA4_Pin 
+  GPIO_InitStruct.Pin = LED_ACT_Pin|FAIL_MBIC_Pin|ATT_CLOCK4_Pin|ATT_DATA4_Pin 
                           |ATT_EN_DL4_Pin|ATT_EN_UL4_Pin|PATH_EN_DL4_Pin|PATH_EN_UL4_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
@@ -808,9 +815,9 @@ static void MX_GPIO_Init(void)
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
-  /*Configure GPIO pins : PATH_EN_DL2_Pin PATH_EN_UL2_Pin LED_ACT_Pin PD15 
+  /*Configure GPIO pins : PATH_EN_DL2_Pin PATH_EN_UL2_Pin LED_FAIL_Pin PD15 
                            ATT_CLOCK2_Pin ATT_DATA2_Pin ATT_EN_DL2_Pin ATT_EN_UL2_Pin */
-  GPIO_InitStruct.Pin = PATH_EN_DL2_Pin|PATH_EN_UL2_Pin|LED_ACT_Pin|GPIO_PIN_15 
+  GPIO_InitStruct.Pin = PATH_EN_DL2_Pin|PATH_EN_UL2_Pin|LED_FAIL_Pin|GPIO_PIN_15 
                           |ATT_CLOCK2_Pin|ATT_DATA2_Pin|ATT_EN_DL2_Pin|ATT_EN_UL2_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
@@ -847,6 +854,10 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
       LDTimerCnt++;
       ALCTimerCnt++;
       AGCTimerCnt++;
+      if(AlarmTimerSet == true)
+        AlarmTimerCnt++;
+      else
+        AlarmTimerCnt = 0;
   }
   /* USER CODE END Callback 1 */
 }