Length High Low 추가 / Atten DL 어텐제어 작업중 Atten UL Function 작업중 / UL Limit 제한 /ALC package Function 구현

Bluecell_Inc/Bluecell_operate.h

@@ -220,7 +220,8 @@ typedef struct{
 typedef enum{
 BLUECELL_HEADER,
 BLUECELL_TYPE,
-BLUECELL_LENGTH,
+BLUECELL_LENGTH_H,
+BLUECELL_LENGTH_L,
 BLUECELL_CRCINDEX,
 BLUECELL_DATA,
 }BLUECELLProt_st;

Bluecell_Src/Bluecell_operate.c

@@ -281,6 +281,7 @@ uint8_t MBIC_DL_PE43711_Calc(uint8_t* Table,int16_t MBIC_Val,int16_t MBIC_UserVa
 
     double ret = 0;
     double ret2 = 0;
+    double ret3 = 0;
     uint8_t Result = 0;
     //ret = PE43711_Double(MBIC_Val); // Hidden Atten Calc
 //    printf("MBIC_UserVal : %x \r\n",MBIC_UserVal); // 2
@@ -597,16 +598,95 @@ void Bluecell_AttenInitialize(){
     PE43711_atten_ctrl(ALL_ATT.ATT_UL4,val);
 
 }
+typedef enum{
+    ATTEN_H = 0,
+    ATTEN_L,        
+};
+void Atten_DL_Ctrl_Function(PE43711_st* ATT,ATT_TABLE_st* Table,uint8_t* CurrAtten,uint8_t* PrevAtten,uint8_t* CurrHiddenAtten,uint8_t* PrevHiddenAtten){
+     uint16_t MBIC_Val = 0;
+     uint16_t MBIC_ALC_Val = 0;
+     uint16_t MBIC_UserVal = 0;
+     uint8_t val = 0;
+    if(CurrAtten[ATTEN_H] != CurrAtten[ATTEN_H]
+      ||CurrAtten[ATTEN_H] != CurrAtten[ATTEN_L]
+      ||CurrHiddenAtten[ATTEN_H] != CurrHiddenAtten[ATTEN_H]
+      ||CurrHiddenAtten[ATTEN_H] != CurrHiddenAtten[ATTEN_L]){
+            PrevAtten[ATTEN_H] = CurrAtten[ATTEN_H];
+            PrevAtten[ATTEN_L] = CurrAtten[ATTEN_L];
+            PrevHiddenAtten[ATTEN_H] = CurrHiddenAtten[ATTEN_H];
+            PrevHiddenAtten[ATTEN_L] = CurrHiddenAtten[ATTEN_L];
+            MBIC_Val = CurrAtten[ATTEN_H] << 8 | CurrAtten[ATTEN_L];
+            MBIC_UserVal = CurrHiddenAtten[ATTEN_H] << 8 | CurrHiddenAtten[ATTEN_L];
+            val = MBIC_DL_PE43711_Calc(&Table->Table_0_0_dBm, // Table Offset
+                                MBIC_Val,
+                               MBIC_UserVal);// User Atten Low Bit
+            printf("%s : %d \r\n",__func__,__LINE__);   
+            printf("%d val = %x \r\n",__LINE__,val);
+            PE43711_atten_ctrl2(ATT,val);
+    }
+
+}
+typedef enum{
+    ATTEN_DL1= 0 ,
+    ATTEN_DL2,
+    ATTEN_DL3,
+    ATTEN_DL4,
+    ATTEN_UL1,    
+    ATTEN_UL2,    
+    ATTEN_UL3,    
+    ATTEN_UL4,    
+    
+};
+void Atten_UL_Ctrl_Function(uint8_t index,ATT_TABLE_st* Table,uint8_t* CurrAtten,uint8_t* PrevAtten,uint8_t* CurrHiddenAtten,uint8_t* PrevHiddenAtten,uint8_t* CurrALCAtten,uint8_t* PrevALCAtten){
+     int16_t MBIC_Val = 0;
+     int16_t MBIC_UserVal = 0;
+     int16_t MBIC_ALCVal = 0;     
+     uint8_t val = 0;
+    if(CurrAtten[ATTEN_H] != CurrAtten[ATTEN_H]
+      ||CurrAtten[ATTEN_L] != CurrAtten[ATTEN_L]
+      ||CurrHiddenAtten[ATTEN_H] != CurrHiddenAtten[ATTEN_H]
+      ||CurrHiddenAtten[ATTEN_L] != CurrHiddenAtten[ATTEN_L]
+      ||PrevALCAtten[ATTEN_H] != CurrALCAtten[ATTEN_H]
+      ||PrevALCAtten[ATTEN_L] != CurrALCAtten[ATTEN_L]){
+
+      
+            PrevAtten[ATTEN_H] = CurrAtten[ATTEN_H];
+            PrevAtten[ATTEN_L] = CurrAtten[ATTEN_L];
+            PrevHiddenAtten[ATTEN_H] = CurrHiddenAtten[ATTEN_H];
+            PrevHiddenAtten[ATTEN_L] = CurrHiddenAtten[ATTEN_L];
+            CurrALCAtten[ATTEN_H] = CurrALCAtten[ATTEN_H];
+            CurrALCAtten[ATTEN_L] = CurrALCAtten[ATTEN_L];
+            MBIC_Val = CurrAtten[ATTEN_H] << 8 | CurrAtten[ATTEN_L];
+            MBIC_UserVal = CurrHiddenAtten[ATTEN_H] << 8 | CurrHiddenAtten[ATTEN_L];
+            MBIC_ALCVal= CurrALCAtten[ATTEN_H] << 8 | CurrALCAtten[ATTEN_L];
+            val = MBIC_UL_PE43711_Calc(&Table->Table_0_0_dBm, // Table Offset
+                                MBIC_Val,
+                               MBIC_UserVal,
+                               MBIC_ALCVal);// User Atten Low Bit
+                               
+            printf("%s : %d \r\n",__func__,__LINE__);   
+            printf("%d val = %x \r\n",__LINE__,val);
+            switch(index){
+                case ATTEN_UL1:    PE43711_atten_ctrl(ALL_ATT.ATT_UL1,val);break;
+                case ATTEN_UL2:    PE43711_atten_ctrl(ALL_ATT.ATT_UL2,val);break;
+                case ATTEN_UL3:    PE43711_atten_ctrl(ALL_ATT.ATT_UL3,val);break;
+                case ATTEN_UL4:    PE43711_UL4_atten_ctrl(val);break;
+            }
+
+    }
+
+}
+
 void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      uint8_t val = 0;
      uint16_t MBIC_Val = 0;
      uint16_t MBIC_ALC_Val = 0;
      uint16_t MBIC_UserVal = 0;
 
-    if((Curr.ATT_DL1_H != Prev.ATT_DL1_H
-     ||Curr.ATT_DL1_L != Prev.ATT_DL1_L)
-     ||(Curr.bluecell_User_DL1_H != Prev.bluecell_User_DL1_H
-     ||Curr.bluecell_User_DL1_L != Prev.bluecell_User_DL1_L)){
+    if((Curr.ATT_DL1_H != Prev.ATT_DL1_H)
+     ||(Curr.ATT_DL1_L != Prev.ATT_DL1_L)
+     ||(Curr.bluecell_User_DL1_H != Prev.bluecell_User_DL1_H)
+     ||(Curr.bluecell_User_DL1_L != Prev.bluecell_User_DL1_L)){
 //         printf("%s : %d \r\n",__func__,__LINE__);   
             bluecell_Prevdatastatus.ATT_DL1_H = bluecell_Currdatastatus.ATT_DL1_H;
             bluecell_Prevdatastatus.ATT_DL1_L = bluecell_Currdatastatus.ATT_DL1_L;
@@ -623,8 +703,8 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
     }
     if((Curr.ATT_DL2_H != Prev.ATT_DL2_H)
      ||(Curr.ATT_DL2_L != Prev.ATT_DL2_L)
-     ||(Curr.bluecell_User_DL2_H != Prev.bluecell_User_DL2_H
-     ||Curr.bluecell_User_DL2_L != Prev.bluecell_User_DL2_L)){
+     ||(Curr.bluecell_User_DL2_H != Prev.bluecell_User_DL2_H)
+     ||(Curr.bluecell_User_DL2_L != Prev.bluecell_User_DL2_L)){
             bluecell_Prevdatastatus.ATT_DL2_H = bluecell_Currdatastatus.ATT_DL2_H;
             bluecell_Prevdatastatus.ATT_DL2_L = bluecell_Currdatastatus.ATT_DL2_L;
             bluecell_Prevdatastatus.bluecell_User_DL2_H = bluecell_Currdatastatus.bluecell_User_DL2_H;
@@ -638,10 +718,10 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
             PE43711_atten_ctrl(ALL_ATT.ATT_DL2,val);
     }
      
-    if((Curr.ATT_DL3_H != Prev.ATT_DL3_H
-     ||Curr.ATT_DL3_L != Prev.ATT_DL3_L)
-     ||(Curr.bluecell_User_DL3_H != Prev.bluecell_User_DL3_H
-     ||Curr.bluecell_User_DL3_L != Prev.bluecell_User_DL3_L)){
+    if((Curr.ATT_DL3_H != Prev.ATT_DL3_H)
+     ||(Curr.ATT_DL3_L != Prev.ATT_DL3_L)
+     ||(Curr.bluecell_User_DL3_H != Prev.bluecell_User_DL3_H)
+     ||(Curr.bluecell_User_DL3_L != Prev.bluecell_User_DL3_L)){
 
         bluecell_Prevdatastatus.ATT_DL3_H = bluecell_Currdatastatus.ATT_DL3_H;
         bluecell_Prevdatastatus.ATT_DL3_L = bluecell_Currdatastatus.ATT_DL3_L;
@@ -659,10 +739,10 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
 //    printf("\r\nCurr.ATT_DL3_H : %x \r\nPrev.ATT_DL3_H : %x \r\n",Curr.ATT_DL3_H,Prev.ATT_DL3_H);
 //     printf("\r\nCurr.ATT_DL3_L : %x \r\nPrev.ATT_DL3_L : %x \r\n",Curr.ATT_DL3_L,Prev.ATT_DL3_L);
      
-    if((Curr.ATT_DL4_H != Prev.ATT_DL4_H
-     ||Curr.ATT_DL4_L != Prev.ATT_DL4_L)
-     ||(Curr.bluecell_User_DL4_H != Prev.bluecell_User_DL4_H
-     ||Curr.bluecell_User_DL4_L != Prev.bluecell_User_DL4_L)){
+    if((Curr.ATT_DL4_H != Prev.ATT_DL4_H)
+     ||(Curr.ATT_DL4_L != Prev.ATT_DL4_L)
+     ||(Curr.bluecell_User_DL4_H != Prev.bluecell_User_DL4_H)
+     ||(Curr.bluecell_User_DL4_L != Prev.bluecell_User_DL4_L)){
      
             bluecell_Prevdatastatus.ATT_DL4_H = bluecell_Currdatastatus.ATT_DL4_H;
             bluecell_Prevdatastatus.ATT_DL4_L = bluecell_Currdatastatus.ATT_DL4_L;
@@ -679,6 +759,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
             printf("%d val = %x \r\n",__LINE__,val);
             PE43711_atten_ctrl(ALL_ATT.ATT_DL4,val);
     }
+
     if(bluecell_Prevdatastatus.bluecell_User_UL1_H != 0xFF)
         bluecell_Prevdatastatus.bluecell_User_UL1_H =0xFF;
     if(bluecell_Prevdatastatus.bluecell_User_UL2_H != 0xFF)
@@ -688,12 +769,13 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
     if(bluecell_Prevdatastatus.bluecell_User_UL4_H != 0xFF)
         bluecell_Prevdatastatus.bluecell_User_UL4_H =0xFF;
     
-    if((Curr.ATT_UL1_H != Prev.ATT_UL1_H
-     ||Curr.ATT_UL1_L != Prev.ATT_UL1_L)
-     ||(Curr.bluecell_User_UL1_H != Prev.bluecell_User_UL1_H
-     ||Curr.bluecell_User_UL1_L != Prev.bluecell_User_UL1_L)
-     ||(Curr.MBIC_ULO_ALC_Atten1_H != Prev.MBIC_ULO_ALC_Atten1_H
-     ||Curr.MBIC_ULO_ALC_Atten1_L != Prev.MBIC_ULO_ALC_Atten1_L)){
+#if 1 // PYJ.2020.06.27_BEGIN -- 
+    if((Curr.ATT_UL1_H != Prev.ATT_UL1_H)
+     ||(Curr.ATT_UL1_L != Prev.ATT_UL1_L)
+     ||(Curr.bluecell_User_UL1_H != Prev.bluecell_User_UL1_H)
+     ||(Curr.bluecell_User_UL1_L != Prev.bluecell_User_UL1_L)
+     ||(Curr.MBIC_ULO_ALC_Atten1_H != Prev.MBIC_ULO_ALC_Atten1_H)
+     ||(Curr.MBIC_ULO_ALC_Atten1_L != Prev.MBIC_ULO_ALC_Atten1_L)){
      
             bluecell_Prevdatastatus.ATT_UL1_H = bluecell_Currdatastatus.ATT_UL1_H;
             bluecell_Prevdatastatus.ATT_UL1_L = bluecell_Currdatastatus.ATT_UL1_L;
@@ -712,12 +794,22 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
     //        printf("%d val = %x \r\n",__LINE__,val);
             PE43711_atten_ctrl(ALL_ATT.ATT_UL1,val);
     }
-    if((Curr.ATT_UL2_H != Prev.ATT_UL2_H
-     ||Curr.ATT_UL2_L != Prev.ATT_UL2_L)
-     ||(Curr.bluecell_User_UL2_H != Prev.bluecell_User_UL2_H
-     ||Curr.bluecell_User_UL2_L != Prev.bluecell_User_UL2_L)
-     ||(Curr.MBIC_ULO_ALC_Atten2_H != Prev.MBIC_ULO_ALC_Atten2_H
-     ||Curr.MBIC_ULO_ALC_Atten2_L != Prev.MBIC_ULO_ALC_Atten2_L)){
+//    Atten_UL_Ctrl_Function(ATTEN_UL1,
+//                            &Att_UL1.Table_0_0_dBm,
+//                            &bluecell_Currdatastatus.ATT_UL1_H,
+//                            &bluecell_Prevdatastatus.ATT_UL1_L,
+//                            &bluecell_Currdatastatus.bluecell_User_UL1_H,
+//                            &bluecell_Prevdatastatus.bluecell_User_UL1_L,
+//                            &bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H,
+//                            &bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten1_L);
+#endif // PYJ.2020.06.27_END -- 
+
+    if((Curr.ATT_UL2_H != Prev.ATT_UL2_H)
+     ||(Curr.ATT_UL2_L != Prev.ATT_UL2_L)
+     ||(Curr.bluecell_User_UL2_H != Prev.bluecell_User_UL2_H)
+     ||(Curr.bluecell_User_UL2_L != Prev.bluecell_User_UL2_L)
+     ||(Curr.MBIC_ULO_ALC_Atten2_H != Prev.MBIC_ULO_ALC_Atten2_H)
+     ||(Curr.MBIC_ULO_ALC_Atten2_L != Prev.MBIC_ULO_ALC_Atten2_L)){
             bluecell_Prevdatastatus.ATT_UL2_H = bluecell_Currdatastatus.ATT_UL2_H;
             bluecell_Prevdatastatus.ATT_UL2_L = bluecell_Currdatastatus.ATT_UL2_L;
             bluecell_Prevdatastatus.bluecell_User_UL2_H = bluecell_Currdatastatus.bluecell_User_UL2_H;
@@ -729,23 +821,23 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
             MBIC_Val = Curr.ATT_UL2_H << 8 | Curr.ATT_UL2_L;
             MBIC_ALC_Val = Curr.MBIC_ULO_ALC_Atten2_H << 8 | Curr.MBIC_ULO_ALC_Atten2_L;
             MBIC_UserVal = Curr.bluecell_User_UL2_H << 8 | Curr.bluecell_User_UL2_L;
-            printf("MBIC_Val : %02X \r\n",MBIC_Val);
-            printf("MBIC_UserVal : %02X \r\n",MBIC_UserVal);
-            printf("MBIC_ALC_Val : %02X \r\n",MBIC_ALC_Val);
+            printf("UL 2MBIC_Val : %02X \r\n",MBIC_Val);
+            printf("UL 2MBIC_UserVal : %02X \r\n",MBIC_UserVal);
+            printf("UL 2MBIC_ALC_Val : %02X \r\n",MBIC_ALC_Val);
             val = MBIC_UL_PE43711_Calc(&Att_UL2.Table_0_0_dBm,// Table Offset
                                 MBIC_Val,// Hidden Atten Low bit
                                MBIC_UserVal,
                                MBIC_ALC_Val);// User Atten Low Bit
-            printf("%d val = %x \r\n",__LINE__,val);
+            printf("UL 2 LINE: %d val = %x \r\n",__LINE__,val);
             PE43711_atten_ctrl(ALL_ATT.ATT_UL2,val);
     }
      
-    if((Curr.ATT_UL3_H != Prev.ATT_UL3_H
-     ||Curr.ATT_UL3_L != Prev.ATT_UL3_L)
-     ||(Curr.bluecell_User_UL3_H != Prev.bluecell_User_UL3_H
-     ||Curr.bluecell_User_UL3_L != Prev.bluecell_User_UL3_L)
-     ||(Curr.MBIC_ULO_ALC_Atten3_H != Prev.MBIC_ULO_ALC_Atten3_H
-     ||Curr.MBIC_ULO_ALC_Atten3_L != Prev.MBIC_ULO_ALC_Atten3_L))
+    if((Curr.ATT_UL3_H != Prev.ATT_UL3_H)
+     ||(Curr.ATT_UL3_L != Prev.ATT_UL3_L)
+     ||(Curr.bluecell_User_UL3_H != Prev.bluecell_User_UL3_H)
+     ||(Curr.bluecell_User_UL3_L != Prev.bluecell_User_UL3_L)
+     ||(Curr.MBIC_ULO_ALC_Atten3_H != Prev.MBIC_ULO_ALC_Atten3_H)
+     ||(Curr.MBIC_ULO_ALC_Atten3_L != Prev.MBIC_ULO_ALC_Atten3_L))
      {
             bluecell_Prevdatastatus.ATT_UL3_H = bluecell_Currdatastatus.ATT_UL3_H;
             bluecell_Prevdatastatus.ATT_UL3_L = bluecell_Currdatastatus.ATT_UL3_L;
@@ -768,13 +860,26 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
 
             PE43711_atten_ctrl(ALL_ATT.ATT_UL3,val);
     }
-    if((Curr.ATT_UL4_H != Prev.ATT_UL4_H
-     ||Curr.ATT_UL4_L != Prev.ATT_UL4_L)
-     ||(Curr.bluecell_User_UL4_H != Prev.bluecell_User_UL4_H
-     ||Curr.bluecell_User_UL4_L != Prev.bluecell_User_UL4_L)
-     ||(Curr.MBIC_ULO_ALC_Atten4_H != Prev.MBIC_ULO_ALC_Atten4_H
-     ||Curr.MBIC_ULO_ALC_Atten4_L != Prev.MBIC_ULO_ALC_Atten4_L))
+    if((Curr.ATT_UL4_H != Prev.ATT_UL4_H)
+     ||(Curr.ATT_UL4_L != Prev.ATT_UL4_L)
+     ||(Curr.bluecell_User_UL4_H != Prev.bluecell_User_UL4_H)
+     ||(Curr.bluecell_User_UL4_L != Prev.bluecell_User_UL4_L)
+     ||(Curr.MBIC_ULO_ALC_Atten4_H != Prev.MBIC_ULO_ALC_Atten4_H)
+     ||(Curr.MBIC_ULO_ALC_Atten4_L != Prev.MBIC_ULO_ALC_Atten4_L))
      {
+            printf("bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_H : %02x \r\n",bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_H);
+            printf("bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_L : %02x \r\n",bluecell_Prevdatastatus.MBIC_ULO_ALC_Atten4_L);
+            printf("bluecell_Prevdatastatus.ATT_UL4_H : %02x \r\n",bluecell_Prevdatastatus.ATT_UL4_H);
+            printf("bluecell_Prevdatastatus.ATT_UL4_L : %02x \r\n",bluecell_Prevdatastatus.ATT_UL4_L);
+            printf("bluecell_Prevdatastatus.bluecell_User_UL4_H : %02x \r\n",bluecell_Prevdatastatus.bluecell_User_UL4_H);
+            printf("bluecell_Prevdatastatus.bluecell_User_UL4_L : %02x \r\n",bluecell_Prevdatastatus.bluecell_User_UL4_L);        
+            printf("============================================================\r\n");
+            printf("bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H : %02x \r\n",bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H);
+            printf("bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L : %02x \r\n",bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L);
+            printf("bluecell_Currdatastatus.ATT_UL4_H : %02x \r\n",bluecell_Currdatastatus.ATT_UL4_H);
+            printf("bluecell_Currdatastatus.ATT_UL4_L : %02x \r\n",bluecell_Currdatastatus.ATT_UL4_L);
+            printf("bluecell_Currdatastatus.bluecell_User_UL4_H : %02x \r\n",bluecell_Currdatastatus.bluecell_User_UL4_H);
+            printf("bluecell_Currdatastatus.bluecell_User_UL4_L : %02x \r\n",bluecell_Currdatastatus.bluecell_User_UL4_L);        
             bluecell_Prevdatastatus.ATT_UL4_H = bluecell_Currdatastatus.ATT_UL4_H;
             bluecell_Prevdatastatus.ATT_UL4_L = bluecell_Currdatastatus.ATT_UL4_L;
             bluecell_Prevdatastatus.bluecell_User_UL4_H = bluecell_Currdatastatus.bluecell_User_UL4_H;
@@ -788,10 +893,6 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
                                 MBIC_Val,// Hidden Atten Low bit
                                MBIC_UserVal,
                                MBIC_ALC_Val);// User Atten Low Bit
-        printf("bluecell_Currdatastatus.ATT_UL4_H : %0x \r\n",bluecell_Currdatastatus.ATT_UL4_H);
-        printf("bluecell_Currdatastatus.ATT_UL4_L : %0x \r\n",bluecell_Currdatastatus.ATT_UL4_L);
-        printf("bluecell_Currdatastatus.bluecell_User_UL4_H : %0x \r\n",bluecell_Currdatastatus.bluecell_User_UL4_H);
-        printf("bluecell_Currdatastatus.bluecell_User_UL4_L : %0x \r\n",bluecell_Currdatastatus.bluecell_User_UL4_L);        
             printf("%d val = %x \r\n",__LINE__,val);
             PE43711_UL4_atten_ctrl(val);
     }
@@ -1294,134 +1395,135 @@ void Bluecell_TableLoad(uint8_t* data,uint8_t type){
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             printf("Table_Length : %d , Table_Ref : %d ",Att_DL1.Table_Length,Att_DL1.Table_Ref);
 //            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_H] = 0;
+            data[BLUECELL_LENGTH_L] = (sizeof(ATT_TABLE_st)) + 7 - 3;;
           break;
         case DLI_P2_ATT_Accuracy_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL1_TABLE_ADDRESDS),&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(ATT_TABLE_st)) + 7 - 3;
             break;
         case DLI_P3_ATT_Accuracy_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL2_TABLE_ADDRESDS),&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );               
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(ATT_TABLE_st)) + 7 - 3;
             break;
         case DLI_P4_ATT_Accuracy_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL3_TABLE_ADDRESDS),&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );               
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(ATT_TABLE_st)) + 7 - 3;
             break;
         case ULO_P1_ATT_Accuracy_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL4_TABLE_ADDRESDS),&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(ATT_TABLE_st)) + 7 - 3;
         break;
         case ULO_P2_ATT_Accuracy_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL1_TABLE_ADDRESDS),&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(ATT_TABLE_st)) + 7 - 3;
             break;
         case ULO_P3_ATT_Accuracy_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL2_TABLE_ADDRESDS),&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(ATT_TABLE_st)) + 7 - 3;
             break;
         case ULO_P4_ATT_Accuracy_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL3_TABLE_ADDRESDS),&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(ATT_TABLE_st)) + 7 - 3;
             break;
         case DLI_P1_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL4_TABLE_ADDRESDS),&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
             printf("Table_Length : %d , Table_Ref : %d ",Det_DL1.Table_Length,Det_DL1.Table_Ref);
