HFR ADC 알고리즘 적용

타이머 7 제거

.settings/language.settings.xml

@@ -4,7 +4,7 @@
 		<extension point="org.eclipse.cdt.core.LanguageSettingsProvider">
 			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
 			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
-			<provider class="com.atollic.truestudio.mbs.GCCSpecsDetectorAtollicArm" console="false" env-hash="-190117911751186495" id="com.atollic.truestudio.mbs.provider" keep-relative-paths="false" name="Atollic ARM Tools Language Settings" parameter="${COMMAND} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
+			<provider class="com.atollic.truestudio.mbs.GCCSpecsDetectorAtollicArm" console="false" env-hash="1395387303521902045" id="com.atollic.truestudio.mbs.provider" keep-relative-paths="false" name="Atollic ARM Tools Language Settings" parameter="${COMMAND} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
 				<language-scope id="org.eclipse.cdt.core.gcc"/>
 				<language-scope id="org.eclipse.cdt.core.g++"/>
 			</provider>
@@ -14,7 +14,7 @@
 		<extension point="org.eclipse.cdt.core.LanguageSettingsProvider">
 			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
 			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
-			<provider class="com.atollic.truestudio.mbs.GCCSpecsDetectorAtollicArm" console="false" env-hash="-190117911751186495" id="com.atollic.truestudio.mbs.provider" keep-relative-paths="false" name="Atollic ARM Tools Language Settings" parameter="${COMMAND} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
+			<provider class="com.atollic.truestudio.mbs.GCCSpecsDetectorAtollicArm" console="false" env-hash="1395387303521902045" id="com.atollic.truestudio.mbs.provider" keep-relative-paths="false" name="Atollic ARM Tools Language Settings" parameter="${COMMAND} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
 				<language-scope id="org.eclipse.cdt.core.gcc"/>
 				<language-scope id="org.eclipse.cdt.core.g++"/>
 			</provider>

Bluecell_Inc/Bluecell_operate.h

@@ -632,7 +632,8 @@ enum DATATYPE
     Bluecell_UL_Det_Path1_Offset,    
     Bluecell_UL_Det_Path2_Offset,    
     Bluecell_UL_Det_Path3_Offset,    
