HFR 검수 중 작업 사항

ALC Alarm 발생 시  ALC LIMIT 과 DET 이 같고 ALC ATTEN 과 Main Atten 의 합이 최대치로 먹었을 때만 Alarm 동작 하도록 수정
ALC retry cnt 가 1보다 클 때 ALC 동작 안하도록 수정
UL Level 측정 실시간으로 하도록 수정

Bluecell_Src/Bluecell_operate.c

@@ -251,16 +251,12 @@ void Boot_LED_Toggle(void){
             }
             LED_TestCnt++;
             LedTimerCnt = 0;
-
           /*Set LED TEST variable False after 12 flashes*/
           if(LED_TestCnt >= 6){
             bluecell_Currdatastatus.LED_TEST = false;
             LED_TestCnt = 0;
-
           }
         }
-
-
   }
   
 }
@@ -333,6 +329,7 @@ uint8_t MBIC_UL_PE43711_Calc(uint8_t* Table,int16_t MBIC_Val,int16_t MBIC_UserVa
     ret = TableAtteGuarantee(Table,ret);//Table Guarantee
 //    printf("ret2 : %f \r\n",ret);
     Result = PE43711_DataToHexConvert(ret);
+//    printf("Result %x \r\n",Result);
     return Result;
 }
 
@@ -391,7 +388,7 @@ double TableAtteGuarantee(uint8_t* Table,double AttenValue){
     }
     
     Bluecell_StructCpy(&GuaranteeData[0],&Table[0],sizeof(ATT_TABLE_st));
-    
+//    printf("cnt : %d \r\n",cnt);
 //    printf("H  : %x   L : %x \r\n",GuaranteeData[cnt * 2],GuaranteeData[cnt * 2 + 1]);
     ret =  GuaranteeData[cnt] * 0.5;
 //= PE43711_Double(GuaranteeData[cnt * 2],GuaranteeData[cnt * 2 + 1]);
@@ -926,7 +923,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
 //    printf("bluecell_Currdatastatus.ATT_UL3_L : %0x \r\n",bluecell_Currdatastatus.ATT_UL3_L);
 //    printf("bluecell_Currdatastatus.bluecell_User_UL3_H : %0x \r\n",bluecell_Currdatastatus.bluecell_User_UL3_H);
 //    printf("bluecell_Currdatastatus.bluecell_User_UL3_L : %0x \r\n",bluecell_Currdatastatus.bluecell_User_UL3_L);        
-        printf("%d val = %x \r\n",__LINE__,val);
+//        printf("%d val = %x \r\n",__LINE__,val);
 
             PE43711_atten_ctrl(ALL_ATT.ATT_UL3,val);
     }
@@ -959,6 +956,9 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
             MBIC_Val = Curr.ATT_UL4_H << 8 | Curr.ATT_UL4_L;
             MBIC_ALC_Val = Curr.MBIC_ULO_ALC_Atten4_H << 8 | Curr.MBIC_ULO_ALC_Atten4_L;
             MBIC_UserVal = Curr.bluecell_User_UL4_H << 8 | Curr.bluecell_User_UL4_L;