-            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
             break;
         case DLI_P2_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL1_TABLE_ADDRESDS),&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
-            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
             break;
         case DLI_P3_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL2_TABLE_ADDRESDS),&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
-            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
             break;
         case DLI_P4_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL3_TABLE_ADDRESDS),&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
-            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
             break;
         case ULO_P1_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL4_TABLE_ADDRESDS),&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
             break;
         case ULO_P2_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL1_TABLE_ADDRESDS),&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
         
             break;
         case ULO_P3_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL2_TABLE_ADDRESDS),&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
             break;
         case ULO_P4_Level_Table_Number: 
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL3_TABLE_ADDRESDS),&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
-            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
 
             break;
         case DLI_P1_ATT_Temp_guarantee_Table_Number:
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
             printf("Table_Length : %d , Table_Ref : %d ",Temp_DL1.Table_Length,Temp_DL1.Table_Ref);            
 
             break;
         case DLI_P2_ATT_Temp_guarantee_Table_Number:
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL1_TABLE_ADDRESDS),&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
 
             break;
         case DLI_P3_ATT_Temp_guarantee_Table_Number:
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
 
             break;
         case DLI_P4_ATT_Temp_guarantee_Table_Number:
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL3_TABLE_ADDRESDS),&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st));
-        data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
+        data[BLUECELL_LENGTH_L] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
 
         break;
         case ULO_P1_ATT_Temp_guarantee_Table_Number:
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
             printf("Table_Length : %d , Table_Ref : %d ",Temp_UL1.Table_Length,Temp_UL1.Table_Ref);
         
             break;
         case ULO_P2_ATT_Temp_guarantee_Table_Number:
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
         
             break;
         case ULO_P3_ATT_Temp_guarantee_Table_Number:
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL2_TABLE_ADDRESDS),&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
         
             break;
         case ULO_P4_ATT_Temp_guarantee_Table_Number:
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL3_TABLE_ADDRESDS),&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );   
             Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st));
