ADC bluecell 알고리즘 적용

Bluecell_Src/Bluecell_operate.c

@@ -44,8 +44,10 @@ extern volatile uint32_t DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL_In
 extern volatile uint32_t DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL_Index_MAX] ;
 
 extern ALL_PE43711_st ALL_ATT;
-//extern volatile uint16_t ADC1valuearray[4][ADC_AVERAGECNT];
-//extern volatile uint16_t ADC3valuearray[5][ADC_AVERAGECNT];
+extern volatile uint16_t ADC1valuearray[4][ADC_AVERAGECNT];
+extern volatile uint16_t ADC3valuearray[5][ADC_AVERAGECNT];
+extern volatile uint16_t ADC1Desc_valuearray[4][ADC_AVERAGECNT];
+extern volatile uint16_t ADC3Desc_valuearray[5][ADC_AVERAGECNT];
 
 extern volatile uint32_t LedTimerCnt;
 extern volatile uint32_t AdcTimerCnt;
@@ -2068,6 +2070,11 @@ bool Bluecell_Operate(uint8_t* data){
 //       printf("DL PATH 1 : %d \r\n",data[BLUECELL_DATA]);
        if(bluecell_Currdatastatus.Carrier_ON_OFF == false)
               return true;
+       if(data[MBIC_PAYLOADSTART] != 0)
+           bluecell_Currdatastatus.Path_TempSave_Bit = 0x80;
+       else
+          bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x80;
+
 
        DL_Path_OnOff(Path1_OnOff,
             data[BLUECELL_DATA],
@@ -2096,6 +2103,10 @@ bool Bluecell_Operate(uint8_t* data){
 #else
         if(bluecell_Currdatastatus.Carrier_ON_OFF == false)
                return true;
+        if(data[MBIC_PAYLOADSTART] != 0)
+            bluecell_Currdatastatus.Path_TempSave_Bit = 0x08;
+        else
+           bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x08;
 
         UL_Path_OnOff(Path1_OnOff,
              data[BLUECELL_DATA],
@@ -2163,6 +2174,10 @@ bool Bluecell_Operate(uint8_t* data){
 #else
         if(bluecell_Currdatastatus.Carrier_ON_OFF == false)
           return true;
+        if(data[MBIC_PAYLOADSTART] != 0)
+            bluecell_Currdatastatus.Path_TempSave_Bit = 0x40;
+        else
+           bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x40;
 
         DL_Path_OnOff(Path2_OnOff,
              data[BLUECELL_DATA],
@@ -2194,6 +2209,10 @@ bool Bluecell_Operate(uint8_t* data){
 #else
         if(bluecell_Currdatastatus.Carrier_ON_OFF == false)
           return true;
+        if(data[MBIC_PAYLOADSTART] != 0)
+            bluecell_Currdatastatus.Path_TempSave_Bit = 0x04;
+        else
+           bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x04;
 
         UL_Path_OnOff(Path2_OnOff,
              data[BLUECELL_DATA],
@@ -2239,6 +2258,10 @@ bool Bluecell_Operate(uint8_t* data){
 #else
         if(bluecell_Currdatastatus.Carrier_ON_OFF == false)
           return true;
+        if(data[MBIC_PAYLOADSTART] != 0)
+            bluecell_Currdatastatus.Path_TempSave_Bit = 0x20;
+        else
+           bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x20;
 
         DL_Path_OnOff(Path3_OnOff,
              data[BLUECELL_DATA],
@@ -2266,6 +2289,10 @@ bool Bluecell_Operate(uint8_t* data){
 #else
         if(bluecell_Currdatastatus.Carrier_ON_OFF == false)
           return true;
+        if(data[MBIC_PAYLOADSTART] != 0)
+            bluecell_Currdatastatus.Path_TempSave_Bit = 0x02;
+        else
+           bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x02;
 
         UL_Path_OnOff(Path3_OnOff,
              data[BLUECELL_DATA],
@@ -2310,6 +2337,10 @@ bool Bluecell_Operate(uint8_t* data){
 #else
         if(bluecell_Currdatastatus.Carrier_ON_OFF == false)
           return true;
+        if(data[MBIC_PAYLOADSTART] != 0)
+            bluecell_Currdatastatus.Path_TempSave_Bit = 0x10;
+        else
+           bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x10;
 
         DL_Path_OnOff(Path4_OnOff,
              data[BLUECELL_DATA],
@@ -2340,6 +2371,10 @@ bool Bluecell_Operate(uint8_t* data){
 #else
         if(bluecell_Currdatastatus.Carrier_ON_OFF == false)
           return true;
+        if(data[MBIC_PAYLOADSTART] != 0)
+            bluecell_Currdatastatus.Path_TempSave_Bit = 0x01;
+        else
+           bluecell_Currdatastatus.Path_TempSave_Bit &= ~0x01;
 
         UL_Path_OnOff(Path4_OnOff,
              data[BLUECELL_DATA],
@@ -2987,7 +3022,7 @@ bool Bluecell_Operate(uint8_t* data){
     case Bluecell_CarrierOnOff:
         bluecell_Currdatastatus.Carrier_ON_OFF = data[BLUECELL_DATA + i++]; 
         Carrier_ONOFF(bluecell_Currdatastatus.Carrier_ON_OFF);
-//        printf("Carrier %d \r\n",bluecell_Currdatastatus.Carrier_ON_OFF);
+        printf("Carrier %d \r\n",bluecell_Currdatastatus.Carrier_ON_OFF);
     break;
     case Bluecell_PCBVersionSet:
 //        printf("Bluecell_PCBVersionSet\r\n");
@@ -3031,7 +3066,7 @@ bool Bluecell_Operate(uint8_t* data){
 //        printf("Bluecell_UL_Det_Path4_Offset : %d \r\n",bluecell_Currdatastatus.UL_Det_Path_Offset[3]);        
         break;
     case Bluecell_Temp_Shutdown_Path_ON_OFF:
-         bluecell_Prevdatastatus.Path_TempShutdown_Set = data[MBIC_PAYLOADSTART + 3];
+         bluecell_Currdatastatus.Path_TempShutdown_Set = data[BLUECELL_DATA];
          Temp_Shutdown_ONOFF(bluecell_Prevdatastatus.Path_TempShutdown_Set);
         break;
   }
@@ -3039,10 +3074,15 @@ bool Bluecell_Operate(uint8_t* data){
   if(datatype != Bluecell_StatusReq
   && datatype != Bluecell_LED_TEST
   && datatype != ATT_TableSet
-  && datatype != ATT_TableGet)
+  && datatype != ATT_TableGet
+  && datatype != Bluecell_Temp_Shutdown_Path_ON_OFF)
+  
   {
-      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));
+//      Bluecell_StructCpy(&DataWrite[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
+      
+      EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS),&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);
@@ -3113,42 +3153,42 @@ void HFR_TypeInit(){
         PrevMBIC_DL_ShutdownCount[i] = 0xFF;        
     }
 #if 1 // PYJ.2020.06.17_BEGIN -- 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x80)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x80)
         bluecell_Currdatastatus.ATT_DL1_PATH = true;
     else
         bluecell_Currdatastatus.ATT_DL1_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x40)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x40)
         bluecell_Currdatastatus.ATT_DL2_PATH = true;
     else
         bluecell_Currdatastatus.ATT_DL2_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x20)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x20)
         bluecell_Currdatastatus.ATT_DL3_PATH = true;
     else
         bluecell_Currdatastatus.ATT_DL3_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x10)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x10)
         bluecell_Currdatastatus.ATT_DL4_PATH = true;
     else
         bluecell_Currdatastatus.ATT_DL4_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x08)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x08)
         bluecell_Currdatastatus.ATT_UL1_PATH = true;
     else
         bluecell_Currdatastatus.ATT_UL1_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x04)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x04)
         bluecell_Currdatastatus.ATT_UL2_PATH = true;
     else
         bluecell_Currdatastatus.ATT_UL2_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x02)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x02)
         bluecell_Currdatastatus.ATT_UL3_PATH = true;
     else
         bluecell_Currdatastatus.ATT_UL3_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x01)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x01)
         bluecell_Currdatastatus.ATT_UL4_PATH = true;
     else
         bluecell_Currdatastatus.ATT_UL4_PATH = false;
