ALC Testing 중... ALC 정상 동작 / HFR 알고리즘 아직 미구현 / ALC 동작 최소 동작 시간 0.5초로 변경 / Shutdown 알고리즘 을 위한 타이머 조건문 추가 /

Bluecell_Src/Bluecell_operate.c

@@ -108,6 +108,8 @@ uint8_t DataWrite[sizeof(BLUESTATUS_st)] = {0,};
 uint8_t Txdata[512];
 int8_t AutoControl_Save[MBIC_Table_INDEX][sizeof(ALC_dBm_t)];
 uint16_t ADC1Ret[4];
+bool UL_ALC_GainAttenSet[ALC_Alarm_UL_Index_MAX] = {false,};
+int16_t ALC_Level_Save[ALC_Alarm_UL_Index_MAX] = {0,};
 bool Initialize = false;
 
 uint16_t ADC3Ret[5];
@@ -3756,24 +3758,43 @@ bool MBIC_Operate(uint8_t* data){
             case  ULO_Gain_Atten1                         :
                 bluecell_Currdatastatus.ATT_UL1_H = data[MBIC_PAYLOADSTART + 3]; 
                 bluecell_Currdatastatus.ATT_UL1_L = data[MBIC_PAYLOADSTART + 4]; 
+                if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+                    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;
+                }
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
                 break;
             case  ULO_Gain_Atten2                         :
                 bluecell_Currdatastatus.ATT_UL2_H = data[MBIC_PAYLOADSTART + 3]; 
                 bluecell_Currdatastatus.ATT_UL2_L = data[MBIC_PAYLOADSTART + 4]; 
+                if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+                    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);
 
                 break;
             case  ULO_Gain_Atten3                         :
                 bluecell_Currdatastatus.ATT_UL3_H = data[MBIC_PAYLOADSTART + 3]; 
                 bluecell_Currdatastatus.ATT_UL3_L = data[MBIC_PAYLOADSTART + 4]; 
+                if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+                    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);
 
                 break;
             case  ULO_Gain_Atten4                         :
                 bluecell_Currdatastatus.ATT_UL4_H = data[MBIC_PAYLOADSTART + 3]; 
                 bluecell_Currdatastatus.ATT_UL4_L = data[MBIC_PAYLOADSTART + 4]; 
+                if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+                    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);
 
                 break;
@@ -4838,11 +4859,11 @@ double AGC_AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t
 //        for(int a = 0; a < sizeof(AGC_dBm_t); a++)
 //            printf("AutoControl_Save[%d] : %d \r\n",a,AutoControl_Save[a]);
     if(first_data < CurrentAdc){
-        printf("(RefTable_Data[0]) : %d \r\n",(RefTable_Data[0]));
+//        printf("(RefTable_Data[0]) : %d \r\n",(RefTable_Data[0]));
         return (RefTable_Data[0]);
     }else{
-        printf("Nomal _Table Data %f",(RefTable_Data[LastIndex] - (dot * 0.1)));
-        printf("LastIndex : %d  / dot : %d  TableAdc : %f \r\n",LastIndex,dot,(RefTable_Data[LastIndex] - (dot * 0.1)));
+//        printf("Nomal _Table Data %f",(RefTable_Data[LastIndex] - (dot * 0.1)));
+//        printf("LastIndex : %d  / dot : %d  TableAdc : %f \r\n",LastIndex,dot,(RefTable_Data[LastIndex] - (dot * 0.1)));
         return (RefTable_Data[LastIndex] - (dot * 0.1));
     }
 }
