Alarm Log Report 기능 구현

 - Alarm Log #define 선언
LED Test
 - 10번 반복으로 변경

HFR 디버깅 문제 사항
 Mask / Unmask 정상 동작 안하는 문제 수정
 Alarm Mask   = Flag 로 값을 주어야한다.

부트로더 Auto Restart 기능 추가  ( 디버깅 후 테스트 완료)

Bluecell_Src/Bluecell_operate.c

@@ -84,8 +84,8 @@ extern volatile uint32_t ADC_100ms_Cnt;
 extern volatile uint32_t HFR_ADC1value[ADC1_CNT];
 extern volatile uint32_t HFR_ADC3value[ADC3_CNT];
 
-uint8_t Selftest_DL_PrevAttenSave[8] = {0,};
-uint8_t Selftest_UL_PrevAttenSave[8] = {0,};
+volatile uint8_t Selftest_DL_PrevAttenSave[8] = {0,};
+volatile uint8_t Selftest_UL_PrevAttenSave[8] = {0,};
 uint8_t TempShutdown_DL_SaveData[4] = {false,};
 uint8_t TempShutdown_UL_SaveData[4] = {false,};    
 
@@ -148,6 +148,36 @@ void UL_Path_OnOff(uint8_t Index,uint8_t value,uint8_t* path,uint8_t* PrevAtten,
 #define TableDataSetting_ATT_UL_LEVEL_STEP -1 
 #define MBIC_AID  0xE0
 
+#define Temp_High 				0xE014
+#define DLI_P4_Level_Low		0xE043
+#define DLI_P3_Level_Low 		0xE042
+#define DLI_P2_Level_Low		0xE041
+#define DLI_P1_Level_Low		0xE040
+#define DLI_P4_Level_High		0xE047
+#define DLI_P3_Level_High		0xE046
+#define DLI_P2_Level_High		0xE045
+#define DLI_P1_Level_High		0xE044
+#define DLI_P4_AGC_Alarm		0xE05A
+#define DLI_P3_AGC_Alarm		0xE059
+#define DLI_P2_AGC_Alarm		0xE058
+#define DLI_P1_AGC_Alarm		0xE057
+#define DLI_P4_Shutdown_Alarm	0xE05E
+#define DLI_P3_Shutdown_Alarm	0xE05D
+#define DLI_P2_Shutdown_Alarm	0xE05C
+#define DLI_P1_Shutdown_Alarm	0xE05B
+#define ULO_P4_Level_High		0xE073
+#define ULO_P3_Level_High		0xE072
+#define ULO_P2_Level_High		0xE071
+#define ULO_P1_Level_High		0xE070
+#define ULO_P4_ALC_Alarm		0xE08A
+#define ULO_P3_ALC_Alarm		0xE089
+#define ULO_P2_ALC_Alarm		0xE088
+#define ULO_P1_ALC_Alarm		0xE087
+#define ULO_P4_Shutdown			0xE08E
+#define ULO_P3_Shutdown		    0xE08D
+#define ULO_P2_Shutdown		    0xE08C
+#define ULO_P1_Shutdown		    0xE08B
+
 
 int8_t DL_DET_Table_ref[AGC_Table_DL_Ref_Index_MAX][TABLE_LENGTH_MAX];
 int8_t UL_DET_Table_ref[ALC_Table_UL_Ref_Index_MAX][TABLE_LENGTH_MAX];
@@ -311,7 +341,7 @@ void Boot_LED_Toggle(void){
             LED_TestCnt++;
             LedTimerCnt = 0;
           /*Set LED TEST variable False after 12 flashes*/
-          if(LED_TestCnt >= 6){
+          if(LED_TestCnt >= 20){
             bluecell_Currdatastatus.LED_TEST = false;
             LED_TestCnt = 0;
           }
@@ -3211,7 +3241,8 @@ void HFR_TypeInit(){
 #endif // PYJ.2020.06.17_END -- 
     
     HAL_Delay(10);
-
+//    printf("UL 1 H : %x \r\n",bluecell_Currdatastatus.ATT_UL4_H);
+//    printf("UL 1 L : %x \r\n",bluecell_Currdatastatus.ATT_UL4_L);    
     CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
     if(bluecell_Currdatastatus.Selftest1==0){
 //        printf("Selftest1 : 0 \r\n");
@@ -3292,12 +3323,14 @@ uint32_t MBIC_DataSend(uint8_t* data){
             data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_Test_Dummy4;
             data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_Test_Dummy5;
         }
+//        printf("Alarm Test Mode ON \r\n");
      }else{
         if(bluecell_Currdatastatus.ALARM_MASK1 != false)
             data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_TEMP_HIGH;
         else
             data[MBIC_PAYLOADSTART + i++] = 0;
         
+#if 0 // PYJ.2020.08.18_BEGIN -- 
         if(bluecell_Currdatastatus.ALARM_MASK2 != false)
             data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_DLI_Level;
         else
@@ -3305,7 +3338,7 @@ uint32_t MBIC_DataSend(uint8_t* data){
 
         if(bluecell_Currdatastatus.ALARM_MASK3 != false)
             data[MBIC_PAYLOADSTART + i++] = (bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & 0xF0 )
-                                       | (bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & 0x0F);
+                                          | (bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & 0x0F);
         else
             data[MBIC_PAYLOADSTART + i++] = 0;    
         if(bluecell_Currdatastatus.ALARM_MASK4 != false)                                      
@@ -3315,9 +3348,220 @@ uint32_t MBIC_DataSend(uint8_t* data){
 
         if(bluecell_Currdatastatus.ALARM_MASK5 != false)
             data[MBIC_PAYLOADSTART + i++] = (bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & 0xF0)
-                                        |(bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & 0x0F);
+                                           |(bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & 0x0F);
         else
-            data[MBIC_PAYLOADSTART + i++] = 0;            
+            data[MBIC_PAYLOADSTART + i++] = 0;     
+#else
+//        printf("bluecell_Currdatastatus.ALARM_DLI_Level : %x \r\n",bluecell_Currdatastatus.ALARM_DLI_Level);
+//        printf("bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm : %x \r\n",bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm);
+//        printf("bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN : %x \r\n",bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN);
+//        printf("bluecell_Currdatastatus.ALARM_ULO_Level : %x \r\n",bluecell_Currdatastatus.ALARM_ULO_Level);
+//        printf("bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm : %x \r\n",bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm);
+//        printf("bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN : %x \r\n",bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN);        
+        data[MBIC_PAYLOADSTART + i++] = 0;
+
+        if(bluecell_Currdatastatus.ALARM_MASK2 & 0x80){
+             data[MBIC_PAYLOADSTART + i - 1] = (bluecell_Currdatastatus.ALARM_DLI_Level & 0x80);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &= ~0x80; 
+        }
+        if(bluecell_Currdatastatus.ALARM_MASK2 & 0x40){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x40);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1 ] &=  ~0x40;
+        }
+        if(bluecell_Currdatastatus.ALARM_MASK2 & 0x20){
+             data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x20);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x20;
+        }
+        
+        if(bluecell_Currdatastatus.ALARM_MASK2 & 0x10){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x10);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x10;
+        }
+        
+        if(bluecell_Currdatastatus.ALARM_MASK2 & 0x08){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x08);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &= ~0x08; 
+        }
+
+        if(bluecell_Currdatastatus.ALARM_MASK2 & 0x04){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x04);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1 ] &=  ~0x04;
+        }
+        if(bluecell_Currdatastatus.ALARM_MASK2 & 0x02){
+             data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x02);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x02;
+        }
+        
+        if(bluecell_Currdatastatus.ALARM_MASK2 & 0x01){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_Level & 0x01);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x01;
+        }
+        
+
+
+        data[MBIC_PAYLOADSTART + i++] = 0;
+
+        if(bluecell_Currdatastatus.ALARM_MASK3 & 0x80){
+             data[MBIC_PAYLOADSTART + i - 1] = (bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & 0x80);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &= ~0x80; 
+        }
+
+        if(bluecell_Currdatastatus.ALARM_MASK3 & 0x40){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & 0x40);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1 ] &=  ~0x40;
+        }
+        if(bluecell_Currdatastatus.ALARM_MASK3 & 0x20){
+             data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & 0x20);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x20;
+        }
+        
+        if(bluecell_Currdatastatus.ALARM_MASK3 & 0x10){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm & 0x10);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x10;
+        }
+        
+        if(bluecell_Currdatastatus.ALARM_MASK3 & 0x08){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & 0x08);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &= ~0x08; 
+        }
+
+        if(bluecell_Currdatastatus.ALARM_MASK3 & 0x04){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & 0x04);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1 ] &=  ~0x04;
+        }
+        if(bluecell_Currdatastatus.ALARM_MASK3 & 0x02){
+             data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & 0x02);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x02;
+        }
+        
+        if(bluecell_Currdatastatus.ALARM_MASK3 & 0x01){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN & 0x01);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x01;
+        }
+        
+//    printf("(bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN ) : %x \r\n",(bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN ));
+       
+        data[MBIC_PAYLOADSTART + i++] = 0;
+
+        if(bluecell_Currdatastatus.ALARM_MASK4 & 0x08){
+             data[MBIC_PAYLOADSTART + i - 1] = (bluecell_Currdatastatus.ALARM_ULO_Level & 0x08);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &= ~0x08; 
+        }
+
+        if(bluecell_Currdatastatus.ALARM_MASK4 & 0x04){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_Level & 0x04);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1 ] &=  ~0x04;
+        }
+        if(bluecell_Currdatastatus.ALARM_MASK4 & 0x02){
+             data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_ULO_Level & 0x02);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x02;
+        }
+
+        if(bluecell_Currdatastatus.ALARM_MASK4 & 0x01){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_Level & 0x01);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x01;
+        }
+
+
+
+//////////////////////////////////
+        data[MBIC_PAYLOADSTART + i++] = 0;
+
+        if(bluecell_Currdatastatus.ALARM_MASK5 & 0x80){
+             data[MBIC_PAYLOADSTART + i - 1] = (bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & 0x80);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &= ~0x80; 
+        }
+
+        if(bluecell_Currdatastatus.ALARM_MASK5 & 0x40){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & 0x40);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1 ] &=  ~0x40;
+        }
+        if(bluecell_Currdatastatus.ALARM_MASK5 & 0x20){
+             data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & 0x20);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x20;
+        }
+        if(bluecell_Currdatastatus.ALARM_MASK5 & 0x10){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm & 0x10);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x10;
+        }
+//        printf("(bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN ) : %x \r\n",(bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN ));
+        if(bluecell_Currdatastatus.ALARM_MASK5 & 0x08){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & 0x08);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &= ~0x08; 
+        }
+
+        if(bluecell_Currdatastatus.ALARM_MASK5 & 0x04){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & 0x04);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1 ] &=  ~0x04;
+        }
+        if(bluecell_Currdatastatus.ALARM_MASK5 & 0x02){
+             data[MBIC_PAYLOADSTART + i - 1 ] |= (bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & 0x02);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x02;
+        }
+        
+        if(bluecell_Currdatastatus.ALARM_MASK5 & 0x01){
+             data[MBIC_PAYLOADSTART + i - 1] |= (bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & 0x01);
+        }
+        else{
+            data[MBIC_PAYLOADSTART + i - 1] &=  ~0x01;
+        }
+        
+
+#endif // PYJ.2020.08.18_END -- 
     }
     /*ALARM BIT MASK*/
     data[MBIC_PAYLOADSTART + i++] = MBIC_AID;