@@ -4389,6 +4429,7 @@ void Carrier_ONOFF(uint8_t val){
         bluecell_Currdatastatus.ATT_UL2_PATH = PATH_DEFAULT;    
         bluecell_Currdatastatus.ATT_UL3_PATH = PATH_DEFAULT;    
         bluecell_Currdatastatus.ATT_UL4_PATH = PATH_DEFAULT;   
+        bluecell_Currdatastatus.Path_TempSave_Bit = 0xFF;
         DL_Path_OnOff(Path1_OnOff,
              true,
              &bluecell_Currdatastatus.ATT_DL1_PATH,
@@ -4452,6 +4493,7 @@ void Carrier_ONOFF(uint8_t val){
         bluecell_Currdatastatus.ATT_UL2_PATH = false;    
         bluecell_Currdatastatus.ATT_UL3_PATH = false;    
         bluecell_Currdatastatus.ATT_UL4_PATH = false; 
+        bluecell_Currdatastatus.Path_TempSave_Bit = 0x00;        
         DL_Path_OnOff(Path1_OnOff,
              false,
              &bluecell_Currdatastatus.ATT_DL1_PATH,
@@ -4654,6 +4696,204 @@ 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 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++] = 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;    
+
+    
+    for(int i = 20; i < 40; i++)
+        Alarm_ReportData[i] = 0;
+    
+ 
+
+    int16_t LimitData_UL_High = 0;
+    
+    int16_t LimitData_DL_High = 0;    
+    int16_t LimitData_DL_Low = 0;    
+
+
+    int16_t LimitData_DL_Shutdown = 0;    
+    int16_t LimitData_UL_Shutdown = 0;    
+    
+    double ret = 0;
+    int16_t Res_DL_dBm[DET_Alarm_DL_Index_MAX] = {0,};
+    int16_t Res_UL_dBm[DET_Alarm_UL_Index_MAX] = {0,};    
+    
+
+    LimitData_UL_High = ConvertTo2byte(bluecell_Currdatastatus.ULO_Level_High_Threshold_H,bluecell_Currdatastatus.ULO_Level_High_Threshold_L) * 0.1;
+    LimitData_DL_High = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level_High_Threshold_H,bluecell_Currdatastatus.DLI_Level_High_Threshold_L)* 0.1;
+    LimitData_DL_Low  = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level_Low_Threshold_H,bluecell_Currdatastatus.DLI_Level_Low_Threshold_L)* 0.1;
+
+    LimitData_DL_Shutdown = ConvertTo2byte(bluecell_Currdatastatus.DLI_Shutdown_Threshold_H,bluecell_Currdatastatus.DLI_Shutdown_Threshold_L)* 0.1;
+    LimitData_UL_Shutdown = ConvertTo2byte(bluecell_Currdatastatus.ULO_Shutdown_Threshold_H,bluecell_Currdatastatus.ULO_Shutdown_Threshold_L)* 0.1;
+    
+
+    ret  = bluecell_Currdatastatus.DLI_P1_Level1_H << 8;
+    ret += bluecell_Currdatastatus.DLI_P1_Level1_L;   
+    ret *= 0.001;    
+    Res_DL_dBm[DET_Alarm_DL1_Index] 
+        = bluecell_Currdatastatus.DLI_Level1_H << 8 | bluecell_Currdatastatus.DLI_Level1_L;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)));
+    ret  = bluecell_Currdatastatus.DLI_P2_Level2_H << 8;
+    ret += bluecell_Currdatastatus.DLI_P2_Level2_L;   
+    ret *= 0.001;  
+
+    Res_DL_dBm[DET_Alarm_DL2_Index] 
+        = bluecell_Currdatastatus.DLI_Level2_H << 8 | bluecell_Currdatastatus.DLI_Level2_L;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)));
+    ret  = bluecell_Currdatastatus.DLI_P3_Level3_H << 8;
+    ret += bluecell_Currdatastatus.DLI_P3_Level3_L;   
+    ret *= 0.001;  
+
+    Res_DL_dBm[DET_Alarm_DL3_Index] 
+        = bluecell_Currdatastatus.DLI_Level3_H << 8 | bluecell_Currdatastatus.DLI_Level3_L;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)));
+
+
+    ret  = bluecell_Currdatastatus.DLI_P4_Level4_H << 8;
+    ret += bluecell_Currdatastatus.DLI_P4_Level4_L;   
+    ret *= 0.001;  
+
+    Res_DL_dBm[DET_Alarm_DL4_Index] 
+        = bluecell_Currdatastatus.DLI_Level4_H << 8 | bluecell_Currdatastatus.DLI_Level4_L;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)));
+
+
+
+    ret  = bluecell_Currdatastatus.ULO_P1_Level1_H << 8;
+    ret += bluecell_Currdatastatus.ULO_P1_Level1_L;   
+    ret *= 0.001;
+
+    Res_UL_dBm[DET_Alarm_UL1_Index] 
+        = bluecell_Currdatastatus.ULO_Level1_H << 8 | bluecell_Currdatastatus.ULO_Level1_L; //(int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,Det_UL1.Table_Length * 2));
+
+
+    ret  = bluecell_Currdatastatus.ULO_P2_Level2_H << 8;
+    ret += bluecell_Currdatastatus.ULO_P2_Level2_L;   
+    ret *= 0.001;
+
+    Res_UL_dBm[DET_Alarm_UL2_Index] 
+        = bluecell_Currdatastatus.ULO_Level2_H << 8 | bluecell_Currdatastatus.ULO_Level2_L;//(int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL2.Table_Det_15_dBm_H,Det_UL2.Table_Length * 2));
+
+    ret  = bluecell_Currdatastatus.ULO_P3_Level3_H << 8;
+    ret += bluecell_Currdatastatus.ULO_P3_Level3_L;   
+    ret *= 0.001;
+
+    Res_UL_dBm[DET_Alarm_UL3_Index] 
+        = bluecell_Currdatastatus.ULO_Level3_H << 8 | bluecell_Currdatastatus.ULO_Level3_L;//(int8_t)Bluecell_TestPro(AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,Det_UL3.Table_Length * 2));
+
+
+    ret  = bluecell_Currdatastatus.ULO_P4_Level4_H << 8;
+    ret += bluecell_Currdatastatus.ULO_P4_Level4_L;   
+    ret *= 0.001;
+
+    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;
+    }
+    
+    Alarm_ReportData[MBIC_PAYLOADSTART + 1] = Alarm_type;    
+    Alarm_ReportData[MBIC_PAYLOADSTART + 2] = val;        
+    
+    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; 
+
+    Uart1_Data_Send(Alarm_ReportData,sizeof(Alarm_ReportData));
+
+    
+    
+
 }
 
 bool MBIC_Operate(uint8_t* data){
@@ -4822,8 +5062,8 @@ bool MBIC_Operate(uint8_t* data){
                     bluecell_Currdatastatus.Manufacture_Date[i] = data[MBIC_PAYLOADSTART + 3 + i]; 
                 break;
             case Temp_Shutdown_Path_ON_OFF:
-                bluecell_Prevdatastatus.Path_TempShutdown_Set = data[MBIC_PAYLOADSTART + 3];
-                Temp_Shutdown_ONOFF(bluecell_Prevdatastatus.Path_TempShutdown_Set);
+                bluecell_Currdatastatus.Path_TempShutdown_Set = data[MBIC_PAYLOADSTART + 3];
+                Temp_Shutdown_ONOFF(bluecell_Currdatastatus.Path_TempShutdown_Set);
                 break;
             case  Carrier_ON_OFF                          :
                 bluecell_Currdatastatus.Carrier_ON_OFF = data[MBIC_PAYLOADSTART + 3]; 
@@ -5449,14 +5689,16 @@ uint16_t Descendingcompare(const void *a, const void *b)    // 내림차순 비
     
     return 0;           // a와 b가 같을 때는 0 반환
 }
-void DascendigFunc(uint16_t* data,uint32_t size ){
+void DascendigFunc(uint16_t* src,uint32_t size ){
   int temp;
+
+  
   for(int i = 0 ; i < size - 1 ; i ++) {
       for(int j = i+1 ; j < size ; j ++) {
-	  if(data[i] < data[j]) {
-              temp = data[j];
-              data[j] = data[i];
-              data[i] = temp;
+	  if(src[i] < src[j]) {
+              temp = src[j];
+              src[j] = src[i];
+              src[i] = temp;
         }
       }
   }
@@ -6477,8 +6719,9 @@ void ADC_Sampling_Func(uint8_t mode,uint16_t Timer2ms_AdcValue,uint8_t index){
 
 
 #endif // PYJ.2020.08.07_END -- 
+#if 0 // PYJ.2020.08.12_BEGIN -- 
 void ADC_Check(void){
-#if 0 // PYJ.2020.08.07_BEGIN -- 
+#if 1 // PYJ.2020.08.07_BEGIN -- 
     //static uint8_t Cnt = 0;
    double ADC1DoubleRet[4];
    double ADC3DoubleRet[5];
@@ -6497,8 +6740,8 @@ void ADC_Check(void){
 //        printf("%d\r\n",ADC_100ms_Cnt);
 //    }
 
-//    if(adc3cnt >= ADC_AVERAGECNT){
-    if(ADC_100ms_Cnt >= 100){
+    if(adc3cnt >= ADC_AVERAGECNT){
+//    if(ADC_100ms_Cnt >= 100){
         ADC_100ms_Cnt = 0;
         printf("adc3cnt : %d \r\n",adc3cnt);
 #if 1 // PYJ.2020.05.25_BEGIN -- 
@@ -6746,6 +6989,176 @@ void ADC_Check(void){
 
     DET_LevelAlarmCheck();/*DL UL Alarm Check*/
 }
+#else
+#define Percent      2
+#define Percent100 10
+void ADC_Check(void){
+#if 1 // PYJ.2020.08.07_BEGIN -- 
+    //static uint8_t Cnt = 0;
+   double ADC1DoubleRet[4];
+   double ADC3DoubleRet[5];
+   uint32_t ADC1_Average_value[ADC1_CNT];
+   static uint32_t HFR_ADC1_Average_value[ADC1_CNT];
+   uint32_t ADC3_Average_value[ADC3_CNT];
+
+   // double ret = 0;
+    uint16_t MIN_ADC[ADC3_CNT] = {0,};
+    uint16_t cnt[ADC3_CNT] = {0,};
+    double temp;
+    
+//    if(AdcTimerCnt > 10){
+    // 정렬할 배열, 요소 개수, 요소 크기, 비교 함수를 넣어줌
+//
+    if(ADC_100ms_Cnt >= 100){
+#if 1 // PYJ.2020.05.25_BEGIN -- 
+    for(int i = 0; i < ADC3_CNT; i++){
+        for(int index = 0; index < 100; index++){
+            ADC3Desc_valuearray[i][index] = ADC3valuearray[i][index];
+        }
+        DascendigFunc(&ADC3Desc_valuearray[i][0],ADC_AVERAGECNT);
+            
+        ADC3_Average_value[i] = SumFunc(&ADC3Desc_valuearray[i][0],Percent100);
+
+        ADC3_Average_value[i] /=Percent100;
+       
+        if(Total_SamplingCnt == HFR_REQUSET_TOTAL_CNT - 1){
+            ArrayMoveBack(&Adc3_HFR_Array[i][0],HFR_REQUSET_TOTAL_CNT);
+            Adc3_HFR_Array[i][Total_SamplingCnt] = ADC3_Average_value[i]; 
+             for(int index = 0; index <6; index++){
+                 Adc3_HFR_Desc_Array[i][index] = Adc3_HFR_Array[i][index] ;
+             }                  
+            
+
+             DascendigFunc(&Adc3_HFR_Desc_Array[i][0],6);
+             ADC3_Average_value[i] = 0;
+             
+            for(int index = 0; index <Percent; index++)
+                 ADC3_Average_value[i] += Adc3_HFR_Desc_Array[i][index];
+            
+            ADC3_Average_value[i] /= Percent;                
+            
+        }
+        else{
+            Adc3_HFR_Array[i][Total_SamplingCnt] = ADC3_Average_value[i];
+        }
+
+        ADC3DoubleRet[i] = (((ADC3_Average_value[i] ) * 3.3 /4096) * 1000);
+        ADC3Ret[i] = ADC3DoubleRet[i];
+        ADC3_Average_value[i] = 0;
+    }
+    bluecell_Currdatastatus.DLI_P1_Level1_H 
+        = ((ADC3Ret[1] & 0xFF00) >> 8);
+    bluecell_Currdatastatus.DLI_P1_Level1_L 
+        = ((ADC3Ret[1] & 0x00FF));
+    
+
+    bluecell_Currdatastatus.DLI_P2_Level2_H 
+        = ((ADC3Ret[2] & 0xFF00) >> 8);
+    bluecell_Currdatastatus.DLI_P2_Level2_L 
+        = ((ADC3Ret[2] & 0x00FF) );
+
+        
+    bluecell_Currdatastatus.DLI_P3_Level3_H 
+        = ((ADC3Ret[3] & 0xFF00) >> 8);
+    bluecell_Currdatastatus.DLI_P3_Level3_L 
+        = ((ADC3Ret[3] & 0x00FF) );
+
+        
+    bluecell_Currdatastatus.DLI_P4_Level4_H 
+        = ((ADC3Ret[4] & 0xFF00) >> 8);
+    bluecell_Currdatastatus.DLI_P4_Level4_L 
+        = ((ADC3Ret[4] & 0x00FF) );
+
+        
+    bluecell_Currdatastatus.ULO_P4_Level4_H 
+        = ((ADC3Ret[0] & 0xFF00) >> 8);
+    bluecell_Currdatastatus.ULO_P4_Level4_L 
+        = ((ADC3Ret[0] & 0x00FF) );
+#endif // PYJ.2020.05.25_END -- 
+        adc3cnt = 0;
+
+    for(int i = 0; i < ADC1_CNT; i++){
+        for(int index = 0; index < 100; index++){
+            ADC1Desc_valuearray[i][index] = ADC1valuearray[i][index];
+        }
+        DascendigFunc(&ADC1Desc_valuearray[i][0],ADC_AVERAGECNT);
+            
+        ADC1_Average_value[i] = SumFunc(&ADC1Desc_valuearray[i][0],Percent);
+
+        ADC1_Average_value[i] /=Percent;
+       
+        if(Total_SamplingCnt == HFR_REQUSET_TOTAL_CNT - 1){
+            ArrayMoveBack(&Adc1_HFR_Array[i][0],HFR_REQUSET_TOTAL_CNT);
+            Adc1_HFR_Array[i][Total_SamplingCnt] = ADC1_Average_value[i]; 
+             for(int index = 0; index <6; index++){
+                 Adc1_HFR_Desc_Array[i][index] = Adc1_HFR_Array[i][index] ;
+             }                  
+            
+
+             DascendigFunc(&Adc1_HFR_Desc_Array[i][0],6);
+             ADC1_Average_value[i] = 0;
+             
+            for(int index = 0; index <3; index++)
+                 ADC1_Average_value[i] += Adc1_HFR_Desc_Array[i][index];
+            
+            ADC1_Average_value[i] /= 3;                
+            
+        }
+        else{
+            Adc1_HFR_Array[i][Total_SamplingCnt] = ADC1_Average_value[i];
+        }
+
+        ADC1DoubleRet[i] = (((ADC1_Average_value[i] ) * 3.3 /4096) * 1000);
+        ADC1Ret[i] = ADC1DoubleRet[i];
+        ADC1_Average_value[i] = 0;
+    }
+
+        bluecell_Currdatastatus.ULO_P1_Level1_H 
+            = ((ADC1Ret[0] & 0xFF00) >> 8);
+        bluecell_Currdatastatus.ULO_P1_Level1_L 
+            = ((ADC1Ret[0] & 0x00FF) );
+
+            
+        bluecell_Currdatastatus.ULO_P2_Level2_H 
+            = ((ADC1Ret[1] & 0xFF00) >> 8);
+        bluecell_Currdatastatus.ULO_P2_Level2_L 
+            = ((ADC1Ret[1] & 0x00FF) );
+
+            
+        bluecell_Currdatastatus.ULO_P3_Level3_H 
+            = ((ADC1Ret[2] & 0xFF00) >> 8);
+        bluecell_Currdatastatus.ULO_P3_Level3_L 
+            = ((ADC1Ret[2] & 0x00FF) );
+
+/* *
+온도 소수점 제거
+*/
+    temp = (ADC1Ret[3] * 0.001);
+    bluecell_Currdatastatus.DET_TEMP =  ((temp - 0.5) * 100);
+    bluecell_Currdatastatus.DET_TEMP  += bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET;
+//    printf("bluecell_Currdatastatus.DET_TEMP : %d \r\n",bluecell_Currdatastatus.DET_TEMP);
+    
+        ADC_100ms_Cnt = 0;
+
+        adc1cnt = 0;
+        
+        Total_SamplingCnt++;
+//         printf("1. Total_SamplingCnt %d\r\n",Total_SamplingCnt);
+        if(Total_SamplingCnt >= 5)
+            Total_SamplingCnt = 5;
+
+    }
+#endif//    ADC_Sampling_Func();
+
+    /*
+        After ADC calculation is completed, start Det Alarm check.
+    */
+
+    DET_LevelAlarmCheck();/*DL UL Alarm Check*/
+}
+
+
+#endif // PYJ.2020.08.12_END -- 
 
 #endif // PYJ.2020.08.07_END -- 
 

Bluecell_Src/MBIC_Bootloader.c

@@ -526,7 +526,7 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
     
     Uart1_Data_Send(MBIC_Resp ,22 + 3 + index);
     if( cmd == MBIC_Complete_Notice_RSP
-        &&bluecell_Currdatastatus.MBIC_Download_Auto_Restart_Set == true){
+        &&bluecell_Currdatastatus.MBIC_Download_Auto_Restart_Set != false){
         HAL_Delay(100);
         NVIC_SystemReset();
     }

Bluecell_Src/eeprom.c

@@ -250,42 +250,42 @@ void EEPROM_M24C08_Init(void){
     bluecell_Currdatastatus.Type = 0;
 
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x80)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x80)
         bluecell_Currdatastatus.ATT_DL1_PATH = true;
     else
         bluecell_Currdatastatus.ATT_DL1_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x40)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x40)
         bluecell_Currdatastatus.ATT_DL2_PATH = true;
     else
         bluecell_Currdatastatus.ATT_DL2_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x20)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x20)
         bluecell_Currdatastatus.ATT_DL3_PATH = true;
     else
         bluecell_Currdatastatus.ATT_DL3_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x10)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x10)
         bluecell_Currdatastatus.ATT_DL4_PATH = true;
     else
         bluecell_Currdatastatus.ATT_DL4_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x08)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x08)
         bluecell_Currdatastatus.ATT_UL1_PATH = true;
     else
         bluecell_Currdatastatus.ATT_UL1_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x04)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x04)
         bluecell_Currdatastatus.ATT_UL2_PATH = true;
     else
         bluecell_Currdatastatus.ATT_UL2_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x02)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x02)
         bluecell_Currdatastatus.ATT_UL3_PATH = true;
     else
         bluecell_Currdatastatus.ATT_UL3_PATH = false;
 