+//            printf("UL 4MBIC_Val : %02X \r\n",MBIC_Val);
+//            printf("UL 4MBIC_UserVal : %02X \r\n",MBIC_UserVal);
+//            printf("UL 4MBIC_ALC_Val : %02X \r\n",MBIC_ALC_Val);            
             val = MBIC_UL_PE43711_Calc(&Att_UL4.Table_0_0_dBm,// Table Offset
                                 MBIC_Val,// Hidden Atten Low bit
                                MBIC_UserVal,
@@ -2919,7 +2919,7 @@ bool Bluecell_Operate(uint8_t* data){
         else if(CurrAtten <= -50 )
             CurrAtten = - 50;    
         
-        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);        
+//        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);        
     
         CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         break;
@@ -2936,10 +2936,14 @@ bool Bluecell_Operate(uint8_t* data){
     case Bluecell_DLI_AGC_ON_OFF:                             
         printf("AGC ON OFF SET : %d \r\n",bluecell_Currdatastatus.DLI_AGC_ON_OFF);
         bluecell_Currdatastatus.DLI_AGC_ON_OFF = data[BLUECELL_DATA + i];
+        if(bluecell_Currdatastatus.DLI_AGC_ON_OFF == 0)
+            bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm = 0;
         break;
     case Bluecell_ULO_ALC_ON_OFF:                             
         printf("ALC ON OFF SET : %d \r\n",bluecell_Currdatastatus.ULO_ALC_ON_OFF);
         bluecell_Currdatastatus.ULO_ALC_ON_OFF = data[BLUECELL_DATA + i];
+        if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == 0)
+            bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm = 0;    
         break;
     case Bluecell_DLI_AGC_Threshold:                          
         bluecell_Currdatastatus.DLI_AGC_Threshold_H = data[BLUECELL_DATA + i++];
@@ -3255,9 +3259,9 @@ typedef enum{
         PrevMBIC_DL_ShutdownCount[i] = 0xFF;        
     }
 
-//  printf("Type %x  Ready....\r\n",bluecell_Currdatastatus.Type);
+  printf("Type %x  Ready....\r\n",bluecell_Currdatastatus.Type);
 
-  //  printf("bluecell_Currdatastatus.Type : %02x \r\n",bluecell_Currdatastatus.Type);
+    printf("bluecell_Currdatastatus.Type : %02x \r\n",bluecell_Currdatastatus.Type);
 #if 1 // PYJ.2020.06.17_BEGIN -- 
     HAL_GPIO_WritePin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin,bluecell_Currdatastatus.ATT_DL1_PATH);   
     HAL_GPIO_WritePin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin,bluecell_Currdatastatus.ATT_DL2_PATH);   
@@ -4405,6 +4409,7 @@ bool MBIC_Operate(uint8_t* data){
                     AGC_AlarmSet[AGC_Alarm_DL2_Index] = false;
                     AGC_AlarmSet[AGC_Alarm_DL3_Index] = false;
                     AGC_AlarmSet[AGC_Alarm_DL4_Index] = false;
+                    bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm = 0;
                 }
                 DL_AGC_StartAtten[AGC_Alarm_DL1_Index] 
                     = bluecell_Currdatastatus.ATT_DL1_H << 8 | bluecell_Currdatastatus.ATT_DL1_L;
@@ -4620,7 +4625,8 @@ bool MBIC_Operate(uint8_t* data){
                 break;
             case  ULO_ALC_ON_OFF                   :
                 bluecell_Currdatastatus.ULO_ALC_ON_OFF = data[MBIC_PAYLOADSTART + 3]; 
-
+                if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == 0)
+                    bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm = 0;
 
                 break;
             case  ULO_ALC_Threshold                       :
@@ -5148,6 +5154,7 @@ void DET_LevelAlarmCheck(){
         else{
             if(LimitData_UL_High - 2 >= Res_UL_dBm[DET_Alarm_UL1_Index + i])
                 ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i] = false;
+            DET_UL_On_AlarmTimerCnt[DET_Alarm_UL1_Index + i] = 0;
 //            printf("OFF _Limit : %d   UL%d : %d  ADC_Alarm_UL_Set %d ,Value : %d\r\n",LimitData_UL_High,i+1,Res_UL_dBm[DET_Alarm_UL1_Index + i],DET_Alarm_UL1_Index + i,ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i]);            
         }
 #if 1 // PYJ.2020.06.22_BEGIN -- 