@@ -4083,7 +4327,7 @@ uint32_t MBIC_DataSend(uint8_t* data){
     data[MBIC_PAYLOADSTART + i++] = 0x03; 
 
     
-    printf("CRC ret : %X \r\n",Crcret);
+//    printf("CRC ret : %X \r\n",Crcret);
     Uart1_Data_Send(data, Length + 22 + 3);
     return Length;
 
@@ -4095,13 +4339,13 @@ void Factory_Set(){
     int16_t tempdata = 0;
 //    printf("Factory Set Start \r\n");
     /*ALARM MASK*/
-    bluecell_Currdatastatus.ALARM_MASK1 = ALAMASK_DEFAULT;
-    bluecell_Currdatastatus.ALARM_MASK2 = ALAMASK_DEFAULT;    
-    bluecell_Currdatastatus.ALARM_MASK3 = ALAMASK_DEFAULT;
-    bluecell_Currdatastatus.ALARM_MASK4 = ALAMASK_DEFAULT;    
-    bluecell_Currdatastatus.ALARM_MASK5 = ALAMASK_DEFAULT;  
+    bluecell_Currdatastatus.ALARM_MASK1 = 0x80;
+    bluecell_Currdatastatus.ALARM_MASK2 = 0xFF ;
+    bluecell_Currdatastatus.ALARM_MASK3 = 0xFF;
+    bluecell_Currdatastatus.ALARM_MASK4 = 0x0F ;
+    bluecell_Currdatastatus.ALARM_MASK5 = 0xFF; 
     /*Temp OFFSET*/
-    bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET = TEMP_OFFSET_DEFAULT;
+//    bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET = TEMP_OFFSET_DEFAULT;
     /*Temp High Thread Hold*/
     bluecell_Currdatastatus.Temp_High_Threshold = Temp_THREADHOLD_DEFAULT;
     /*Carrier On off*/
@@ -4748,73 +4992,43 @@ void Temp_Shutdown_ONOFF(uint8_t val){
 //        HAL_Delay(10);
     CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);    
 }
-typedef enum{
-    Temperature_AlarmType,
-    DLI_P4_Level_LowType,
-    DLI_P3_Level_LowType,   
-    DLI_P2_Level_LowType,  
-    DLI_P1_Level_LowType, 
-    DLI_P4_Level_HighType,   
-    DLI_P3_Level_HighType,   
-    DLI_P2_Level_HighType,   
-    DLI_P1_Level_HighType,   
-    DLI_P4_AGC_AlarmType,    
-    DLI_P3_AGC_AlarmType,    
-    DLI_P2_AGC_AlarmType,    
-    DLI_P1_AGC_AlarmType,    
-    DLI_P4_Shutdown_AlarmType,   
-    DLI_P3_Shutdown_AlarmType,   
-    DLI_P2_Shutdown_AlarmType,   
-    DLI_P1_Shutdown_AlarmType,   
-    ULO_P4_Level_HighType,   
-    ULO_P3_Level_HighType,   
-    ULO_P2_Level_HighType,   
-    ULO_P1_Level_HighType,   
-    ULO_P4_ALC_AlarmType,    
-    ULO_P3_ALC_AlarmType,    
-    ULO_P2_ALC_AlarmType,    
-    ULO_P1_ALC_AlarmType,    
-    ULO_P4_ShutdownType, 
-    ULO_P3_ShutdownType, 
-    ULO_P2_ShutdownType, 
-    ULO_P1_ShutdownType, 
-    Alarm_type_IndexMax
-}Alarm_type;
+
 #define OVERPOWER_STR "Overpower"
 #define OVER_INPUT_STR "Over-Input"
-uint8_t AlarmReport_History[Alarm_type_IndexMax] = {0,};
-uint8_t* Alarm_Report_Send(uint8_t Alarm_type,uint8_t val){
-    if(AlarmReport_History[Alarm_type] != true){
-        return;
-    }
-    static uint8_t Alarm_ReportData[40 + 21 + 3] = {0,};
+//uint8_t AlarmReport_History[Alarm_type_IndexMax] = {0,};
+uint8_t* Alarm_Report_Send(uint16_t Alarm_type,uint8_t val){
+//    if(AlarmReport_History[Alarm_type] != true){
+//        return;
+//    }
+    static uint8_t Alarm_ReportData[40 + 2 + 21 + 3] = {0,}; // 40 Alarm Data + 2 UNIT ID, 21 Header , 3 Tail
     uint8_t index = 0;
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0xE0;
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = Alarm_type;    
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = val;
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;    
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;    
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;    
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;    
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;    
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;    
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;    
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0x00;       //UNIT ID0
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0xF1;       //UNIT ID1
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = (uint8_t)((Alarm_type & 0xFF00) >> 8);       //A ID 0 
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = (uint8_t)(Alarm_type & 0x00FF); //A ID 1
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = val;        //Status 1
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;          //Alarm Time
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;          //Alarm Time
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;          //Alarm Time      
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;          //Alarm Time      
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;          //Alarm Time      
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;          //Alarm Time      
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;          //Clear Time      
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;          //Clear Time      
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;          //Clear Time      
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;          //Clear Time      
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;          //Clear Time      
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;          //Clear Time      
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;          //Band ID : MBIC : 0x00 Default
     Alarm_ReportData[MBIC_PAYLOADSTART + index++] = bluecell_Currdatastatus.Carrier_ID;
     Alarm_ReportData[MBIC_PAYLOADSTART + index++] = bluecell_Currdatastatus.Freq_ID;    
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;
-    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;    
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;//Alarm SeqNum0 RF Board Default 0
+    Alarm_ReportData[MBIC_PAYLOADSTART + index++] = 0;//Alarm SeqNum1 RF Board Default 0   
 
-    
-    for(int i = 20; i < 40; i++)
+    // 0~ 19 
+    for(int i = MBIC_PAYLOADSTART + 22; i < MBIC_PAYLOADSTART + 42; i++)
         Alarm_ReportData[i] = 0;
     
- 
 
     int16_t LimitData_UL_High = 0;
     
@@ -4895,50 +5109,90 @@ uint8_t* Alarm_Report_Send(uint8_t Alarm_type,uint8_t val){
 
     Res_UL_dBm[DET_Alarm_UL4_Index] 
         = bluecell_Currdatastatus.ULO_Level4_H << 8 | bluecell_Currdatastatus.ULO_Level4_L;//(int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,Det_UL4.Table_Length * 2));
-    
+
+
+ 
     switch(Alarm_type){
-        case Temperature_AlarmType:     sprintf(&Alarm_ReportData[20],"Temp:%2.1f, Th:%2.1f",bluecell_Currdatastatus.DET_TEMP,bluecell_Currdatastatus.Temp_High_Threshold);    break;
-        case DLI_P4_Level_LowType:      sprintf(&Alarm_ReportData[20],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL1_Index],LimitData_DL_Low);    break;
-        case DLI_P3_Level_LowType:      sprintf(&Alarm_ReportData[20],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL2_Index],LimitData_DL_Low);    break;
-        case DLI_P2_Level_LowType:      sprintf(&Alarm_ReportData[20],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL3_Index],LimitData_DL_Low);    break;
-        case DLI_P1_Level_LowType:      sprintf(&Alarm_ReportData[20],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL4_Index],LimitData_DL_Low);    break;
-        case DLI_P4_Level_HighType:     sprintf(&Alarm_ReportData[20],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL1_Index],LimitData_DL_High);    break;
-        case DLI_P3_Level_HighType:     sprintf(&Alarm_ReportData[20],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL2_Index],LimitData_DL_High);    break;
-        case DLI_P2_Level_HighType:     sprintf(&Alarm_ReportData[20],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL3_Index],LimitData_DL_High);    break;
-        case DLI_P1_Level_HighType:     sprintf(&Alarm_ReportData[20],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL4_Index],LimitData_DL_High);    break;
-        case DLI_P4_AGC_AlarmType:
-        case DLI_P3_AGC_AlarmType:
-        case DLI_P2_AGC_AlarmType:
-        case DLI_P1_AGC_AlarmType:      break;
-        case DLI_P4_Shutdown_AlarmType: sprintf(&Alarm_ReportData[20],OVERPOWER_STR);    break;
-        case DLI_P3_Shutdown_AlarmType: sprintf(&Alarm_ReportData[20],OVERPOWER_STR);    break;
-        case DLI_P2_Shutdown_AlarmType: sprintf(&Alarm_ReportData[20],OVERPOWER_STR);    break;
-        case DLI_P1_Shutdown_AlarmType: sprintf(&Alarm_ReportData[20],OVERPOWER_STR);    break;
-        case ULO_P4_Level_HighType:     sprintf(&Alarm_ReportData[20],"ULO:%2.1f, Th:%2.1f",Res_UL_dBm[DET_Alarm_UL1_Index],LimitData_UL_High);    break;
-        case ULO_P3_Level_HighType:     sprintf(&Alarm_ReportData[20],"ULO:%2.1f, Th:%2.1f",Res_UL_dBm[DET_Alarm_UL2_Index],LimitData_UL_High);    break;
-        case ULO_P2_Level_HighType:     sprintf(&Alarm_ReportData[20],"ULO:%2.1f, Th:%2.1f",Res_UL_dBm[DET_Alarm_UL3_Index],LimitData_UL_High);    break;
-        case ULO_P1_Level_HighType:     sprintf(&Alarm_ReportData[20],"ULO:%2.1f, Th:%2.1f",Res_UL_dBm[DET_Alarm_UL4_Index],LimitData_UL_High);    break;
-        case ULO_P4_ALC_AlarmType:
-        case ULO_P3_ALC_AlarmType:
-        case ULO_P2_ALC_AlarmType:
-        case ULO_P1_ALC_AlarmType:      break;
-        case ULO_P4_ShutdownType:       sprintf(&Alarm_ReportData[20],OVER_INPUT_STR);    break;
-        case ULO_P3_ShutdownType:       sprintf(&Alarm_ReportData[20],OVER_INPUT_STR);    break;
-        case ULO_P2_ShutdownType:       sprintf(&Alarm_ReportData[20],OVER_INPUT_STR);    break;
-        case ULO_P1_ShutdownType:       sprintf(&Alarm_ReportData[20],OVER_INPUT_STR);    break;
+        case Temp_High:             sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"Temp:%d, Th:%d",bluecell_Currdatastatus.DET_TEMP,bluecell_Currdatastatus.Temp_High_Threshold);    break;
+        case DLI_P4_Level_Low:      sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL1_Index],LimitData_DL_Low);    break;
+        case DLI_P3_Level_Low:      sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL2_Index],LimitData_DL_Low);    break;
+        case DLI_P2_Level_Low:      sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL3_Index],LimitData_DL_Low);    break;
+        case DLI_P1_Level_Low:      sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL4_Index],LimitData_DL_Low);    break;
+        case DLI_P4_Level_High:     sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL1_Index],LimitData_DL_High);    break;
+        case DLI_P3_Level_High:     sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL2_Index],LimitData_DL_High);    break;
+        case DLI_P2_Level_High:     sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL3_Index],LimitData_DL_High);    break;
+        case DLI_P1_Level_High:     sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"DLI:%2.1f, Th:%2.1f",Res_DL_dBm[DET_Alarm_DL4_Index],LimitData_DL_High);    break;
+        case DLI_P4_AGC_Alarm:
+        case DLI_P3_AGC_Alarm:
+        case DLI_P2_AGC_Alarm:
+        case DLI_P1_AGC_Alarm:      break;
+        case DLI_P4_Shutdown_Alarm: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVERPOWER_STR);    break;
+        case DLI_P3_Shutdown_Alarm: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVERPOWER_STR);    break;
+        case DLI_P2_Shutdown_Alarm: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVERPOWER_STR);    break;
+        case DLI_P1_Shutdown_Alarm: sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVERPOWER_STR);    break;
+        case ULO_P4_Level_High:     sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"ULO:%2.1f, Th:%2.1f",Res_UL_dBm[DET_Alarm_UL1_Index],LimitData_UL_High);    break;
+        case ULO_P3_Level_High:     sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"ULO:%2.1f, Th:%2.1f",Res_UL_dBm[DET_Alarm_UL2_Index],LimitData_UL_High);    break;
+        case ULO_P2_Level_High:     sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"ULO:%2.1f, Th:%2.1f",Res_UL_dBm[DET_Alarm_UL3_Index],LimitData_UL_High);    break;
+        case ULO_P1_Level_High:     sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],"ULO:%2.1f, Th:%2.1f",Res_UL_dBm[DET_Alarm_UL4_Index],LimitData_UL_High);    break;
+        case ULO_P4_ALC_Alarm:
+        case ULO_P3_ALC_Alarm:
+        case ULO_P2_ALC_Alarm:
+        case ULO_P1_ALC_Alarm:      break;
+        case ULO_P4_Shutdown:       sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVER_INPUT_STR);    break;
+        case ULO_P3_Shutdown:       sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVER_INPUT_STR);    break;
+        case ULO_P2_Shutdown:       sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVER_INPUT_STR);    break;
+        case ULO_P1_Shutdown:       sprintf(&Alarm_ReportData[MBIC_PAYLOADSTART + 22],OVER_INPUT_STR);    break;
+        default: printf("Wrong Type \r\n");break;
     }
     