@@ -4979,17 +5000,32 @@ void ALC_Function(){ //DL
   //  int32_t CurrnALC_MIN_SettingValue = 0;
   //  int32_t ALC_Result = 0;
     int16_t Limitdata = 0;
+    static int16_t PrevLimitdata[ALC_Alarm_UL_Index_MAX] = {0,};
     double ResdBm = 0;
     int16_t ResultData = 0;
+    int16_t PrevResultData[ALC_Alarm_UL_Index_MAX] = {0,};    
     int16_t IwillGiveAtten = 0;
     static int8_t* ALC_Table;
+    int16_t tmpcalc = 0;
+    int16_t UL_Atten[ALC_Alarm_UL_Index_MAX] = {0,};
+    int16_t Main_Atten[ALC_Alarm_UL_Index_MAX] = {0,};
+    static int16_t PrevIwillGiveAtten[ALC_Alarm_UL_Index_MAX] ={0,};
 //    uint8_t tempadc[256];
 
     
 //    Bluecell_StructCpy(&AutoControl_Save[0],&ALC_Table_ref.DET_UL_0,sizeof(ALC_dBm_t));
 //    Bluecell_StructCpy(&tempadc[0],&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-    if(ALCTimerCnt > 400){
+    if(ALCTimerCnt > 500){
         if(bluecell_Currdatastatus.ULO_ALC_ON_OFF == true){
+            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;
+            UL_Atten[ALC_Alarm_UL4_Index] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
+            Main_Atten[ALC_Alarm_UL1_Index] = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
+            Main_Atten[ALC_Alarm_UL2_Index] = bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L;
+            Main_Atten[ALC_Alarm_UL3_Index] = bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L;
+            Main_Atten[ALC_Alarm_UL4_Index] = bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L;
+            
 #if 1 // PYJ.2020.06.20_BEGIN -- 
             /***************************************************************************************************************/
             /*                                             ALC 1                                                           */
@@ -5004,22 +5040,23 @@ void ALC_Function(){ //DL
             
             Limitdata = (( bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8) & 0xFF00) ;
             Limitdata +=  bluecell_Currdatastatus.ULO_ALC_Threshold_L ;
+            
             Limitdata /= 10;
             
             
             ResdBm = AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,Det_UL1.Table_Length * 2,ALC_Table);
             ResultData = ResdBm;
-#if 0 // PYJ.2020.06.20_BEGIN -- 
-            printf("==================START================\r\n");
+#if 1 // PYJ.2020.06.20_BEGIN -- 
+            printf("=============ALC ON =====START================\r\n");
             printf("Current UL ADC VALUE : %f \r\n",ret);
             printf("ResdBm : UL1 : %f \r\n",ResdBm);
-            printf("ResdBm  : %x /////  bluecell_Currdatastatus.ULO_Level1_H : %x \r\n",ResultData,bluecell_Currdatastatus.ULO_Level1_H);
-            printf("ResdBm  : %x /////  bluecell_Currdatastatus.ULO_Level1_L : %x \r\n",ResultData,bluecell_Currdatastatus.ULO_Level1_L);            
-            printf("==================END================\r\n");
+//            printf("ResdBm  : %x /////  bluecell_Currdatastatus.ULO_Level1_H : %x \r\n",ResultData,bluecell_Currdatastatus.ULO_Level1_H);
+//            printf("ResdBm  : %x /////  bluecell_Currdatastatus.ULO_Level1_L : %x \r\n",ResultData,bluecell_Currdatastatus.ULO_Level1_L);            
+
 #endif // PYJ.2020.06.20_END -- 
 
             
-            CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL1_H,bluecell_Currdatastatus.ATT_UL1_L);
+//            CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL1_H,bluecell_Currdatastatus.ATT_UL1_L);
 
             bluecell_Currdatastatus.ULO_Level1_H = ((int16_t)ResultData & 0xFF00) >> 8;
             bluecell_Currdatastatus.ULO_Level1_L = ((int16_t)ResultData & 0x00FF);
@@ -5047,10 +5084,29 @@ void ALC_Function(){ //DL
 
                 bluecell_Currdatastatus.ULO_Level1_H = ((int16_t)ResultData & 0xFF00) >> 8;
                 bluecell_Currdatastatus.ULO_Level1_L = ((int16_t)ResultData & 0x00FF);       
+                printf("ORIGIN ResdBm : %f  %d\r\n",ResdBm,Main_Atten[ALC_Alarm_UL1_Index]);
+                printf("After ResdBm : %f \r\n",ResdBm);
+                Limitdata += (Main_Atten[ALC_Alarm_UL1_Index] / 10);
                 IwillGiveAtten = ALC_Calc(ALC_Alarm_UL1_Index,CurrentATTENVALUE,Limitdata,ResdBm);
-//                printf("CurrentATTENVALUE : %f I WILL GIVE ATTEN  : %d \r\n",CurrentATTENVALUE,IwillGiveAtten);  
-//                printf("ADC : %f Current : %f  Threas : %d : I WILL GIVE ATTEN  : %f \r\n",ret,ResdBm , Limitdata,IwillGiveAtten);  
+                //IwillGiveAtten = ALC_Calc(ALC_Alarm_UL1_Index,CurrentATTENVALUE,Limitdata,ResdBm);                
                 
+//                ResdBm = ResdBm + (Main_Atten[ALC_Alarm_UL1_Index] / 10);
+                IwillGiveAtten += UL_Atten[ALC_Alarm_UL1_Index];
+                if(ResdBm <= (Limitdata - 3)){
+                    if(IwillGiveAtten <= -10){
+                        IwillGiveAtten += 10;
+                    }
+                }
+
+                if(UL_Atten[ALC_Alarm_UL1_Index] + IwillGiveAtten <= -200){
+
+                    tmpcalc = (-200 + (Main_Atten[ALC_Alarm_UL1_Index] * -1));
+                    IwillGiveAtten =tmpcalc;
+                }
+                    
+                printf(" UL_Atten[ALC_Alarm_UL1_Index] : %d I WILL GIVE ATTEN  : %d \r\n", UL_Atten[ALC_Alarm_UL1_Index],IwillGiveAtten);  
+                printf("ADC : %f CURR ATT : %f  Threas : %d : I WILL GIVE ATTEN  : %d \r\n",ret,ResdBm , Limitdata,IwillGiveAtten);  
+                printf("==================END================\r\n");                
 
 //                printf("CurrentATTENVALUE : %f \r\n",CurrentATTENVALUE);
 //                if(CurrentATTENVALUE < 20 && IwillGiveAtten != 0){
@@ -5061,13 +5117,22 @@ void ALC_Function(){ //DL
 //                printf("CurrentATTENVALUE : %f I WILL GIVE ATTEN  : %d \r\n",CurrentATTENVALUE,IwillGiveAtten);  
 //                if(IwillGiveAtten < 0)
 //                printf("CurrentATTENVALUE %f \r\n",CurrentATTENVALUE);
-                if( (IwillGiveAtten > 0) || (CurrentATTENVALUE >= (IwillGiveAtten))){
-                    tempcurratten = CurrentATTENVALUE * 10;
-                    bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H = (((uint16_t)((tempcurratten + IwillGiveAtten)) & 0xFF00) >> 8);
-                    bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L = ((uint16_t)(tempcurratten + IwillGiveAtten)) & 0x00FF;
-                    CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+/*                if(ALC_Level_Save[ALC_Alarm_UL1_Index] != ResultData
+                    || Limitdata != PrevLimitdata[ALC_Alarm_UL1_Index])*/
+                    if(Limitdata != PrevLimitdata[ALC_Alarm_UL1_Index]
+                       ||ResultData!= PrevResultData[ALC_Alarm_UL1_Index]
+                       ||UL_ALC_GainAttenSet[ALC_Alarm_UL1_Index] == true){
+                        if( (IwillGiveAtten > 0) || (CurrentATTENVALUE >= (IwillGiveAtten))){
+                            tempcurratten = CurrentATTENVALUE * 10;
+                            bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H = (((uint16_t)((tempcurratten + IwillGiveAtten)) & 0xFF00) >> 8);
+                            bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L = ((uint16_t)(tempcurratten + IwillGiveAtten)) & 0x00FF;
+                            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+                        }
+                        PrevLimitdata[ALC_Alarm_UL1_Index] = Limitdata; 
+                        PrevResultData[ALC_Alarm_UL1_Index] = ResultData;
+                        UL_ALC_GainAttenSet[ALC_Alarm_UL1_Index] = false;
                 }
-                CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H,bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L);             
+//                CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H,bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L);             
 
 //                 printf("CurrentATTENVALUE : %f\r\n",CurrentATTENVALUE );  
 //                 printf("==================END================\r\n");
@@ -5223,7 +5288,7 @@ void ALC_Function(){ //DL
 //            }
             bluecell_Currdatastatus.ULO_Level1_H = ((int16_t)ResultData & 0xFF00) >> 8;
             bluecell_Currdatastatus.ULO_Level1_L = ((int16_t)ResultData & 0x00FF);
-#if 0 // PYJ.2020.06.20_BEGIN -- 
+#if 1 // PYJ.2020.06.20_BEGIN -- 
             printf("============ALC_OFF======START================\r\n");
             printf("Current UL ADC VALUE : %f \r\n",ret);
             printf("ResdBm : UL1 : %f \r\n",ResdBm);
@@ -6333,7 +6398,8 @@ void ULO_ShutdownAlarmCheck(){
 
         }
         else{
-            if(DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC){
+            if(DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC
+                && bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1 != RETRYCNT_MAX){
                 bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~ALARM_ULO_SHUTDOWN_P1;
                 bluecell_Currdatastatus.ULO_Shutdown_Alarm1       = false;            
             }
@@ -6409,7 +6475,8 @@ void ULO_ShutdownAlarmCheck(){
 #endif // PYJ.2020.06.21_END -- 
         }
         else{
-            if(DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL2_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC){
+            if(DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL2_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC
+                && bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2!= RETRYCNT_MAX){
                 bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~ALARM_ULO_SHUTDOWN_P2;
                 bluecell_Currdatastatus.ULO_Shutdown_Alarm2       = false;            
             }
@@ -6452,7 +6519,8 @@ void ULO_ShutdownAlarmCheck(){
 
         }
         else{
-            if(DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL3_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC){
+            if(DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL3_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC
+                && bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3 != RETRYCNT_MAX){
                 bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~ALARM_ULO_SHUTDOWN_P3;
                 bluecell_Currdatastatus.ULO_Shutdown_Alarm3       = false;            
             }
@@ -6497,7 +6565,8 @@ void ULO_ShutdownAlarmCheck(){
 
         }
         else{
-            if(DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL4_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC){
+            if(DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL4_Shutdown_Index] >= MBIC_OFF_MAINTAIN_SEC
+                && bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 != RETRYCNT_MAX){
                 bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~ALARM_ULO_SHUTDOWN_P4;
                 bluecell_Currdatastatus.ULO_Shutdown_Alarm4       = false;            
             }

Src/main.c

@@ -430,7 +430,7 @@ int main(void)  {
 //  Bluecell_AttenInitialize();
 #if 1 // PYJ.2020.05.06_BEGIN -- 
       printf("****************************************\r\n");
-      printf("MBIC Project _ COPY _\r\n");
+      printf("MBIC Project\r\n");
       printf("Build at %s %s\r\n", __DATE__, __TIME__);
       printf("Copyright (c) 2020. BLUECELL\r\n");
       printf("****************************************\r\n");
@@ -442,9 +442,9 @@ int main(void)  {
   //   printf("data %d\r\n",LedTimerCnt);
     Boot_LED_Toggle(); /*LED Check*/
     Uart_Check();      /*Usart Rx*/
-    ADC_Check();       /*Det Calc + DL/UL Alarm Check Function*/
     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*/
 //    Uart1_Data_Send("A",1);
 //    HAL_Delay(1);