MBIC ThresHlod Get Set 추가 / 속도 변경

Bluecell_Inc/Bluecell_operate.h

@@ -281,8 +281,31 @@ enum DATATYPE
     Bluecell_UL2_USER = 0x85,
     Bluecell_UL3_USER = 0x86,
     Bluecell_UL4_USER = 0x87,    
-    Bluecell_TEMP_USER = 0x88,    
-    
+    Bluecell_TEMP_USER = 0x88,
+    Bluecell_DLI_AGC_ON_OFF,
+    Bluecell_ULO_ALC_ON_OFF,
+    Bluecell_DLI_AGC_Threshold,
+    Bluecell_DLI_AGC_Threshold_Default,
+    Bluecell_DLI_Shutdown_ON_OFF,  
+    Bluecell_DLI_Shutdown_Threshold,
+    Bluecell_DLI_Shutdown_Threshold_Default,
+    Bluecell_DLI_Shutdown_Count,
+    Bluecell_DLI_Level_High_Threshold                ,
+    Bluecell_DLI_Level_Low_Threshold                 ,
+    Bluecell_DLI_Level_High_Low_Threshold_default    ,
+    Bluecell_LED_TEST  ,
+    Bluecell_Temperature_Offset                      ,
+    Bluecell_Temp_High_Threshold                     ,
+    Bluecell_Temp_High_Threshold_Default             ,     
+    Bluecell_ULO_Level_High_Threshold                ,
+    Bluecell_ULO_Level_High_Threshold_default        ,    
+    Bluecell_ULO_ALC_Threshold                       ,
+    Bluecell_ULO_ALC_Threshold_Default               ,
+    Bluecell_ULO_Shutdown_ON_OFF                     ,
+    Bluecell_ULO_Shutdown_Threshold                  ,
+    Bluecell_ULO_Shutdown_Threshold_Default          ,
+    Bluecell_ULO_Shutdown_Retry_Count                ,
+
 };
 
 /*FLAG BIT START */