-    Alarm_ReportData[MBIC_PAYLOADSTART + 1] = Alarm_type;    
-    Alarm_ReportData[MBIC_PAYLOADSTART + 2] = val;        
+//    Alarm_ReportData[MBIC_PAYLOADSTART + 1] = Alarm_type;    
+//    Alarm_ReportData[MBIC_PAYLOADSTART + 2] = val;        
+    
+    printf("%s \r\n",&Alarm_ReportData[MBIC_PAYLOADSTART + 22]);
+    printf("size length : %d \r\n",sizeof(Alarm_ReportData));
+//    MBIC_HeaderMergeFunction(Alarm_ReportData,42);
+    Alarm_ReportData[MBIC_PREAMBLE_0] = MBIC_PREAMBLE0;
+    Alarm_ReportData[MBIC_PREAMBLE_1] = MBIC_PREAMBLE1;
+    Alarm_ReportData[MBIC_PREAMBLE_2] = MBIC_PREAMBLE2;
+    Alarm_ReportData[MBIC_PREAMBLE_3] = MBIC_PREAMBLE3;   
+
+    Alarm_ReportData[MBIC_SUBUID_0] = MBIC_SUBUID0;
+    Alarm_ReportData[MBIC_SUBUID_1] = MBIC_SUBUID1;
+
+    Alarm_ReportData[MBIC_RCODE_0] = 0;
+
+    Alarm_ReportData[MBIC_TRID_0] = 0;
+    Alarm_ReportData[MBIC_TRID_1] = 0;
+
+    Alarm_ReportData[MBIC_SEQSUM_0] = 0;
+
+    Alarm_ReportData[MBIC_TTL_0] = 0;
+
+    Alarm_ReportData[MBIC_TIME_0] = 0;
+    Alarm_ReportData[MBIC_TIME_1] = 0;
+    Alarm_ReportData[MBIC_TIME_2] = 0;
+    Alarm_ReportData[MBIC_TIME_3] = 0;
+    Alarm_ReportData[MBIC_TIME_4] = 0;
+    Alarm_ReportData[MBIC_TIME_5] = 0;
+    Alarm_ReportData[MBIC_ERRRESPONSE_0] = MBIC_ERRRESPONSE;
+    Alarm_ReportData[MBIC_CMD_0] = 0xF1;
+
+
+
+
+
+    Alarm_ReportData[MBIC_LENGTH_0] = (sizeof(Alarm_ReportData) & 0xFF00) >> 8;
+    Alarm_ReportData[MBIC_LENGTH_1] = sizeof(Alarm_ReportData) & 0x00FF;
+
+    Alarm_ReportData[MBIC_HEADERCHECKSUM_0] = Chksum_Create(Alarm_ReportData);    
+
+    
+    uint16_t crcret = ((CRC16_Generate(&Alarm_ReportData[MBIC_PAYLOADSTART], 42) ) );
     