-            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
+            data[BLUECELL_LENGTH_L] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
             break;
     }
         
@@ -1930,7 +2032,7 @@ bool Bluecell_Operate(uint8_t* data){
 
   //double ret = 0 ,tmp = 0.1;
   int16_t tempdata = 0;
-  
+  int16_t CurrAtten = 0;
   uint8_t i = 0;
   switch(datatype){
     case BLUECELL_SOFTWARERESET:
@@ -1942,8 +2044,10 @@ bool Bluecell_Operate(uint8_t* data){
         
         bluecell_Currdatastatus.ATT_DL1_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_DL1_L = data[BLUECELL_DATA + i++];
-//        printf("bluecell_Currdatastatus.ATT_DL1_H : %x\r\n",bluecell_Currdatastatus.ATT_DL1_H);
-//        printf("bluecell_Currdatastatus.ATT_DL1_L : %x\r\n",bluecell_Currdatastatus.ATT_DL1_L);        
+        printf("bluecell_Currdatastatus.ATT_DL1_H : %x\r\n",bluecell_Currdatastatus.ATT_DL1_H);
+        printf("bluecell_Currdatastatus.ATT_DL1_L : %x\r\n",bluecell_Currdatastatus.ATT_DL1_L);  
+        CurrAtten = bluecell_Currdatastatus.ATT_DL1_H << 8 | bluecell_Currdatastatus.ATT_DL1_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
         /*
             Atten Ctrl Function
         */
@@ -1952,6 +2056,11 @@ bool Bluecell_Operate(uint8_t* data){
     case Bluecell_ATT_DL2                :
         bluecell_Currdatastatus.ATT_DL2_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_DL2_L = data[BLUECELL_DATA + i++];
+        printf("bluecell_Currdatastatus.ATT_DL2_H : %x\r\n",bluecell_Currdatastatus.ATT_DL2_H);
+        printf("bluecell_Currdatastatus.ATT_DL2_L : %x\r\n",bluecell_Currdatastatus.ATT_DL2_L);        
+        CurrAtten = bluecell_Currdatastatus.ATT_DL2_H << 8 | bluecell_Currdatastatus.ATT_DL2_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
+        
 
         /*
             Atten Ctrl Function
@@ -1961,6 +2070,8 @@ bool Bluecell_Operate(uint8_t* data){
 	case Bluecell_ATT_DL3 				 :        
         bluecell_Currdatastatus.ATT_DL3_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_DL3_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.ATT_DL3_H << 8 | bluecell_Currdatastatus.ATT_DL3_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
 
         /*
             Atten Ctrl Function
@@ -1970,6 +2081,8 @@ bool Bluecell_Operate(uint8_t* data){
 	case Bluecell_ATT_DL4 				 :    
         bluecell_Currdatastatus.ATT_DL4_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_DL4_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.ATT_DL4_H << 8 | bluecell_Currdatastatus.ATT_DL4_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
 
         /*
             Atten Ctrl Function
@@ -1980,6 +2093,13 @@ bool Bluecell_Operate(uint8_t* data){
 
         bluecell_Currdatastatus.ATT_UL1_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_UL1_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
+        if(CurrAtten <= -200){
+            bluecell_Currdatastatus.ATT_UL1_H = (CurrAtten & 0xFF00) >> 8;
+            bluecell_Currdatastatus.ATT_UL1_L = (CurrAtten & 0x00FF);
+        }
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
+    
         /*
             Atten Ctrl Function
         */
@@ -1991,6 +2111,12 @@ bool Bluecell_Operate(uint8_t* data){
     case Bluecell_ATT_UL2                :        
         bluecell_Currdatastatus.ATT_UL2_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_UL2_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
+        if(CurrAtten <= -200){
+            bluecell_Currdatastatus.ATT_UL2_H = (CurrAtten & 0xFF00) >> 8;
+            bluecell_Currdatastatus.ATT_UL2_L = (CurrAtten & 0x00FF);
+        }
 
         /*
             Atten Ctrl Function
@@ -2001,6 +2127,12 @@ bool Bluecell_Operate(uint8_t* data){
     case Bluecell_ATT_UL3                :    
         bluecell_Currdatastatus.ATT_UL3_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_UL3_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
+        if(CurrAtten <= -200){
+            bluecell_Currdatastatus.ATT_UL3_H = (CurrAtten & 0xFF00) >> 8;
+            bluecell_Currdatastatus.ATT_UL3_L = (CurrAtten & 0x00FF);
+        }
 
         /*
             Atten Ctrl Function
@@ -2011,8 +2143,12 @@ bool Bluecell_Operate(uint8_t* data){
     case Bluecell_ATT_UL4                :        
         bluecell_Currdatastatus.ATT_UL4_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_UL4_L = data[BLUECELL_DATA + i++];
-        printf("bluecell_Currdatastatus.ATT_UL4_H : %0x \r\n",bluecell_Currdatastatus.ATT_UL4_H);
-        printf("bluecell_Currdatastatus.ATT_UL4_L : %0x \r\n",bluecell_Currdatastatus.ATT_UL4_L);        
+        CurrAtten = bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L;
+        if(CurrAtten <= -200){
+            bluecell_Currdatastatus.ATT_UL4_H = (CurrAtten & 0xFF00) >> 8;
+            bluecell_Currdatastatus.ATT_UL4_L = (CurrAtten & 0x00FF);
+        }        
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
         ALCTimerCnt = 0;
 
 
@@ -2193,19 +2329,19 @@ bool Bluecell_Operate(uint8_t* data){
         Bluecell_TableLoad(data, data[BLUECELL_DATA]);
         data[BLUECELL_TYPE] = ATT_TableGet;
 
-        data[data[BLUECELL_LENGTH] + 1] = ((CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH]) & 0xFF00) >> 8);
-        data[data[BLUECELL_LENGTH] + 2] = CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH]) & 0x00FF;        
-        data[data[BLUECELL_LENGTH] + 3] = 0xEB;
+        data[data[BLUECELL_LENGTH_L] + 1] = ((CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH_L]) & 0xFF00) >> 8);
+        data[data[BLUECELL_LENGTH_L] + 2] = CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH_L]) & 0x00FF;        
+        data[data[BLUECELL_LENGTH_L] + 3] = 0xEB;
         
-        Bluecell_StructCpy(&Txdata[0],&data[0],data[BLUECELL_LENGTH] + 4);
-        Uart1_Data_Send(&Txdata[0], Txdata[BLUECELL_LENGTH] + 4);
+        Bluecell_StructCpy(&Txdata[0],&data[0],data[BLUECELL_LENGTH_L] + 4);
+        Uart1_Data_Send(&Txdata[0], Txdata[BLUECELL_LENGTH_L] + 4);
 #if 0 // PYJ.2020.04.22_BEGIN -- 
-        for(int i = 0 ; i < data[BLUECELL_LENGTH] + 3; i++ ){
+        for(int i = 0 ; i < data[BLUECELL_LENGTH_L] + 3; i++ ){
 //            printf("%x ",data[i]);
         Txdata[0] = data[0];        }
         printf("\r\n");
 #endif // PYJ.2020.04.22_END -- 
-//        printf("\r\nuint8_t data : %x  data[BLUECELL_LENGTH] + 6 : %d\r\n",data[0],data[BLUECELL_LENGTH] + 6);
+//        printf("\r\nuint8_t data : %x  data[BLUECELL_LENGTH_L] + 6 : %d\r\n",data[0],data[BLUECELL_LENGTH_L] + 6);
         break;
     case Bluecell_StatusReq:
         if(Initialize == false){
@@ -2218,17 +2354,17 @@ bool Bluecell_Operate(uint8_t* data){
         DataStatusSet();
 #if 0 // PYJ.2020.05.28_BEGIN -- 
         Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,94);
-        Txdata[BLUECELL_LENGTH] = 94 - 3;//sizeof(BLUESTATUS_st) - 3;
-        Txdata[94 - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]);
+        Txdata[BLUECELL_LENGTH_L] = 94 - 3;//sizeof(BLUESTATUS_st) - 3;
+        Txdata[94 - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH_L]);
 #else        
 //        printf("bluecell_Currdatastatus.ATT_UL4_H : %0x \r\n",bluecell_Currdatastatus.ATT_UL4_H);
 //        printf("bluecell_Currdatastatus.ATT_UL4_L : %0x \r\n",bluecell_Currdatastatus.ATT_UL4_L);
 
         Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
-        Txdata[BLUECELL_LENGTH] = sizeof(BLUESTATUS_st) - 3;//sizeof(BLUESTATUS_st) - 3;
-//        Txdata[sizeof(BLUESTATUS_st) - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]);
-        Txdata[sizeof(BLUESTATUS_st) - 3] = ((CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH]) & 0xFF00) >> 8);
-        Txdata[sizeof(BLUESTATUS_st) - 2] = CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH]) & 0x00FF;        
+        Txdata[BLUECELL_LENGTH_L] = sizeof(BLUESTATUS_st) - 3;//sizeof(BLUESTATUS_st) - 3;
+//        Txdata[sizeof(BLUESTATUS_st) - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH_L]);
+        Txdata[sizeof(BLUESTATUS_st) - 3] = ((CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH_L]) & 0xFF00) >> 8);
+        Txdata[sizeof(BLUESTATUS_st) - 2] = CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH_L]) & 0x00FF;        
         
 #endif // PYJ.2020.05.28_END -- 
 #if 0 // PYJ.2020.04.22_BEGIN -- 
@@ -2255,46 +2391,85 @@ bool Bluecell_Operate(uint8_t* data){
     case Bluecell_DL1_USER: 
         bluecell_Currdatastatus.bluecell_User_DL1_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.bluecell_User_DL1_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.bluecell_User_DL1_H << 8 | bluecell_Currdatastatus.bluecell_User_DL1_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
         
         CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         break;
     case Bluecell_DL2_USER:
         bluecell_Currdatastatus.bluecell_User_DL2_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.bluecell_User_DL2_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.bluecell_User_DL2_H << 8 | bluecell_Currdatastatus.bluecell_User_DL2_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);    
         CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         break;
     case Bluecell_DL3_USER:
         bluecell_Currdatastatus.bluecell_User_DL3_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.bluecell_User_DL3_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.bluecell_User_DL3_H << 8 | bluecell_Currdatastatus.bluecell_User_DL3_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);    
         CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         break;
     case Bluecell_DL4_USER:     
         bluecell_Currdatastatus.bluecell_User_DL4_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.bluecell_User_DL4_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.bluecell_User_DL4_H << 8 | bluecell_Currdatastatus.bluecell_User_DL4_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);    
         CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         break;
 
     case Bluecell_UL1_USER: 
         bluecell_Currdatastatus.bluecell_User_UL1_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.bluecell_User_UL1_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.bluecell_User_UL1_H << 8 | bluecell_Currdatastatus.bluecell_User_UL1_L;
+        if(CurrAtten >= 0 )
+            CurrAtten = bluecell_Currdatastatus.bluecell_User_UL1_H =  bluecell_Currdatastatus.bluecell_User_UL1_L = 0;
+        else if(CurrAtten <= -50 )
+            CurrAtten = - 50;
+
+
+        bluecell_Currdatastatus.bluecell_User_UL1_H = (CurrAtten & 0xFF00) >> 8;
+        bluecell_Currdatastatus.bluecell_User_UL1_L = CurrAtten & 0x00FF;
         
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);        
         CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         break;
     case Bluecell_UL2_USER:
         bluecell_Currdatastatus.bluecell_User_UL2_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.bluecell_User_UL2_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.bluecell_User_UL2_H << 8 | bluecell_Currdatastatus.bluecell_User_UL2_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);        
+        if(CurrAtten >= 0 )
+            CurrAtten = bluecell_Currdatastatus.bluecell_User_UL2_H =  bluecell_Currdatastatus.bluecell_User_UL2_L = 0;
+        else if(CurrAtten <= -50 )
+            CurrAtten = - 50;    
         CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
         break;
     case Bluecell_UL3_USER:
         bluecell_Currdatastatus.bluecell_User_UL3_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.bluecell_User_UL3_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.bluecell_User_UL3_H << 8 | bluecell_Currdatastatus.bluecell_User_UL3_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);        
+        if(CurrAtten >= 0 )
+            CurrAtten = bluecell_Currdatastatus.bluecell_User_UL3_H =  bluecell_Currdatastatus.bluecell_User_UL3_L = 0;
+        else if(CurrAtten <= -50 )
+            CurrAtten = - 50;    
+    
         CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
         break;
     case Bluecell_UL4_USER:
         bluecell_Currdatastatus.bluecell_User_UL4_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.bluecell_User_UL4_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.bluecell_User_UL4_H << 8 | bluecell_Currdatastatus.bluecell_User_UL4_L;
+        if(CurrAtten >= 0 )
+            CurrAtten = bluecell_Currdatastatus.bluecell_User_UL4_H =  bluecell_Currdatastatus.bluecell_User_UL4_L = 0;
+        else if(CurrAtten <= -50 )
+            CurrAtten = - 50;    
+        
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);        
+    
         CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         break;
 
@@ -2494,21 +2669,33 @@ bool Bluecell_Operate(uint8_t* data){
     case BLuecell_ATT_ALC1:
         bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);     
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
         break;
     case BLuecell_ATT_ALC2:
-        bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);        
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
         break;
     case BLuecell_ATT_ALC3:
-        bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);        
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
         break;
     case BLuecell_ATT_ALC4:
-        bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L = data[BLUECELL_DATA + i++];
+        CurrAtten = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
+        printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);        
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
         break;
   }
@@ -2518,7 +2705,7 @@ bool Bluecell_Operate(uint8_t* data){
   {
       Bluecell_StructCpy(&DataWrite[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
       EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS),&DataWrite[0],sizeof(BLUESTATUS_st));
-      EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_WINDOW_STATUS_ADDRESDS,&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st) );
+//      EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_WINDOW_STATUS_ADDRESDS,&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st) );
 //      Bluecell_StructCpy(&Txdata[0],&DataWrite[0],sizeof(BLUESTATUS_st));
 //      Txdata[sizeof(BLUESTATUS_st) - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], sizeof(BLUESTATUS_st) - 3);
 //      Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st));        
@@ -4771,21 +4958,21 @@ int8_t Bluecell_TestPro2(double value ){
         minusset = true;
     }
     value *= 10;
-    printf("value*10 : %f \r\n",value);
+//    printf("value*10 : %f \r\n",value);
     temp = (int8_t)value;
-    printf("temp <-value*10 : %d \r\n",temp );
+//    printf("temp <-value*10 : %d \r\n",temp );
     remine = (temp % 10);  
-    printf("temp <-value*10 % remine : %f \r\n",remine);
+//    printf("temp <-value*10 % remine : %f \r\n",remine);
 
    
         if(remine >= 5){
-            printf("temp : %d remind : %d \r\n",temp,remine);
+//            printf("temp : %d remind : %d \r\n",temp,remine);
             temp = temp - remine;
-            printf("tempret  : %d \r\n",temp);        
-            printf("1.temp : %d \r\n",temp);
+//            printf("tempret  : %d \r\n",temp);        
+//            printf("1.temp : %d \r\n",temp);
 //            if(value >= 10){
                 temp += 10;//0.5 for
-            printf("2.temp : %d \r\n",temp);
+//            printf("2.temp : %d \r\n",temp);
 //            }
         }else{
             if(originval > 1)
@@ -4794,14 +4981,14 @@ int8_t Bluecell_TestPro2(double value ){
                temp = (int8_t)originval;
             }
             temp *= 10;
-            printf("originval : %f  temp : %d \r\n",originval,temp);
+//            printf("originval : %f  temp : %d \r\n",originval,temp);
         }
 
         value = (temp * 0.1);
-        printf("1.round Ret : %f \r\n",value);
+//        printf("1.round Ret : %f \r\n",value);
         if(minusset ==true)
            value = value * -1;
-        printf("2.round Ret : %f \r\n",value);    
+//        printf("2.round Ret : %f \r\n",value);    
     return value;
 
 }
@@ -4953,7 +5140,7 @@ double AutoControl_ADC_Compare(double CurrentAdc,uint8_t* CompareAdc,uint8_t siz
         return (RefTable_Data[LastIndex] - (dot * 0.1));
     }
     else{
-        printf("CurrentAdc : %f     TableAdc : %f \r\n",CurrentAdc,TableAdc);
+//        printf("CurrentAdc : %f     TableAdc : %f \r\n",CurrentAdc,TableAdc);
         return (RefTable_Data[0]);
     }
 }
@@ -5112,24 +5299,24 @@ int16_t ALC_Calc(uint8_t num,double CurrAtten ,int8_t threshold,double CurrDet){
 #endif // PYJ.2020.06.20_END -- 
     if(threshold < CurrDet){
         ret = CurrDet - threshold ;
-        printf("1. %f : %f - %d\r\n",ret,CurrDet,threshold);
+//        printf("1. %f : %f - %d\r\n",ret,CurrDet,threshold);
 
         
-        printf("2. %f : %f - %d\r\n",ret,CurrDet,threshold);
+//        printf("2. %f : %f - %d\r\n",ret,CurrDet,threshold);
         result = Bluecell_TestPro2(ret /*+( CurrAtten * -1)*/);
-        printf("2.5. Ret : %d \r\n",result);
+//        printf("2.5. Ret : %d \r\n",result);
         result *= -1;  
-        printf("3. Ret : %d \r\n",result);
+//        printf("3. Ret : %d \r\n",result);
 //        if(CurrAtten <= -20)
 //            ALC_AlarmSet[num] = true;
     }
     else if(threshold -2 > CurrDet ){
         if(CurrAtten < 0){
             ret =  (threshold - 2) - CurrDet ;// -27 ///// - 29
-            printf("%f  =  %d - %f\r\n",ret,(threshold - 2),CurrDet);
-            printf("CurrAtten : %f\r\n",CurrAtten);
+//            printf("%f  =  %d - %f\r\n",ret,(threshold - 2),CurrDet);
+//            printf("CurrAtten : %f\r\n",CurrAtten);
             result = Bluecell_TestPro2(ret);
-            printf("3.ret : %d\r\n",result);
+//            printf("3.ret : %d\r\n",result);
             result += CurrAtten;
             if(CurrAtten < 0){
                 int8_t tmp = CurrAtten * - 1;
@@ -5137,7 +5324,7 @@ int16_t ALC_Calc(uint8_t num,double CurrAtten ,int8_t threshold,double CurrDet){
             result = CurrAtten + 1;
             result *= -1;     
              
-            printf("4.ret : %d\r\n",result);
+//            printf("4.ret : %d\r\n",result);
 //            ALC_AlarmSet[num] = false; 
 
         }
@@ -5221,17 +5408,17 @@ void ALC_Package_Operate(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st
     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,ResdBm);    
-    printf("ORIGIN ResdBm : %f  %d\r\n",ResdBm,Main_Atten);
-    printf("After ResdBm : %f \r\n",ResdBm);
+//    printf("=============ALC ON =====START================\r\n");
+//    printf("Current UL ADC VALUE : %f \r\n",ret);
+//    printf("ResdBm : UL%d : %f \r\n",TableIndex,ResdBm);    
+//    printf("ORIGIN ResdBm : %f  %d\r\n",ResdBm,Main_Atten);
+//    printf("After ResdBm : %f \r\n",ResdBm);
     Limitdata += (Main_Atten * 0.1);
     ALC_Alarm_TimerSet(TableIndex,Limitdata,ResdBm,UL_Atten);
     IwillGiveAtten = ALC_Calc(TableIndex,CurrentATTENVALUE,Limitdata,ResdBm);
-    printf("STEP 1 : I WILL GIVE ATTEN  %d \r\n",IwillGiveAtten);
+//    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);    
+//    printf("STEP 2 : I WILL GIVE ATTEN PLUS  ALC ATTEN  %d \r\n",IwillGiveAtten);    
     if(ResdBm <= (Limitdata - 3)){
         if(IwillGiveAtten <= -10){
             IwillGiveAtten += 10;
@@ -5248,9 +5435,9 @@ void ALC_Package_Operate(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st
     if(IwillGiveAtten >= 0){
         IwillGiveAtten = 0;
     }       
-    printf(" UL_Atten: %d I WILL GIVE ATTEN  : %d \r\n", UL_Atten,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(" UL_Atten: %d I WILL GIVE ATTEN  : %d \r\n", UL_Atten,IwillGiveAtten);  
+//    printf("ADC : %f CURR ATT : %f  Threas : %d : I WILL GIVE ATTEN  : %d \r\n",ret,ResdBm , Limitdata,IwillGiveAtten);  
+//    printf("==================END================\r\n");          
     
 //    if( (IwillGiveAtten > 0) || (CurrentATTENVALUE >= (IwillGiveAtten))){
 //    IwillGiveAtten *= 10;
@@ -5881,8 +6068,59 @@ void AGC_Alarm_Check(uint8_t Path_Index,double AGC_Det,uint8_t* AGC_Table,uint16
     }
 
 }
+typedef enum{
+    DLI_ALC_H = 0,
+    DLI_ALC_L,
+};
+
+#if 0 // 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,uint8_t,DET_TABLEDL_st* DL_Table){
+        double ret = 0;
+        int8_t ResdBm = 0;
+        
+        int16_t Levelret = 0;
+        int i = 0;
+        int16_t Limitdata = 0;
+        int16_t IwillgiveAtten = 0;
+        int16_t ResultData = 0;
+        int8_t* AGC_Table;// = &AGC_Table_ref[MBIC_Table_DL1_INDEX].DET_DL_0;
 
 
+        
+
+        AGC_Table = &AGC_Table_ref[Tableindex].DET_DL_0;
+        ret  = DLI_ADC_Level[DLI_ALC_H] << 8;
+        ret += DLI_ADC_Level[DLI_ALC_L];   
+        ret *= 0.001;
+        ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&DL_Table->Table_Det5_dBm_H,DL_Table->Table_Length * 2,AGC_Table));
+        DLI_Level[DLI_ALC_H] = ((int16_t)ResdBm & 0xFF00) >> 8;
+        DLI_Level[DLI_ALC_L] = ((int16_t)ResdBm & 0x00FF);
+        for(i = 0; i < sizeof(AGC_dBm_t); i++){
+            if(AGC_Table[i] == ResdBm)
+                break;
+        }
+        IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
+        IwillgiveAtten *= -1;
+//        printf("==================================\r\n");
+//        printf("Current DL1 ADC VALUE : %f \r\n",ret);
+//        printf("ResdBm : DL1 : %d \r\n",ResdBm);
+//        printf("I WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten);            
+//        printf("AGC  : %d\r\n",Limitdata);            
+
+
+        if(ResdBm > Limitdata &&  DL_PrevIwillgiveAtten[Tableindex] > IwillgiveAtten){
+//            printf("IwillgiveAtten : %d \r\n",IwillgiveAtten);
+            DL_PrevIwillgiveAtten[Tableindex] = IwillgiveAtten;
+            IwillgiveAtten = (DL_AGC_StartAtten[Tableindex]/10) + IwillgiveAtten;
+//            printf("WILLATTEN RET : %d \r\n",IwillgiveAtten);
+            AGC_Alarm_Check(AGC_Alarm_DL1_Index,ret,&Det_DL1.Table_Det5_dBm_H,IwillgiveAtten);
+            DL_MainAtten[DLI_ALC_H] = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
+            DL_MainAtten[DLI_ALC_L] = (((IwillgiveAtten * 10) & 0x00FF));     
+            CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+        }
+
+}
+#endif // PYJ.2020.06.27_END -- 
 
 void AGC_Function(){//DL
     double ret = 0;

Bluecell_Src/CRC.c

@@ -205,7 +205,7 @@ etError CRC16_Check(uint8_t* buf_ptr, int len,uint16_t checksum)
     uint16_t crc = 0;
     for (uint32_t counter = 0; counter < len; counter++)
         crc = (uint16_t)((crc << 8) ^ crc16_tab[(uint32_t)(((crc >> 8) ^ buf_ptr[counter]) & 0x00FF)]);
-
+    printf("REAL CRC %x / IN CRC : %x \r\n",crc,checksum);
     return (crc == checksum ? CHECKSUM_ERROR : NO_ERROR);
 }
 
@@ -219,7 +219,7 @@ uint16_t CRC16_Generate(uint8_t* buf_ptr, int len)
 //      printf("%d CRC : %x  buf_ptr : %x Counter %d\r\n",a,crc,buf_ptr[counter],counter);
       a++;
     }
-//    printf("len : %d \r\n",len);
+    printf("len : %d \r\n",len);
     return crc;
 }   
 

Bluecell_Src/PE43711.c

@@ -196,6 +196,36 @@ void PE43711_atten_ctrl(PE43711_st ATT ,uint8_t data){
     Pol_Delay_us(10);
     HAL_GPIO_WritePin(ATT.LE_PORT,ATT.LE_PIN,GPIO_PIN_RESET);
 }
+void PE43711_atten_ctrl2(PE43711_st* ATT ,uint8_t data){
+    uint8_t i = 0;
+    uint8_t temp = 0;
+    //data = 4 * data; // ATTEN ERROR 수정 
+    temp = (uint8_t)data;
+    
+    HAL_GPIO_WritePin(ATT->LE_PORT,ATT->LE_PIN,GPIO_PIN_RESET);
+    Pol_Delay_us(10);
+    for(i = 0; i < 8; i++){
+        if((uint8_t)temp & 0x01){
+           HAL_GPIO_WritePin(ATT->DATA_PORT,ATT->DATA_PIN,GPIO_PIN_SET);//DATA
+        }
+           else{
+           HAL_GPIO_WritePin(ATT->DATA_PORT,ATT->DATA_PIN,GPIO_PIN_RESET);//DATA
+           }
+
+		HAL_GPIO_WritePin(ATT->CLK_PORT,ATT->CLK_PIN,GPIO_PIN_SET);//CLOCK
+		Pol_Delay_us(10);
+		HAL_GPIO_WritePin(ATT->CLK_PORT,ATT->CLK_PIN,GPIO_PIN_RESET);//CLOCK
+		Pol_Delay_us(10);
+		temp >>= 1;
+    }
+    
+	HAL_GPIO_WritePin(ATT->CLK_PORT,ATT->CLK_PIN,GPIO_PIN_RESET);//CLOCK
+    HAL_GPIO_WritePin(ATT->DATA_PORT,ATT->DATA_PIN,GPIO_PIN_RESET);//DATA
+    Pol_Delay_us(10);
+    HAL_GPIO_WritePin(ATT->LE_PORT,ATT->LE_PIN,GPIO_PIN_SET);//LE
+    Pol_Delay_us(10);
+    HAL_GPIO_WritePin(ATT->LE_PORT,ATT->LE_PIN,GPIO_PIN_RESET);
+}
 
 
 void PE43711_UL4_atten_ctrl(uint8_t data){

Bluecell_Src/uart.c

@@ -98,7 +98,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 0// PYJ.2019.07.15_BEGIN --
+#if 1// PYJ.2019.07.15_BEGIN --
             printf("\r\n[RX]");
             for(int i = 0; i < cnt; i++){
                 printf("%02x ",uart_buf[i]);
@@ -106,6 +106,9 @@ void GetDataFromUartQueue(UART_HandleTypeDef *huart)
             printf("                       CNT : %d \r\n",cnt);
 #endif // PYJ.2019.07.15_END --
             if(uart_buf[0] == 0xbe){
+                Length = uart_buf[BLUECELL_LENGTH_H] << 8  |  uart_buf[BLUECELL_LENGTH_L] ;
+                CrcChk = uart_buf[Length + 1] << 8 | uart_buf[Length  + 2] ;
+                if(CRC16_Check(&uart_buf[BLUECELL_TYPE], Length,CrcChk))
             	Bluecell_Operate(uart_buf);
             }else if(uart_buf[0] == MBIC_PREAMBLE0
                    &&uart_buf[1] == MBIC_PREAMBLE1
@@ -147,11 +150,11 @@ 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);   
-//    printf("\r\n [TX] : ");
-    for(int i = 0; i< size; i++)
-        printf("%02x ",data[i]);
-    printf("\r\n\tCOUNT : %d \r\n",size);
-    printf("\r\n");
+//    printf("\r\n [TX] : {");
+//    for(int i = 0; i< size; i++)
+//        printf(",0x%02x ",data[i]);
+//    printf("};\r\n\tCOUNT : %d \r\n",size);
+//    printf("\r\n");
     
 }
 

Src/main.c

@@ -117,7 +117,6 @@ volatile uint32_t Alarm_DL_Level_TimerOnCnt = 0;
 volatile uint32_t Alarm_UL_Level_TimerOffCnt = 0;
 volatile uint32_t Alarm_UL_Level_TimerOnCnt = 0;
 
-volatile uint32_t ALC_GainOffset_TimerCnt = 0;