ATT TABLE MBIC Protocol 로 변경 / EEPROM 메모리 주소변경 /

통신속도 115200으로 변경

Bluecell_Inc/Bluecell_operate.h

@@ -305,6 +305,7 @@ enum DATATYPE
     Bluecell_ULO_Shutdown_Threshold                  ,
     Bluecell_ULO_Shutdown_Threshold_Default          ,
     Bluecell_ULO_Shutdown_Retry_Count                ,
+    Bluecell_Reset,
 
 };
 
@@ -345,7 +346,28 @@ enum DATATYPE
 #define ALARM_ULO_SHUTDOWN_P3 0x04
 #define ALARM_ULO_SHUTDOWN_P2 0x02
 #define ALARM_ULO_SHUTDOWN_P1 0x01
+
+
 /*FLAG BIT END*/
+#define MBIC_DLI_AGC_Threshold_Default_H 0xFF
+#define MBIC_DLI_AGC_Threshold_Default_L 0xF6
+#define MBIC_DLI_Shutdown_Threshold_Default_H 0xFF
+#define MBIC_DLI_Shutdown_Threshold_Default_L 0xFF
+
+
+
+#define MBIC_DLI_Level_High_Threshold_default_H 0x00
+#define MBIC_DLI_Level_High_Threshold_default_L 0x07
+#define MBIC_DLI_Level_Low_Threshold_default_H 0xFF
+#define MBIC_DLI_Level_Low_Threshold_default_L 0xD5
+#define MBIC_ULO_Level_High_Threshold_Default_H 0xFF
+#define MBIC_ULO_Level_High_Threshold_Default_L 0xEE
+
+#define MBIC_Temp_High_Threshold_Default 0x50
+#define MBIC_ULO_ALC_Threshold_Default_H 0xFF
+#define MBIC_ULO_ALC_Threshold_Default_L 0xD8
+#define MBIC_ULO_Shutdown_Threshold_Default_H 0xFF
+#define MBIC_ULO_Shutdown_Threshold_Default_L 0xF0
 
 
 typedef enum{
@@ -418,8 +440,8 @@ typedef struct{
     uint8_t DET_UL3_IN_L;//ADC1   6
     uint8_t DET_UL4_IN_H;//ADC3   4
     uint8_t DET_UL4_IN_L;//ADC3   4
-    uint8_t DET_TEMP_H;
-    uint8_t DET_TEMP_L;
+    uint8_t BLUECELL_RESERVE1;
+    uint8_t DET_TEMP;
     uint8_t ATT_AGC1_ONOFF;
     uint8_t ATT_ALC1_ONOFF;
     uint8_t ATT_AGC2_ONOFF;
@@ -436,8 +458,8 @@ typedef struct{
     uint8_t ATT_ALC3_MAX_L;
     uint8_t ATT_ALC4_MAX_H;
     uint8_t ATT_ALC4_MAX_L;
-    uint8_t ATT_ALC1_MIN_H;
-    uint8_t ATT_ALC1_MIN_L;
+    uint8_t ULO_ALC_Threshold_H;
+    uint8_t ULO_ALC_Threshold_L;
     uint8_t ATT_ALC2_MIN_H;
     uint8_t ATT_ALC2_MIN_L;
     uint8_t ATT_ALC3_MIN_H;
@@ -462,10 +484,9 @@ typedef struct{
     uint8_t bluecell_User_UL4_L;
     uint8_t bluecell_User_TEMP_H;  
     uint8_t bluecell_User_TEMP_L;
-    uint8_t bluecell_User_TEMP_OFFSET_H;  
-    uint8_t bluecell_User_TEMP_OFFSET_L;    
-    uint8_t Temp_High_Threshold;
-    uint8_t Temp_High_Threshold_Default;
+    int8_t bluecell_User_TEMP_OFFSET;  
+    int8_t Temp_High_Threshold;
+    int8_t Temp_High_Threshold_Default;
     uint8_t DLI_Level_High_Threshold_H;
     uint8_t DLI_Level_High_Threshold_L;
     uint8_t DLI_Level_Low_Threshold_H;
@@ -477,10 +498,6 @@ typedef struct{
     uint8_t ALARM_ULO_Level;
     uint8_t ALARM_ULO_AGC_SHTUTDOWN;
     uint8_t ALARM_MASK1;
-    uint8_t ALARM_MASK2;
-    uint8_t ALARM_MASK3;
-    uint8_t ALARM_MASK4;
-    uint8_t ALARM_MASK5;
     uint8_t ALARM_TESTMODE;
     uint8_t ALARM_Test_Dummy1;
     uint8_t ALARM_Test_Dummy2;
@@ -601,8 +618,8 @@ typedef struct{
     uint8_t ULO_Level_High_Alarm3;
     uint8_t ULO_Level_High_Alarm4;
     uint8_t ULO_ALC_ON_OFF;
-    uint8_t ULO_ALC_Threshold_H;
-    uint8_t ULO_ALC_Threshold_L;    
+//    uint8_t ULO_ALC_Threshold_H;
+//    uint8_t ULO_ALC_Threshold_L;    
     uint8_t ULO_ALC_Threshold_Default;
     uint8_t ULO_Shutdown_ON_OFF;
     uint8_t ULO_Shutdown_Threshold_H;
@@ -625,134 +642,70 @@ typedef struct{
 
 }BLUESTATUS_st;
 typedef struct{
-  uint8_t Table_0_0_dBm_H;
-  uint8_t Table_0_0_dBm_L; // 1
-  uint8_t Table_0_5_dBm_H;
-  uint8_t Table_0_5_dBm_L; // 3
-  uint8_t Table_1_0_dBm_H;
-  uint8_t Table_1_0_dBm_L;//4
-  uint8_t Table_1_5_dBm_H;
-  uint8_t Table_1_5_dBm_L;//5
-  uint8_t Table_2_0_dBm_H;
-  uint8_t Table_2_0_dBm_L;//6
-  uint8_t Table_2_5_dBm_H;
-  uint8_t Table_2_5_dBm_L;
-  uint8_t Table_3_0_dBm_H;
-  uint8_t Table_3_0_dBm_L;
-  uint8_t Table_3_5_dBm_H;
-  uint8_t Table_3_5_dBm_L;
-  uint8_t Table_4_0_dBm_H;
-  uint8_t Table_4_0_dBm_L;
-  uint8_t Table_4_5_dBm_H;
-  uint8_t Table_4_5_dBm_L;
-  uint8_t Table_5_0_dBm_H;
-  uint8_t Table_5_0_dBm_L;
-  uint8_t Table_5_5_dBm_H;
-  uint8_t Table_5_5_dBm_L;
-  uint8_t Table_6_0_dBm_H;
-  uint8_t Table_6_0_dBm_L;
-  uint8_t Table_6_5_dBm_H;
-  uint8_t Table_6_5_dBm_L;
-  uint8_t Table_7_0_dBm_H;
-  uint8_t Table_7_0_dBm_L;
-  uint8_t Table_7_5_dBm_H;
-  uint8_t Table_7_5_dBm_L;
-  uint8_t Table_8_0_dBm_H;
-  uint8_t Table_8_0_dBm_L;
-  uint8_t Table_8_5_dBm_H;
-  uint8_t Table_8_5_dBm_L;
-  uint8_t Table_9_0_dBm_H;
-  uint8_t Table_9_0_dBm_L;
-  uint8_t Table_9_5_dBm_H;
-  uint8_t Table_9_5_dBm_L;
-  uint8_t Table_10_0_dBm_H;
-  uint8_t Table_10_0_dBm_L;
-  uint8_t Table_10_5_dBm_H;
-  uint8_t Table_10_5_dBm_L;
-  uint8_t Table_11_0_dBm_H;
-  uint8_t Table_11_0_dBm_L;
-  uint8_t Table_11_5_dBm_H;
-  uint8_t Table_11_5_dBm_L;
-  uint8_t Table_12_0_dBm_H;
-  uint8_t Table_12_0_dBm_L;
-  uint8_t Table_12_5_dBm_H;
-  uint8_t Table_12_5_dBm_L;
-  uint8_t Table_13_0_dBm_H;
-  uint8_t Table_13_0_dBm_L;
-  uint8_t Table_13_5_dBm_H;
-  uint8_t Table_13_5_dBm_L;
-  uint8_t Table_14_0_dBm_H;
-  uint8_t Table_14_0_dBm_L;
-  uint8_t Table_14_5_dBm_H;
-  uint8_t Table_14_5_dBm_L;
-  uint8_t Table_15_0_dBm_H;
-  uint8_t Table_15_0_dBm_L;
-  uint8_t Table_15_5_dBm_H;
-  uint8_t Table_15_5_dBm_L;
-  uint8_t Table_16_0_dBm_H;
-  uint8_t Table_16_0_dBm_L;
-  uint8_t Table_16_5_dBm_H;
-  uint8_t Table_16_5_dBm_L;
-  uint8_t Table_17_0_dBm_H;
-  uint8_t Table_17_0_dBm_L;
-  uint8_t Table_17_5_dBm_H;
-  uint8_t Table_17_5_dBm_L;
-  uint8_t Table_18_0_dBm_H;
-  uint8_t Table_18_0_dBm_L;
-  uint8_t Table_18_5_dBm_H;
-  uint8_t Table_18_5_dBm_L;
-  uint8_t Table_19_0_dBm_H;
-  uint8_t Table_19_0_dBm_L;
-  uint8_t Table_19_5_dBm_H;
-  uint8_t Table_19_5_dBm_L;
-  uint8_t Table_20_0_dBm_H;
-  uint8_t Table_20_0_dBm_L;
-  uint8_t Table_20_5_dBm_H;
-  uint8_t Table_20_5_dBm_L;
-  uint8_t Table_21_0_dBm_H;
-  uint8_t Table_21_0_dBm_L;
-  uint8_t Table_21_5_dBm_H;
-  uint8_t Table_21_5_dBm_L;
-  uint8_t Table_22_0_dBm_H;
-  uint8_t Table_22_0_dBm_L;
-  uint8_t Table_22_5_dBm_H;
-  uint8_t Table_22_5_dBm_L;
-  uint8_t Table_23_0_dBm_H;
-  uint8_t Table_23_0_dBm_L;
-  uint8_t Table_23_5_dBm_H;
-  uint8_t Table_23_5_dBm_L;
-  uint8_t Table_24_0_dBm_H;
-  uint8_t Table_24_0_dBm_L;
-  uint8_t Table_24_5_dBm_H;
-  uint8_t Table_24_5_dBm_L;
-  uint8_t Table_25_0_dBm_H;
-  uint8_t Table_25_0_dBm_L;
-  uint8_t Table_25_5_dBm_H;
-  uint8_t Table_25_5_dBm_L;
-  uint8_t Table_26_0_dBm_H;
-  uint8_t Table_26_0_dBm_L;
-  uint8_t Table_26_5_dBm_H;
-  uint8_t Table_26_5_dBm_L;
-  uint8_t Table_27_0_dBm_H;
-  uint8_t Table_27_0_dBm_L;
-  uint8_t Table_27_5_dBm_H;
-  uint8_t Table_27_5_dBm_L;
-  uint8_t Table_28_0_dBm_H;
-  uint8_t Table_28_0_dBm_L;
-  uint8_t Table_28_5_dBm_H;
-  uint8_t Table_28_5_dBm_L;
-  uint8_t Table_29_0_dBm_H;
-  uint8_t Table_29_0_dBm_L;
-  uint8_t Table_29_5_dBm_H;
-  uint8_t Table_29_5_dBm_L;
-  uint8_t Table_30_0_dBm_H;
-  uint8_t Table_30_0_dBm_L;
-  uint8_t Table_30_5_dBm_H;
-  uint8_t Table_30_5_dBm_L;
-  uint8_t Table_31_0_dBm_H;
-  uint8_t Table_31_0_dBm_L;
-  uint8_t Table_31_5_dBm_H;
-  uint8_t Table_31_5_dBm_L;
+  uint8_t Table_0_0_dBm;
+  uint8_t Table_0_5_dBm;
+  uint8_t Table_1_0_dBm;
+  uint8_t Table_1_5_dBm;
+  uint8_t Table_2_0_dBm;
+  uint8_t Table_2_5_dBm;
+  uint8_t Table_3_0_dBm;
+  uint8_t Table_3_5_dBm;
+  uint8_t Table_4_0_dBm;
+  uint8_t Table_4_5_dBm;
+  uint8_t Table_5_0_dBm;
+  uint8_t Table_5_5_dBm;
+  uint8_t Table_6_0_dBm;
+  uint8_t Table_6_5_dBm;
+  uint8_t Table_7_0_dBm;
+  uint8_t Table_7_5_dBm;
+  uint8_t Table_8_0_dBm;
+  uint8_t Table_8_5_dBm;
+  uint8_t Table_9_0_dBm;
+  uint8_t Table_9_5_dBm;
+  uint8_t Table_10_0_dBm;
+  uint8_t Table_10_5_dBm;
+  uint8_t Table_11_0_dBm;
+  uint8_t Table_11_5_dBm;
+  uint8_t Table_12_0_dBm;
+  uint8_t Table_12_5_dBm;
+  uint8_t Table_13_0_dBm;
+  uint8_t Table_13_5_dBm;
+  uint8_t Table_14_0_dBm;
+  uint8_t Table_14_5_dBm;
+  uint8_t Table_15_0_dBm;
+  uint8_t Table_15_5_dBm;
+  uint8_t Table_16_0_dBm;
+  uint8_t Table_16_5_dBm;
+  uint8_t Table_17_0_dBm;
+  uint8_t Table_17_5_dBm;
+  uint8_t Table_18_0_dBm;
+  uint8_t Table_18_5_dBm;
+  uint8_t Table_19_0_dBm;
+  uint8_t Table_19_5_dBm;
+  uint8_t Table_20_0_dBm;
+  uint8_t Table_20_5_dBm;
+  uint8_t Table_21_0_dBm;
+  uint8_t Table_21_5_dBm;
+  uint8_t Table_22_0_dBm;
+  uint8_t Table_22_5_dBm;
+  uint8_t Table_23_0_dBm;
+  uint8_t Table_23_5_dBm;
+  uint8_t Table_24_0_dBm;
+  uint8_t Table_24_5_dBm;
+  uint8_t Table_25_0_dBm;
+  uint8_t Table_25_5_dBm;
+  uint8_t Table_26_0_dBm;
+  uint8_t Table_26_5_dBm;
+  uint8_t Table_27_0_dBm;
+  uint8_t Table_27_5_dBm;
+  uint8_t Table_28_0_dBm;
+  uint8_t Table_28_5_dBm;
+  uint8_t Table_29_0_dBm;
+  uint8_t Table_29_5_dBm;
+  uint8_t Table_30_0_dBm;
+  uint8_t Table_30_5_dBm;
+  uint8_t Table_31_0_dBm;
+  uint8_t Table_31_5_dBm;
 }ATT_TABLE_st;
 typedef struct{
 

Bluecell_Inc/eeprom.h

@@ -11,11 +11,11 @@
 
 #define EEPROM_M24C08_ID                  0xA0
 #define EEPROM_Block0_ADDRESS             EEPROM_M24C08_ID
-#define EEPROM_ATT_BASE					  0x0000
+#define EEPROM_ATT_BASE					  0x0000 + 96
 
 #if 1 // PYJ.2020.04.25_BEGIN -- 
 
-#define EEPROM_ATT_DL1_TABLE_ADDRESDS	 (( EEPROM_ATT_BASE  + (sizeof(ATT_TABLE_st))  )& 0xFFFF) //128
+#define EEPROM_ATT_DL1_TABLE_ADDRESDS	 (( EEPROM_ATT_BASE                 +(sizeof(ATT_TABLE_st))   )  & 0xFFFF) //128
 #define EEPROM_ATT_DL2_TABLE_ADDRESDS	 (( EEPROM_ATT_DL1_TABLE_ADDRESDS  + (sizeof(ATT_TABLE_st))  ) & 0xFFFF) 
 #define EEPROM_ATT_DL3_TABLE_ADDRESDS	 (( EEPROM_ATT_DL2_TABLE_ADDRESDS  + (sizeof(ATT_TABLE_st))  ) & 0xFFFF)
 #define EEPROM_ATT_DL4_TABLE_ADDRESDS	 (( EEPROM_ATT_DL3_TABLE_ADDRESDS  + (sizeof(ATT_TABLE_st))  ) & 0xFFFF)

Bluecell_Src/Bluecell_operate.c

@@ -293,6 +293,7 @@ uint8_t PE43711_Calc_NoTable(uint8_t high_bit,uint8_t low_bit){
     PE43711_DataToHexConvert(ret);
     return 0;
 }
+/*2 byte Data Double Convert Function*/
 double PE43711_Double(uint8_t high_bit,uint8_t low_bit){
     uint16_t tmp_h = 0,tmp_l = 0;
     double ret = 0;
@@ -301,6 +302,7 @@ double PE43711_Double(uint8_t high_bit,uint8_t low_bit){
     tmp_l = low_bit;
     ret = ((tmp_h << 8) & 0xFF00);
     ret += (tmp_l & 0x00FF);
+    /*Minus Convert*/
     if((((tmp_h << 8) & 0xFF00) & 0xF000) == 0xF000){
 //        printf("minus Calc Start\r\n");
         ret = 0xFFFF - ret;
@@ -315,8 +317,8 @@ double PE43711_Double(uint8_t high_bit,uint8_t low_bit){
     return ret;
 
 }
-uint8_t GuaranteeData[256];
 double TableAtteGuarantee(uint8_t* Table,double AttenValue){
+    int8_t GuaranteeData[256];
     double ret = 0;
     //double ref = 0;
     uint8_t cnt = 0;
@@ -327,7 +329,8 @@ double TableAtteGuarantee(uint8_t* Table,double AttenValue){
     Bluecell_StructCpy(&GuaranteeData[0],&Table[0],sizeof(ATT_TABLE_st));
     
 //    printf("H  : %x   L : %x \r\n",GuaranteeData[cnt * 2],GuaranteeData[cnt * 2 + 1]);
-    ret = PE43711_Double(GuaranteeData[cnt * 2],GuaranteeData[cnt * 2 + 1]);
+    ret =  GuaranteeData[cnt] / 2;
+//= PE43711_Double(GuaranteeData[cnt * 2],GuaranteeData[cnt * 2 + 1]);
 //    printf("ret3 : %f \r\n",ret); //1
     ret += AttenValue;
 //    printf("ret4 : %f \r\n",ret);
@@ -352,7 +355,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
             bluecell_Prevdatastatus.ATT_DL1_L = bluecell_Currdatastatus.ATT_DL1_L;
             bluecell_Prevdatastatus.bluecell_User_DL1_H = bluecell_Currdatastatus.bluecell_User_DL1_H;
             bluecell_Prevdatastatus.bluecell_User_DL1_L = bluecell_Currdatastatus.bluecell_User_DL1_L;
-            val = PE43711_Calc(&Att_DL1.Table_0_0_dBm_H,
+            val = PE43711_Calc(&Att_DL1.Table_0_0_dBm,
                                 Curr.ATT_DL1_H,
                                 Curr.ATT_DL1_L,
                                bluecell_Currdatastatus.bluecell_User_DL1_H,
@@ -373,7 +376,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
                 bluecell_Prevdatastatus.ATT_DL2_L = bluecell_Currdatastatus.ATT_DL2_L;
                 bluecell_Prevdatastatus.bluecell_User_DL2_H = bluecell_Currdatastatus.bluecell_User_DL2_H;
                 bluecell_Prevdatastatus.bluecell_User_DL2_L = bluecell_Currdatastatus.bluecell_User_DL2_L;
-                val = PE43711_Calc(&Att_DL2.Table_0_0_dBm_H,
+                val = PE43711_Calc(&Att_DL2.Table_0_0_dBm,
                                     Curr.ATT_DL2_H,
                                     Curr.ATT_DL2_L,
                                    bluecell_Currdatastatus.bluecell_User_DL2_H,
@@ -395,7 +398,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
             bluecell_Prevdatastatus.ATT_DL3_L = bluecell_Currdatastatus.ATT_DL3_L;
             bluecell_Prevdatastatus.bluecell_User_DL3_H = bluecell_Currdatastatus.bluecell_User_DL3_H;
             bluecell_Prevdatastatus.bluecell_User_DL3_L = bluecell_Currdatastatus.bluecell_User_DL3_L;
-            val = PE43711_Calc(&Att_DL3.Table_0_0_dBm_H,
+            val = PE43711_Calc(&Att_DL3.Table_0_0_dBm,
                                 Curr.ATT_DL3_H,
                                 Curr.ATT_DL3_L,
                                bluecell_Currdatastatus.bluecell_User_DL3_H,
@@ -419,7 +422,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
             bluecell_Prevdatastatus.ATT_DL4_L = bluecell_Currdatastatus.ATT_DL4_L;
             bluecell_Prevdatastatus.bluecell_User_DL4_H = bluecell_Currdatastatus.bluecell_User_DL4_H;
             bluecell_Prevdatastatus.bluecell_User_DL4_L = bluecell_Currdatastatus.bluecell_User_DL4_L;
-            val = PE43711_Calc(&Att_DL4.Table_0_0_dBm_H,
+            val = PE43711_Calc(&Att_DL4.Table_0_0_dBm,
                                 Curr.ATT_DL4_H,
                                 Curr.ATT_DL4_L,
                                bluecell_Currdatastatus.bluecell_User_DL4_H,
@@ -442,7 +445,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
             bluecell_Prevdatastatus.ATT_UL1_L = bluecell_Currdatastatus.ATT_UL1_L;
             bluecell_Prevdatastatus.bluecell_User_UL1_H = bluecell_Currdatastatus.bluecell_User_UL1_H;
             bluecell_Prevdatastatus.bluecell_User_UL1_L = bluecell_Currdatastatus.bluecell_User_UL1_L;
-            val = PE43711_Calc(&Att_UL1.Table_0_0_dBm_H,
+            val = PE43711_Calc(&Att_UL1.Table_0_0_dBm,
                                 Curr.ATT_UL1_H,
                                 Curr.ATT_UL1_L,
                                bluecell_Currdatastatus.bluecell_User_UL1_H,
@@ -462,7 +465,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
             bluecell_Prevdatastatus.ATT_UL2_L = bluecell_Currdatastatus.ATT_UL2_L;
             bluecell_Prevdatastatus.bluecell_User_UL2_H = bluecell_Currdatastatus.bluecell_User_UL2_H;
             bluecell_Prevdatastatus.bluecell_User_UL2_L = bluecell_Currdatastatus.bluecell_User_UL2_L;
-            val = PE43711_Calc(&Att_UL2.Table_0_0_dBm_H,
+            val = PE43711_Calc(&Att_UL2.Table_0_0_dBm,
                                 Curr.ATT_UL2_H,
                                 Curr.ATT_UL2_L,
                                bluecell_Currdatastatus.bluecell_User_UL2_H,
@@ -485,7 +488,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
             bluecell_Prevdatastatus.bluecell_User_UL3_H = bluecell_Currdatastatus.bluecell_User_UL3_H;
             bluecell_Prevdatastatus.bluecell_User_UL3_L = bluecell_Currdatastatus.bluecell_User_UL3_L;
             
-            val = PE43711_Calc(&Att_UL3.Table_0_0_dBm_H,
+            val = PE43711_Calc(&Att_UL3.Table_0_0_dBm,
                                 Curr.ATT_UL3_H,
                                 Curr.ATT_UL3_L,
                                bluecell_Currdatastatus.bluecell_User_UL3_H,
@@ -506,7 +509,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
             bluecell_Prevdatastatus.bluecell_User_UL4_H = bluecell_Currdatastatus.bluecell_User_UL4_H;
             bluecell_Prevdatastatus.bluecell_User_UL4_L = bluecell_Currdatastatus.bluecell_User_UL4_L;
             
-            val = PE43711_Calc(&Att_UL4.Table_0_0_dBm_H,
+            val = PE43711_Calc(&Att_UL4.Table_0_0_dBm,
                                 Curr.ATT_UL4_H,
                                 Curr.ATT_UL4_L,
                                bluecell_Currdatastatus.bluecell_User_UL4_H,
@@ -526,7 +529,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
         bluecell_Prevdatastatus.ATT_ALC1_MAX_L = bluecell_Currdatastatus.ATT_ALC1_MAX_L;
         bluecell_Prevdatastatus.bluecell_User_UL1_H = bluecell_Currdatastatus.bluecell_User_UL1_H;
         bluecell_Prevdatastatus.bluecell_User_UL1_L = bluecell_Currdatastatus.bluecell_User_UL1_L;
-        val = PE43711_Calc(&Att_UL1.Table_0_0_dBm_H,
+        val = PE43711_Calc(&Att_UL1.Table_0_0_dBm,
                             Curr.ATT_ALC1_MAX_H,
                             Curr.ATT_ALC1_MAX_L,
                            bluecell_Currdatastatus.bluecell_User_DL1_H,
@@ -543,7 +546,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
         bluecell_Prevdatastatus.ATT_ALC2_MAX_L = bluecell_Currdatastatus.ATT_ALC2_MAX_L;
         bluecell_Prevdatastatus.bluecell_User_UL2_H = bluecell_Currdatastatus.bluecell_User_UL2_H;
         bluecell_Prevdatastatus.bluecell_User_UL2_L = bluecell_Currdatastatus.bluecell_User_UL2_L;
-        val = PE43711_Calc(&Att_UL2.Table_0_0_dBm_H,
+        val = PE43711_Calc(&Att_UL2.Table_0_0_dBm,
                             Curr.ATT_ALC2_MAX_H,
                             Curr.ATT_ALC2_MAX_L,
                            bluecell_Currdatastatus.bluecell_User_DL2_H,
@@ -560,7 +563,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
         bluecell_Prevdatastatus.ATT_ALC3_MAX_L = bluecell_Currdatastatus.ATT_ALC3_MAX_L;
         bluecell_Prevdatastatus.bluecell_User_UL3_H = bluecell_Currdatastatus.bluecell_User_UL3_H;
         bluecell_Prevdatastatus.bluecell_User_UL3_L = bluecell_Currdatastatus.bluecell_User_UL3_L;
-        val = PE43711_Calc(&Att_UL3.Table_0_0_dBm_H,
+        val = PE43711_Calc(&Att_UL3.Table_0_0_dBm,
             Curr.ATT_ALC3_MAX_H,
             Curr.ATT_ALC3_MAX_L,
                            bluecell_Currdatastatus.bluecell_User_DL3_H,
@@ -578,7 +581,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
         bluecell_Prevdatastatus.ATT_ALC4_MAX_L = bluecell_Currdatastatus.ATT_ALC4_MAX_L;
         bluecell_Prevdatastatus.bluecell_User_UL4_H = bluecell_Currdatastatus.bluecell_User_UL4_H;
         bluecell_Prevdatastatus.bluecell_User_UL4_L = bluecell_Currdatastatus.bluecell_User_UL4_L;
-        val = PE43711_Calc(&Att_UL4.Table_0_0_dBm_H,
+        val = PE43711_Calc(&Att_UL4.Table_0_0_dBm,
             Curr.ATT_ALC4_MAX_H,
             Curr.ATT_ALC4_MAX_L,
                            bluecell_Currdatastatus.bluecell_User_DL4_H,
@@ -589,17 +592,17 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
     }
 
     
-    if((Curr.ATT_ALC1_MIN_H != Prev.ATT_ALC1_MIN_H
-     ||Curr.ATT_ALC1_MIN_L != Prev.ATT_ALC1_MIN_L)
+    if((Curr.ULO_ALC_Threshold_H != Prev.ULO_ALC_Threshold_H
+     ||Curr.ULO_ALC_Threshold_L != Prev.ULO_ALC_Threshold_L)
      ||(Curr.bluecell_User_UL1_H != Prev.bluecell_User_UL1_H
      ||Curr.bluecell_User_UL1_L != Prev.bluecell_User_UL1_L)){
-        bluecell_Prevdatastatus.ATT_ALC1_MIN_H = bluecell_Currdatastatus.ATT_ALC1_MIN_H;
-        bluecell_Prevdatastatus.ATT_ALC1_MIN_L = bluecell_Currdatastatus.ATT_ALC1_MIN_L;
+        bluecell_Prevdatastatus.ULO_ALC_Threshold_H = bluecell_Currdatastatus.ULO_ALC_Threshold_H;
+        bluecell_Prevdatastatus.ULO_ALC_Threshold_L = bluecell_Currdatastatus.ULO_ALC_Threshold_L;
         bluecell_Prevdatastatus.bluecell_User_UL1_H = bluecell_Currdatastatus.bluecell_User_UL1_H;
         bluecell_Prevdatastatus.bluecell_User_UL1_L = bluecell_Currdatastatus.bluecell_User_UL1_L;
-        val = PE43711_Calc(&Att_DL1.Table_0_0_dBm_H,
-            Curr.ATT_ALC1_MIN_H,
-            Curr.ATT_ALC1_MIN_L,
+        val = PE43711_Calc(&Att_DL1.Table_0_0_dBm,
+            Curr.ULO_ALC_Threshold_H,
+            Curr.ULO_ALC_Threshold_L,
                            bluecell_Currdatastatus.bluecell_User_UL1_H,
                            bluecell_Currdatastatus.bluecell_User_UL1_L);
 
@@ -614,7 +617,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
         bluecell_Prevdatastatus.ATT_ALC2_MIN_L = bluecell_Currdatastatus.ATT_ALC2_MIN_L;
         bluecell_Prevdatastatus.bluecell_User_UL2_H = bluecell_Currdatastatus.bluecell_User_UL2_H;
         bluecell_Prevdatastatus.bluecell_User_UL2_L = bluecell_Currdatastatus.bluecell_User_UL2_L;
-        val = PE43711_Calc(&Att_DL2.Table_0_0_dBm_H,
+        val = PE43711_Calc(&Att_DL2.Table_0_0_dBm,
             Curr.ATT_ALC2_MIN_H,
             Curr.ATT_ALC2_MIN_L,
                            bluecell_Currdatastatus.bluecell_User_UL2_H,
@@ -631,7 +634,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
         bluecell_Prevdatastatus.ATT_ALC3_MIN_L = bluecell_Currdatastatus.ATT_ALC3_MIN_L;
         bluecell_Prevdatastatus.bluecell_User_UL3_H = bluecell_Currdatastatus.bluecell_User_UL3_H;
         bluecell_Prevdatastatus.bluecell_User_UL3_L = bluecell_Currdatastatus.bluecell_User_UL3_L;
-        val = PE43711_Calc(&Att_DL3.Table_0_0_dBm_H,
+        val = PE43711_Calc(&Att_DL3.Table_0_0_dBm,
             Curr.ATT_ALC3_MIN_H,
             Curr.ATT_ALC3_MIN_L,
                            bluecell_Currdatastatus.bluecell_User_UL3_H,
@@ -648,7 +651,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
         bluecell_Prevdatastatus.ATT_ALC4_MIN_L = bluecell_Currdatastatus.ATT_ALC4_MIN_L;
         bluecell_Prevdatastatus.bluecell_User_UL4_H = bluecell_Currdatastatus.bluecell_User_UL4_H;
         bluecell_Prevdatastatus.bluecell_User_UL4_L = bluecell_Currdatastatus.bluecell_User_UL4_L;
-        val = PE43711_Calc(&Att_DL4.Table_0_0_dBm_H,
+        val = PE43711_Calc(&Att_DL4.Table_0_0_dBm,
             Curr.ATT_ALC4_MIN_H,
             Curr.ATT_ALC4_MIN_L,
                            bluecell_Currdatastatus.bluecell_User_UL4_H,
@@ -725,44 +728,46 @@ void Bluecell_TableLoad(uint8_t* data){
 //    printf("%s : %x \r\n",__func__,tabletype);
     switch(tabletype){
         case Bluecell_Table_ATT_DL1: 
-            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,EEPROM_WINDOW_STATUS_ADDRESDS              ,&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
-            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
-//            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,EEPROM_ATT_BASE              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
+//            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,EEPROM_WINDOW_STATUS_ADDRESDS              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
+
+            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
+//            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
           break;
         case Bluecell_Table_ATT_DL2: 
-            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL1_TABLE_ADDRESDS),&Att_DL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );   
-            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            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;
             break;
         case Bluecell_Table_ATT_DL3: 
-            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL2_TABLE_ADDRESDS),&Att_DL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );               
-            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            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;
             break;
         case Bluecell_Table_ATT_DL4: 
-            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL3_TABLE_ADDRESDS),&Att_DL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );               
-            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            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;
             break;
         case Bluecell_Table_ATT_UL1: 
-            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL4_TABLE_ADDRESDS),&Att_UL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );   
-            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            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;
         break;
         case Bluecell_Table_ATT_UL2: 
-            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL1_TABLE_ADDRESDS),&Att_UL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );   
-            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            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;
             break;
         case Bluecell_Table_ATT_UL3: 
-            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL2_TABLE_ADDRESDS),&Att_UL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );   
-            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            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;
             break;
         case Bluecell_Table_ATT_UL4: 
-            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL3_TABLE_ADDRESDS),&Att_UL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );   
-            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            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;
             break;
         case Bluecell_Table_DET_DL1: 
@@ -866,46 +871,46 @@ void Bluecell_TableSave(uint8_t* data){
     //printf("%s : %x \r\n",__func__,tabletype);
     switch(tabletype){
         case Bluecell_Table_ATT_DL1: 
-            Bluecell_DataCopy(&Att_DL1.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
-            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS)              ,&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
-//            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            Bluecell_DataCopy(&Att_DL1.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_BASE)              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
+//            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
 //            printf("ADDRESS : %d \r\n",EEPROM_WINDOW_STATUS_ADDRESDS );
-//            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+//            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             break;
             
         case Bluecell_Table_ATT_DL2: 
-            Bluecell_DataCopy(&Att_DL2.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
-            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL1_TABLE_ADDRESDS),&Att_DL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
+            Bluecell_DataCopy(&Att_DL2.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL1_TABLE_ADDRESDS),&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
 //            printf("ADDRESS : %d \r\n",EEPROM_ATT_DL1_TABLE_ADDRESDS );
 
             break;
             
         case Bluecell_Table_ATT_DL3: 
-            Bluecell_DataCopy(&Att_DL3.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
-            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL2_TABLE_ADDRESDS),&Att_DL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            Bluecell_DataCopy(&Att_DL3.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL2_TABLE_ADDRESDS),&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             break;
             
         case Bluecell_Table_ATT_DL4: 
-            Bluecell_DataCopy(&Att_DL4.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
-            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL3_TABLE_ADDRESDS),&Att_DL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            Bluecell_DataCopy(&Att_DL4.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL3_TABLE_ADDRESDS),&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             break;
 
             
         case Bluecell_Table_ATT_UL1: 
-            Bluecell_DataCopy(&Att_UL1.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
-            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL4_TABLE_ADDRESDS),&Att_UL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            Bluecell_DataCopy(&Att_UL1.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL4_TABLE_ADDRESDS),&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             break;
         case Bluecell_Table_ATT_UL2: 
-            Bluecell_DataCopy(&Att_UL2.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
-            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL1_TABLE_ADDRESDS),&Att_UL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            Bluecell_DataCopy(&Att_UL2.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL1_TABLE_ADDRESDS),&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             break;
         case Bluecell_Table_ATT_UL3: 
-            Bluecell_DataCopy(&Att_UL3.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
-            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL2_TABLE_ADDRESDS),&Att_UL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            Bluecell_DataCopy(&Att_UL3.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL2_TABLE_ADDRESDS),&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             break;
         case Bluecell_Table_ATT_UL4: 
-            Bluecell_DataCopy(&Att_UL4.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
-            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL3_TABLE_ADDRESDS),&Att_UL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            Bluecell_DataCopy(&Att_UL4.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL3_TABLE_ADDRESDS),&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             break;
         case Bluecell_Table_DET_DL1: 
             Bluecell_DataCopy(&Det_DL1.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st));
@@ -984,11 +989,18 @@ void Bluecell_TableSave(uint8_t* data){
 uint8_t Txdata[512];
 extern HAL_StatusTypeDef EEPROM_M24C08_Zerowrite(uint8_t devid,uint16_t Address);
 
+
+
+
+
+
+
 bool Bluecell_Operate(uint8_t* data){
   uint8_t datatype = data[BLUECELL_TYPE];
 
 
   //double ret = 0 ,tmp = 0.1;
+  int16_t tempdata = 0;
 
   uint8_t i = 0;
   switch(datatype){
@@ -1025,8 +1037,8 @@ bool Bluecell_Operate(uint8_t* data){
         bluecell_Currdatastatus.ATT_ALC3_MAX_L = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_ALC4_MAX_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_ALC4_MAX_L = data[BLUECELL_DATA + i++];
-        bluecell_Currdatastatus.ATT_ALC1_MIN_H = data[BLUECELL_DATA + i++]; // 20
-        bluecell_Currdatastatus.ATT_ALC1_MIN_L = data[BLUECELL_DATA + i++];
+        bluecell_Currdatastatus.ULO_ALC_Threshold_H = data[BLUECELL_DATA + i++]; // 20
+        bluecell_Currdatastatus.ULO_ALC_Threshold_L = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_ALC2_MIN_H = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_ALC2_MIN_L = data[BLUECELL_DATA + i++];
         bluecell_Currdatastatus.ATT_ALC3_MIN_H = data[BLUECELL_DATA + i++];
@@ -1270,9 +1282,9 @@ bool Bluecell_Operate(uint8_t* data){
       break;
     case ATT_TableSet:
         Bluecell_TableSave(data);
-    break;
     case ATT_TableGet:
         Bluecell_TableLoad(data);
+        data[BLUECELL_TYPE] = ATT_TableGet;
         data[data[BLUECELL_LENGTH] + 1] = STH30_CreateCrc(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH]);
         Bluecell_StructCpy(&Txdata[0],&data[0],data[BLUECELL_LENGTH] + 3);
         Uart1_Data_Send(&Txdata[0], Txdata[BLUECELL_LENGTH] + 3);
@@ -1360,8 +1372,8 @@ bool Bluecell_Operate(uint8_t* data){
 #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++];
+        bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET = data[BLUECELL_DATA + i++];
+//        bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET_L = data[BLUECELL_DATA + i++];
 
         break;
     case Bluecell_DLI_AGC_ON_OFF:                             
@@ -1380,11 +1392,19 @@ bool Bluecell_Operate(uint8_t* data){
     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++];
+        tempdata = (( bluecell_Currdatastatus.DLI_AGC_Threshold_H << 8) & 0xFF00) ;
+        tempdata +=  bluecell_Currdatastatus.DLI_AGC_Threshold_L ;
+        tempdata /= 10;
+        bluecell_Currdatastatus.DLI_AGC_Threshold_H = ((tempdata & 0xFF00) >> 8);
+        bluecell_Currdatastatus.DLI_AGC_Threshold_L = (tempdata & 0x00FF);    
 
         break;
     case Bluecell_DLI_AGC_Threshold_Default:                  
         bluecell_Currdatastatus.DLI_AGC_Threshold_default = data[BLUECELL_DATA + i++];
-
+        if(bluecell_Currdatastatus.DLI_AGC_Threshold_default == true){
+            bluecell_Currdatastatus.DLI_AGC_Threshold_H = MBIC_DLI_AGC_Threshold_Default_H;
+            bluecell_Currdatastatus.DLI_AGC_Threshold_L = MBIC_DLI_AGC_Threshold_Default_L;
+        }
         break;
     case Bluecell_DLI_Shutdown_ON_OFF:                        
         bluecell_Currdatastatus.DLI_Shutdown_ON_OFF = data[BLUECELL_DATA + i++];
@@ -1393,10 +1413,21 @@ bool Bluecell_Operate(uint8_t* data){
     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++];
+        tempdata = (( bluecell_Currdatastatus.DLI_Shutdown_Threshold_H << 8) & 0xFF00) ;
+        tempdata +=  bluecell_Currdatastatus.DLI_Shutdown_Threshold_L ;
+        tempdata /= 10;
+        bluecell_Currdatastatus.DLI_Shutdown_Threshold_H = ((tempdata & 0xFF00) >> 8);
+        bluecell_Currdatastatus.DLI_Shutdown_Threshold_L = (tempdata & 0x00FF);
+//        printf("tempdata %d \r\n",tempdata);
 
         break;
     case Bluecell_DLI_Shutdown_Threshold_Default:             
         bluecell_Currdatastatus.DLI_Shutdown_Threshold_Default = data[BLUECELL_DATA + i++];
+        if(bluecell_Currdatastatus.DLI_Shutdown_Threshold_Default == true){
+            bluecell_Currdatastatus.DLI_Shutdown_Threshold_H = MBIC_DLI_Shutdown_Threshold_Default_H;
+            bluecell_Currdatastatus.DLI_Shutdown_Threshold_L = MBIC_DLI_Shutdown_Threshold_Default_L;
+        }
+//      printf("bluecell_Currdatastatus.DLI_Shutdown_Threshold_Default : %d \r\n",bluecell_Currdatastatus.DLI_Shutdown_Threshold_Default);
         break;
     case Bluecell_DLI_Shutdown_Count:                         
         /*NOP*/
@@ -1404,22 +1435,36 @@ bool Bluecell_Operate(uint8_t* data){
     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++];
-
+        tempdata = (( bluecell_Currdatastatus.DLI_Level_High_Threshold_H << 8) & 0xFF00) ;
+        tempdata +=  bluecell_Currdatastatus.DLI_Level_High_Threshold_L ;
+        tempdata /= 10;
+        bluecell_Currdatastatus.DLI_Level_High_Threshold_H = ((tempdata & 0xFF00) >> 8);
+        bluecell_Currdatastatus.DLI_Level_High_Threshold_L = (tempdata & 0x00FF);
         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++];
+        tempdata = (( bluecell_Currdatastatus.DLI_Level_Low_Threshold_H << 8) & 0xFF00) ;
+        tempdata +=  bluecell_Currdatastatus.DLI_Level_Low_Threshold_L ;
+        tempdata /= 10;
+        bluecell_Currdatastatus.DLI_Level_Low_Threshold_H = ((tempdata & 0xFF00) >> 8);
+        bluecell_Currdatastatus.DLI_Level_Low_Threshold_L = (tempdata & 0x00FF);    
 
         break;
     case Bluecell_DLI_Level_High_Low_Threshold_default    :   
         bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default = data[BLUECELL_DATA + i++];
+        if(bluecell_Currdatastatus.DLI_Level_High_Low_Threshold_default == true){
+            bluecell_Currdatastatus.DLI_Level_High_Threshold_H = MBIC_DLI_Level_High_Threshold_default_H;
+            bluecell_Currdatastatus.DLI_Level_High_Threshold_L = MBIC_DLI_Level_High_Threshold_default_L;
+            bluecell_Currdatastatus.DLI_Level_Low_Threshold_H = MBIC_DLI_Level_Low_Threshold_default_H;
+            bluecell_Currdatastatus.DLI_Level_Low_Threshold_L = MBIC_DLI_Level_Low_Threshold_default_L;
+        }
         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++];
+        bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET = data[BLUECELL_DATA + i++];
 
         break;
     case Bluecell_Temp_High_Threshold                     :   
@@ -1427,6 +1472,9 @@ bool Bluecell_Operate(uint8_t* data){
         break;
     case Bluecell_Temp_High_Threshold_Default             :   
         bluecell_Currdatastatus.Temp_High_Threshold_Default = data[BLUECELL_DATA + i++];
+        if(bluecell_Currdatastatus.Temp_High_Threshold_Default == true){
+            bluecell_Currdatastatus.Temp_High_Threshold_Default = MBIC_Temp_High_Threshold_Default;
+        }
         break;
     case Bluecell_ULO_Level_High_Threshold                :   
         bluecell_Currdatastatus.ULO_Level_High_Threshold_H = data[BLUECELL_DATA + i++];
@@ -1435,14 +1483,27 @@ bool Bluecell_Operate(uint8_t* data){
         break;
     case Bluecell_ULO_Level_High_Threshold_default        :   
         bluecell_Currdatastatus.ULO_Level_High_Threshold_default = data[BLUECELL_DATA + i++];
+        if(bluecell_Currdatastatus.ULO_Level_High_Threshold_default == true){
+            bluecell_Currdatastatus.ULO_Level_High_Threshold_H = MBIC_ULO_Level_High_Threshold_Default_H;
+            bluecell_Currdatastatus.ULO_Level_High_Threshold_L = MBIC_ULO_Level_High_Threshold_Default_L;
+        }
         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++];
+        tempdata = (( bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8) & 0xFF00) ;
+        tempdata +=  bluecell_Currdatastatus.ULO_ALC_Threshold_L ;
+        tempdata /= 10;
+        bluecell_Currdatastatus.ULO_ALC_Threshold_H = ((tempdata & 0xFF00) >> 8);
+        bluecell_Currdatastatus.ULO_ALC_Threshold_L = (tempdata & 0x00FF);      
 
         break;
     case Bluecell_ULO_ALC_Threshold_Default               :   
         bluecell_Currdatastatus.ULO_ALC_Threshold_Default = data[BLUECELL_DATA + i++];
+        if(bluecell_Currdatastatus.ULO_Level_High_Threshold_default == true){
+            bluecell_Currdatastatus.ULO_ALC_Threshold_H = MBIC_ULO_ALC_Threshold_Default_H;
+            bluecell_Currdatastatus.ULO_ALC_Threshold_L = MBIC_ULO_ALC_Threshold_Default_L;
+        }
 
         break;
     case Bluecell_ULO_Shutdown_ON_OFF                     :   
@@ -1452,18 +1513,26 @@ bool Bluecell_Operate(uint8_t* data){
     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++];
+        tempdata = (( bluecell_Currdatastatus.ULO_Shutdown_Threshold_H << 8) & 0xFF00) ;
+        tempdata +=  bluecell_Currdatastatus.ULO_Shutdown_Threshold_L ;
+        tempdata /= 10;
+        bluecell_Currdatastatus.ULO_Shutdown_Threshold_H = ((tempdata & 0xFF00) >> 8);
+        bluecell_Currdatastatus.ULO_Shutdown_Threshold_L = (tempdata & 0x00FF);     
 
         break;
     case Bluecell_ULO_Shutdown_Threshold_Default          :   
         bluecell_Currdatastatus.ULO_Shutdown_Threshold_Default = data[BLUECELL_DATA + i++];
-
+        if(bluecell_Currdatastatus.ULO_Level_High_Threshold_default == true){
+            bluecell_Currdatastatus.ULO_Shutdown_Threshold_H = MBIC_ULO_Shutdown_Threshold_Default_H;
+            bluecell_Currdatastatus.ULO_Shutdown_Threshold_L = MBIC_ULO_Shutdown_Threshold_Default_L;
+        }
         break;
     case Bluecell_ULO_Shutdown_Retry_Count                :   
         break;
   }
   if(datatype != Bluecell_StatusReq){
       Bluecell_StructCpy(&DataWrite[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
-      EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_BASE),&DataWrite[0],sizeof(BLUESTATUS_st));
+      EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS),&DataWrite[0],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));        
@@ -1473,8 +1542,8 @@ bool Bluecell_Operate(uint8_t* data){
 void DataStatusSet(void){
         bluecell_Currdatastatus.bluecell_header = 0xbe;
         bluecell_Currdatastatus.bluecell_type = Bluecell_StatusReq;
-        bluecell_Currdatastatus.bluecell_length = sizeof(bluecell_Currdatastatus) - 3;    
-        bluecell_Currdatastatus.bluecell_crcindex = sizeof(bluecell_Currdatastatus) - 2 + 1;    
+        bluecell_Currdatastatus.bluecell_length = 94 - 3;
+        bluecell_Currdatastatus.bluecell_crcindex = 94 - 2 + 1;
         bluecell_Currdatastatus.ATT_DL2_PATH = HAL_GPIO_ReadPin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin);//CLOCK;
         bluecell_Currdatastatus.ATT_DL3_PATH = HAL_GPIO_ReadPin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin);//CLOCK;
         bluecell_Currdatastatus.ATT_DL4_PATH = HAL_GPIO_ReadPin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin);//CLOCK;
@@ -1610,10 +1679,6 @@ bool MBIC_Operate(uint8_t* data){
         /*ALARM FLAG*/
 #if 0    
         data[MBIC_PAYLOADSTART + 0] = bluecell_Currdatastatus.ALARM_MASK1;
-        data[MBIC_PAYLOADSTART + 1] = bluecell_Currdatastatus.ALARM_MASK2;
-        data[MBIC_PAYLOADSTART + 2] = bluecell_Currdatastatus.ALARM_MASK3;
-        data[MBIC_PAYLOADSTART + 3] = bluecell_Currdatastatus.ALARM_MASK4;
-        data[MBIC_PAYLOADSTART + 4] = bluecell_Currdatastatus.ALARM_MASK5;
         
         /*ALARM BIT LIST*/
         data[MBIC_PAYLOADSTART + 5] = bluecell_Currdatastatus.ALARM_TEMP_HIGH;
@@ -1632,10 +1697,6 @@ bool MBIC_Operate(uint8_t* data){
         /*ALARM BIT LIST*/
 
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK1;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK2;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK3;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK4;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK5;
         
 
 #endif
@@ -1684,8 +1745,8 @@ bool MBIC_Operate(uint8_t* data){
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.S_W_Reset;
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Factory_Set_Initialization;
 
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_TEMP_H;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET_H;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.DET_TEMP;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET;
 
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Temp_High_Threshold;
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.Temp_High_Threshold_Default;
@@ -1961,10 +2022,6 @@ bool MBIC_Operate(uint8_t* data){
                 break;
             case  Alarm_Mask                              :
                 bluecell_Currdatastatus.ALARM_MASK1 = data[MBIC_PAYLOADSTART + 0]; 
-                bluecell_Currdatastatus.ALARM_MASK2 = data[MBIC_PAYLOADSTART + 1]; 
-                bluecell_Currdatastatus.ALARM_MASK3 = data[MBIC_PAYLOADSTART + 2]; 
-                bluecell_Currdatastatus.ALARM_MASK4 = data[MBIC_PAYLOADSTART + 3]; 
-                bluecell_Currdatastatus.ALARM_MASK5 = data[MBIC_PAYLOADSTART + 4]; 
                 break;
             case  Alarm_Test_Mode                         :
                 bluecell_Currdatastatus.ALARM_TESTMODE = data[MBIC_PAYLOADSTART + 0]; 
@@ -2032,10 +2089,10 @@ bool MBIC_Operate(uint8_t* data){
                 break;
             case  Temperature                     :
                 /*I WILL MODIFY*/
-                bluecell_Currdatastatus.DET_TEMP_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.DET_TEMP = data[MBIC_PAYLOADSTART + 0]; 
                 break;
             case  Temperature_Offset                      :
-                bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET_H = data[MBIC_PAYLOADSTART + 0]; 
+                bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET = data[MBIC_PAYLOADSTART + 0]; 
                 break;
             case  Temp_High_Threshold                     :
                 bluecell_Currdatastatus.Temp_High_Threshold = data[MBIC_PAYLOADSTART + 0]; 
@@ -2590,11 +2647,12 @@ void ADC_Check(void){
             =((ADC1Ret[3] & 0xFF00) >> 8);
         bluecell_Currdatastatus.DET_TEMP_L  
             =((ADC1Ret[3] & 0x00FF) );
-#else        
-    bluecell_Currdatastatus.DET_TEMP_L  
-        = ((ADC1Ret[3] * 3.3 / 4095) - 0.5) * 100 ;
-
-
+#else    
+/* *
+온도 소수점 제거  
+*/
+    bluecell_Currdatastatus.DET_TEMP  
+        = ((((ADC1Ret[3] * 3.3 / 4095) - 0.5) * 100)  + bluecell_Currdatastatus.bluecell_User_TEMP_OFFSET);
 #endif // PYJ.2020.05.14_END -- 
 
 
@@ -2764,11 +2822,12 @@ void ALC_Function(){ //DL
             ret += bluecell_Currdatastatus.DET_UL1_IN_L;   
             ret *= Volt_Calc_val;
             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 : %f \r\n",ResdBm);
-//            HAL_Delay(1000);
             
+#if 0 // PYJ.2020.05.14_BEGIN -- 
+            //            printf("==================================\r\n");
+            //            printf("Current UL ADC VALUE : %f \r\n",ret);
+            //            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;
             CurrnALC_MAX_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL1_IN_H,CurrnALC_MAX_SettingValue);
@@ -2776,6 +2835,7 @@ void ALC_Function(){ //DL
             CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC1_MIN_H << 8;
             CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC1_MIN_L;
             CurrnALC_MIN_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL1_IN_H,CurrnALC_MIN_SettingValue);
+
 //            printf("CurrnALC_MAX_SettingValue : %d \r\n",CurrnALC_MAX_SettingValue);      
 //            printf("CurrnALC_MIN_SettingValue : %d \r\n",CurrnALC_MIN_SettingValue);                  
 //            printf("I WILL GIVE YOU ATTEN MAX : %d \r\n",ResdBm - CurrnALC_MAX_SettingValue);
@@ -2790,6 +2850,11 @@ void ALC_Function(){ //DL
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
             }else{
             }
+#endif // PYJ.2020.05.14_END -- 
+            CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8;
+            CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ULO_ALC_Threshold_L;
+            CurrnALC_MIN_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL1_IN_H,CurrnALC_MIN_SettingValue);
+
             CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL1_H,bluecell_Currdatastatus.ATT_UL1_L);
             uint16_t tempValue = 0;
             if(CurrnALC_MIN_SettingValue > ResdBm && CurrentATTENVALUE > 0){
@@ -2816,13 +2881,13 @@ void ALC_Function(){ //DL
             ret += bluecell_Currdatastatus.DET_UL2_IN_L;   
             ret *= Volt_Calc_val;
             ResdBm = AutoControl_ADC_Compare(ret,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+
+#if 0 // PYJ.2020.05.14_BEGIN -- 
             CurrnALC_MAX_SettingValue = bluecell_Currdatastatus.ATT_ALC2_MAX_H << 8;
             CurrnALC_MAX_SettingValue += bluecell_Currdatastatus.ATT_ALC2_MAX_L;
             CurrnALC_MAX_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL2_IN_H,CurrnALC_MAX_SettingValue);
-            
-            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;
+            
             if(ALC_Result > 0){
                 ALC_Result *= 100;
                 ALC_Result +=  bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L;
@@ -2830,6 +2895,9 @@ void ALC_Function(){ //DL
                 bluecell_Currdatastatus.ATT_UL2_L =  ALC_Result & 0x00FF;               
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
             }
+#endif // PYJ.2020.05.14_END -- 
+            CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8;
+            CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ULO_ALC_Threshold_L;
             CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL2_H,bluecell_Currdatastatus.ATT_UL2_L);
             uint16_t tempValue = 0;
             if(CurrnALC_MIN_SettingValue > ResdBm && CurrentATTENVALUE > 0){
@@ -2852,13 +2920,12 @@ void ALC_Function(){ //DL
              ret += bluecell_Currdatastatus.DET_UL3_IN_L;   
              ret *= Volt_Calc_val;
              ResdBm = AutoControl_ADC_Compare(ret,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+#if 0 // PYJ.2020.05.14_BEGIN -- 
              CurrnALC_MAX_SettingValue = bluecell_Currdatastatus.ATT_ALC3_MAX_H << 8;
              CurrnALC_MAX_SettingValue += bluecell_Currdatastatus.ATT_ALC3_MAX_L;
              CurrnALC_MAX_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL3_IN_H,CurrnALC_MAX_SettingValue);
-             
-             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;
+             
              if(ALC_Result > 0){
                  ALC_Result *= 100;
                  ALC_Result +=  bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L;
@@ -2866,6 +2933,9 @@ void ALC_Function(){ //DL
                  bluecell_Currdatastatus.ATT_UL3_L =  ALC_Result & 0x00FF;               
                  CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
              }
+#endif // PYJ.2020.05.14_END -- 
+             CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ULO_ALC_Threshold_H << 8;
+             CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ULO_ALC_Threshold_L;
              CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL3_H,bluecell_Currdatastatus.ATT_UL3_L);
              uint16_t tempValue = 0;
              if(CurrnALC_MIN_SettingValue > ResdBm && CurrentATTENVALUE > 0){
@@ -2889,12 +2959,10 @@ void ALC_Function(){ //DL
              ret += bluecell_Currdatastatus.DET_UL4_IN_L;   
              ret *= Volt_Calc_val;
              ResdBm = AutoControl_ADC_Compare(ret,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));
+#if 0 // PYJ.2020.05.14_BEGIN -- 
              CurrnALC_MAX_SettingValue = bluecell_Currdatastatus.ATT_ALC4_MAX_H << 8;
              CurrnALC_MAX_SettingValue += bluecell_Currdatastatus.ATT_ALC4_MAX_L;
              CurrnALC_MAX_SettingValue = MinusConvert(bluecell_Currdatastatus.DET_UL4_IN_H,CurrnALC_MAX_SettingValue);
-             
-             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;
              if(ALC_Result > 0){
                  ALC_Result *= 100;
@@ -2903,6 +2971,10 @@ void ALC_Function(){ //DL
                  bluecell_Currdatastatus.ATT_UL4_L =  ALC_Result & 0x00FF;               
                  CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
              }
+#endif // PYJ.2020.05.14_END -- 
+             
+             CurrnALC_MIN_SettingValue = bluecell_Currdatastatus.ATT_ALC4_MIN_H << 8;
+             CurrnALC_MIN_SettingValue += bluecell_Currdatastatus.ATT_ALC4_MIN_L;
              CurrentATTENVALUE = PE43711_Double(bluecell_Currdatastatus.ATT_UL4_H,bluecell_Currdatastatus.ATT_UL4_L);
              uint16_t tempValue = 0;
              if(CurrnALC_MIN_SettingValue > ResdBm && CurrentATTENVALUE > 0){
@@ -3008,3 +3080,9 @@ void AGC_Function(){//DL
         AGCTimerCnt = 0;
     }
 }
+void Alarm_Check(){
+    if(bluecell_Currdatastatus.Temp_High_Threshold > bluecell_Currdatastatus.DET_TEMP){
+        bluecell_Currdatastatus.ALARM_MASK1 = true;
+    }
+//    if()
+}

Bluecell_Src/PE43711.c

@@ -189,7 +189,7 @@ void PE43711_atten_ctrl(PE43711_st ATT ,uint8_t data){
     
 	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
-    HAL_Delay(5);
+    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);

Bluecell_Src/eeprom.c

@@ -16,32 +16,24 @@ HAL_StatusTypeDef EEPROM_M24C08_ByteRead(uint16_t devid,uint16_t Address,uint8_t
 
 
 
-unsigned char E2promWriteByte( uint16_t addr, uint8_t data );
 
-/////////////////////////////////////////////////////////////
-
-unsigned char E2promReadByte( uint16_t addr );
-
-
-bool		EEPROM24XX_Save(uint16_t Address,void *data,size_t size_of_data);
-bool		EEPROM24XX_Load(uint16_t Address,void *data,size_t size_of_data);
 
 
 
 
 
 void EEPROM_M24C08_Init(void){
-    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE,&bluecell_Currdatastatus.bluecell_header,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,&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
-    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL1_TABLE_ADDRESDS,&Att_DL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
-    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL2_TABLE_ADDRESDS,&Att_DL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
-    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL3_TABLE_ADDRESDS,&Att_DL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL1_TABLE_ADDRESDS,&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL2_TABLE_ADDRESDS,&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL3_TABLE_ADDRESDS,&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
 
-    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL4_TABLE_ADDRESDS,&Att_UL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
-    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL1_TABLE_ADDRESDS,&Att_UL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
-    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL2_TABLE_ADDRESDS,&Att_UL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
-    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL3_TABLE_ADDRESDS,&Att_UL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL4_TABLE_ADDRESDS,&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL1_TABLE_ADDRESDS,&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL2_TABLE_ADDRESDS,&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL3_TABLE_ADDRESDS,&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
 
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL4_TABLE_ADDRESDS,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_DL1_TABLE_ADDRESDS,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
@@ -121,7 +113,7 @@ HAL_StatusTypeDef EEPROM_M24C08_Read(uint8_t devid,uint16_t Address,uint8_t* dat
       if(ret == HAL_ERROR)
             printf("Write ERR\r\n");
         else
-        HAL_Delay(20);
+            HAL_Delay(20);
 
     return ret;   
 }
@@ -206,322 +198,6 @@ HAL_StatusTypeDef EEPROM_M24C08_Zerowrite(uint8_t devid,uint16_t Address){
 
 
 
-HAL_StatusTypeDef EEPROM_M24C08_ByteRead(uint16_t devid,uint16_t Address,uint8_t* data,uint8_t size){
-   HAL_StatusTypeDef ret = HAL_ERROR;
-#if 0 // PYJ.2020.04.24_BEGIN -- 
-   for(int i = 0; i < size; i++){
-     ret = HAL_I2C_Mem_Read(&hi2c2, devid, Address + i, I2C_MEMADD_SIZE_8BIT, &data[i], 1, 1024);
-//     ret = HAL_I2C_Mem_Read(&hi2c2, devid|(((Address + i)&0x0700>>7)),((Address + i)&0xff),  I2C_MEMADD_SIZE_16BIT, &data[i], 1, 1024);     
-       if(ret == HAL_ERROR)
-        printf("Write ERR\r\n");
-//     ret = HAL_I2C_Mem_Read_IT(&hi2c2, devid, Address + i, I2C_MEMADD_SIZE_8BIT, &data[i], 1);
-     HAL_Delay(10);
-   }
-#endif // PYJ.2020.04.24_END -- 
-    return ret;   
-}
-uint8_t I2CWrite[1024];
-HAL_StatusTypeDef EEPROM_M24C08_Bytewrite(uint16_t devid,uint16_t Address,uint8_t* data,uint8_t size){
-    HAL_StatusTypeDef ret = HAL_ERROR;
-#if 0 // PYJ.2020.04.24_BEGIN -- 
-
-    for(int i = 0; i < size; i++){
-        ret = HAL_I2C_Mem_Write(&hi2c2, devid, Address + i,  I2C_MEMADD_SIZE_8BIT, &data[i], 1, 1024);
-//        ret = HAL_I2C_Mem_Write(&hi2c2, devid|(((Address + i)&0x0700>>7)),((Address + i)&0xff),  I2C_MEMADD_SIZE_16BIT, &data[i], 1, 1024);
-
-        if(ret == HAL_ERROR)
-            printf("Write ERR\r\n");
-        else
-            HAL_Delay(7);
-//        ret = HAL_I2C_Mem_Write_IT(&hi2c2, devid, Address + i, I2C_MEMADD_SIZE_8BIT, &data[i], 1);
-    }
-#endif // PYJ.2020.04.24_END -- 
-    return ret;
-}
-
-
-
-
-#define _EEPROM_SIZE_KBIT 8
-
-bool EEPROM24XX_IsConnected(void)
-{
-	#if	(_EEPROM_USE_WP_PIN==1)
-	#endif
-	if(HAL_I2C_IsDeviceReady(&hi2c2,0xa0,1,100)==HAL_OK)
-		return true;
-	else
-		return false;	
-}
-//##########################################################################
-bool		EEPROM24XX_Save(uint16_t Address,void *data,size_t size_of_data)
-{
-	#if ((_EEPROM_SIZE_KBIT==1) || (_EEPROM_SIZE_KBIT==2))
-	if(size_of_data > 8)
-		return false;
-	#elif ((_EEPROM_SIZE_KBIT==4) || (_EEPROM_SIZE_KBIT==8) || (_EEPROM_SIZE_KBIT==16))
-	if(size_of_data > 16)
-		return false;
-	#else 
-	if(size_of_data > 32)
-		return false;
-	#endif
-	
-	#if	(_EEPROM_USE_WP_PIN==1)
-	HAL_GPIO_WritePin(_EEPROM_WP_GPIO,_EEPROM_WP_PIN,GPIO_PIN_RESET);
-	#endif
-	
-	#if ((_EEPROM_SIZE_KBIT==1) || (_EEPROM_SIZE_KBIT==2))
-	if(HAL_I2C_Mem_Write(&hi2c2,0xa0,Address,I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
-	#elif	(_EEPROM_SIZE_KBIT==4)
-	if(HAL_I2C_Mem_Write(&hi2c2,0xa0|((Address&0x0100>>7)),(Address&0xff),I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
-	#elif	(_EEPROM_SIZE_KBIT==8)
-	if(HAL_I2C_Mem_Write(&hi2c2,0xa0|((Address&0x0300>>7)),(Address&0xff),I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
-	#elif	(_EEPROM_SIZE_KBIT==16)
-	if(HAL_I2C_Mem_Write(&hi2c2,0xa0|((Address&0x0700>>7)),(Address&0xff),I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)		
-	#else
-	if(HAL_I2C_Mem_Write(&hi2c2,0xa0,Address,I2C_MEMADD_SIZE_16BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
-	#endif
-	{
-		HAL_Delay(7);
-	}
-	else
-	{
-	}
-	return 0;
-}
-//##########################################################################
-bool		EEPROM24XX_Load(uint16_t Address,void *data,size_t size_of_data)
-{
-	#if	(_EEPROM_USE_WP_PIN==1)
-	HAL_GPIO_WritePin(_EEPROM_WP_GPIO,_EEPROM_WP_PIN,GPIO_PIN_SET);
-	#endif
-	#if ((_EEPROM_SIZE_KBIT==1) || (_EEPROM_SIZE_KBIT==2))
-	if(HAL_I2C_Mem_Read(&hi2c2,0xa0,Address,I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
-	#elif (_EEPROM_SIZE_KBIT==4)
-	if(HAL_I2C_Mem_Read(&hi2c2,0xa0|((Address&0x0100>>7)),(Address&0xff),I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
-	#elif (_EEPROM_SIZE_KBIT==8)
-	if(HAL_I2C_Mem_Read(&hi2c2,0xa0|((Address&0x0300>>7)),(Address&0xff),I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
-	#elif (_EEPROM_SIZE_KBIT==16)
-	if(HAL_I2C_Mem_Read(&hi2c2,0xa0|((Address&0x0700>>7)),(Address&0xff),I2C_MEMADD_SIZE_8BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
-	#else
-	if(HAL_I2C_Mem_Read(&hi2c2,0xa0,Address,I2C_MEMADD_SIZE_16BIT,(uint8_t*)data,size_of_data,100) == HAL_OK)
-	#endif
-		return true;
-	else
-		return false;		
-}
-
-
-
-
-
-
-
-
-// EEPROM 24lcXXX 
-/// ST에서 제공하는 I2C 소스는 뭘 해도 안된다.. 내가 잘못한건지 뭔지 참..
-/// while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)); ??????????
-/// 중국애들?이 제공하는 소스로 하니 바로 되버리는 이 현상은 뭘까...
-///////////////////////// 
-///// i2c gpio 직접 제어 코드..
-
-#define E2PROM_SDA EEPROM_SCL_Pin
-#define E2PROM_SCL EEPROM_SDA_Pin
-
-#define E2PROM_CMD_WRITE 0xA0
-#define E2PROM_CMD_READ 0xA1
-#define I2C_PageSize     16
-
-void I2CStart( void )
-{
-  HAL_GPIO_WritePin( GPIOB, E2PROM_SDA ,GPIO_PIN_SET );
-  HAL_Delay(10);
-  HAL_GPIO_WritePin( GPIOB, E2PROM_SCL,GPIO_PIN_SET );
-  HAL_Delay(10);
-  HAL_GPIO_WritePin( GPIOB, E2PROM_SDA,GPIO_PIN_RESET );
-  HAL_Delay(10);
-
-  HAL_GPIO_WritePin( GPIOB, E2PROM_SCL ,GPIO_PIN_RESET);
-}
-
-
-void I2CStop( void )
-{
-  HAL_GPIO_WritePin( GPIOB, E2PROM_SDA,GPIO_PIN_RESET );
-  HAL_Delay(10);
-  HAL_GPIO_WritePin( GPIOB, E2PROM_SCL ,GPIO_PIN_SET);
-  HAL_Delay(10);
-  HAL_GPIO_WritePin( GPIOB, E2PROM_SDA ,GPIO_PIN_SET);
-  HAL_Delay(10);
-
-  HAL_GPIO_WritePin( GPIOB, E2PROM_SCL,GPIO_PIN_RESET );
-}
-
-
-unsigned char I2CSlaveAck( void )
-{
-  GPIO_InitTypeDef GPIO_InitStruct;
-  unsigned int TimeOut;
-  unsigned char RetValue;
-
-  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;  /*?里一定要?成?入上拉，否?不能?出?据*/
-  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
-  GPIO_InitStruct.Pin = E2PROM_SDA;
-
-
-  
-  HAL_GPIO_Init( GPIOB, &GPIO_InitStruct );
-
-  HAL_GPIO_WritePin( GPIOB, E2PROM_SCL,GPIO_PIN_SET );
-  TimeOut = 10000;
-  while( TimeOut-- > 0 )
-  {
-    if( SET == HAL_GPIO_ReadPin( GPIOB, E2PROM_SDA ) )
-    {
-      RetValue = RESET;
-      break;
-    }
-    else
-    {
-      RetValue = SET;
-    }
-  }
-  HAL_GPIO_WritePin( GPIOB, E2PROM_SCL,GPIO_PIN_RESET );
-  
-  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
-  HAL_GPIO_Init( GPIOB, &GPIO_InitStruct );
-  return RetValue;
-}
-
-void I2CWriteByte( unsigned char byte )
-{
-  unsigned char i;
-
-  for( i=0; i<8; i++ )
-  {
-    if( 0X80 & byte )
-      HAL_GPIO_WritePin( GPIOB, E2PROM_SDA ,GPIO_PIN_SET);
-    else
-      HAL_GPIO_WritePin( GPIOB, E2PROM_SDA,GPIO_PIN_RESET );
-    byte <<= 1;
-    HAL_Delay(10);
-
-    HAL_GPIO_WritePin( GPIOB, E2PROM_SCL ,GPIO_PIN_SET);
-    HAL_Delay(10);
-    HAL_GPIO_WritePin( GPIOB, E2PROM_SCL,GPIO_PIN_RESET );
-    HAL_Delay(10);
-  }
-}
-
-
-unsigned char I2CReadByte( void )
-{
-  unsigned char i;
-  unsigned char ReadValue = 0;
-  GPIO_InitTypeDef GPIO_InitStruct;
-  unsigned char bit;
-
-  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;  
-  GPIO_InitStruct.Pin = E2PROM_SDA;
-  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
-  HAL_GPIO_Init( GPIOB, &GPIO_InitStruct );
-  for( i=0; i<8; i++ )
-  {
-    HAL_GPIO_WritePin( GPIOB, E2PROM_SCL ,GPIO_PIN_SET);
-    HAL_Delay(10);
-    if( SET == HAL_GPIO_ReadPin( GPIOB, E2PROM_SDA ) )
-      bit = 0X01;
-    else
-      bit = 0x00;
-      
-    ReadValue = (ReadValue<<1)|bit;
-    HAL_GPIO_WritePin( GPIOB, E2PROM_SCL,GPIO_PIN_RESET );
-    HAL_Delay(10);
-  }
-
-  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
-  HAL_GPIO_Init( GPIOB, &GPIO_InitStruct );
-  return ReadValue;
-}
-
-
-unsigned char E2promWriteByte( uint16_t addr, uint8_t data )
-{
-
-  I2CStart();
-
-  I2CWriteByte( E2PROM_CMD_WRITE );
-  if( RESET == I2CSlaveAck() )
-  {
-    return RESET;
-  }
-
-  I2CWriteByte((unsigned char)(addr>>8));
-  if( RESET == I2CSlaveAck() )
-  {
-    return RESET;
-  }
-  I2CWriteByte((uint8_t)(addr));
-  if( RESET == I2CSlaveAck() )
-  {
-    return RESET;
-  }
-
-  I2CWriteByte( data );
-  if( RESET == I2CSlaveAck() )
-  {
-    return RESET;
-  }
-  I2CStop();
-  //asm("CPSIE I");  //?中?
-
-  return SET;
-}
-
-/////////////////////////////////////////////////////////////
-
-unsigned char E2promReadByte( uint16_t addr )
-{
-  unsigned char ReadValue;
-
-  I2CStart();
-
-  I2CWriteByte( E2PROM_CMD_WRITE );
-  if( RESET == I2CSlaveAck() )
-  {
-    return RESET;
-  }
-
-  I2CWriteByte((unsigned char)(addr>>8));
-  if( RESET == I2CSlaveAck() )
-  {
-    return RESET;
-  }
-  I2CWriteByte((uint8_t)(addr));
-  if( RESET == I2CSlaveAck() )
-  {
-    return RESET;
-  }
-
-  I2CStart();
-  I2CWriteByte( E2PROM_CMD_READ );
-  if( RESET == I2CSlaveAck() )
-  {
-    return RESET;
-  }
-  ReadValue = I2CReadByte();
-  I2CStop();
-
-  return ReadValue;  
-}
-
- 
-
-  
-
-
-
 
 
 

Bluecell_Src/uart.c

@@ -107,7 +107,7 @@ void GetDataFromUartQueue(UART_HandleTypeDef *huart)
 //        for(int i  = 0; i < cnt; i++)
 //            uart_buf[i] = 0;
         cnt = 0;
-        HAL_Delay(1);
+//        HAL_Delay(1);
     }
 
 }

STM32F103ZET_JDASMBIC.ioc

@@ -118,63 +118,61 @@ Mcu.Name=STM32F103Z(C-D-E)Tx
 Mcu.Package=LQFP144
 Mcu.Pin0=PE3
 Mcu.Pin1=PE4
-Mcu.Pin10=PC2
-Mcu.Pin11=PA2
-Mcu.Pin12=PA3
-Mcu.Pin13=PA4
-Mcu.Pin14=PA5
-Mcu.Pin15=PA6
-Mcu.Pin16=PG0
-Mcu.Pin17=PG1
-Mcu.Pin18=PE10
-Mcu.Pin19=PE11
+Mcu.Pin10=PA3
+Mcu.Pin11=PA4
+Mcu.Pin12=PA5
+Mcu.Pin13=PA6
+Mcu.Pin14=PG0
+Mcu.Pin15=PG1
+Mcu.Pin16=PE10
+Mcu.Pin17=PE11
+Mcu.Pin18=PE12
+Mcu.Pin19=PE13
 Mcu.Pin2=PC15-OSC32_OUT
-Mcu.Pin20=PE12
-Mcu.Pin21=PE13
-Mcu.Pin22=PE14
-Mcu.Pin23=PE15
-Mcu.Pin24=PB10
-Mcu.Pin25=PB11
-Mcu.Pin26=PB14
-Mcu.Pin27=PB15
-Mcu.Pin28=PD10
-Mcu.Pin29=PD11
+Mcu.Pin20=PE14
+Mcu.Pin21=PE15
+Mcu.Pin22=PB10
+Mcu.Pin23=PB11
+Mcu.Pin24=PB14
+Mcu.Pin25=PB15
+Mcu.Pin26=PD10
+Mcu.Pin27=PD11
+Mcu.Pin28=PD14
+Mcu.Pin29=PD15
 Mcu.Pin3=PF6
-Mcu.Pin30=PD14
-Mcu.Pin31=PD15
-Mcu.Pin32=PG2
-Mcu.Pin33=PG3
-Mcu.Pin34=PG4
-Mcu.Pin35=PG5
-Mcu.Pin36=PG8
-Mcu.Pin37=PC6
-Mcu.Pin38=PA9
-Mcu.Pin39=PA10
+Mcu.Pin30=PG2
+Mcu.Pin31=PG3
+Mcu.Pin32=PG4
+Mcu.Pin33=PG5
+Mcu.Pin34=PG8
+Mcu.Pin35=PC6
+Mcu.Pin36=PA9
+Mcu.Pin37=PA10
+Mcu.Pin38=PA13
+Mcu.Pin39=PA14
 Mcu.Pin4=PF7
-Mcu.Pin40=PA13
-Mcu.Pin41=PA14
-Mcu.Pin42=PD2
-Mcu.Pin43=PD3
-Mcu.Pin44=PD4
-Mcu.Pin45=PD7
-Mcu.Pin46=PG9
-Mcu.Pin47=PG10
-Mcu.Pin48=PG11
-Mcu.Pin49=PG12
+Mcu.Pin40=PD2
+Mcu.Pin41=PD3
+Mcu.Pin42=PD4
+Mcu.Pin43=PD7
+Mcu.Pin44=PG9
+Mcu.Pin45=PG10
+Mcu.Pin46=PG11
+Mcu.Pin47=PG12
+Mcu.Pin48=PG13
+Mcu.Pin49=PG14
 Mcu.Pin5=PF8
-Mcu.Pin50=PG13
-Mcu.Pin51=PG14
-Mcu.Pin52=PG15
-Mcu.Pin53=PB6
-Mcu.Pin54=PB7
-Mcu.Pin55=PB9
-Mcu.Pin56=VP_SYS_VS_tim2
-Mcu.Pin57=VP_TIM6_VS_ClockSourceINT
+Mcu.Pin50=PG15
+Mcu.Pin51=PB6
+Mcu.Pin52=PB7
+Mcu.Pin53=PB9
+Mcu.Pin54=VP_SYS_VS_tim2
+Mcu.Pin55=VP_TIM6_VS_ClockSourceINT
 Mcu.Pin6=PF9
 Mcu.Pin7=PF10
-Mcu.Pin8=OSC_IN
-Mcu.Pin9=OSC_OUT
-Mcu.PinsNb=58
+Mcu.Pin8=PC2
+Mcu.Pin9=PA2
+Mcu.PinsNb=56
 Mcu.ThirdPartyNb=0
 Mcu.UserConstants=
 Mcu.UserName=STM32F103ZETx
@@ -205,10 +203,6 @@ NVIC.TimeBaseIP=TIM2
 NVIC.USART1_IRQn=true\:0\:0\:false\:true\:true\:4\:true\:true
 NVIC.USART2_IRQn=true\:0\:0\:false\:true\:true\:5\:true\:true
 NVIC.UsageFault_IRQn=true\:0\:0\:false\:false\:true\:false\:false
-OSC_IN.Mode=HSE-External-Oscillator
-OSC_IN.Signal=RCC_OSC_IN
-OSC_OUT.Mode=HSE-External-Oscillator
-OSC_OUT.Signal=RCC_OSC_OUT
 PA10.GPIOParameters=GPIO_Label
 PA10.GPIO_Label=MBIC_DOWN
 PA10.Mode=Asynchronous
@@ -452,33 +446,32 @@ ProjectManager.TargetToolchain=TrueSTUDIO
 ProjectManager.ToolChainLocation=
 ProjectManager.UnderRoot=true
 ProjectManager.functionlistsort=1-MX_GPIO_Init-GPIO-false-HAL-true,2-MX_DMA_Init-DMA-false-HAL-true,3-SystemClock_Config-RCC-false-HAL-false,4-MX_USART1_UART_Init-USART1-false-HAL-true,5-MX_ADC1_Init-ADC1-false-HAL-true,6-MX_ADC3_Init-ADC3-false-HAL-true,7-MX_USART2_UART_Init-USART2-false-HAL-true,8-MX_TIM6_Init-TIM6-false-HAL-true,9-MX_I2C2_Init-I2C2-false-HAL-true
-RCC.ADCFreqValue=12000000
-RCC.ADCPresc=RCC_ADCPCLK2_DIV6
-RCC.AHBFreq_Value=72000000
+RCC.ADCFreqValue=14000000
+RCC.ADCPresc=RCC_ADCPCLK2_DIV4
+RCC.AHBFreq_Value=56000000
 RCC.APB1CLKDivider=RCC_HCLK_DIV2
-RCC.APB1Freq_Value=36000000
-RCC.APB1TimFreq_Value=72000000
-RCC.APB2Freq_Value=72000000
-RCC.APB2TimFreq_Value=72000000
-RCC.FCLKCortexFreq_Value=72000000
-RCC.FSMCFreq_Value=72000000
+RCC.APB1Freq_Value=28000000
+RCC.APB1TimFreq_Value=56000000
+RCC.APB2Freq_Value=56000000
+RCC.APB2TimFreq_Value=56000000
+RCC.FCLKCortexFreq_Value=56000000
+RCC.FSMCFreq_Value=56000000
 RCC.FamilyName=M
-RCC.HCLKFreq_Value=72000000
-RCC.I2S2Freq_Value=72000000
-RCC.I2S3Freq_Value=72000000
-RCC.IPParameters=ADCFreqValue,ADCPresc,AHBFreq_Value,APB1CLKDivider,APB1Freq_Value,APB1TimFreq_Value,APB2Freq_Value,APB2TimFreq_Value,FCLKCortexFreq_Value,FSMCFreq_Value,FamilyName,HCLKFreq_Value,I2S2Freq_Value,I2S3Freq_Value,MCOFreq_Value,PLLCLKFreq_Value,PLLMCOFreq_Value,PLLMUL,PLLSourceVirtual,SDIOFreq_Value,SDIOHCLKDiv2FreqValue,SYSCLKFreq_VALUE,SYSCLKSource,TimSysFreq_Value,USBFreq_Value,VCOOutput2Freq_Value
-RCC.MCOFreq_Value=72000000
-RCC.PLLCLKFreq_Value=72000000
-RCC.PLLMCOFreq_Value=36000000
-RCC.PLLMUL=RCC_PLL_MUL9
-RCC.PLLSourceVirtual=RCC_PLLSOURCE_HSE
-RCC.SDIOFreq_Value=72000000
-RCC.SDIOHCLKDiv2FreqValue=36000000
-RCC.SYSCLKFreq_VALUE=72000000
+RCC.HCLKFreq_Value=56000000
+RCC.I2S2Freq_Value=56000000
+RCC.I2S3Freq_Value=56000000
+RCC.IPParameters=ADCFreqValue,ADCPresc,AHBFreq_Value,APB1CLKDivider,APB1Freq_Value,APB1TimFreq_Value,APB2Freq_Value,APB2TimFreq_Value,FCLKCortexFreq_Value,FSMCFreq_Value,FamilyName,HCLKFreq_Value,I2S2Freq_Value,I2S3Freq_Value,MCOFreq_Value,PLLCLKFreq_Value,PLLMCOFreq_Value,PLLMUL,SDIOFreq_Value,SDIOHCLKDiv2FreqValue,SYSCLKFreq_VALUE,SYSCLKSource,TimSysFreq_Value,USBFreq_Value,VCOOutput2Freq_Value
+RCC.MCOFreq_Value=56000000
+RCC.PLLCLKFreq_Value=56000000
+RCC.PLLMCOFreq_Value=28000000
+RCC.PLLMUL=RCC_PLL_MUL14
+RCC.SDIOFreq_Value=56000000
+RCC.SDIOHCLKDiv2FreqValue=28000000
+RCC.SYSCLKFreq_VALUE=56000000
 RCC.SYSCLKSource=RCC_SYSCLKSOURCE_PLLCLK
-RCC.TimSysFreq_Value=72000000
-RCC.USBFreq_Value=72000000
-RCC.VCOOutput2Freq_Value=8000000
+RCC.TimSysFreq_Value=56000000
+RCC.USBFreq_Value=56000000
+RCC.VCOOutput2Freq_Value=4000000
 SH.ADCx_IN12.0=ADC1_IN12,IN12
 SH.ADCx_IN12.ConfNb=1
 SH.ADCx_IN4.0=ADC1_IN4,IN4
@@ -489,11 +482,11 @@ SH.ADCx_IN6.0=ADC1_IN6,IN6
 SH.ADCx_IN6.ConfNb=1
 TIM6.IPParameters=Prescaler,Period
 TIM6.Period=10
-TIM6.Prescaler=7200 - 1
-USART1.BaudRate=921600
+TIM6.Prescaler=5600 - 1
+USART1.BaudRate=115200
 USART1.IPParameters=VirtualMode,BaudRate
 USART1.VirtualMode=VM_ASYNC
-USART2.BaudRate=921600
+USART2.BaudRate=115200
 USART2.IPParameters=VirtualMode,BaudRate
 USART2.VirtualMode=VM_ASYNC
 VP_SYS_VS_tim2.Mode=TIM2

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)
     {
@@ -214,7 +214,7 @@ uint8_t i2cTestData[1] = {44};
 #endif // PYJ.2020.04.23_END -- 
 #if 0
 uint8_t eepromtestarray[1024 * 4];
-uint8_t eepromtestReadarray[1024 * 4];
+
 uint8_t eepromtestarray1[EEPROM_WINDOW_STATUS_ADDRESDS];
 uint8_t eepromtestReadarray1[EEPROM_WINDOW_STATUS_ADDRESDS];
 #define TESTINDEX  sizeof(TEMP_TABLE_st) 
@@ -242,33 +242,18 @@ void EEPROMTEST_J(){
 
 }
 #endif // PYJ.2020.04.25_END -- 
-#if 0 // PYJ.2020.04.23_BEGIN -- 
-void eepromtest_j1(){
-uint8_t ret  = 0;
-  for(int i = 0; i < 128; i++)
-      eepromtestarray[i] = i;
-  printf("Value %x\r\n",eepromtestarray[1]);
-  printf("Address Start %x\r\n",EEPROM_ATT_BASE);
-  EEPROM_M24C08_Read(EEPROM_M24C08_ID ,EEPROM_ATT_BASE,eepromtestReadarray,4096 );
-
-    for(int i = 0; i< 4096 ; i++)
-        printf("%x ",eepromtestReadarray[i]);
-           printf("\r\n");
+#if 1 // PYJ.2020.04.23_BEGIN -- 
 
-}
-#endif // PYJ.2020.04.23_END -- 
-#if 0 // PYJ.2020.04.23_BEGIN -- 
-void eepromtest_j1(){
-  for(int i = 0; i< 128; i++)
-        eepromtestarray[i] = i;
 
-  HAL_I2C_Mem_Write(&hi2c2,0xa0|((0x01&0x0300>>7)),(0x01&0xff),I2C_MEMADD_SIZE_16BIT,eepromtestarray,128,100);
-  HAL_Delay(10);
-  HAL_I2C_Mem_Read(&hi2c2,0xa0|((0x01&0x0300>>7)),(0x01&0xff),I2C_MEMADD_SIZE_16BIT,eepromtestReadarray,128,100);
-    for(int i = 0; i< 128; i++)
-        printf("%d ",eepromtestReadarray[i]);
-       printf("\r\n");
+void eepromtest_j1(){
+    uint8_t eepromtestReadarray[1024 * 4];
+    uint8_t ret  = 0;
 
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID ,EEPROM_ATT_BASE + 96,eepromtestReadarray,128 );
+    for(int i = 0; i< 128 ; i++){
+        printf("%x ",eepromtestReadarray[i]);
+    }
+    printf("\r\n");
 
 }
 #endif // PYJ.2020.04.23_END -- 
@@ -380,13 +365,12 @@ void SystemClock_Config(void)
 
   /** Initializes the CPU, AHB and APB busses clocks 
   */
-  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
-  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
-  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
+  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
+  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
-  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
-  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
+  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI_DIV2;
+  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL14;
   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
   {
     Error_Handler();
@@ -405,7 +389,7 @@ void SystemClock_Config(void)
     Error_Handler();
   }
   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
-  PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV6;
+  PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV4;
   if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
   {
     Error_Handler();
@@ -648,7 +632,7 @@ static void MX_TIM6_Init(void)
 
   /* USER CODE END TIM6_Init 1 */
   htim6.Instance = TIM6;
-  htim6.Init.Prescaler = 7200 - 1;
+  htim6.Init.Prescaler = 5600 - 1;
   htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
   htim6.Init.Period = 10;
   htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
@@ -684,7 +668,7 @@ static void MX_USART1_UART_Init(void)
 
   /* USER CODE END USART1_Init 1 */
   huart1.Instance = USART1;
-  huart1.Init.BaudRate = 921600;
+  huart1.Init.BaudRate = 115200;
   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   huart1.Init.StopBits = UART_STOPBITS_1;
   huart1.Init.Parity = UART_PARITY_NONE;
@@ -717,7 +701,7 @@ static void MX_USART2_UART_Init(void)
 
   /* USER CODE END USART2_Init 1 */
   huart2.Instance = USART2;
-  huart2.Init.BaudRate = 921600;
+  huart2.Init.BaudRate = 115200;
   huart2.Init.WordLength = UART_WORDLENGTH_8B;
   huart2.Init.StopBits = UART_STOPBITS_1;
   huart2.Init.Parity = UART_PARITY_NONE;