-    printf("%s \r\n",&Alarm_ReportData[20]);
-    MBIC_HeaderMergeFunction(Alarm_ReportData,40);
-    Alarm_ReportData[MBIC_HEADERCHECKSUM_0] = Chksum_Create(Alarm_ReportData);        
-    uint16_t crcret = ((CRC16_Generate(&Alarm_ReportData[MBIC_PAYLOADSTART], 40) ) );
 //                        printf("\r\n crc ret : %x \r\n",crcret);
-    Alarm_ReportData[MBIC_PAYLOADSTART + (Alarm_ReportData[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] ) + 5] =(( crcret  & 0xFF00)>> 8);  
-    Alarm_ReportData[MBIC_PAYLOADSTART + (Alarm_ReportData[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] ) + 6] = (( crcret  & 0x00FF));  
-    Alarm_ReportData[MBIC_PAYLOADSTART + (Alarm_ReportData[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] ) + 7] = 0x03; 
+    Alarm_ReportData[MBIC_PAYLOADSTART + 41] =(( crcret  & 0xFF00)>> 8);  
+    Alarm_ReportData[MBIC_PAYLOADSTART + 42] = (( crcret  & 0x00FF));  
+    Alarm_ReportData[MBIC_PAYLOADSTART + 43] = 0x03; 
     Uart1_Data_Send(Alarm_ReportData,sizeof(Alarm_ReportData));
 }
 
