FRBT 위치 변경 , AGC/ ALC 동작 알고리즘 수정 / 반올림 함수 추가 /

Bluecell_Src/Bluecell_operate.c

@@ -1717,7 +1717,7 @@ void MBIC_TableSave(uint8_t* data,uint8_t type){
             Temp_DL1.Table_Length= data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length];
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st));                    
             MBIC_TableHeaderCopy(&data[MBIC_PAYLOADSTART + 5],sizeof(ATT_TABLE_st));   
-            printf("Temp_DL1 Length : %d \r\n",data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]);
+//            printf("Temp_DL1 Length : %d \r\n",data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length]);
 
             break;
         case DLI_P2_ATT_Temp_guarantee_Table_Number:
@@ -2056,7 +2056,8 @@ void SelfTest_Operate(uint8_t onoff){
         Prev_PathStatus[ATT_UL_PATH4] = bluecell_Currdatastatus.ATT_UL4_PATH;        
         bluecell_Currdatastatus.Carrier_ON_OFF = onoff; 
 //        printf("ALC AGC OFF\r\n");
-    }else{
+    }
+    else{
         bluecell_Currdatastatus.ULO_ALC_ON_OFF = Prev_ALC_OnOff;
         bluecell_Currdatastatus.DLI_AGC_ON_OFF = Prev_AGC_OnOff;
         bluecell_Currdatastatus.DLI_Shutdown_ON_OFF = Prev_DL_Shutdown_OnOff;
@@ -2077,9 +2078,10 @@ void SelfTest_Operate(uint8_t onoff){
           bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1 = Prev_ShutdownCnt[ATT_UL_ShutdownCnt1];
           bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2 = Prev_ShutdownCnt[ATT_UL_ShutdownCnt2];
           bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3 = Prev_ShutdownCnt[ATT_UL_ShutdownCnt3];
-          bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 = Prev_ShutdownCnt[ATT_UL_ShutdownCnt4];        
+          bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 = Prev_ShutdownCnt[ATT_UL_ShutdownCnt4];   
     }
     Path_Ctrl(onoff,&Prev_PathStatus);
+    
 }
 
 bool Bluecell_Operate(uint8_t* data){
@@ -5137,7 +5139,7 @@ uint8_t* Alarm_Report_Send(uint16_t Alarm_type,uint8_t val){
 //    Alarm_ReportData[MBIC_PAYLOADSTART + 1] = Alarm_type;    
 //    Alarm_ReportData[MBIC_PAYLOADSTART + 2] = val;        
     
-    printf("%s \r\n",&Alarm_ReportData[MBIC_PAYLOADSTART + 22]);
+//    printf("%s \r\n",&Alarm_ReportData[MBIC_PAYLOADSTART + 22]);
 //    printf("Type : %x  size length : %d \r\n",Alarm_type,sizeof(Alarm_ReportData));
 //    MBIC_HeaderMergeFunction(Alarm_ReportData,ALARM_REPORT_LENGTH);
     Alarm_ReportData[MBIC_PREAMBLE_0] = MBIC_PREAMBLE0;
@@ -5186,7 +5188,7 @@ uint8_t* Alarm_Report_Send(uint16_t Alarm_type,uint8_t val){
     Alarm_ReportData[MBIC_PAYLOADSTART + 44] = 0x03; 
 //        printf(" Alarm_ReportData[MBIC_PAYLOADSTART + 43] : %x \r\n", Alarm_ReportData[MBIC_PAYLOADSTART + 43]);    
     Uart1_Data_Send(&Alarm_ReportData[0],sizeof(Alarm_ReportData));
-    printf(" Alarm_ReportData[MBIC_PAYLOADSTART + 42] : %x \r\n", Alarm_ReportData[MBIC_PAYLOADSTART + 42]);
+//    printf(" Alarm_ReportData[MBIC_PAYLOADSTART + 42] : %x \r\n", Alarm_ReportData[MBIC_PAYLOADSTART + 42]);
 }
 
 bool MBIC_Operate(uint8_t* data){
@@ -5758,7 +5760,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");
+//                printf("data ctrl\r\n");
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
                 break;
@@ -7521,6 +7523,8 @@ void ADC_Check(void){
     uint16_t MIN_ADC[ADC3_CNT] = {0,};
     uint16_t cnt[ADC3_CNT] = {0,};
     double temp;
+    if(bluecell_Currdatastatus.SelfTest == true)
+        return;
     
 //    if(AdcTimerCnt > 10){
     // 정렬할 배열, 요소 개수, 요소 크기, 비교 함수를 넣어줌
@@ -8260,29 +8264,18 @@ void ALC_Alarm_TimerSet(uint8_t num,int16_t threshold,double CurrDet,int16_t Att
 //        CurrAtten,MainAtten,threshold,CurrDet);
 //        printf("ALC_AlarmSet[%d] %d \r\n",num,ALC_AlarmSet[num]);
 }
-double HFR_CntUpCalc(double ret){
-    double origin = ret;
-    int16_t calctmp = 0;
-//    printf("+++++++++++++++++++++++++++++++++++++++++\r\n");
-    ret *= -1;
-//    printf("CALC VALUE : %f \r\n",ret);
-    ret *= 10;
-    calctmp = ret;
-//    printf("1. ret : %f \r\n",ret);
-    calctmp %= 10;
-//    printf("2. ret : %f \r\n",ret);
-    
+#if 1 // PYJ.2020.10.23_BEGIN -- 
+int HFR_CntUpCalc(double ret){
+
+    if(ret > 0)
+        ret += 0.4;
+    else
+        ret -= 0.4;
     
-    if(calctmp >= 6){
-//        printf("minus return \r\n");
-        origin = (origin -1) + (calctmp  * 0.1);
-    }else{
-        origin += (calctmp  * 0.1);
-//        printf("ZERO return \r\n");        
-    }
-//    printf("HFR RET : %f \r\n",origin);
-    return origin;
+
+    return ret;
 }
+#endif // PYJ.2020.10.23_END -- 
 typedef enum{
     ULO_ALC_H = 0,
     ULO_ALC_L,
@@ -8304,7 +8297,7 @@ void ALC_Package_Operate(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st
     int16_t UL_Atten = 0;
     int16_t Main_Atten = 0;
     int16_t GiveAttenPlusULAtten = 0;
-
+    int16_t Plus_ResultData = 0;
     if(*retrycnt > 0)
         return;
     
@@ -8334,11 +8327,13 @@ void ALC_Package_Operate(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st
     printf("=============ALC ON =====START================\r\n");
     printf("Current UL ADC VALUE : %f \r\n",ret);
     printf("ResdBm : UL%d : %f \r\n",TableIndex + 1,ResdBm);    
-    printf("ORIGIN ResdBm : %f  %d\r\n",ResdBm,Main_Atten);
-    printf("After ResdBm : %f \r\n",ResdBm);
+//    printf("ORIGIN ResdBm : %f  %d\r\n",ResdBm,Main_Atten);
+//    printf("After ResdBm : %f \r\n",ResdBm);
 #endif // PYJ.2020.10.19_END -- 
     
-    ResultData = HFR_CntUpCalc(ResdBm); 
+    ResultData = Bluecell_RoundCalc(ResdBm); 
+    Plus_ResultData = HFR_CntUpCalc(ResdBm);
+
     int HFR_Dot5 = ((int)(ResdBm * 10) % 10);
 
     
@@ -8363,7 +8358,9 @@ void ALC_Package_Operate(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st
 //    printf("STEP 2 : I WILL GIVE ATTEN PLUS  ALC ATTEN  %d \r\n",IwillGiveAtten);    
 //    printf("STEP 3 :ResdBm : %f (Limitdata - 1) : %d   HFR_Dot5  %d \r\n",ResdBm,(Limitdata - 1),HFR_Dot5);    
     
-    if((ResultData <= (Limitdata - 1)) ) {
+    if((Plus_ResultData <= (Limitdata - 2 )) ) {
+//        printf("ResultData : %d \r\n",Plus_ResultData);
+//        printf("(Limitdata - 2 - 0.1) : %f \r\n",(Limitdata - 2));
         if(IwillGiveAtten <= -10){
             IwillGiveAtten += 10;
         }
@@ -8472,7 +8469,7 @@ void ALC_Function(){ //DL
 //    Bluecell_StructCpy(&AutoControl_Save[0],&UL_DET_Table_ref[TABLE_MAX_VALUE],sizeof(ALC_dBm_t));
 //    Bluecell_StructCpy(&tempadc[0],&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
     if(ALCTimerCnt > 500){
-        if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+        if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true && bluecell_Currdatastatus.SelfTest == false){
             UL_Atten[ALC_Alarm_UL1_Index] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
             UL_Atten[ALC_Alarm_UL2_Index] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L;
             UL_Atten[ALC_Alarm_UL3_Index] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L;
@@ -8618,22 +8615,38 @@ void AGC_Alarm_Check(uint8_t Path_Index,double AGC_Det,uint8_t* AGC_Table,uint16
 }
 
 
+int Bluecell_RoundCalc(double data){
+    int ret = 0;
+    if(data > 0){
+        ret = data + 0.5;
+    }
+    else{
+        ret = data - 0.5;
+    }
+
+    return ret;
+}
+#define AGC_PRINT 0
 #if 1 // PYJ.2020.06.27_BEGIN -- 
 void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tableindex,uint8_t* DLI_ADC_Level,uint8_t* DLI_Level,DET_TABLEDL_st* DL_Table,uint8_t* FRBT){
         double ret = 0;
+        int Round_ResdBm_Ret =0;
         int16_t ResdBm = 0;
         double Temp_ResdBm = 0;
+        static double Prev_ResdBm = 0;
+        static uint8_t Prev_Dcrease_Increase_Status = 0;        
+        static uint8_t Dcrease_Increase_Status = 0;
         int16_t CurrAtten = 0;
         int16_t Levelret = 0;
         int i = 0;
         int16_t Limitdata = 0;
         int16_t IwillgiveAtten = 0;
+        static int16_t PrevIwillgiveAtten = 0;        
         int16_t ResultData = 0;
         int8_t* AGC_Table;// = &DL_DET_Table_ref[MBIC_Table_DL1_INDEX][TABLE_MAX_VALUE];
         int16_t FRBT_Atten = 0;
-
-
-        
+        static int16_t RefValue = 0;
+        static int8_t Gurantee = 0;
         FRBT_Atten =  FRBT[DLI_AGC_H] << 8 | FRBT[DLI_AGC_L];   
         FRBT_Atten *= 0.1;
         
@@ -8648,10 +8661,13 @@ void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tablei
 
         CurrAtten = (int16_t)(DL_MainAtten[DLI_AGC_H] << 8 |  DL_MainAtten[DLI_AGC_L]);
         CurrAtten *= 0.1;
+//        printf("Apply 1 Curr ATTEN %d \r\n", (int16_t)(DL_MainAtten[DLI_AGC_H] << 8 |  DL_MainAtten[DLI_AGC_L]));        
         ResdBm = (int16_t)(DLI_Level[DLI_AGC_H] << 8 |  DLI_Level[DLI_AGC_L]) * 10;//(int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&DL_Table->Table_Det5_dBm_H,DL_Table->Table_Length,AGC_Table));
         Temp_ResdBm = ResdBm *0.01 ;
 //        printf("ResdBm %d \r\n",ResdBm);
         ResdBm = (int16_t)Bluecell_TestPro(ResdBm/10);
+        int HFR_Dot5 = ((int)(Temp_ResdBm * 10) % 10);
+
 //        DLI_Level[DLI_AGC_H] = ((int16_t)ResdBm & 0xFF00) >> 8;
 //        DLI_Level[DLI_AGC_L] = ((int16_t)ResdBm & 0x00FF);
         for(i = 0; i < sizeof(AGC_dBm_t); i++){
@@ -8660,38 +8676,82 @@ void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tablei
         }
         if(bluecell_Currdatastatus.DLI_FRBT_Status != FRBT_IDEL){
             IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
+        }
+#if AGC_PRINT // PYJ.2020.10.23_BEGIN -- 
+        printf("==================================\r\n");       
+#endif // PYJ.2020.10.23_END -- 
+        if(bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_IDEL){
+            ResdBm = Round_ResdBm_Ret = Bluecell_RoundCalc(Temp_ResdBm);
+            IwillgiveAtten = New_AGC_Calc(Limitdata,ResdBm);
+//            if(IwillgiveAtten )
 
+#if AGC_PRINT // PYJ.2020.10.23_BEGIN -- 
+            printf("222 WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten);
 
+            printf("Round_ResdBm_Ret : %d \r\n",Round_ResdBm_Ret);
+            printf("RefValue : %d \r\n",RefValue);            
+#endif // PYJ.2020.10.23_END -- 
 
-        }
-      
-        if(bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_IDEL){
-           if(Limitdata < ResdBm){
-                int HFR_Dot5 = ((int)(Temp_ResdBm * 10) % 10);
-                if(HFR_Dot5 == -5){
-                    ResdBm = Limitdata + (CurrAtten * -1);
-                }
-            }           
-//            printf("3ResdBm : DL%d : %d \r\n",Tableindex+1,ResdBm);
+            if(Round_ResdBm_Ret < RefValue + 0.5 && RefValue != 0){
+                
+                
+            }else{
+#if AGC_PRINT // PYJ.2020.10.23_BEGIN -- 
+                        printf("1Curr ATTEN %d \r\n",CurrAtten );
+                        printf("Current DL% ADC VALUE : %f \r\n",Tableindex+1,ret);
+                        printf("Temp_ResdBm : DL%d : %f \r\n",Tableindex+1,Temp_ResdBm);
+                        printf("I WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten);
+                        printf("AGC  : %d\r\n",Limitdata);
+#endif // PYJ.2020.10.23_END -- 
+                RefValue = Round_ResdBm_Ret;
+                return;
+            }
+            if(Round_ResdBm_Ret > RefValue - 1.5  && RefValue != 0){
+                if(CurrAtten < (IwillgiveAtten * -1)){
+                    if(((Limitdata + (CurrAtten * -1)) - 1.5) <= Temp_ResdBm){
+#if AGC_PRINT // PYJ.2020.10.23_BEGIN -- 
+                        printf("4Curr ATTEN %d \r\n",CurrAtten );
+                        printf("Current DL% ADC VALUE : %f \r\n",Tableindex+1,ret);
+                        printf("Temp_ResdBm : DL%d : %f \r\n",Tableindex+1,Temp_ResdBm);
+                        printf("I WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten* -1);
+                        printf("AGC  : %d\r\n",Limitdata);
+#endif // PYJ.2020.10.23_END --                           
+                        return;
+                    }
+                }                
+            }
+            else
+            {
+#if AGC_PRINT // PYJ.2020.10.23_BEGIN -- 
+        printf("2Curr ATTEN %d \r\n",CurrAtten );
+        printf("Current DL% ADC VALUE : %f \r\n",Tableindex+1,ret);
+        printf("Temp_ResdBm : DL%d : %f \r\n",Tableindex+1,Temp_ResdBm);
+        printf("I WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten);
+        printf("AGC  : %d\r\n",Limitdata);
+#endif // PYJ.2020.10.23_END --                 
+                RefValue = Round_ResdBm_Ret;
+                return;
 
-            IwillgiveAtten = New_AGC_Calc(Limitdata,ResdBm);
+            }
+
+            
             if(Limitdata == ResdBm){
                 IwillgiveAtten = CurrAtten;
             }
             if(IwillgiveAtten == CurrAtten)
-                IwillgiveAtten = 0;
-            
+                    IwillgiveAtten = 0;            
+//            RefValue = Round_ResdBm_Ret;
         }
-        
+       
         IwillgiveAtten *= -1;
-#if 0// PYJ.2020.09.14_BEGIN -- 
-        printf("==================================\r\n");         
-        printf("Curr ATTEN %d \r\n",CurrAtten );
+          
+#if AGC_PRINT // PYJ.2020.10.23_BEGIN -- 
+        printf("3Curr ATTEN %d \r\n",CurrAtten );
         printf("Current DL% ADC VALUE : %f \r\n",Tableindex+1,ret);
         printf("Temp_ResdBm : DL%d : %f \r\n",Tableindex+1,Temp_ResdBm);
         printf("I WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten);
         printf("AGC  : %d\r\n",Limitdata);
-#endif // PYJ.2020.09.14_END -- 
+#endif // PYJ.2020.10.23_END -- 
 
 
         if(bluecell_Currdatastatus.DLI_FRBT_Status != FRBT_IDEL && (CurrAtten) < IwillgiveAtten){
@@ -8702,9 +8762,8 @@ void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tablei
             IwillgiveAtten = -15;
 
             
-        if(bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_IDEL){
+        if(bluecell_Currdatastatus.DLI_FRBT_Status == FRBT_IDEL && bluecell_Currdatastatus.DLI_FRBT_D_Day == 0){
              if(Limitdata != ResdBm){
-         
                 if(CurrAtten + ResdBm <= Limitdata - 1)
                     IwillgiveAtten = ((CurrAtten) + 1);
                 if(CurrAtten == 0)
@@ -8715,7 +8774,7 @@ void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tablei
                 DL_PrevIwillgiveAtten[Tableindex] = IwillgiveAtten;
                 DL_MainAtten[DLI_AGC_H] = ((((IwillgiveAtten)  * 10) & 0xFF00) >> 8) ;
                 DL_MainAtten[DLI_AGC_L] = ((((IwillgiveAtten) * 10) & 0x00FF));  
-                printf("Apply 2 Curr ATTEN %d \r\n", (int16_t)(DL_MainAtten[DLI_AGC_H] << 8 |  DL_MainAtten[DLI_AGC_L]));
+//                printf("Apply 2 Curr ATTEN %d \r\n", (int16_t)(DL_MainAtten[DLI_AGC_H] << 8 |  DL_MainAtten[DLI_AGC_L]));
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);            
             }else{
                 if(Limitdata == ResdBm){
@@ -8843,7 +8902,7 @@ void AGC_Function(){//DL
     };
          
     if(AGCTimerCnt > 500){
-        if(bluecell_Currdatastatus.DLI_AGC_ON_OFF == true){
+        if(bluecell_Currdatastatus.DLI_AGC_ON_OFF == true && bluecell_Currdatastatus.SelfTest == false){
             
             Limitdata = (( bluecell_Currdatastatus.DLI_AGC_Threshold_H << 8) & 0xFF00) ;
             Limitdata +=  bluecell_Currdatastatus.DLI_AGC_Threshold_L ;
@@ -9540,12 +9599,12 @@ uint8_t DLI_FRBT_Status;
 void FRBT_Tracking_Package(uint8_t Index, uint8_t* FRBT,uint8_t* DL_MainAtten,uint8_t path){
     int16_t DL_Atten = 0;
     int16_t FRBT_Atten = 0;
-
-    if(path == false)
-        return;
     
     FRBT_Atten = FRBT[FRBT_H] << 8 | FRBT[FRBT_L];    
     DL_Atten = DL_MainAtten[FRBT_H] << 8 | DL_MainAtten[FRBT_L];
+
+    if(path == false || DL_Atten > 0 || FRBT_Atten <= DL_Atten)
+        return;
     if(FRBT_Atten == DL_Atten){
 //        printf("Tracking Return %d \r\n ");
 //        printf("FRBT_Atten : %d DL_Atten :  %d \r\n",FRBT_Atten,DL_Atten);        

Bluecell_Src/uart.c

@@ -14,6 +14,9 @@
 #include "CRC.h"
 
 
+#define DEBUG_PRINT 0
+
+
 UARTQUEUE TerminalQueue;
 UARTQUEUE WifiQueue;
 uart_hal_tx_type uart_hal_tx;
@@ -102,7 +105,7 @@ void GetDataFromUartQueue(UART_HandleTypeDef *huart)
 //        printf("data cnt zero !!!  \r\n");
         //RF_Ctrl_Main(&uart_buf[Header]);
 //        HAL_UART_Transmit(dst, &temp_buf[BLUECELL_HEADER00], 11, 3000);
-#if 1// PYJ.2019.07.15_BEGIN --
+#if DEBUG_PRINT// PYJ.2019.07.15_BEGIN --
             printf("\r\n[RX]");
             for(int i = 0; i < cnt; i++){
                 printf("%02x ",uart_buf[i]);
@@ -155,7 +158,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 1 // PYJ.2020.07.19_BEGIN -- 
+#if DEBUG_PRINT // PYJ.2020.07.19_BEGIN -- 
     printf("\r\n [TX] : ");
     for(int i = 0; i< size; i++)
         printf("%02x ",data[i]);

Src/main.c

@@ -359,8 +359,8 @@ int main(void)
     ALC_Function();    /*ALC Function*/
     AGC_Function();    /*AGC Function*/
     Alarm_Check();     /*Function to check all alarm status variables*/
-    FRBT_Operate();
     SelfTestTimer_Operate();
+    FRBT_Operate();
     AlarmLog_Report();
     HAL_IWDG_Refresh(&hiwdg);
 #if 0 // PYJ.2020.08.11_BEGIN --