@@ -5875,13 +5882,21 @@ int16_t ALC_Calc(uint8_t num,double CurrAtten ,int8_t threshold,double CurrDet){
 void ALC_Alarm_TimerSet(uint8_t num,int16_t threshold,int16_t CurrDet,int16_t Atten,int16_t MainAtten){
     int16_t ret =0;
     int16_t CurrAtten = 0;
+    double M_Atten = 0;
+    M_Atten = (MainAtten*0.1);
     CurrAtten = Atten * 0.1;
-        if(threshold < CurrDet){
+        if(CurrAtten + M_Atten >= -18){
+            ALC_AlarmSet[num] = false;
+//            printf("Alarm 3 \r\n");                
+        }    
+        else if(threshold <= CurrDet){
             ret = CurrDet - threshold ;
             ret = Bluecell_TestPro(ret +( CurrAtten * 0.1 * -1));
             ret *= -1;  
-            if(CurrAtten + (MainAtten*0.1) <= -20)
+            if(CurrAtten + M_Atten <= -20){
                 ALC_AlarmSet[num] = true;
+//                printf("Alarm 1 \r\n");
+            }
         }
         else if(threshold -2 > CurrDet){
             if(CurrAtten < 0){
@@ -5889,14 +5904,43 @@ void ALC_Alarm_TimerSet(uint8_t num,int16_t threshold,int16_t CurrDet,int16_t At
                 ret = Bluecell_TestPro(ret);
                 ret += CurrAtten;
                 ALC_AlarmSet[num] = false; 
+//                printf("Alarm 2 \r\n");                
             }
         }
+//        printf("threshold : %d \r\n",threshold);
+//        printf("Curr Atten : %d    Main Atten : %d    Thre : %d    CurrDet : %d \r\n",
+//        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(calctmp >= 5){
+//        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;
 }
 typedef enum{
     ULO_ALC_H = 0,
     ULO_ALC_L,
 };
-void ALC_Package_Operate(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st*      UL_Table,uint8_t TableIndex,uint8_t* ALC_Atten,uint8_t* UL_Main_Atten,uint8_t* GainOffset ){
+   
+void ALC_Package_Operate(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st*      UL_Table,uint8_t TableIndex,uint8_t* ALC_Atten,uint8_t* UL_Main_Atten,uint8_t* GainOffset,uint8_t* retrycnt ){
     /*static int16_t PrevLimitdata[ALC_Alarm_UL_Index_MAX] = {0,};
     static int8_t* ALC_Table;
     int16_t tmpcalc = 0;
@@ -5912,6 +5956,9 @@ void ALC_Package_Operate(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st
     int16_t Main_Atten = 0;
     int16_t GiveAttenPlusULAtten = 0;
 
+    if(*retrycnt > 0)
+        return;
+    
     UL_Atten = ALC_Atten[ULO_ALC_H] << 8 | ALC_Atten[ULO_ALC_L];
     Main_Atten = UL_Main_Atten[ULO_ALC_H] << 8 | UL_Main_Atten[ULO_ALC_L];
     Gain_Atten = GainOffset[ULO_ALC_H] << 8 | GainOffset[ULO_ALC_L];
@@ -5928,22 +5975,27 @@ void ALC_Package_Operate(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st
     ResdBm = AutoControl_ADC_Compare(ret,&UL_Table->Table_Det_15_dBm_H,UL_Table->Table_Length * 2,&UL_DET_Table_ref[TableIndex][TABLE_MAX_VALUE]);
     //ret 현재 Voltage 값 출력
     //ret 에 따른 현재 DBM 구현
-    ResultData = ResdBm;
+
     CurrentATTENVALUE = PE43711_Double(ALC_Atten[ULO_ALC_H],ALC_Atten[ULO_ALC_L]);
-    ULO_Level[ULO_ALC_H] = (ResultData & 0xFF00) >> 8;
-    ULO_Level[ULO_ALC_L] = (ResultData & 0x00FF);
+
 //    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);
+    ResdBm = HFR_CntUpCalc(ResdBm);
+    ResultData = ResdBm;
+//    printf("HFR CALC RET : %d \r\n",ResultData);
+    ULO_Level[ULO_ALC_H] = (ResultData & 0xFF00) >> 8;
+    ULO_Level[ULO_ALC_L] = (ResultData & 0x00FF);    
     Limitdata += (Main_Atten * 0.1);
-    ALC_Alarm_TimerSet(TableIndex,Limitdata,ResdBm,UL_Atten,Main_Atten);
+//    printf("Limitdata : %d | ResultData : %d \r\n",Limitdata,ResultData);
+    ALC_Alarm_TimerSet(TableIndex,Limitdata,ResultData,UL_Atten,Main_Atten);
     IwillGiveAtten = ALC_Calc(TableIndex,CurrentATTENVALUE,Limitdata,ResdBm);
 //    printf("STEP 1 : I WILL GIVE ATTEN  %d \r\n",IwillGiveAtten);
     IwillGiveAtten += UL_Atten;
 //    printf("STEP 2 : I WILL GIVE ATTEN PLUS  ALC ATTEN  %d \r\n",IwillGiveAtten);    
-    if(ResdBm <= (Limitdata - 3)){
+    if(ResdBm <= (Limitdata - 1)){
         if(IwillGiveAtten <= -10){
             IwillGiveAtten += 10;
         }
@@ -5983,9 +6035,17 @@ int16_t ResultData = 0;
     ResdBm = AutoControl_ADC_Compare(ret,&UL_Table->Table_Det_15_dBm_H,UL_Table->Table_Length * 2,&UL_DET_Table_ref[TableIndex][TABLE_MAX_VALUE]);
     //ret 현재 Voltage 값 출력
     //ret 에 따른 현재 DBM 구현
+    ResdBm = HFR_CntUpCalc(ResdBm);
     ResultData = ResdBm;
+//    printf("HFR CALC RET : %d \r\n",ResultData);
     ULO_Level[ULO_ALC_H] = (ResultData & 0xFF00) >> 8;
-    ULO_Level[ULO_ALC_L] = (ResultData & 0x00FF);
+    ULO_Level[ULO_ALC_L] = (ResultData & 0x00FF);  
+
+
+//    
+//    ResultData = ResdBm;
+//    ULO_Level[ULO_ALC_H] = (ResultData & 0xFF00) >> 8;
+//    ULO_Level[ULO_ALC_L] = (ResultData & 0x00FF);
 //    printf("============ALC_OFF======START================\r\n");
 //    printf("Current UL ADC VALUE : %f \r\n",ret);
 //    printf("ResdBm : UL1 : %f \r\n",ResdBm);
@@ -6143,29 +6203,35 @@ void ALC_Function(){ //DL
                             ALC_Alarm_UL1_Index,
                             &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H,
                             &bluecell_Currdatastatus.ATT_UL1_H,
-                            &bluecell_Currdatastatus.bluecell_User_UL1_H);
+                            &bluecell_Currdatastatus.bluecell_User_UL1_H,
+                            &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1);
+#if 1 // PYJ.2020.07.01_BEGIN -- 
         ALC_Package_Operate(&bluecell_Currdatastatus.ULO_P2_Level2_H,
                             &bluecell_Currdatastatus.ULO_Level2_H,
                             &Det_UL2.Table_Det_15_dBm_H,
                             ALC_Alarm_UL2_Index,
                             &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H,
                             &bluecell_Currdatastatus.ATT_UL2_H,
-                            &bluecell_Currdatastatus.bluecell_User_UL2_H);
+                            &bluecell_Currdatastatus.bluecell_User_UL2_H,
+                            &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2);
         ALC_Package_Operate(&bluecell_Currdatastatus.ULO_P3_Level3_H,
                             &bluecell_Currdatastatus.ULO_Level3_H,
                             &Det_UL3.Table_Det_15_dBm_H,
                             ALC_Alarm_UL3_Index,
                             &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H,
                             &bluecell_Currdatastatus.ATT_UL3_H,
-                            &bluecell_Currdatastatus.bluecell_User_UL3_H);
+                            &bluecell_Currdatastatus.bluecell_User_UL3_H,
+                            &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3);
         ALC_Package_Operate(&bluecell_Currdatastatus.ULO_P4_Level4_H,
                             &bluecell_Currdatastatus.ULO_Level4_H,
                             &Det_UL4.Table_Det_15_dBm_H,
                             ALC_Alarm_UL4_Index,
                             &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H,
                             &bluecell_Currdatastatus.ATT_UL4_H,
-                            &bluecell_Currdatastatus.bluecell_User_UL4_H);
+                            &bluecell_Currdatastatus.bluecell_User_UL4_H,
+                            &bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4);
         
+#endif // PYJ.2020.07.01_END -- 
         
 
 
@@ -6508,6 +6574,7 @@ void ALC_Function(){ //DL
             printf("==================END================\r\n");
 #endif // PYJ.2020.06.20_END -- 
 #else
+#if 0 // PYJ.2020.07.01_BEGIN -- 
             UL_Curr_Level(&bluecell_Currdatastatus.ULO_P1_Level1_H,
                           &bluecell_Currdatastatus.ULO_Level1_H,
                           &Det_UL1.Table_Det_15_dBm_H,
@@ -6524,6 +6591,7 @@ void ALC_Function(){ //DL
                           &bluecell_Currdatastatus.ULO_Level4_H,
                           &Det_UL4.Table_Det_15_dBm_H,
                            ALC_Alarm_UL4_Index);            
+#endif // PYJ.2020.07.01_END -- 
 
 
 #endif // PYJ.2020.06.21_END -- 
@@ -6605,6 +6673,22 @@ void ALC_Function(){ //DL
 #endif // PYJ.2020.06.20_END -- 
 
         }
+        UL_Curr_Level(&bluecell_Currdatastatus.ULO_P1_Level1_H,
+                      &bluecell_Currdatastatus.ULO_Level1_H,
+                      &Det_UL1.Table_Det_15_dBm_H,
+                       ALC_Alarm_UL1_Index);
+        UL_Curr_Level(&bluecell_Currdatastatus.ULO_P2_Level2_H,
+                      &bluecell_Currdatastatus.ULO_Level2_H,
+                      &Det_UL2.Table_Det_15_dBm_H,
+                       ALC_Alarm_UL2_Index);
+        UL_Curr_Level(&bluecell_Currdatastatus.ULO_P3_Level3_H,
+                      &bluecell_Currdatastatus.ULO_Level3_H,
+                      &Det_UL3.Table_Det_15_dBm_H,
+                       ALC_Alarm_UL3_Index);
+        UL_Curr_Level(&bluecell_Currdatastatus.ULO_P4_Level4_H,
+                      &bluecell_Currdatastatus.ULO_Level4_H,
+                      &Det_UL4.Table_Det_15_dBm_H,
+                       ALC_Alarm_UL4_Index);             
     }
 }
 //-15 ~ -5

Bluecell_Src/uart.c

@@ -120,7 +120,7 @@ void GetDataFromUartQueue(UART_HandleTypeDef *huart)
                if(Chksum_Check(uart_buf,MBIC_HEADER_SIZE - 4,uart_buf[MBIC_CHECKSHUM_INDEX]))
                {
                     Length = ((uart_buf[MBIC_LENGTH_0] << 8) | uart_buf[MBIC_LENGTH_1]);
-                    CrcChk = ((uart_buf[MBIC_PAYLOADSTART + Length + 1] << 8) | (uart_buf[MBIC_PAYLOADSTART + Length + 2]));
+                    CrcChk = ((uart_buf[MBIC_PAYLOADSTART + Length ] << 8) | (uart_buf[MBIC_PAYLOADSTART + Length + 1]));
                     if(CRC16_Check(&uart_buf[MBIC_PAYLOADSTART], Length,CrcChk))
                         MBIC_Operate(uart_buf);
                     else

STM32F103ZET_JDASMBIC.elf.launch

@@ -57,5 +57,5 @@
 </listAttribute>
 <stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#13;&#10;&lt;memoryBlockExpressionList context=&quot;reserved-for-future-use&quot;/&gt;&#13;&#10;"/>
 <stringAttribute key="process_factory_id" value="org.eclipse.cdt.dsf.gdb.GdbProcessFactory"/>
-<stringAttribute key="saved_expressions&lt;seperator&gt;Unknown" value="uart_buf,0x08005000,0x8005000,Bank2data,data,Currdata,Currdata[MBIC_BOOT_VERSION + 2],Bank1data,retrycnt,MBIC_DL_ShutdownCount,MBIC_DL_ShutdownCount[3],MBIC_DL_ShutdownCount[0],MBIC_DL_ShutdownCount[1],MBIC_DL_ShutdownCount[2],MBIC_DL_ShutdownCount[4]"/>
+<stringAttribute key="saved_expressions&lt;seperator&gt;Unknown" value="0x08005000,0x8005000,Bank2data,data,Currdata,Currdata[MBIC_BOOT_VERSION + 2],Bank1data,retrycnt,MBIC_DL_ShutdownCount,MBIC_DL_ShutdownCount[3],MBIC_DL_ShutdownCount[0],MBIC_DL_ShutdownCount[1],MBIC_DL_ShutdownCount[2],MBIC_DL_ShutdownCount[4],ALC_AlarmSet"/>
 </launchConfiguration>