@@ -5463,7 +5717,7 @@ bool MBIC_Operate(uint8_t* data){
                     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  ;                      
                 }
-            
+                printf("data ctrl\r\n");
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
                 break;
@@ -5527,6 +5781,7 @@ bool MBIC_Operate(uint8_t* data){
                 break;
             case ULO_SelfTest4:
                 SelfTest_Ctrl(SelfTest4,data[MBIC_PAYLOADSTART + 3],&bluecell_Currdatastatus.Selftest4,&bluecell_Currdatastatus.ATT_DL4_H,&bluecell_Currdatastatus.ATT_UL4_H);
+                printf("UL SelfTest \r\n");
                 break;
             case  ULO_ALC_ON_OFF                   :
                 bluecell_Currdatastatus.ULO_ALC_ON_OFF = data[MBIC_PAYLOADSTART + 3]; 
@@ -8934,13 +9189,16 @@ void SelfTest_Ctrl(uint8_t num,uint8_t val,uint8_t* selftest,uint8_t* DL_Atten,u
         Pin =  PATH_SW4_Pin;        
         break;        
     }
-
+    if(*selftest == val)
+        return;
         
     if(val == true){
         Selftest_DL_PrevAttenSave[num * 2]         = DL_Atten[Atten_H];
         Selftest_DL_PrevAttenSave[((num * 2) + 1)] = DL_Atten[Atten_L];
         Selftest_UL_PrevAttenSave[num * 2]         = UL_Atten[Atten_H];
         Selftest_UL_PrevAttenSave[((num * 2) + 1)] = UL_Atten[Atten_L];
+//        for(int i =0; i< 8; i++)
+//            printf("Selftest_UL_PrevAttenSave[%d] : %x \r\n",i,Selftest_UL_PrevAttenSave[i]);        
         DL_Atten[Atten_H] = 0;
         DL_Atten[Atten_L] = 0;
         UL_Atten[Atten_H] = 0;
@@ -8951,7 +9209,10 @@ void SelfTest_Ctrl(uint8_t num,uint8_t val,uint8_t* selftest,uint8_t* DL_Atten,u
         DL_Atten[Atten_H] = Selftest_DL_PrevAttenSave[num * 2];
         DL_Atten[Atten_L] = Selftest_DL_PrevAttenSave[((num * 2) + 1)];    
         UL_Atten[Atten_H] = Selftest_UL_PrevAttenSave[num * 2];
-        UL_Atten[Atten_L] = Selftest_UL_PrevAttenSave[((num * 2) + 1)];              
+        UL_Atten[Atten_L] = Selftest_UL_PrevAttenSave[((num * 2) + 1)];    
+//        for(int i =0; i< 8; i++)
+//            printf("Selftest_UL_PrevAttenSave[%d] : %x \r\n",i,Selftest_UL_PrevAttenSave[i]);        
+
         HAL_GPIO_WritePin(_Port,_Pin,GPIO_PIN_RESET);//CLOCK
         HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK
     }
@@ -8996,6 +9257,7 @@ void FRBT_Operate(){
 }
 void LED_Alarm_Check(){
     if(bluecell_Currdatastatus.ALARM_TESTMODE == false){
+#if 0 // PYJ.2020.08.18_BEGIN -- 
       if(  (bluecell_Currdatastatus.ALARM_TEMP_HIGH      > 0 && bluecell_Currdatastatus.ALARM_MASK1 != false) 
         || (bluecell_Currdatastatus.ALARM_DLI_Level      > 0 && bluecell_Currdatastatus.ALARM_MASK2 != false)
         || (bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN  > 0 && bluecell_Currdatastatus.ALARM_MASK3 != false)
@@ -9017,6 +9279,21 @@ void LED_Alarm_Check(){
     //            printf("=================AlarmTimerOffCnt=================\r\n");
     //        }
         }
+#else
+          if(  (bluecell_Currdatastatus.ALARM_TEMP_HIGH      > 0 && bluecell_Currdatastatus.ALARM_MASK1 != false) 
+            || (bluecell_Currdatastatus.ALARM_DLI_Level      > 0 && bluecell_Currdatastatus.ALARM_MASK2 != false)
+            || (bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN  > 0 && bluecell_Currdatastatus.ALARM_MASK3 != false)
+            || (bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm  > 0 && bluecell_Currdatastatus.ALARM_MASK3 != false)
+            || (bluecell_Currdatastatus.ALARM_ULO_Level      > 0 && bluecell_Currdatastatus.ALARM_MASK4 != false)
+            || (bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm  > 0 && bluecell_Currdatastatus.ALARM_MASK5 != false)
+            || (bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN  > 0 && bluecell_Currdatastatus.ALARM_MASK5 != false))
+            {
+                    Alarm_LED_OnSet  = true;
+            }else{
+                    Alarm_LED_OnSet = false;
+            }
+
+#endif // PYJ.2020.08.18_END -- 
     }
     else{
         if(bluecell_Currdatastatus.ALARM_Test_Dummy1         > 0 
@@ -9050,3 +9327,96 @@ void Alarm_Check(){
     DLI_LevelAlarmCheck();
     ULO_LevelAlarmCheck();
 }
+
+typedef struct{
+    uint8_t Temperature_Status ;
+    uint8_t DLI_Path4_Low ;
+    uint8_t DLI_Path3_Low ;
+    uint8_t DLI_Path2_Low ;
+    uint8_t DLI_Path1_Low ;    
+
+    uint8_t DLI_Path4_High ;
+    uint8_t DLI_Path3_High ;
+    uint8_t DLI_Path2_High ;
+    uint8_t DLI_Path1_High ;    
+
+    uint8_t DLI_Path1_AGC ;    
+    uint8_t DLI_Path2_AGC ;    
+    uint8_t DLI_Path3_AGC ;    
+    uint8_t DLI_Path4_AGC ;    
+    uint8_t DLI_Path1_Shutdown ;    
+    uint8_t DLI_Path2_Shutdown ;    
+    uint8_t DLI_Path3_Shutdown ;    
+    uint8_t DLI_Path4_Shutdown ;    
+
+    uint8_t ULO_Path4_High ;
+    uint8_t ULO_Path3_High ;
+    uint8_t ULO_Path2_High ;
+    uint8_t ULO_Path1_High ;    
+
+    uint8_t ULO_Path1_ALC ;    
+    uint8_t ULO_Path2_ALC ;    
+    uint8_t ULO_Path3_ALC ;    
+    uint8_t ULO_Path4_ALC ;    
+    uint8_t ULO_Path1_Shutdown ;    
+    uint8_t ULO_Path2_Shutdown ;    
+    uint8_t ULO_Path3_Shutdown ;    
+    uint8_t ULO_Path4_Shutdown ;    
+}Alarm_Report_t;
+Alarm_Report_t Curr_Alarm_Status_Save;
+
+void Alarm_Compare(uint8_t* Prev_Data,uint8_t* Curr_data,uint16_t mode,uint8_t flag){
+
+    if(*Prev_Data != *Curr_data){
+//        printf("Data Report Occur !!\r\n");
+        if(*Curr_data & flag){
+            Alarm_Report_Send(mode,true);
+        }
+        else{
+            Alarm_Report_Send(mode,false);
+        }
+    }
+     *Prev_Data = *Curr_data;
+
+}
+void AlarmLog_Report(){
+    
+    Alarm_Compare(&Curr_Alarm_Status_Save.Temperature_Status,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x80);
+
+#if 1 // PYJ.2020.08.18_BEGIN -- 
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_Low,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x80);
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path3_Low,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x40);
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path2_Low,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x20);
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path1_Low,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x10);
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_High,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x08);    
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_High,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x04);
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_High,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x02);
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_High,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x01);
+
+
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path1_AGC,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x80);
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path2_AGC,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x40);
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path3_AGC,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x20);
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_AGC,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x10);
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path1_Shutdown,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x08);
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path2_Shutdown,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x04);
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path3_Shutdown,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x02);
+    Alarm_Compare(&Curr_Alarm_Status_Save.DLI_Path4_Shutdown,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x01);
+
+    Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path1_High,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x08);
+    Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path2_High,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x04);
+    Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path3_High,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x02);
+    Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path4_High,&bluecell_Currdatastatus.ALARM_TEMP_HIGH,Temp_High,0x01);
+
+    Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path1_ALC,&bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm,Temp_High,0x80);
+    Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path2_ALC,&bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm,Temp_High,0x40);
+    Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path3_ALC,&bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm,Temp_High,0x20);
+    Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path4_ALC,&bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm,Temp_High,0x10);
+
+    Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path1_Shutdown,&bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN,Temp_High,0x08);
+    Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path2_Shutdown,&bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN,Temp_High,0x04);
+    Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path3_Shutdown,&bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN,Temp_High,0x02);
+    Alarm_Compare(&Curr_Alarm_Status_Save.ULO_Path4_Shutdown,&bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN,Temp_High,0x01);
+#endif // PYJ.2020.08.18_END -- 
+
+}