-    Bluecell_UL_Det_Path4_Offset,        
+    Bluecell_UL_Det_Path4_Offset, 
+    Bluecell_Temp_Shutdown_Path_ON_OFF
 };
 typedef enum{    
 	DLI_P1_Level_Table_Number = 0x00,
@@ -1044,7 +1045,8 @@ typedef struct{
     uint8_t DL_Det_ALL_Offset;
     uint8_t MBIC_Download_Auto_Restart_Set;    
     uint8_t Path_TempSave_Bit;/*DL1 / DL 2 /DL3 /DL4 /UL1/UL2/UL3/UL4*/
-    int8_t UL_Det_Path_Offset[2];
+    uint8_t Path_TempShutdown_Set;/*DL1 / DL 2 /DL3 /DL4 /UL1/UL2/UL3/UL4*/
+    int8_t UL_Det_Path_Offset[1];
     uint8_t bluecell_crc_H;
     uint8_t bluecell_crc_L;
     uint8_t bluecell_etx;

Bluecell_Src/Bluecell_operate.c

@@ -44,8 +44,8 @@ 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 uint32_t LedTimerCnt;
 extern volatile uint32_t AdcTimerCnt;
@@ -78,6 +78,9 @@ extern volatile uint32_t Alarm_UL_Level_TimerOnCnt ;
 extern volatile uint32_t SelfTestLifeCnt[4];
 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,};
 uint8_t TempShutdown_DL_SaveData[4] = {false,};
@@ -1954,11 +1957,11 @@ bool Bluecell_Operate(uint8_t* data){
         if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
             Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
             Tmpdata2 = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
-//            if(Tmpdata + Tmpdata2 <= -200){
-//                Tmpdata2 = -200 + (Tmpdata * -1);
-//                bluecell_Currdatastatus.ATT_UL1_H = ((Tmpdata2 & 0xFF00) >> 8);
-//                bluecell_Currdatastatus.ATT_UL1_L = Tmpdata2 & 0x00FF;                    
-//            }
+            if(Tmpdata + Tmpdata2 <= -200){
+                Tmpdata2 = -200 + (Tmpdata * -1);
+                bluecell_Currdatastatus.ATT_UL1_H = ((Tmpdata2 & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ATT_UL1_L = Tmpdata2 & 0x00FF;                    
+            }
             UL_ALC_GainAttenSet[ALC_Alarm_UL1_Index] = true;
             ALC_Level_Save[ALC_Alarm_UL1_Index] = bluecell_Currdatastatus.ULO_Level1_H << 8 | bluecell_Currdatastatus.ULO_Level1_L;
         }
@@ -1980,15 +1983,15 @@ bool Bluecell_Operate(uint8_t* data){
         if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
             Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L;
             Tmpdata2 = bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L;
-//            if(Tmpdata + Tmpdata2 <= -200){
-//                Tmpdata2 = -200 + (Tmpdata * -1);
-//                bluecell_Currdatastatus.ATT_UL2_H = ((Tmpdata2 & 0xFF00) >> 8);
-//                bluecell_Currdatastatus.ATT_UL2_L = Tmpdata2 & 0x00FF;                    
-//            }
+            if(Tmpdata + Tmpdata2 <= -200){
+                Tmpdata2 = -200 + (Tmpdata * -1);
+                bluecell_Currdatastatus.ATT_UL2_H = ((Tmpdata2 & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ATT_UL2_L = Tmpdata2 & 0x00FF;                    
+            }
             UL_ALC_GainAttenSet[ALC_Alarm_UL2_Index] = true;
             ALC_Level_Save[ALC_Alarm_UL2_Index] = bluecell_Currdatastatus.ULO_Level2_H << 8 | bluecell_Currdatastatus.ULO_Level2_L;
         }
-//        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
 
         /*
@@ -2003,15 +2006,15 @@ bool Bluecell_Operate(uint8_t* data){
         if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
             Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L;
             Tmpdata2 = bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L;
-//            if(Tmpdata + Tmpdata2 <= -200){
-//                Tmpdata2 = -200 + (Tmpdata * -2);
-//                bluecell_Currdatastatus.ATT_UL3_H = ((Tmpdata2 & 0xFF00) >> 8);
-//                bluecell_Currdatastatus.ATT_UL3_L = Tmpdata2 & 0x00FF;                    
-//            }
+            if(Tmpdata + Tmpdata2 <= -200){
+                Tmpdata2 = -200 + (Tmpdata * -2);
+                bluecell_Currdatastatus.ATT_UL3_H = ((Tmpdata2 & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ATT_UL3_L = Tmpdata2 & 0x00FF;                    
+            }
             UL_ALC_GainAttenSet[ALC_Alarm_UL3_Index] = true;
             ALC_Level_Save[ALC_Alarm_UL3_Index] = bluecell_Currdatastatus.ULO_Level3_H << 8 | bluecell_Currdatastatus.ULO_Level3_L;
         }
-//        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
         /*
             Atten Ctrl Function
@@ -2025,15 +2028,15 @@ bool Bluecell_Operate(uint8_t* data){
         if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
             Tmpdata = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
             Tmpdata2 = bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L;
-//            if(Tmpdata + Tmpdata2 <= -200){
-//                Tmpdata2 = -200 + (Tmpdata * -2);
-//                bluecell_Currdatastatus.ATT_UL4_H = ((Tmpdata2 & 0xFF00) >> 8);
-//                bluecell_Currdatastatus.ATT_UL4_L = Tmpdata2 & 0x00FF;                    
-//            }
+            if(Tmpdata + Tmpdata2 <= -200){
+                Tmpdata2 = -200 + (Tmpdata * -2);
+                bluecell_Currdatastatus.ATT_UL4_H = ((Tmpdata2 & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ATT_UL4_L = Tmpdata2 & 0x00FF;                    
+            }
             UL_ALC_GainAttenSet[ALC_Alarm_UL4_Index] = true;
             ALC_Level_Save[ALC_Alarm_UL4_Index] = bluecell_Currdatastatus.ULO_Level4_H << 8 | bluecell_Currdatastatus.ULO_Level4_L;
         }
-//        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
         ALCTimerCnt = 0;
 
@@ -3027,6 +3030,10 @@ bool Bluecell_Operate(uint8_t* data){
         bluecell_Currdatastatus.UL_Det_Path_Offset[3] = data[BLUECELL_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];
+         Temp_Shutdown_ONOFF(bluecell_Prevdatastatus.Path_TempShutdown_Set);
+        break;
   }
   
   if(datatype != Bluecell_StatusReq
@@ -4532,7 +4539,7 @@ void Carrier_ONOFF(uint8_t val){
     }
 }
 void Temp_Shutdown_ONOFF(uint8_t val){
-    if(val == 0){// ON
+    if(val == 0){// ON //Path ON
          bluecell_Currdatastatus.ATT_DL1_PATH= TempShutdown_DL_SaveData[0];    
          bluecell_Currdatastatus.ATT_DL2_PATH= TempShutdown_DL_SaveData[1];    
          bluecell_Currdatastatus.ATT_DL3_PATH= TempShutdown_DL_SaveData[2];    
@@ -4553,6 +4560,8 @@ void Temp_Shutdown_ONOFF(uint8_t val){
         TempShutdown_UL_SaveData[1] = bluecell_Currdatastatus.ATT_UL2_PATH;
         TempShutdown_UL_SaveData[2] = bluecell_Currdatastatus.ATT_UL3_PATH;
         TempShutdown_UL_SaveData[3] = bluecell_Currdatastatus.ATT_UL4_PATH;
+
+        
         bluecell_Currdatastatus.ATT_DL1_PATH = false;    
         bluecell_Currdatastatus.ATT_DL2_PATH = false;    
         bluecell_Currdatastatus.ATT_DL3_PATH = false;    
@@ -4813,8 +4822,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.MBIC_Download_Auto_Restart_Set = data[MBIC_PAYLOADSTART + 3];
-                Temp_Shutdown_ONOFF(bluecell_Prevdatastatus.MBIC_Download_Auto_Restart_Set);
+                bluecell_Prevdatastatus.Path_TempShutdown_Set = data[MBIC_PAYLOADSTART + 3];
+                Temp_Shutdown_ONOFF(bluecell_Prevdatastatus.Path_TempShutdown_Set);
                 break;
             case  Carrier_ON_OFF                          :
                 bluecell_Currdatastatus.Carrier_ON_OFF = data[MBIC_PAYLOADSTART + 3]; 
@@ -5284,7 +5293,6 @@ bool MBIC_Operate(uint8_t* data){
         }
          data[MBIC_CMD_0] = 0x81;//MBIC_ERRRESPONSE;
         Length = MBIC_DataSend(data);
-//        if(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));
     }
@@ -6106,23 +6114,24 @@ void ADC_Sampling_Func(){
         Total_SamplingCnt = 5;
 }
 #else
+uint32_t Adc1_ret[ADC1_CNT] = {0,};
+uint16_t Adc1_arrange[ADC1_CNT] = {0,};
+uint16_t Adc1_HFR_Array[ADC1_CNT][6] = {0,};
+uint16_t Adc1_HFR_Desc_Array[ADC1_CNT][6] = {0,};
+uint32_t Adc1_HFR_Ret[ADC1_CNT]= {0,};
+
+uint32_t Adc3_ret[ADC3_CNT] = {0,};
+uint16_t Adc3_arrange[ADC3_CNT] = {0,};
+uint16_t Adc3_HFR_Array[ADC3_CNT][6] = {0,};
+uint16_t Adc3_HFR_Desc_Array[ADC3_CNT][6] = {0,};
+uint32_t Adc3_HFR_Ret[ADC3_CNT]= {0,};
+
+uint8_t Sampling_Cnt = 0; // 1cbt 100ms
+uint8_t Total_SamplingCnt = 0; // 6 Cnt - 600ms
+#if 0 // PYJ.2020.08.11_BEGIN -- 
 void ADC_Sampling_Func(){
     uint8_t ret = ADC_100ms_Cnt % 2;
     
-    static uint32_t Adc1_ret[ADC1_CNT] = {0,};
-    static uint16_t Adc1_arrange[ADC1_CNT] = {0,};
-    static uint16_t Adc1_HFR_Array[ADC1_CNT][6] = {0,};
-    static uint16_t Adc1_HFR_Desc_Array[ADC1_CNT][6] = {0,};
-    static uint32_t Adc1_HFR_Ret[ADC1_CNT]= {0,};
-    
-    static uint32_t Adc3_ret[ADC3_CNT] = {0,};
-    static uint16_t Adc3_arrange[ADC3_CNT] = {0,};
-    static uint16_t Adc3_HFR_Array[ADC3_CNT][6] = {0,};
-    static uint16_t Adc3_HFR_Desc_Array[ADC3_CNT][6] = {0,};
-    static uint32_t Adc3_HFR_Ret[ADC3_CNT]= {0,};
-    
-    static uint8_t Sampling_Cnt = 0; // 1cbt 100ms
-    static uint8_t Total_SamplingCnt = 0; // 6 Cnt - 600ms
 
     double ADC1DoubleRet[ADC1_CNT];
     double ADC3DoubleRet[ADC3_CNT];
@@ -6143,6 +6152,9 @@ void ADC_Sampling_Func(){
         adc1cnt = 0;
         adc3cnt = 0;
         Sampling_Cnt++;
+        printf("ADC_100ms_Cnt : %d \r\n",ADC_100ms_Cnt);
+    }else{
+        return;
     }
     
 
@@ -6276,6 +6288,192 @@ void ADC_Sampling_Func(){
     if(Total_SamplingCnt >= 5)
         Total_SamplingCnt = 5;
 }
+//#else 
+void ADC_Sampling_Func(uint8_t mode,uint16_t Timer2ms_AdcValue,uint8_t index){
+    static uint32_t TempAdc1[ADC1_CNT] = {0,};
+    static uint32_t TempAdc3[ADC3_CNT] = {0,}; 
+    static uint8_t ADC1_TotalCnt[ADC1_CNT] = {0,} ;
+    static uint8_t ADC3_TotalCnt[ADC3_CNT] = {0,} ;  
+    
+    static uint8_t ADC1_TotalSamplingCnt[ADC1_CNT] = {0,} ;
+    static uint8_t ADC3_TotalSamplingCnt[ADC3_CNT] = {0,} ;  
+    double temp = 0;
+    double ADC1DoubleRet[ADC1_CNT];
+    double ADC3DoubleRet[ADC3_CNT];
+
+
+    if(mode == 1){
+        TempAdc1[index] += Timer2ms_AdcValue;
+        ADC1_TotalCnt[index]++;
+
+        if(ADC1_TotalCnt[index] >= 50){
+            TempAdc1[index] /= ADC1_TotalCnt[index];
+           /* ADC1DoubleRet[index]  = ((TempAdc1[index] * 3.3 /4096) * 1000);
+            TempAdc1[index] = ADC1DoubleRet[index];*/
+            /**/
+
+            
+           if(ADC1_TotalSamplingCnt[index] == HFR_REQUSET_TOTAL_CNT - 1){
+               ArrayMoveBack(&Adc1_HFR_Array[index][0],HFR_REQUSET_TOTAL_CNT);
+               Adc1_HFR_Array[index][HFR_REQUSET_TOTAL_CNT - 1] 
+                   = TempAdc1[index];
+           }
+           else{
+               Adc1_HFR_Array[index][ADC1_TotalSamplingCnt[index]] 
+                   = TempAdc1[index];
+           }
+
+           for(int repl = 0; repl < 6; repl++){
+              Adc1_HFR_Desc_Array[index][repl] = Adc1_HFR_Array[index][repl];
+//               if(index == 3)
+//                printf("Adc1_HFR_Array[index] : %d \r\n",Adc1_HFR_Array[index][repl]);
+              
+           }
+           
+           DascendigFunc(&Adc1_HFR_Desc_Array[index][0],HFR_REQUSET_TOTAL_CNT);
+           for(int a = 1; a < 5; a++){
+               Adc1_HFR_Ret[index] += Adc1_HFR_Desc_Array[index][a];
+               
+           }
+           Adc1_HFR_Ret[index] /= 4;
+
+           ADC1DoubleRet[index] = ((Adc1_HFR_Ret[index] * 3.3 /4096) * 1000);
+           ADC1Ret[index] = ADC1DoubleRet[index];
+
+
+
+            /**/
+            if(index == 0){
+                bluecell_Currdatastatus.ULO_P1_Level1_H 
+                    = (((uint16_t)ADC1Ret[index] & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ULO_P1_Level1_L 
+                        = (((uint16_t)ADC1Ret[index] & 0x00FF) );
+            }
+            else if(index == 1){
+                bluecell_Currdatastatus.ULO_P2_Level2_H 
+                    = (((uint16_t)ADC1Ret[index] & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ULO_P2_Level2_L 
+                    = (((uint16_t)ADC1Ret[index] & 0x00FF) );
+            }
+            else if(index == 2){
+
+                bluecell_Currdatastatus.ULO_P3_Level3_H 
+                    = (((uint16_t)ADC1Ret[index] & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ULO_P3_Level3_L 
+                    = (((uint16_t)ADC1Ret[index] & 0x00FF) );
+            }
+            /* *
+            온도 소수점 제거
+            */
+            else if(index == 3){
+//                printf("Temp %d \r\n",ADC1Ret[index]);
+                temp = ((uint16_t)ADC1Ret[index] * 0.001);
+                bluecell_Currdatastatus.DET_TEMP =  ((temp - 0.5) * 100);
+                bluecell_Currdatastatus.DET_TEMP  += bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET;        
+            }
+            Adc1_ret[index] = 0;
+            Adc1_arrange[index] = 0;
+            Adc1_HFR_Ret[index] = 0;            
+            ADC1_TotalCnt[index] = 0;
+            TempAdc1[index] = 0;
+            ADC1_TotalSamplingCnt[index]++;
+        }        
+    }
+    else if(mode == 3){
+        TempAdc3[index] += Timer2ms_AdcValue;    
+        ADC3_TotalCnt[index]++;
+
+        if(ADC3_TotalCnt[index] >= 50){
+            TempAdc3[index] /= ADC3_TotalCnt[index];
+//            ADC3DoubleRet[index]  = ((TempAdc3[index] * 3.3 /4096) * 1000);
+//            TempAdc3[index] = ADC3DoubleRet[index];
+
+
+
+/**/
+
+            
+           if(ADC3_TotalSamplingCnt[index] == HFR_REQUSET_TOTAL_CNT - 1){
+               ArrayMoveBack(&Adc3_HFR_Array[index][0],HFR_REQUSET_TOTAL_CNT);
+               Adc3_HFR_Array[index][HFR_REQUSET_TOTAL_CNT - 1] 
+                   = TempAdc3[index];
+           }
+           else{
+               Adc3_HFR_Array[index][ADC3_TotalSamplingCnt[index]] 
+                   = TempAdc3[index];
+           }
+
+           for(int repl = 0; repl < 6; repl++){
+              Adc3_HFR_Desc_Array[index][repl] = Adc3_HFR_Array[index][repl];
+//               if(index == 3)
+//                printf("Adc3_HFR_Array[index] : %d \r\n",Adc3_HFR_Array[index][repl]);
+              
+           }
+           
+           DascendigFunc(&Adc3_HFR_Desc_Array[index][0],HFR_REQUSET_TOTAL_CNT);
+           for(int a = 1; a < 5; a++){
+               Adc3_HFR_Ret[index] += Adc3_HFR_Desc_Array[index][a];
+               
+           }
+           Adc3_HFR_Ret[index] /= 4;
+
+           ADC3DoubleRet[index] = ((Adc3_HFR_Ret[index] * 3.3 /4096) * 1000);
+           ADC3Ret[index] = ADC3DoubleRet[index];
+
+
+
+            /**/
+
+            if(index == 1){
+                bluecell_Currdatastatus.DLI_P1_Level1_H 
+                    = (((uint16_t)TempAdc3[index] & 0xFF00) >> 8);
+                bluecell_Currdatastatus.DLI_P1_Level1_L 
+                    = (((uint16_t)TempAdc3[index] & 0x00FF));
+            }
+            else if(index == 2){
+                bluecell_Currdatastatus.DLI_P2_Level2_H 
+                    = (((uint16_t)TempAdc3[index] & 0xFF00) >> 8);
+                bluecell_Currdatastatus.DLI_P2_Level2_L 
+                    = (((uint16_t)TempAdc3[index] & 0x00FF) );
+            }
+            else if(index == 3){                
+                bluecell_Currdatastatus.DLI_P3_Level3_H 
+                    = (((uint16_t)TempAdc3[index] & 0xFF00) >> 8);
+                bluecell_Currdatastatus.DLI_P3_Level3_L 
+                    = (((uint16_t)TempAdc3[index] & 0x00FF) );
+            }
+            else if(index == 4){                
+                bluecell_Currdatastatus.DLI_P4_Level4_H 
+                    = (((uint16_t)TempAdc3[index] & 0xFF00) >> 8);
+                bluecell_Currdatastatus.DLI_P4_Level4_L 
+                    = (((uint16_t)TempAdc3[index] & 0x00FF) );
+            }
+            else if(index == 0){                
+                bluecell_Currdatastatus.ULO_P4_Level4_H 
+                    = (((uint16_t)TempAdc3[index] & 0xFF00) >> 8);
+                bluecell_Currdatastatus.ULO_P4_Level4_L 
+                    = (((uint16_t)TempAdc3[index] & 0x00FF) );           
+            }
+            Adc3_ret[index] = 0;
+            Adc3_arrange[index] = 0;
+            Adc3_HFR_Ret[index] = 0;            
+            ADC3_TotalCnt[index] = 0;
+            TempAdc3[index] = 0;
+            ADC3_TotalSamplingCnt[index]++;
+
+        }        
+
+    }
+
+    if(ADC1_TotalSamplingCnt[index] >= 5)
+        ADC1_TotalSamplingCnt[index] = 5;   
+    if(ADC3_TotalSamplingCnt[index] >= 5)
+        ADC3_TotalSamplingCnt[index] = 5;   
+    
+    
+}
+
+#endif // PYJ.2020.08.11_END -- 
 
 
 #endif // PYJ.2020.08.07_END -- 
@@ -6299,7 +6497,10 @@ void ADC_Check(void){
 //        printf("%d\r\n",ADC_100ms_Cnt);
 //    }
 
-    if(adc3cnt >= ADC_AVERAGECNT){
+//    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 -- 
       for(int i = 0; i < ADC3_CNT; i++){
                 DascendigFunc(&ADC3valuearray[i][0],ADC_AVERAGECNT);
@@ -6404,10 +6605,145 @@ void ADC_Check(void){
         adc1cnt = 0;
 
     }
+#else    
+    //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){
+//        printf("%d\r\n",ADC_100ms_Cnt);
+//    }
+
+//    if(adc3cnt >= ADC_AVERAGECNT){
+    if(ADC_100ms_Cnt >= 100){
+        
+        //        printf("adc3cnt : %d \r\n",adc3cnt);
+        for(int i = 0; i < ADC3_CNT; i++){
+            ADC3DoubleRet[i] = HFR_ADC3value[i] / adc3cnt;
+            
+            Adc3_HFR_Array[i][Total_SamplingCnt] = ADC3DoubleRet[i];
+            if(Total_SamplingCnt == HFR_REQUSET_TOTAL_CNT - 1){
+                ArrayMoveBack(&Adc3_HFR_Array[i][0],HFR_REQUSET_TOTAL_CNT);
+            }
+            for(int repl = 0; repl < 6; repl++){
+               Adc3_HFR_Desc_Array[i][repl] = Adc3_HFR_Array[i][repl];
+               
+            }
+            DascendigFunc(&Adc3_HFR_Desc_Array[i][0],HFR_REQUSET_TOTAL_CNT);
+            for(int a = 1; a < 5; a++){
+                Adc3_HFR_Ret[i] += Adc3_HFR_Desc_Array[i][a];
+                
+            }
+            Adc3_HFR_Ret[i] /= 4;
+            ADC3DoubleRet[i] = ((Adc3_HFR_Ret[i] * 3.3 /4096) * 1000);
+            ADC3Ret[i] = ADC3DoubleRet[i];
+            Adc3_HFR_Ret[i] = 0;      
+            HFR_ADC3value[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) );
+
+        
+        for(int i = 0; i < ADC1_CNT; i++){
+            ADC1DoubleRet[i] = HFR_ADC1value[i] / adc1cnt;
+            Adc1_HFR_Array[i][Total_SamplingCnt] = ADC1DoubleRet[i];
+            if(Total_SamplingCnt == HFR_REQUSET_TOTAL_CNT - 1){
+                ArrayMoveBack(&Adc1_HFR_Array[i][0],HFR_REQUSET_TOTAL_CNT);
+            }
+            for(int repl = 0; repl < 6; repl++){
+               Adc1_HFR_Desc_Array[i][repl] = Adc1_HFR_Array[i][repl];
+               
+            }
+            DascendigFunc(&Adc1_HFR_Desc_Array[i][0],HFR_REQUSET_TOTAL_CNT);
+            for(int a = 1; a < 5; a++){
+                Adc1_HFR_Ret[i] += Adc1_HFR_Desc_Array[i][a];
+                
+            }
+            Adc1_HFR_Ret[i] /= 4;
+            ADC1DoubleRet[i] = ((Adc1_HFR_Ret[i] * 3.3 /4096) * 1000);
+            ADC1Ret[i] = ADC1DoubleRet[i];
+            Adc1_HFR_Ret[i] = 0;     
+            HFR_ADC1value[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;        
+
+
+        Total_SamplingCnt++;
+        
+        if(Total_SamplingCnt >=5)
+            Total_SamplingCnt = 5;
+         
+        adc3cnt = 0;
+        adc1cnt = 0;
+        ADC_100ms_Cnt = 0;
+
+    }
+
 #endif // PYJ.2020.08.07_END -- 
+//    ADC_Sampling_Func();
+
     /*
         After ADC calculation is completed, start Det Alarm check.
     */
+
     DET_LevelAlarmCheck();/*DL UL Alarm Check*/
 }
 

Bluecell_Src/eeprom.c

@@ -250,6 +250,46 @@ void EEPROM_M24C08_Init(void){
     bluecell_Currdatastatus.Type = 0;
 
 
+    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)
+        bluecell_Currdatastatus.ATT_DL2_PATH = true;
+    else
+        bluecell_Currdatastatus.ATT_DL2_PATH = false;
+
+    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)
+        bluecell_Currdatastatus.ATT_DL4_PATH = true;
+    else
+        bluecell_Currdatastatus.ATT_DL4_PATH = false;
+
+    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)
+        bluecell_Currdatastatus.ATT_UL2_PATH = true;
+    else
+        bluecell_Currdatastatus.ATT_UL2_PATH = false;
+
+    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)
+        bluecell_Currdatastatus.ATT_UL4_PATH = true;
+    else
+        bluecell_Currdatastatus.ATT_UL4_PATH = false;
+
 //    printf("PCB Version : %d.%d \r\n",bluecell_Currdatastatus.PCB_Version[0],bluecell_Currdatastatus.PCB_Version[1]);
 //    printf("Serial Number : ");
 //    for(int a = 0; a < 20; a++){

STM32F103ZET_JDASMBIC.ioc

@@ -177,7 +177,7 @@ Mcu.UserConstants=
 Mcu.UserName=STM32F103ZETx
 MxCube.Version=5.6.1
 MxDb.Version=DB.5.0.60
-NVIC.ADC1_2_IRQn=true\:0\:0\:false\:false\:true\:true\:true
+NVIC.ADC1_2_IRQn=true\:0\:0\:false\:true\:true\:11\:true\:true
 NVIC.ADC3_IRQn=true\:0\:0\:false\:true\:true\:6\:true\:true
 NVIC.BusFault_IRQn=true\:0\:0\:false\:false\:true\:false\:false
 NVIC.DMA1_Channel1_IRQn=true\:0\:0\:false\:true\:true\:1\:false\:true

Src/main.c

@@ -67,8 +67,11 @@ DMA_HandleTypeDef hdma_usart2_tx;
 volatile uint16_t ADC1value[ADC1_CNT];
 volatile uint16_t ADC3value[ADC3_CNT];
 
-volatile uint16_t ADC1valuearray[ADC1_CNT][ADC_AVERAGECNT];
-volatile uint16_t ADC3valuearray[ADC3_CNT][ADC_AVERAGECNT];
+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 uint32_t AdcTimerCnt = 0;
 volatile uint32_t LedTimerCnt = 0;
@@ -221,10 +224,16 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
         }
     }
 #else
+//    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++;
     }
@@ -232,10 +241,13 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
     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);
+    
 
 #endif // PYJ.2020.08.07_END -- 
 }
@@ -246,7 +258,7 @@ extern void DET_LevelAlarmCheck();
 extern void ALC_Function();
 extern void Boot_LED_Toggle(void);
 extern void ADC_Check(void);
-extern void ADC_Sampling_Func();
+extern void ADC_Sampling_Func(uint8_t mode,uint16_t Timer2ms_AdcValue,uint8_t index);
 
 uint8_t MBICTest_Firmdata[8]  = {1,2,3,4,5,6,7,8};
 
@@ -299,6 +311,7 @@ int main(void)
   HAL_ADC_Start_DMA(&hadc1, (uint16_t*)ADC1value, 4);
   HAL_TIM_Base_Start_IT(&htim6);
 
+
   setbuf(stdout, NULL);
   uint32_t  CurrApiAddress = 0,Bank1Address=0,Bank2Address = 0;
   int32_t CrcLength = 0;
@@ -333,18 +346,33 @@ int main(void)
   /* USER CODE BEGIN WHILE */
   while (1)
   {
+//    ADC_Sampling_Func();
+    ADC_Check();       /*Det Calc + DL/UL Alarm Check Function*/
     Boot_LED_Toggle(); /*LED Check*/
     Uart_Check();      /*Usart Rx*/
     ALC_Function();    /*ALC Function*/
     AGC_Function();    /*AGC Function*/
-    ADC_Check();       /*Det Calc + DL/UL Alarm Check Function*/
     Alarm_Check();     /*Function to check all alarm status variables*/
     FRBT_Operate();
     SelfTestTimer_Operate();
     HAL_IWDG_Refresh(&hiwdg);
+#if 0 // PYJ.2020.08.11_BEGIN -- 
+      for(int i = 0; i < ADC1_CNT; i++){
+          ADC_Sampling_Func(1,HFR_ADC1value[i]/adc1cnt,i);
+          HFR_ADC1value[i] = 0;
+      }
+      for(int i = 0; i < ADC3_CNT; i++){
+          ADC_Sampling_Func(3,HFR_ADC3value[i]/adc3cnt,i);
+          HFR_ADC3value[i] = 0;
+      }
+      
+      adc1cnt = 0;
+      adc3cnt = 0;     
+#endif // PYJ.2020.08.11_END -- 
     /* USER CODE END WHILE */
 
     /* USER CODE BEGIN 3 */
+ 
   }
   /* USER CODE END 3 */
 }
@@ -426,6 +454,9 @@ static void MX_NVIC_Init(void)
   /* DMA1_Channel5_IRQn interrupt configuration */
   HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 0, 0);
   HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
+  /* ADC1_2_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(ADC1_2_IRQn, 0, 0);
+  HAL_NVIC_EnableIRQ(ADC1_2_IRQn);
 }
 
 /**
@@ -938,8 +969,8 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
       LDTimerCnt++;
       ALCTimerCnt++;
       AGCTimerCnt++;
-      ADC_Sampling_Func();
       ADC_100ms_Cnt++;
+
 //    pdata = &bluecell_Currdatastatus.ATT_UL1_PATH;
     UL_Shutdown_Timer(DET_Alarm_UL1_Shutdown_Index);
 //    pdata = &bluecell_Currdatastatus.ATT_UL2_PATH;

Src/stm32f1xx_hal_msp.c

@@ -140,9 +140,6 @@ void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc)
 
     __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc1);
 
-    /* ADC1 interrupt Init */
-    HAL_NVIC_SetPriority(ADC1_2_IRQn, 0, 0);
-    HAL_NVIC_EnableIRQ(ADC1_2_IRQn);
   /* USER CODE BEGIN ADC1_MspInit 1 */
 
   /* USER CODE END ADC1_MspInit 1 */