-    if(bluecell_Currdatastatus.Path_TempSave_Bit == 0x01)
+    if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x01)
         bluecell_Currdatastatus.ATT_UL4_PATH = true;
     else
         bluecell_Currdatastatus.ATT_UL4_PATH = false;

Src/main.c

@@ -70,8 +70,10 @@ volatile uint16_t ADC3value[ADC3_CNT];
 volatile uint32_t HFR_ADC1value[ADC1_CNT];
 volatile uint32_t HFR_ADC3value[ADC3_CNT];
 
-//volatile uint16_t ADC1valuearray[ADC1_CNT][ADC_AVERAGECNT];
-//volatile uint16_t ADC3valuearray[ADC3_CNT][ADC_AVERAGECNT];
+volatile uint16_t ADC1valuearray[ADC1_CNT][ADC_AVERAGECNT];
+volatile uint16_t ADC3valuearray[ADC3_CNT][ADC_AVERAGECNT];
+volatile uint16_t ADC1Desc_valuearray[4][ADC_AVERAGECNT];
+volatile uint16_t ADC3Desc_valuearray[5][ADC_AVERAGECNT];
 
 volatile uint32_t AdcTimerCnt = 0;
 volatile uint32_t LedTimerCnt = 0;
@@ -224,28 +226,29 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
         }
     }
 #else
-//    if(adc1cnt == ADC_AVERAGECNT)
-//        adc1cnt = 0;
-//    if(adc3cnt == ADC_AVERAGECNT)
-//        adc3cnt = 0;
+    if(adc1cnt == ADC_AVERAGECNT)
+        adc1cnt = 0;
+    if(adc3cnt == ADC_AVERAGECNT)
+        adc3cnt = 0;
     if(hadc->Instance == hadc1.Instance)
     {
         for(int i = 0; i < 4; i++){
-//            ADC1valuearray[i][adc1cnt] = ADC1value[i];
+            ADC1valuearray[i][adc1cnt] = ADC1value[i];
             HFR_ADC1value[i] += ADC1value[i];
 
         }
         adc1cnt++;
     }
-
+   
     if(hadc->Instance == hadc3.Instance)
     {
         for(int i = 0; i < 5; i++){
-//            ADC3valuearray[i][adc3cnt] = ADC3value[i];
+            ADC3valuearray[i][adc3cnt] = ADC3value[i];
             HFR_ADC3value[i] += ADC3value[i];            
         }
         adc3cnt++;
     }    
+    
 //    printf("ADC_100ms_Cnt : %d \r\n",ADC_100ms_Cnt);