Bluecell_Src/MBIC_Bootloader.c

@@ -243,6 +243,11 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
             printf("MBIC DOWNLOAD REQUEST \r\n");
             cmd = MBIC_Notice_RSP;
             CRCERR = false;
+            bluecell_Currdatastatus.MBIC_Download_Auto_Restart_Set 
+                = Download_Option 
+                = data[MBIC_PAYLOADSTART + 4];
+            printf("bluecell_Currdatastatus.MBIC_Download_Auto_Restart_Set  : %d \r\n",bluecell_Currdatastatus.MBIC_Download_Auto_Restart_Set );
+            
             /*TOTAL FRAME NUMBER*/
             data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 0];
             data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 1];        
@@ -250,9 +255,13 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
             data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 3];        
             /*DOWNLOAD OPTION*/        
             data[MBIC_PAYLOADSTART + index++] = 1;
-            bluecell_Currdatastatus.MBIC_Download_Auto_Restart_Set 
-                = Download_Option 
-                = data[MBIC_PAYLOADSTART + 4];
+//            data[MBIC_PAYLOADSTART + index++] = 0;//data[MBIC_PAYLOADSTART + 4];
+//            for(int i =0; i < 33; i++)
+//                printf("%x ",data[i]);
+//            printf("\r\n");
+            
+
+            
             /*DOWNLOAD DELAY REQUEST*/
             data[MBIC_PAYLOADSTART + index++] = 3;
             /*DOWNLOAD Reserve*/