@@ -448,7 +471,7 @@ typedef struct{
     uint8_t DLI_Level_Low_Threshold_H;
     uint8_t DLI_Level_Low_Threshold_L;
     uint8_t DLI_Level_High_Low_Threshold_default;
-    uint8_t ALARM_TEMP_HIGH;
+    uint8_t ALARM_TEMP_HIGH; //bit
     uint8_t ALARM_DLI_Level;
     uint8_t ALARM_DLI_AGC_SHTUTDOWN;
     uint8_t ALARM_ULO_Level;
@@ -551,15 +574,28 @@ typedef struct{
     uint8_t DLI_Shutdown_Alarm4;
 
     
-    uint8_t ULO_Level_High_Threshold;
 
     
     uint8_t ULO_Level_High_Threshold_H;
     uint8_t ULO_Level_High_Threshold_L;
     
     uint8_t ULO_Level_High_Threshold_default;
-    uint8_t ULO_Level;
-    
+    uint8_t ULO_Level1_H;
+    uint8_t ULO_Level1_L;
+    uint8_t ULO_Level2_H;
+    uint8_t ULO_Level2_L;
+    uint8_t ULO_Level3_H;
+    uint8_t ULO_Level3_L;
+    uint8_t ULO_Level4_H;
+    uint8_t ULO_Level4_L;
+    uint8_t DLI_Level1_H;
+    uint8_t DLI_Level1_L;
+    uint8_t DLI_Level2_H;
+    uint8_t DLI_Level2_L;
+    uint8_t DLI_Level3_H;
+    uint8_t DLI_Level3_L;
+    uint8_t DLI_Level4_H;
+    uint8_t DLI_Level4_L;
     uint8_t ULO_Level_High_Alarm1;
     uint8_t ULO_Level_High_Alarm2;
     uint8_t ULO_Level_High_Alarm3;
@@ -584,8 +620,6 @@ typedef struct{
     uint8_t ULO_Shutdown_Alarm2;
     uint8_t ULO_Shutdown_Alarm3;
     uint8_t ULO_Shutdown_Alarm4;
-
-    
     uint8_t bluecell_crc;
     uint8_t bluecell_etx;
 
@@ -786,52 +820,98 @@ typedef struct{
     uint8_t Table_Det_25_dBm_L	;
 }DET_TABLEDL_st;
 typedef struct{
-  uint8_t Table_Det_15_dBm_H	;   uint8_t Table_Det_15_dBm_L	;
-  uint8_t Table_Det_16_dBm_H	;   uint8_t Table_Det_16_dBm_L	;
-  uint8_t Table_Det_17_dBm_H	;   uint8_t Table_Det_17_dBm_L	;
-  uint8_t Table_Det_18_dBm_H	;   uint8_t Table_Det_18_dBm_L	;
-  uint8_t Table_Det_19_dBm_H	;   uint8_t Table_Det_19_dBm_L	;
-  uint8_t Table_Det_20_dBm_H	;   uint8_t Table_Det_20_dBm_L	;
-  uint8_t Table_Det_21_dBm_H	;   uint8_t Table_Det_21_dBm_L	;
-  uint8_t Table_Det_22_dBm_H	;   uint8_t Table_Det_22_dBm_L	;
-  uint8_t Table_Det_23_dBm_H	;   uint8_t Table_Det_23_dBm_L	;
-  uint8_t Table_Det_24_dBm_H	;   uint8_t Table_Det_24_dBm_L	;
-  uint8_t Table_Det_25_dBm_H	;   uint8_t Table_Det_25_dBm_L	;
-  uint8_t Table_Det_26_dBm_H	;   uint8_t Table_Det_26_dBm_L	;
-  uint8_t Table_Det_27_dBm_H	;   uint8_t Table_Det_27_dBm_L	;
-  uint8_t Table_Det_28_dBm_H	;   uint8_t Table_Det_28_dBm_L	;
-  uint8_t Table_Det_29_dBm_H	;   uint8_t Table_Det_29_dBm_L	;
-  uint8_t Table_Det_30_dBm_H	;   uint8_t Table_Det_30_dBm_L	;
-  uint8_t Table_Det_31_dBm_H	;   uint8_t Table_Det_31_dBm_L	;
-  uint8_t Table_Det_32_dBm_H	;   uint8_t Table_Det_32_dBm_L	;
-  uint8_t Table_Det_33_dBm_H	;   uint8_t Table_Det_33_dBm_L	;
-  uint8_t Table_Det_34_dBm_H	;   uint8_t Table_Det_34_dBm_L	;
-  uint8_t Table_Det_35_dBm_H	;   uint8_t Table_Det_35_dBm_L	;
-  uint8_t Table_Det_36_dBm_H	;   uint8_t Table_Det_36_dBm_L	;
-  uint8_t Table_Det_37_dBm_H	;   uint8_t Table_Det_37_dBm_L	;
-  uint8_t Table_Det_38_dBm_H	;   uint8_t Table_Det_38_dBm_L	;
-  uint8_t Table_Det_39_dBm_H	;   uint8_t Table_Det_39_dBm_L	;
-  uint8_t Table_Det_40_dBm_H	;   uint8_t Table_Det_40_dBm_L	;
-  uint8_t Table_Det_41_dBm_H	;   uint8_t Table_Det_41_dBm_L	;
-  uint8_t Table_Det_42_dBm_H	;   uint8_t Table_Det_42_dBm_L	;
-  uint8_t Table_Det_43_dBm_H	;   uint8_t Table_Det_43_dBm_L	;
-  uint8_t Table_Det_44_dBm_H	;   uint8_t Table_Det_44_dBm_L	;
-  uint8_t Table_Det_45_dBm_H	;   uint8_t Table_Det_45_dBm_L	;
-  uint8_t Table_Det_46_dBm_H	;   uint8_t Table_Det_46_dBm_L	;
-  uint8_t Table_Det_47_dBm_H	;   uint8_t Table_Det_47_dBm_L	;
-  uint8_t Table_Det_48_dBm_H	;   uint8_t Table_Det_48_dBm_L	;
-  uint8_t Table_Det_49_dBm_H	;   uint8_t Table_Det_49_dBm_L	;
-  uint8_t Table_Det_50_dBm_H	;   uint8_t Table_Det_50_dBm_L	;
-  uint8_t Table_Det_51_dBm_H	;   uint8_t Table_Det_51_dBm_L	;
-  uint8_t Table_Det_52_dBm_H	;   uint8_t Table_Det_52_dBm_L	;
-  uint8_t Table_Det_53_dBm_H	;   uint8_t Table_Det_53_dBm_L	;
-  uint8_t Table_Det_54_dBm_H	;   uint8_t Table_Det_54_dBm_L	;
-  uint8_t Table_Det_55_dBm_H	;   uint8_t Table_Det_55_dBm_L	;
-  uint8_t Table_Det_56_dBm_H	;   uint8_t Table_Det_56_dBm_L	;
-  uint8_t Table_Det_57_dBm_H	;   uint8_t Table_Det_57_dBm_L	;
-  uint8_t Table_Det_58_dBm_H	;   uint8_t Table_Det_58_dBm_L	;
-  uint8_t Table_Det_59_dBm_H	;   uint8_t Table_Det_59_dBm_L	;
-  uint8_t Table_Det_60_dBm_H	;   uint8_t Table_Det_60_dBm_L	;
+  uint8_t Table_Det_15_dBm_H	;   
+  uint8_t Table_Det_15_dBm_L	;
+  uint8_t Table_Det_16_dBm_H	;   
+  uint8_t Table_Det_16_dBm_L	;
+  uint8_t Table_Det_17_dBm_H	;   
+  uint8_t Table_Det_17_dBm_L	;
+  uint8_t Table_Det_18_dBm_H	;   
+  uint8_t Table_Det_18_dBm_L	;
+  uint8_t Table_Det_19_dBm_H	;   
+  uint8_t Table_Det_19_dBm_L	;
+  uint8_t Table_Det_20_dBm_H	;//1.8
+  uint8_t Table_Det_20_dBm_L	;//1.6
+  uint8_t Table_Det_21_dBm_H	;//1.4   
+  uint8_t Table_Det_21_dBm_L	;
+  uint8_t Table_Det_22_dBm_H	;   
+  uint8_t Table_Det_22_dBm_L	;
+  uint8_t Table_Det_23_dBm_H	;   
+  uint8_t Table_Det_23_dBm_L	;
+  uint8_t Table_Det_24_dBm_H	;   
+  uint8_t Table_Det_24_dBm_L	;
+  uint8_t Table_Det_25_dBm_H	;   
+  uint8_t Table_Det_25_dBm_L	;
+  uint8_t Table_Det_26_dBm_H	;   
+  uint8_t Table_Det_26_dBm_L	;
+  uint8_t Table_Det_27_dBm_H	;   
+  uint8_t Table_Det_27_dBm_L	;
+  uint8_t Table_Det_28_dBm_H	;   
+  uint8_t Table_Det_28_dBm_L	;
+  uint8_t Table_Det_29_dBm_H	;   
+  uint8_t Table_Det_29_dBm_L	;
+  uint8_t Table_Det_30_dBm_H	;   
+  uint8_t Table_Det_30_dBm_L	;
+  uint8_t Table_Det_31_dBm_H	;   
+  uint8_t Table_Det_31_dBm_L	;
+  uint8_t Table_Det_32_dBm_H	;   
+  uint8_t Table_Det_32_dBm_L	;
+  uint8_t Table_Det_33_dBm_H	;   
+  uint8_t Table_Det_33_dBm_L	;
+  uint8_t Table_Det_34_dBm_H	;   
+  uint8_t Table_Det_34_dBm_L	;
+  uint8_t Table_Det_35_dBm_H	;   
+  uint8_t Table_Det_35_dBm_L	;
+  uint8_t Table_Det_36_dBm_H	;  
+  uint8_t Table_Det_36_dBm_L	;
+  uint8_t Table_Det_37_dBm_H	;  
+  uint8_t Table_Det_37_dBm_L	;
+  uint8_t Table_Det_38_dBm_H	;   
+  uint8_t Table_Det_38_dBm_L	;
+  uint8_t Table_Det_39_dBm_H	;  
+  uint8_t Table_Det_39_dBm_L	;
+  uint8_t Table_Det_40_dBm_H	;  
+  uint8_t Table_Det_40_dBm_L	;
+  uint8_t Table_Det_41_dBm_H	;  
+  uint8_t Table_Det_41_dBm_L	;
+  uint8_t Table_Det_42_dBm_H	; 
+  uint8_t Table_Det_42_dBm_L	;
+  uint8_t Table_Det_43_dBm_H	;  
+  uint8_t Table_Det_43_dBm_L	;
+  uint8_t Table_Det_44_dBm_H	;  
+  uint8_t Table_Det_44_dBm_L	;
+  uint8_t Table_Det_45_dBm_H	;  
+  uint8_t Table_Det_45_dBm_L	;
+  uint8_t Table_Det_46_dBm_H	;   
+  uint8_t Table_Det_46_dBm_L	;
+  uint8_t Table_Det_47_dBm_H	; 
+  uint8_t Table_Det_47_dBm_L	;
+  uint8_t Table_Det_48_dBm_H	;   
+  uint8_t Table_Det_48_dBm_L	;
+  uint8_t Table_Det_49_dBm_H	; 
+  uint8_t Table_Det_49_dBm_L	;
+  uint8_t Table_Det_50_dBm_H	;  
+  uint8_t Table_Det_50_dBm_L	;
+  uint8_t Table_Det_51_dBm_H	;  
+  uint8_t Table_Det_51_dBm_L	;
+  uint8_t Table_Det_52_dBm_H	;  
+  uint8_t Table_Det_52_dBm_L	;
+  uint8_t Table_Det_53_dBm_H	;  
+  uint8_t Table_Det_53_dBm_L	;
+  uint8_t Table_Det_54_dBm_H	;  
+  uint8_t Table_Det_54_dBm_L	;
+  uint8_t Table_Det_55_dBm_H	;  
+  uint8_t Table_Det_55_dBm_L	;
+  uint8_t Table_Det_56_dBm_H	;  
+  uint8_t Table_Det_56_dBm_L	;
+  uint8_t Table_Det_57_dBm_H	;  
+  uint8_t Table_Det_57_dBm_L	;
+  uint8_t Table_Det_58_dBm_H	;  
+  uint8_t Table_Det_58_dBm_L	;
+  uint8_t Table_Det_59_dBm_H	;  
+  uint8_t Table_Det_59_dBm_L	;
+  uint8_t Table_Det_60_dBm_H	;   
+  uint8_t Table_Det_60_dBm_L	;
 }DET_TABLEUL_st;
 
 typedef struct{

Bluecell_Src/Bluecell_operate.c

@@ -1,5 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include <math.h>
+
 #include "main.h"
 #include "Bluecell_operate.h"
 #include "PE43711.h"
@@ -9,6 +11,8 @@ extern volatile uint32_t LedTimerCnt;
 extern volatile uint32_t AdcTimerCnt;
 extern void PE43711_atten_ctrl(PE43711_st ATT ,uint8_t data);
 extern void Uart1_Data_Send(uint8_t* data,uint8_t size);
+nt8_t AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size);
+
 uint8_t Alarm_Status[MAX_ALARM_Len] = {0,};
 //uint8_t data123[10000];
 uint8_t ResultData[1024] = {0,};
@@ -249,7 +253,7 @@ double TableAtteGuarantee(uint8_t* Table,double AttenValue);
 uint8_t PE43711_Calc(uint8_t* Table,uint8_t high_bit,uint8_t low_bit,uint8_t offset_h,uint8_t offset_l);
 uint8_t PE43711_Calc_NoTable(uint8_t high_bit,uint8_t low_bit);
 double PE43711_Double(uint8_t high_bit,uint8_t low_bit);
-uint8_t AutoControl_Save[sizeof(ALC_dBm_t)];
+int8_t AutoControl_Save[sizeof(ALC_dBm_t)];
 
 uint8_t MBIC_TxDataArray[256] = {0,};
 
@@ -1280,15 +1284,15 @@ bool Bluecell_Operate(uint8_t* data){
     case Bluecell_StatusReq:
         DataStatusSet();
         Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
-        Txdata[BLUECELL_LENGTH] = sizeof(BLUESTATUS_st) - 3;
-        Txdata[sizeof(BLUESTATUS_st) - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]);
+        Txdata[BLUECELL_LENGTH] = 94 - 3;//sizeof(BLUESTATUS_st) - 3;
+        Txdata[94 - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]);
 #if 0 // PYJ.2020.04.22_BEGIN -- 
         for(int i = 0 ; i < sizeof(BLUESTATUS_st); i++ ){
             printf("%x ",Txdata[i]);
         }
         printf("\r\n");
 #endif // PYJ.2020.04.22_END --    
-        Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st));
+        Uart1_Data_Send(&Txdata[0], 94);
         break;
     case Bluecell_StatusSave:
 //        printf("Copy Complete");