@@ -274,6 +283,16 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
                 for(int i = 0; i < 41; i++)
                     pdata[i] = 0xFF;  
               }           
+            if(bluecell_Currdatastatus.MBIC_Download_Auto_Restart_Set != false){
+//                printf("MBIC_Download_Auto_Restart_Set == true\r\n");
+                if(bluecell_Currdatastatus.CPU_Current_Bank == HFR_BANK1_SEL){
+                    bluecell_Currdatastatus.CPU_Bank_Select = HFR_BANK2_SEL;
+//                    printf("Download Bank sel = Bank 2 \r\n");
+                }else{
+                    bluecell_Currdatastatus.CPU_Bank_Select = HFR_BANK1_SEL;
+//                    printf("Download Bank sel = Bank 1 \r\n");            
+                }
+            }              
 //            MBIC_DataBankWrite(1);
             //if()
 //            MBIC_DataErase_Func(bluecell_Currdatastatus.CPU_Bank_Select);
@@ -468,16 +487,7 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
             bluecell_Currdatastatus.CPU_Bank2_Image_Version1 = Bank2data[MBIC_BOOT_VERSION + 0];
             bluecell_Currdatastatus.CPU_Bank2_Image_Version2 = Bank2data[MBIC_BOOT_VERSION + 1];
             bluecell_Currdatastatus.CPU_Bank2_Image_Version3 = Bank2data[MBIC_BOOT_VERSION + 2];