@@ -1346,6 +1350,113 @@ bool Bluecell_Operate(uint8_t* data){
         bluecell_Currdatastatus.bluecell_User_UL4_L = data[BLUECELL_DATA + i++];
         CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         break;
+
+        /*******/
+#if 0 // PYJ.2020.05.13_BEGIN -- 
+    수정 및 추가 
+#endif // PYJ.2020.05.13_END -- 
+        /*******/
+    case Bluecell_TEMP_USER                               :
+        bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET_H = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET_L = data[BLUECELL_DATA + i++];
+
+        break;
+    case Bluecell_DLI_AGC_ON_OFF:                             
+        bluecell_Currdatastatus.ATT_AGC1_ONOFF = data[BLUECELL_DATA + i];
+        bluecell_Currdatastatus.ATT_AGC2_ONOFF = data[BLUECELL_DATA + i];
+        bluecell_Currdatastatus.ATT_AGC3_ONOFF = data[BLUECELL_DATA + i];
+        bluecell_Currdatastatus.ATT_AGC4_ONOFF = data[BLUECELL_DATA + i];
+
+        break;
+    case Bluecell_ULO_ALC_ON_OFF:                             
+        bluecell_Currdatastatus.ATT_ALC1_ONOFF = data[BLUECELL_DATA + i];
+        bluecell_Currdatastatus.ATT_ALC2_ONOFF = data[BLUECELL_DATA + i];
+        bluecell_Currdatastatus.ATT_ALC3_ONOFF = data[BLUECELL_DATA + i];
+        bluecell_Currdatastatus.ATT_ALC4_ONOFF = data[BLUECELL_DATA + i];
+        break;
+    case Bluecell_DLI_AGC_Threshold:                          
+        bluecell_Currdatastatus.DLI_AGC_Threshold_H = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.DLI_AGC_Threshold_L = data[BLUECELL_DATA + i++];
+
+        break;
+    case Bluecell_DLI_AGC_Threshold_Default:                  
+        bluecell_Currdatastatus.DLI_AGC_Threshold_default = data[BLUECELL_DATA + i++];
+
+        break;
+    case Bluecell_DLI_Shutdown_ON_OFF:                        
+        bluecell_Currdatastatus.DLI_Shutdown_ON_OFF = data[BLUECELL_DATA + i++];
+        
+        break;
+    case Bluecell_DLI_Shutdown_Threshold:                     
+        bluecell_Currdatastatus.DLI_Shutdown_Threshold_H = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.DLI_Shutdown_Threshold_L = data[BLUECELL_DATA + i++];
+
+        break;
+    case Bluecell_DLI_Shutdown_Threshold_Default:             
+        bluecell_Currdatastatus.DLI_Shutdown_Threshold_Default = data[BLUECELL_DATA + i++];
+        break;
+    case Bluecell_DLI_Shutdown_Count:                         
+        /*NOP*/
+        break;
+    case Bluecell_DLI_Level_High_Threshold                :   
+        bluecell_Currdatastatus.DLI_Level_High_Threshold_H = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.DLI_Level_High_Threshold_L = data[BLUECELL_DATA + i++];
+
+        break;
+    case Bluecell_DLI_Level_Low_Threshold                 :   
+        bluecell_Currdatastatus.DLI_Level_Low_Threshold_H = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.DLI_Level_Low_Threshold_L = data[BLUECELL_DATA + i++];
+
+        break;
+    case Bluecell_DLI_Level_High_Low_Threshold_default    :   
+        bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default = data[BLUECELL_DATA + i++];
+        break;
+    case Bluecell_LED_TEST  :                                 
+        bluecell_Currdatastatus.LED_TEST = data[BLUECELL_DATA + i++];
+        break;
+    case Bluecell_Temperature_Offset                      :   
+        bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET_H = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET_L = data[BLUECELL_DATA + i++];
+
+        break;
+    case Bluecell_Temp_High_Threshold                     :   
+        bluecell_Currdatastatus.Temp_High_Threshold = data[BLUECELL_DATA + i++];
+        break;
+    case Bluecell_Temp_High_Threshold_Default             :   
+        bluecell_Currdatastatus.Temp_High_Threshold_Default = data[BLUECELL_DATA + i++];
+        break;
+    case Bluecell_ULO_Level_High_Threshold                :   
+        bluecell_Currdatastatus.ULO_Level_High_Threshold_H = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.ULO_Level_High_Threshold_L = data[BLUECELL_DATA + i++];
+
+        break;
+    case Bluecell_ULO_Level_High_Threshold_default        :   
+        bluecell_Currdatastatus.ULO_Level_High_Threshold_default = data[BLUECELL_DATA + i++];
+        break;
+    case Bluecell_ULO_ALC_Threshold                       :   
+        bluecell_Currdatastatus.ULO_ALC_Threshold_H = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.ULO_ALC_Threshold_L = data[BLUECELL_DATA + i++];
+
+        break;
+    case Bluecell_ULO_ALC_Threshold_Default               :   
+        bluecell_Currdatastatus.ULO_ALC_Threshold_Default = data[BLUECELL_DATA + i++];
+
+        break;
+    case Bluecell_ULO_Shutdown_ON_OFF                     :   
+        bluecell_Currdatastatus.ULO_Shutdown_ON_OFF = data[BLUECELL_DATA + i++];
+
+        break;
+    case Bluecell_ULO_Shutdown_Threshold                  :   
+        bluecell_Currdatastatus.ULO_Shutdown_Threshold_H = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.ULO_Shutdown_Threshold_L = data[BLUECELL_DATA + i++];
+
+        break;
+    case Bluecell_ULO_Shutdown_Threshold_Default          :   
+        bluecell_Currdatastatus.ULO_Shutdown_Threshold_Default = data[BLUECELL_DATA + i++];
+
+        break;
+    case Bluecell_ULO_Shutdown_Retry_Count                :   
+        break;
   }
   if(datatype != Bluecell_StatusReq){
       Bluecell_StructCpy(&DataWrite[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
@@ -1485,6 +1596,8 @@ bool MBIC_Operate(uint8_t* data){
     uint8_t SubData[256] = {0,};
     uint16_t Temp_ADC = 0;
     uint16_t i = 0;
+    double temp = 0;
+    int16_t Level = 0;
     /*AID*/
     for(int i = 0; i < Length; i++){
         SubData[i] = (data[MBIC_PROT_SUB_DATA_INDEX + 3 + i]);
@@ -1573,7 +1686,7 @@ bool MBIC_Operate(uint8_t* data){
 
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Temp_High_Threshold;
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Temp_High_Threshold_Default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_TEMP_HIGH;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Temp_High_Alarm;
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.LED_TEST;
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.NODE;
 
@@ -1653,14 +1766,43 @@ bool MBIC_Operate(uint8_t* data){
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
 
         /*DLI LEVEL QUESTION START ???? */
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
+
+        temp  = (bluecell_Currdatastatus.DET_DL1_IN_H << 8 
+              | bluecell_Currdatastatus.DET_DL1_IN_L) * 3.3/4095; 
+        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+        Level *= 10;
+        bluecell_Currdatastatus.DLI_Level1_H = ((Level & 0xFF00) >> 8);
+        bluecell_Currdatastatus.DLI_Level1_L = ((Level & 0xFF00) >> 8);
+        temp  = (bluecell_Currdatastatus.DET_DL2_IN_H << 8 
+              | bluecell_Currdatastatus.DET_DL2_IN_L) * 3.3/4095; 
+        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+        Level *= 10;
+        bluecell_Currdatastatus.DLI_Level1_H = ((Level & 0xFF00) >> 8);
+        bluecell_Currdatastatus.DLI_Level1_L = ((Level & 0xFF00) >> 8);
+        
+        temp  = (bluecell_Currdatastatus.DET_DL3_IN_H << 8 
+              | bluecell_Currdatastatus.DET_DL3_IN_L) * 3.3/4095; 
+        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+        Level *= 10;
+        bluecell_Currdatastatus.DLI_Level1_H = ((Level & 0xFF00) >> 8);
+        bluecell_Currdatastatus.DLI_Level1_L = ((Level & 0xFF00) >> 8);
+        
+        temp  = (bluecell_Currdatastatus.DET_DL4_IN_H << 8 
+              | bluecell_Currdatastatus.DET_DL4_IN_L) * 3.3/4095; 
+        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+        Level *= 10;
+        bluecell_Currdatastatus.DLI_Level1_H = ((Level & 0xFF00) >> 8);
+        bluecell_Currdatastatus.DLI_Level1_L = ((Level & 0xFF00) >> 8);
+
+        
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level1_H;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level1_L;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level2_H;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level2_L;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level3_H;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level3_L;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level4_H;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level4_L;
         /*DLI LEVEL QUESTION END ???? */
 
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Alarm1;
@@ -1737,14 +1879,44 @@ bool MBIC_Operate(uint8_t* data){
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level_High_Threshold_L;
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level_High_Threshold_default;
         /*ULO LEVEL QUESTION START ???? */
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default;
+
+
+        temp  = (bluecell_Currdatastatus.DET_UL1_IN_H << 8 
+              | bluecell_Currdatastatus.DET_UL1_IN_L) * 3.3/4095; 
+        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+        Level *= 10;
+        bluecell_Currdatastatus.ULO_Level1_H = ((Level & 0xFF00) >> 8);
+        bluecell_Currdatastatus.ULO_Level1_L = ((Level & 0xFF00) >> 8);
+        temp  = (bluecell_Currdatastatus.DET_UL2_IN_H << 8 
+              | bluecell_Currdatastatus.DET_UL2_IN_L) * 3.3/4095; 
+        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+        Level *= 10;
+        bluecell_Currdatastatus.ULO_Level2_H = ((Level & 0xFF00) >> 8);
+        bluecell_Currdatastatus.ULO_Level2_L = ((Level & 0xFF00) >> 8);
+        
+        temp  = (bluecell_Currdatastatus.DET_UL3_IN_H << 8 
+              | bluecell_Currdatastatus.DET_UL3_IN_L) * 3.3/4095; 
+        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+        Level *= 10;
+        bluecell_Currdatastatus.ULO_Level3_H = ((Level & 0xFF00) >> 8);
+        bluecell_Currdatastatus.ULO_Level3_L = ((Level & 0xFF00) >> 8);
+        
+        temp  = (bluecell_Currdatastatus.DET_UL4_IN_H << 8 
+              | bluecell_Currdatastatus.DET_UL4_IN_L) * 3.3/4095; 
+        Level = AutoControl_ADC_Compare(temp,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+        Level *= 10;
+        bluecell_Currdatastatus.ULO_Level4_H = ((Level & 0xFF00) >> 8);
+        bluecell_Currdatastatus.ULO_Level4_L = ((Level & 0xFF00) >> 8);
+
+        
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level1_H;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level1_L;        
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level2_H;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level2_L;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level3_H;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level3_L;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level4_H;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level4_L;
         /*ULO LEVEL QUESTION END ???? */
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level_High_Alarm1;
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ULO_Level_High_Alarm2;
@@ -1856,6 +2028,7 @@ bool MBIC_Operate(uint8_t* data){
                 bluecell_Currdatastatus.Factory_Set_Initialization = data[MBIC_PAYLOADSTART + 0]; 
                 break;
             case  Temperature                     :
+                /*I WILL MODIFY*/
                 bluecell_Currdatastatus.DET_TEMP_H = data[MBIC_PAYLOADSTART + 0]; 
                 break;
             case  Temperature_Offset                      :
@@ -1870,17 +2043,20 @@ bool MBIC_Operate(uint8_t* data){
 
                 break;
             case  Temp_High_Alarm                         :
-                bluecell_Currdatastatus.ALARM_TEMP_HIGH = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.Temp_High_Alarm = data[MBIC_PAYLOADSTART + 0]; 
 
                 break;
             case  LED_TEST                                :
-                bluecell_Currdatastatus.ALARM_TEMP_HIGH = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.LED_TEST = data[MBIC_PAYLOADSTART + 0]; 
 
                 break;
+#if 0
             case  Node                                    :
+//                bluecell_Currdatastatus.LED_TEST = data[MBIC_PAYLOADSTART + 0]; 
 
                 break;
             case  Type                                    :
+//                bluecell_Currdatastatus.LED_TEST = data[MBIC_PAYLOADSTART + 0]; 
 
                 break;
             case  PCB_Version                             :
@@ -1923,81 +2099,304 @@ bool MBIC_Operate(uint8_t* data){
             case  ULO_P2_Level                            :break;
             case  ULO_P3_Level                            :break;
             case  ULO_P4_Level                            :break;
-            case  DLI_RF_Path1_ON_OFF             :break;
-            case  DLI_RF_Path2_ON_OFF                     :break;
-            case  DLI_RF_Path3_ON_OFF                     :break;
-            case  DLI_RF_Path4_ON_OFF                     :break;
-            case  DLI_Gain_Atten1                         :break;
-            case  DLI_Gain_Atten2                         :break;
-            case  DLI_Gain_Atten3                         :break;
-            case  DLI_Gain_Atten4                         :break;
-            case  DLI_Gain_Atten_Offset1                  :break;
-            case  DLI_Gain_Atten_Offset2                  :break;
-            case  DLI_Gain_Atten_Offset3                  :break;
-            case  DLI_Gain_Atten_Offset4                  :break;
-            case  DLI_Level_High_Threshold                :break;
-            case  DLI_Level_Low_Threshold                 :break;
-            case  DLI_Level_High_Low_Threshold_default    :break;
-            case  DLI_Level                               :break;
-            case  DLI_Level_High_Alarm1            :break;
-            case  DLI_Level_High_Alarm2                   :break;
-            case  DLI_Level_High_Alarm3                   :break;
-            case  DLI_Level_High_Alarm4                   :break;
-            case  DLI_Level_Low_Alarm1                    :break;
-            case  DLI_Level_Low_Alarm2                    :break;
+#endif
+            case  DLI_RF_Path1_ON_OFF             :
+                bluecell_Currdatastatus.ATT_DL1_PATH = data[MBIC_PAYLOADSTART + 0]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+                break;
+            case  DLI_RF_Path2_ON_OFF                     :
+                bluecell_Currdatastatus.ATT_DL2_PATH = data[MBIC_PAYLOADSTART + 0]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+                break;
+            case  DLI_RF_Path3_ON_OFF                     :
+                bluecell_Currdatastatus.ATT_DL3_PATH = data[MBIC_PAYLOADSTART + 0]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+                break;
+            case  DLI_RF_Path4_ON_OFF                     :
+                bluecell_Currdatastatus.ATT_DL4_PATH = data[MBIC_PAYLOADSTART + 0]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+                break;
+            case  DLI_Gain_Atten1                         :
+                bluecell_Currdatastatus.ATT_DL1_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ATT_DL1_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+                break;
+            case  DLI_Gain_Atten2                         :
+                bluecell_Currdatastatus.ATT_DL2_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ATT_DL2_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  DLI_Gain_Atten3                         :
+                bluecell_Currdatastatus.ATT_DL3_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ATT_DL3_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  DLI_Gain_Atten4                         :
+                bluecell_Currdatastatus.ATT_DL4_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ATT_DL4_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  DLI_Gain_Atten_Offset1                  :
+                bluecell_Currdatastatus.bluecell_User_DL1_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.bluecell_User_DL1_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  DLI_Gain_Atten_Offset2                  :
+                bluecell_Currdatastatus.bluecell_User_DL2_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.bluecell_User_DL2_L = data[MBIC_PAYLOADSTART + 1];
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  DLI_Gain_Atten_Offset3                  :
+                bluecell_Currdatastatus.bluecell_User_DL3_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.bluecell_User_DL3_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  DLI_Gain_Atten_Offset4                  :
+                bluecell_Currdatastatus.bluecell_User_DL4_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.bluecell_User_DL4_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  DLI_Level_High_Threshold                :
+                bluecell_Currdatastatus.DLI_Level_High_Threshold_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.DLI_Level_High_Threshold_L = data[MBIC_PAYLOADSTART + 1]; 
+
+                break;
+            case  DLI_Level_Low_Threshold                 :
+                bluecell_Currdatastatus.DLI_Level_Low_Threshold_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.DLI_Level_Low_Threshold_L = data[MBIC_PAYLOADSTART + 1]; 
+
+                break;
+            case  DLI_Level_High_Low_Threshold_default    :
+                bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default = data[MBIC_PAYLOADSTART + 0]; 
+
+                break;
+#if 0 // PYJ.2020.05.12_BEGIN -- 
+            case  DLI_Level                               :
+                bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default = data[MBIC_PAYLOADSTART + 0]; 
+                break;
+            case  DLI_Level_High_Alarm1            :
+
+                break;
+            case  DLI_Level_High_Alarm2                   :
+
+                break;
+            case  DLI_Level_High_Alarm3                   :
+
+                break;
+            case  DLI_Level_High_Alarm4                   :
+
+                break;
+            case  DLI_Level_Low_Alarm1                    :
+
+                break;
+            case  DLI_Level_Low_Alarm2                    :
+
+                break;
             case  DLI_Level_Low_Alarm3                    :break;
             case  DLI_Level_Low_Alarm4                    :break;
-            case  DLI_AGC_ON_OFF                   :break;
-            case  DLI_AGC_Threshold                       :break;
-            case  DLI_AGC_Threshold_Default               :break;
-            case  DLI_Shutdown_ON_OFF                     :break;
-            case  DLI_Shutdown_Threshold                  :break;
-            case  DLI_Shutdown_Threshold_Default          :break;
-            case  DLI_Shutdown_Count                      :break;
-            case  DLI_AGC_Alarm1                          :break;
-            case  DLI_AGC_Alarm2                          :break;
-            case  DLI_AGC_Alarm3                          :break;
-            case  DLI_AGC_Alarm4                          :break;
+#endif // PYJ.2020.05.12_END -- 
+            case  DLI_AGC_ON_OFF                   :
+                /*AGC multi apply*/
+                bluecell_Currdatastatus.ATT_AGC1_ONOFF = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ATT_AGC2_ONOFF = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ATT_AGC3_ONOFF = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ATT_AGC4_ONOFF = data[MBIC_PAYLOADSTART + 0]; 
+                break;
+            case  DLI_AGC_Threshold                       :
+                bluecell_Currdatastatus.DLI_AGC_Threshold_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.DLI_AGC_Threshold_L = data[MBIC_PAYLOADSTART + 1]; 
+
+                break;
+            case  DLI_AGC_Threshold_Default               :
+                bluecell_Currdatastatus.DLI_AGC_Threshold_default = data[MBIC_PAYLOADSTART + 0]; 
+                break;
+            case  DLI_Shutdown_ON_OFF                     :
+                bluecell_Currdatastatus.DLI_Shutdown_ON_OFF = data[MBIC_PAYLOADSTART + 0]; 
+
+                break;
+            case  DLI_Shutdown_Threshold                  :
+                bluecell_Currdatastatus.DLI_Shutdown_Threshold_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.DLI_Shutdown_Threshold_L = data[MBIC_PAYLOADSTART + 1]; 
+
+                break;
+            case  DLI_Shutdown_Threshold_Default          :
+                bluecell_Currdatastatus.DLI_Shutdown_Threshold_Default = data[MBIC_PAYLOADSTART + 0]; 
+
+                break;
+            case  DLI_Shutdown_Count                      :
+                bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 = data[MBIC_PAYLOADSTART + 1]; 
+                bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = data[MBIC_PAYLOADSTART + 2]; 
+                bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 = data[MBIC_PAYLOADSTART + 3]; 
+
+                break;
+#if 0 // PYJ.2020.05.12_BEGIN -- 
+            case  DLI_AGC_Alarm1                          :
+
+                break;
+            case  DLI_AGC_Alarm2                          :
+
+                break;
+            case  DLI_AGC_Alarm3                          :
+
+                break;
+            case  DLI_AGC_Alarm4                          :
+
+                break;
             case  DLI_Shutdown_Alarm1                     :break;
             case  DLI_Shutdown_Alarm2                     :break;
             case  DLI_Shutdown_Alarm3                     :break;
             case  DLI_Shutdown_Alarm4                     :break;
-            case  ULO_RF_Path1_ON_OFF1            :break;
-            case  ULO_RF_Path2_ON_OFF2                    :break;
-            case  ULO_RF_Path3_ON_OFF3                    :break;
-            case  ULO_RF_Path4_ON_OFF4                    :break;
-            case  ULO_Gain_Atten1                         :break;
-            case  ULO_Gain_Atten2                         :break;
-            case  ULO_Gain_Atten3                         :break;
-            case  ULO_Gain_Atten4                         :break;
-            case  ULO_Gain_Atten_Offset1                  :break;
-            case  ULO_Gain_Atten_Offset2                  :break;
-            case  ULO_Gain_Atten_Offset3                  :break;
-            case  ULO_Gain_Atten_Offset4                  :break;
-            case  ULO_Level_High_Threshold                :break;
-            case  SERIAL_UL_NULL0                         :break;
-            case  ULO_Level_High_Threshold_default        :break;
-            case  ULO_Level                               :break;
-            case  ULO_Level_High_Alarm1             :break;
-            case  ULO_Level_High_Alarm2                   :break;
+#endif // PYJ.2020.05.12_END -- 
+            case  ULO_RF_Path1_ON_OFF1            :
+                bluecell_Currdatastatus.ATT_UL1_PATH = data[MBIC_PAYLOADSTART + 0]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+                break;
+            case  ULO_RF_Path2_ON_OFF2                    :
+                bluecell_Currdatastatus.ATT_UL2_PATH = data[MBIC_PAYLOADSTART + 0]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  ULO_RF_Path3_ON_OFF3                    :
+                bluecell_Currdatastatus.ATT_UL3_PATH = data[MBIC_PAYLOADSTART + 0]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  ULO_RF_Path4_ON_OFF4                    :
+                bluecell_Currdatastatus.ATT_UL4_PATH = data[MBIC_PAYLOADSTART + 0]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  ULO_Gain_Atten1                         :
+                bluecell_Currdatastatus.ATT_UL1_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ATT_UL1_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  ULO_Gain_Atten2                         :
+                bluecell_Currdatastatus.ATT_UL2_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ATT_UL2_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  ULO_Gain_Atten3                         :
+                bluecell_Currdatastatus.ATT_UL3_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ATT_UL3_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  ULO_Gain_Atten4                         :
+                bluecell_Currdatastatus.ATT_UL4_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ATT_UL4_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  ULO_Gain_Atten_Offset1                  :
+                bluecell_Currdatastatus.bluecell_User_UL1_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.bluecell_User_UL1_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  ULO_Gain_Atten_Offset2                  :
+                bluecell_Currdatastatus.bluecell_User_UL2_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.bluecell_User_UL2_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  ULO_Gain_Atten_Offset3                  :
+                bluecell_Currdatastatus.bluecell_User_UL3_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.bluecell_User_UL3_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  ULO_Gain_Atten_Offset4                  :
+                bluecell_Currdatastatus.bluecell_User_UL4_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.bluecell_User_UL4_L = data[MBIC_PAYLOADSTART + 1]; 
+                CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+                break;
+            case  ULO_Level_High_Threshold                :
+                bluecell_Currdatastatus.ULO_Level_High_Threshold_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ULO_Level_High_Threshold_L = data[MBIC_PAYLOADSTART + 1]; 
+                break;
+            case  ULO_Level_High_Threshold_default        :
+                bluecell_Currdatastatus.ULO_Level_High_Threshold_default = data[MBIC_PAYLOADSTART + 0]; 
+                break;
+#if 0 // PYJ.2020.05.12_BEGIN -- 
+            case  ULO_Level                               :
+                break;
+            case  ULO_Level_High_Alarm1                  :break;
+            case  ULO_Level_High_Alarm2                  :break;
             case  ULO_Level_High_Alarm3                  :break;
             case  ULO_Level_High_Alarm4                  :break;
-            case  SERIAL_UL_NULL1                         :break;
-            case  ULO_ALC_ON_OFF                   :break;
-            case  ULO_ALC_Threshold                       :break;
-            case  ULO_ALC_Threshold_Default               :break;
-            case  ULO_Shutdown_ON_OFF                     :break;
-            case  ULO_Shutdown_Threshold                  :break;
-            case  ULO_Shutdown_Threshold_Default          :break;
-            case  ULO_Shutdown_Retry_Count                :break;
-            case  ULO_ALC_Alarm1                          :break;
-            case  ULO_ALC_Alarm2                          :break;
-            case  ULO_ALC_Alarm3                          :break;
-            case  ULO_ALC_Alarm4                          :break;
-            case  ULO_Shutdown_Alarm1                     :break;
-            case  ULO_Shutdown_Alarm2                     :break;
-            case  ULO_Shutdown_Alarm3                     :break;
-            case  ULO_Shutdown_Alarm4                     :break;
+            case  SERIAL_UL_NULL1                        :break;
+#endif // PYJ.2020.05.12_END -- 
+            case  ULO_ALC_ON_OFF                   :
+                bluecell_Currdatastatus.ULO_ALC_ON_OFF = data[MBIC_PAYLOADSTART + 0]; 
+
+                break;
+            case  ULO_ALC_Threshold                       :
+                bluecell_Currdatastatus.ULO_ALC_Threshold_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ULO_ALC_Threshold_L = data[MBIC_PAYLOADSTART + 1]; 
+
+                break;
+            case  ULO_ALC_Threshold_Default               :
+                bluecell_Currdatastatus.ULO_ALC_Threshold_Default = data[MBIC_PAYLOADSTART + 0]; 
+
+                break;
+            case  ULO_Shutdown_ON_OFF                     :
+                bluecell_Currdatastatus.ULO_Shutdown_ON_OFF = data[MBIC_PAYLOADSTART + 0]; 
+
+                break;
+            case  ULO_Shutdown_Threshold                  :
+                bluecell_Currdatastatus.ULO_Shutdown_Threshold_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ULO_Shutdown_Threshold_L = data[MBIC_PAYLOADSTART + 1]; 
+
+                break;
+            case  ULO_Shutdown_Threshold_Default          :
+                bluecell_Currdatastatus.ULO_Shutdown_Threshold_Default = data[MBIC_PAYLOADSTART + 0]; 
+
+
+                break;
+            case  ULO_Shutdown_Retry_Count                :
+                bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1 = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2 = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3 = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 = data[MBIC_PAYLOADSTART + 0]; 
+                break;
+#if 0 // PYJ.2020.05.13_BEGIN -- 
+            case  ULO_ALC_Alarm1                          :
+
+                break;
+            case  ULO_ALC_Alarm2                          :
+
+                break;
+            case  ULO_ALC_Alarm3                          :
+
+                break;
+            case  ULO_ALC_Alarm4                          :
+
+                break;
+            case  ULO_Shutdown_Alarm1                     :
+
+                break;
+            case  ULO_Shutdown_Alarm2                     :
+
+                break;
+            case  ULO_Shutdown_Alarm3                     :
+
+                break;
+            case  ULO_Shutdown_Alarm4                     :
+#endif // PYJ.2020.05.13_END -- 
+
+                break;
         }
     }
         else{
@@ -2204,6 +2603,98 @@ void ADC_Check(void){
 
 
 
+#if 1 // PYJ.2020.05.12_BEGIN -- 
+
+/*One Point  round*/
+double Bluecell_round( double value )
+{
+    unsigned short data = value * 1000;
+    unsigned short temp = 0;
+    double ret = 0;
+//    printf("1: %d\r\n",data);
+    temp = data % 10;
+    if(temp >= 5){
+        data = data - temp + 10;
+    }else{
+        data = data - temp;
+    }
+//    printf("2: %d\r\n",data);
+    temp = (data % 100) / 10;
+//    printf("3: %d\r\n",temp);
+    if(temp >= 5){
+        data = data - (temp * 10)+ 100;
+    }else{
+        data = data - (temp * 10);
+    }
+//     printf("4: %d\r\n",data);
+     ret = data;
+//        printf("ret : %f\r\n",ret / 1000);
+
+     return ret / 1000;
+}
+
+
+#endif // PYJ.2020.05.12_END -- 
+
+#if 0 // PYJ.2020.05.12_BEGIN -- 
+double AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size){
+    double ret = 0xFF,CurrRet = 0,TableAdc,TableAdcret; 
+    uint8_t LastIndex = 0;
+    double Max_ADC = 0,Min_ADC = 0;
+    double step = 0;
+    double dot = 0,tempret = 0xFF;
+    for(int i =0; i < size / 2; i++){
+        TableAdc = CompareAdc[i * 2] << 8;
+        TableAdc += CompareAdc[i * 2 + 1];
+        TableAdc /= 1000;
+//        printf("TableAdc[%d] : %f \r\n",i,TableAdc);
+        CurrRet = TableAdc - CurrentAdc;
+        
+        if(CurrRet < 0){ // plus 공식 
+            CurrRet = (CurrRet * -2) + CurrRet;
+        }
+        if(ret > CurrRet){
+            ret = CurrRet;
+            TableAdcret = TableAdc;
+            LastIndex = i;
+        }
+    }
+    
+    /*MIN*/
+    TableAdc = CompareAdc[LastIndex * 2] << 8;
+    TableAdc += CompareAdc[LastIndex * 2 + 1];
+    TableAdc /= 1000;
+    Min_ADC = TableAdc;
+    /*MAX*/
+    TableAdc = CompareAdc[LastIndex * 2 - 2 ] << 8;
+    TableAdc += CompareAdc[LastIndex * 2 - 1];
+    TableAdc /= 1000;
+    Max_ADC = TableAdc;
+
+    
+    step = ((Max_ADC - Min_ADC) / 10);
+    
+//    Min_ADC = Bluecell_round(Min_ADC);
+//    CurrentAdc = Bluecell_round(CurrentAdc);
+//    printf("1:STEP : %f , %f  > %f > %f \r\n",step,Max_ADC,CurrentAdc,Min_ADC);
+    for(double d = 0; d < 1; d += 0.1){
+        CurrRet = CurrentAdc - Min_ADC;
+        if(tempret >= CurrRet & CurrRet > 0){
+//            printf("(%f >= %f)\r\n",tempret,CurrRet);
+            tempret = CurrRet;
+//            printf("2:STEP : %f , %f  > %f > %f \r\n",step,Max_ADC,CurrentAdc,Min_ADC);
+            Min_ADC += step;
+            dot = d;
+        }
+   }    
+//    printf("dot : %f \r\n",dot);
+    dot = AutoControl_Save[LastIndex] - dot;
+    
+//    printf("AutoControl_Save[LastIndex]:%d + dot:%f : %f \r\n",AutoControl_Save[LastIndex] + dot);
+//    printf(" %f  > %f > %f \r\n",Max_ADC,CurrentAdc,Min_ADC);
+    return dot;
+}
+#else
 int8_t AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t size){
     double ret = 0xFF,CurrRet = 0,TableAdc; 
     uint8_t LastIndex = 0;
@@ -2226,6 +2717,8 @@ int8_t AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t siz
     }
     return AutoControl_Save[LastIndex];
 }
+
+#endif // PYJ.2020.05.12_END -- 
 int32_t MinusConvert(uint8_t Temp_h, int32_t Value){
     int32_t ret;
     if((((bluecell_Currdatastatus.ATT_ALC1_MAX_H << 8) & 0xFF00) & 0xF000) == 0xF000){
@@ -2248,9 +2741,10 @@ void ALC_Function(){ //DL
     int32_t CurrnALC_MAX_SettingValue = 0;    
     int32_t CurrnALC_MIN_SettingValue = 0;        
     int32_t ALC_Result = 0;
-    int8_t ResdBm = 0;
-
+    double ResdBm = 0;
+    uint8_t tempadc[100];
     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 > 100){
         if(bluecell_Currdatastatus.ATT_ALC1_ONOFF == true){
 #if 1 // PYJ.2020.04.29_BEGIN -- 
@@ -2262,10 +2756,8 @@ void ALC_Function(){ //DL
             ResdBm = AutoControl_ADC_Compare(ret,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
 //            printf("==================================\r\n");
 //            printf("Current UL ADC VALUE : %f \r\n",ret);
-//            printf("ResdBm : UL1 : %d \r\n",ResdBm);
-            
-            
-            
+//            printf("ResdBm : UL1 : %f \r\n",ResdBm);
+//            HAL_Delay(1000);
             
             CurrnALC_MAX_SettingValue = bluecell_Currdatastatus.ATT_ALC1_MAX_H << 8;
             CurrnALC_MAX_SettingValue += bluecell_Currdatastatus.ATT_ALC1_MAX_L;
@@ -2279,7 +2771,7 @@ void ALC_Function(){ //DL
 //            printf("I WILL GIVE YOU ATTEN MAX : %d \r\n",ResdBm - CurrnALC_MAX_SettingValue);
 //            printf("I WILL GIVE YOU ATTEN MIN : %d \r\n",ResdBm - CurrnALC_MIN_SettingValue);
 //            printf("==================================\r\n");            
-            ALC_Result  += ResdBm - CurrnALC_MAX_SettingValue;
+            ALC_Result  = ResdBm - CurrnALC_MAX_SettingValue;
             if(ALC_Result > 0){
                 ALC_Result *= 100;
                 ALC_Result +=  bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
@@ -2320,7 +2812,7 @@ void ALC_Function(){ //DL
             
             CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC2_MIN_H << 8;
             CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC2_MIN_L;
-            ALC_Result  += ResdBm - CurrnALC_MAX_SettingValue;
+            ALC_Result  = ResdBm - CurrnALC_MAX_SettingValue;
             if(ALC_Result > 0){
                 ALC_Result *= 100;
                 ALC_Result +=  bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L;
@@ -2356,7 +2848,7 @@ void ALC_Function(){ //DL
              
              CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC3_MIN_H << 8;
              CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC3_MIN_L;
-             ALC_Result  += ResdBm - CurrnALC_MAX_SettingValue;
+             ALC_Result  = ResdBm - CurrnALC_MAX_SettingValue;
              if(ALC_Result > 0){
                  ALC_Result *= 100;
                  ALC_Result +=  bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L;
@@ -2393,7 +2885,7 @@ void ALC_Function(){ //DL
              
              CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC4_MIN_H << 8;
              CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC4_MIN_L;
-             ALC_Result  += ResdBm - CurrnALC_MAX_SettingValue;
+             ALC_Result  = ResdBm - CurrnALC_MAX_SettingValue;
              if(ALC_Result > 0){
                  ALC_Result *= 100;
                  ALC_Result +=  bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L;

Src/main.c

@@ -118,7 +118,7 @@ uint16_t adc3cnt = 0 ;
 void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
 {
 //?��?��?�� 코드 ?��?��
-//諤嵸烄 ?嚙踝蕭?嚙踝蕭 adc?嚙踝蕭嚙???????? 嚙?????????嚙踝蕭?嚙踝蕭 ?嚙踝蕭 ?嚙踝蕭?嚙踝蕭嚙???????? ?嚙踝蕭?嚙踝蕭嚙???????? ?嚙踝蕭?嚙踝蕭?? 穈軤𦚯 魽國探嚙???????? ?嚙踝蕭?嚙踝蕭
+//만약 ?��?�� adc?���???????? �?????????��?�� ?�� ?��?���???????? ?��?���???????? ?��?��?? 같이 조건�???????? ?��?��
 
     if(hadc->Instance == hadc1.Instance)
     {
@@ -681,7 +681,7 @@ static void MX_USART1_UART_Init(void)
 
   /* USER CODE END USART1_Init 1 */
   huart1.Instance = USART1;
-  huart1.Init.BaudRate = 115200;
+  huart1.Init.BaudRate = 921600;
   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   huart1.Init.StopBits = UART_STOPBITS_1;
   huart1.Init.Parity = UART_PARITY_NONE;