-            if(bluecell_Currdatastatus.MBIC_Download_Auto_Restart_Set == true){
-                printf("MBIC_Download_Auto_Restart_Set == true\r\n");
-                if(bluecell_Currdatastatus.CPU_Current_Bank == HFR_BANK1_SEL){
-                    bluecell_Currdatastatus.CPU_Bank_Select = HFR_BANK2_SEL;
-                    printf("Download Bank sel = Bank 2 \r\n");
-                }else{
-                    bluecell_Currdatastatus.CPU_Bank_Select = HFR_BANK1_SEL;
-                    printf("Download Bank sel = Bank 1 \r\n");            
-                }
-            }
+
 
 
 //          if(BankNum == HFR_BANK1){
@@ -523,13 +533,13 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
     MBIC_Resp[(DataLength - 1) - 2] = (Crcret & 0xFF00) >> 8;  
     MBIC_Resp[(DataLength - 1) - 1] = (Crcret & 0x00FF);       
     
-    
     Uart1_Data_Send(MBIC_Resp ,22 + 3 + index);
     if( cmd == MBIC_Complete_Notice_RSP
-        &&bluecell_Currdatastatus.MBIC_Download_Auto_Restart_Set != false){
+        &&bluecell_Currdatastatus.MBIC_Download_Auto_Restart_Set != false)
+    {
+        printf("Reset Start \r\n");
         HAL_Delay(100);
         NVIC_SystemReset();
     }
-
     MBIC_DataErase_Func(BankNum);
 }

Bluecell_Src/uart.c

@@ -155,7 +155,7 @@ void Uart1_Data_Send(uint8_t* data,uint16_t size){
   //HAL_UART_Transmit_IT(&hTerminal, &data[0],size);
 //    printf("data[278] : %x \r\n",data[278]);
 ////    HAL_Delay(1);   
-#if 0 // PYJ.2020.07.19_BEGIN -- 
+#if 1 // PYJ.2020.07.19_BEGIN -- 
     printf("\r\n [TX] : ");
     for(int i = 0; i< size; i++)
         printf("%02x ",data[i]);

Src/main.c

@@ -272,7 +272,7 @@ uint8_t MBICTest_Firmdata[8]  = {1,2,3,4,5,6,7,8};
   * @retval int
   */
 int main(void)
-{
+  {
   /* USER CODE BEGIN 1 */
 
 
@@ -358,6 +358,7 @@ int main(void)
     Alarm_Check();     /*Function to check all alarm status variables*/
     FRBT_Operate();
     SelfTestTimer_Operate();
+    AlarmLog_Report();
     HAL_IWDG_Refresh(&hiwdg);
 #if 0 // PYJ.2020.08.11_BEGIN -- 
       for(int i = 0; i < ADC1_CNT; i++){