Table 구조체 1byte 형식으로 변경 // EEPROM 주소 변경

/ PE43711 계산식 변경 Table Offset값 추가 할 수 있도록 변경 / EEPROM 변경 /ADC 값 100번 평균 후 값 출력

Bluecell_Inc/Bluecell_operate.h

@@ -515,166 +515,261 @@ typedef struct{
 
 }BLUESTATUS_st;
 typedef struct{
-  uint16_t Table_0_0_dBm	;
-  uint16_t Table_0_5_dBm	;
-  uint16_t Table_1_0_dBm	;
-  uint16_t Table_1_5_dBm	;
-  uint16_t Table_2_0_dBm	;
-  uint16_t Table_2_5_dBm	;
-  uint16_t Table_3_0_dBm	;
-  uint16_t Table_3_5_dBm	;
-  uint16_t Table_4_0_dBm	;
-  uint16_t Table_4_5_dBm	;
-  uint16_t Table_5_0_dBm	;
-  uint16_t Table_5_5_dBm	;
-  uint16_t Table_6_0_dBm	;
-  uint16_t Table_6_5_dBm	;
-  uint16_t Table_7_0_dBm	;
-  uint16_t Table_7_5_dBm	;
-  uint16_t Table_8_0_dBm	;
-  uint16_t Table_8_5_dBm	;
-  uint16_t Table_9_0_dBm	;
-  uint16_t Table_9_5_dBm	;
-  uint16_t Table_10_0_dBm;
-  uint16_t Table_10_5_dBm;
-  uint16_t Table_11_0_dBm;
-  uint16_t Table_11_5_dBm;
-  uint16_t Table_12_0_dBm;
-  uint16_t Table_12_5_dBm;
-  uint16_t Table_13_0_dBm;
-  uint16_t Table_13_5_dBm;
-  uint16_t Table_14_0_dBm;
-  uint16_t Table_14_5_dBm;
-  uint16_t Table_15_0_dBm;
-  uint16_t Table_15_5_dBm;
-  uint16_t Table_16_0_dBm;
-  uint16_t Table_16_5_dBm;
-  uint16_t Table_17_0_dBm;
-  uint16_t Table_17_5_dBm;
-  uint16_t Table_18_0_dBm;
-  uint16_t Table_18_5_dBm;
-  uint16_t Table_19_0_dBm;
-  uint16_t Table_19_5_dBm;
-  uint16_t Table_20_0_dBm;
-  uint16_t Table_20_5_dBm;
-  uint16_t Table_21_0_dBm;
-  uint16_t Table_21_5_dBm;
-  uint16_t Table_22_0_dBm;
-  uint16_t Table_22_5_dBm;
-  uint16_t Table_23_0_dBm;
-  uint16_t Table_23_5_dBm;
-  uint16_t Table_24_0_dBm;
-  uint16_t Table_24_5_dBm;
-  uint16_t Table_25_0_dBm;
-  uint16_t Table_25_5_dBm;
-  uint16_t Table_26_0_dBm;
-  uint16_t Table_26_5_dBm;
-  uint16_t Table_27_0_dBm;
-  uint16_t Table_27_5_dBm;
-  uint16_t Table_28_0_dBm;
-  uint16_t Table_28_5_dBm;
-  uint16_t Table_29_0_dBm;
-  uint16_t Table_29_5_dBm;
-  uint16_t Table_30_0_dBm;
-  uint16_t Table_30_5_dBm;
-  uint16_t Table_31_0_dBm;
-  uint16_t Table_31_5_dBm;
+  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;
 }ATT_TABLE_st;
 typedef struct{
 
-  uint16_t Table_Det5_dBm	;
-  uint16_t Table_Det4_dBm	;
-  uint16_t Table_Det3_dBm	;
-  uint16_t Table_Det2_dBm	;
-  uint16_t Table_Det1_dBm	;
-  uint16_t Table_Det0_dBm	;
-  uint16_t Table_Det_1_dBm	;
-  uint16_t Table_Det_2_dBm	;
-  uint16_t Table_Det_3_dBm	;
-  uint16_t Table_Det_4_dBm	;
-  uint16_t Table_Det_5_dBm	;
-  uint16_t Table_Det_6_dBm	;
-  uint16_t Table_Det_7_dBm	;
-  uint16_t Table_Det_8_dBm	;
-  uint16_t Table_Det_9_dBm	;
-  uint16_t Table_Det_10_dBm	;
-  uint16_t Table_Det_11_dBm	;
-  uint16_t Table_Det_12_dBm	;
-  uint16_t Table_Det_13_dBm	;
-  uint16_t Table_Det_14_dBm	;
-  uint16_t Table_Det_15_dBm	;
-  uint16_t Table_Det_16_dBm	;
-  uint16_t Table_Det_17_dBm	;
-  uint16_t Table_Det_18_dBm	;
-  uint16_t Table_Det_19_dBm	;
-  uint16_t Table_Det_20_dBm	;
-  uint16_t Table_Det_21_dBm	;
-  uint16_t Table_Det_22_dBm	;
-  uint16_t Table_Det_23_dBm	;
-  uint16_t Table_Det_24_dBm	;
-  uint16_t Table_Det_25_dBm	;
+    uint8_t Table_Det5_dBm_H	;
+    uint8_t Table_Det5_dBm_L	;
+    uint8_t Table_Det4_dBm_H	;
+    uint8_t Table_Det4_dBm_L	;  
+    uint8_t Table_Det3_dBm_H	;
+    uint8_t Table_Det3_dBm_L	;
+    uint8_t Table_Det2_dBm_H	;
+    uint8_t Table_Det2_dBm_L	;
+    uint8_t Table_Det1_dBm_H	;
+    uint8_t Table_Det1_dBm_L	;
+    uint8_t Table_Det0_dBm_H	;
+    uint8_t Table_Det0_dBm_L	;
+    uint8_t Table_Det_1_dBm_H	;
+    uint8_t Table_Det_1_dBm_L	;
+    uint8_t Table_Det_2_dBm_H	;
+    uint8_t Table_Det_2_dBm_L	;
+    uint8_t Table_Det_3_dBm_H	;
+    uint8_t Table_Det_3_dBm_L	;
+    uint8_t Table_Det_4_dBm_H	;
+    uint8_t Table_Det_4_dBm_L	;
+    uint8_t Table_Det_5_dBm_H	;
+    uint8_t Table_Det_5_dBm_L	;  
+    uint8_t Table_Det_6_dBm_H	;
+    uint8_t Table_Det_6_dBm_L	;  
+    uint8_t Table_Det_7_dBm_H	;
+    uint8_t Table_Det_7_dBm_L	;
+    uint8_t Table_Det_8_dBm_H	;
+    uint8_t Table_Det_8_dBm_L	;
+    uint8_t Table_Det_9_dBm_H	;
+    uint8_t Table_Det_9_dBm_L	;
+    uint8_t Table_Det_10_dBm_H	;
+    uint8_t Table_Det_10_dBm_L	;  
+    uint8_t Table_Det_11_dBm_H	;
+    uint8_t Table_Det_11_dBm_L	;
+    uint8_t Table_Det_12_dBm_H	;
+    uint8_t Table_Det_12_dBm_L	;
+    uint8_t Table_Det_13_dBm_H	;
+    uint8_t Table_Det_13_dBm_L	;
+    uint8_t Table_Det_14_dBm_H	;
+    uint8_t Table_Det_14_dBm_L	;
+    uint8_t Table_Det_15_dBm_H	;
+    uint8_t Table_Det_15_dBm_L	;
+    uint8_t Table_Det_16_dBm_H	;
+    uint8_t Table_Det_16_dBm_L	;
+    uint8_t Table_Det_17_dBm_H	;
+    uint8_t Table_Det_17_dBm_L	;
+    uint8_t Table_Det_18_dBm_H	;
+    uint8_t Table_Det_18_dBm_L	;
+    uint8_t Table_Det_19_dBm_H	;
+    uint8_t Table_Det_19_dBm_L	;
+    uint8_t Table_Det_20_dBm_H	;
+    uint8_t Table_Det_20_dBm_L	;
+    uint8_t Table_Det_21_dBm_H	;
+    uint8_t Table_Det_21_dBm_L	;
+    uint8_t Table_Det_22_dBm_H	;
+    uint8_t Table_Det_22_dBm_L	;
+    uint8_t Table_Det_23_dBm_H	;
+    uint8_t Table_Det_23_dBm_L	;
+    uint8_t Table_Det_24_dBm_H	;
+    uint8_t Table_Det_24_dBm_L	;
+    uint8_t Table_Det_25_dBm_H	;
+    uint8_t Table_Det_25_dBm_L	;
 }DET_TABLEDL_st;
 typedef struct{
-  uint16_t Table_Det_15_dBm	;
-  uint16_t Table_Det_16_dBm	;
-  uint16_t Table_Det_17_dBm	;
-  uint16_t Table_Det_18_dBm	;
-  uint16_t Table_Det_19_dBm	;
-  uint16_t Table_Det_20_dBm	;
-  uint16_t Table_Det_21_dBm	;
-  uint16_t Table_Det_22_dBm	;
-  uint16_t Table_Det_23_dBm	;
-  uint16_t Table_Det_24_dBm	;
-  uint16_t Table_Det_25_dBm	;
-  uint16_t Table_Det_26_dBm	;
-  uint16_t Table_Det_27_dBm	;
-  uint16_t Table_Det_28_dBm	;
-  uint16_t Table_Det_29_dBm	;
-  uint16_t Table_Det_30_dBm	;
-  uint16_t Table_Det_31_dBm	;
-  uint16_t Table_Det_32_dBm	;
-  uint16_t Table_Det_33_dBm	;
-  uint16_t Table_Det_34_dBm	;
-  uint16_t Table_Det_35_dBm	;
-  uint16_t Table_Det_36_dBm	;
-  uint16_t Table_Det_37_dBm	;
-  uint16_t Table_Det_38_dBm	;
-  uint16_t Table_Det_39_dBm	;
-  uint16_t Table_Det_40_dBm	;
-  uint16_t Table_Det_41_dBm	;
-  uint16_t Table_Det_42_dBm	;
-  uint16_t Table_Det_43_dBm	;
-  uint16_t Table_Det_44_dBm	;
-  uint16_t Table_Det_45_dBm	;
-  uint16_t Table_Det_46_dBm	;
-  uint16_t Table_Det_47_dBm	;
-  uint16_t Table_Det_48_dBm	;
-  uint16_t Table_Det_49_dBm	;
-  uint16_t Table_Det_50_dBm	;
-  uint16_t Table_Det_51_dBm	;
-  uint16_t Table_Det_52_dBm	;
-  uint16_t Table_Det_53_dBm	;
-  uint16_t Table_Det_54_dBm	;
-  uint16_t Table_Det_55_dBm	;
-  uint16_t Table_Det_56_dBm	;
-  uint16_t Table_Det_57_dBm	;
-  uint16_t Table_Det_58_dBm	;
-  uint16_t Table_Det_59_dBm	;
-  uint16_t Table_Det_60_dBm	;
+  uint8_t Table_Det_15_dBm_H	;   uint8_t Table_Det_15_dBm_L	;
+  uint8_t Table_Det_16_dBm_H	;   uint8_t Table_Det_16_dBm_L	;
+  uint8_t Table_Det_17_dBm_H	;   uint8_t Table_Det_17_dBm_L	;
+  uint8_t Table_Det_18_dBm_H	;   uint8_t Table_Det_18_dBm_L	;
+  uint8_t Table_Det_19_dBm_H	;   uint8_t Table_Det_19_dBm_L	;
+  uint8_t Table_Det_20_dBm_H	;   uint8_t Table_Det_20_dBm_L	;
+  uint8_t Table_Det_21_dBm_H	;   uint8_t Table_Det_21_dBm_L	;
+  uint8_t Table_Det_22_dBm_H	;   uint8_t Table_Det_22_dBm_L	;
+  uint8_t Table_Det_23_dBm_H	;   uint8_t Table_Det_23_dBm_L	;
+  uint8_t Table_Det_24_dBm_H	;   uint8_t Table_Det_24_dBm_L	;
+  uint8_t Table_Det_25_dBm_H	;   uint8_t Table_Det_25_dBm_L	;
+  uint8_t Table_Det_26_dBm_H	;   uint8_t Table_Det_26_dBm_L	;
+  uint8_t Table_Det_27_dBm_H	;   uint8_t Table_Det_27_dBm_L	;
+  uint8_t Table_Det_28_dBm_H	;   uint8_t Table_Det_28_dBm_L	;
+  uint8_t Table_Det_29_dBm_H	;   uint8_t Table_Det_29_dBm_L	;
+  uint8_t Table_Det_30_dBm_H	;   uint8_t Table_Det_30_dBm_L	;
+  uint8_t Table_Det_31_dBm_H	;   uint8_t Table_Det_31_dBm_L	;
+  uint8_t Table_Det_32_dBm_H	;   uint8_t Table_Det_32_dBm_L	;
+  uint8_t Table_Det_33_dBm_H	;   uint8_t Table_Det_33_dBm_L	;
+  uint8_t Table_Det_34_dBm_H	;   uint8_t Table_Det_34_dBm_L	;
+  uint8_t Table_Det_35_dBm_H	;   uint8_t Table_Det_35_dBm_L	;
+  uint8_t Table_Det_36_dBm_H	;   uint8_t Table_Det_36_dBm_L	;
+  uint8_t Table_Det_37_dBm_H	;   uint8_t Table_Det_37_dBm_L	;
+  uint8_t Table_Det_38_dBm_H	;   uint8_t Table_Det_38_dBm_L	;
+  uint8_t Table_Det_39_dBm_H	;   uint8_t Table_Det_39_dBm_L	;
+  uint8_t Table_Det_40_dBm_H	;   uint8_t Table_Det_40_dBm_L	;
+  uint8_t Table_Det_41_dBm_H	;   uint8_t Table_Det_41_dBm_L	;
+  uint8_t Table_Det_42_dBm_H	;   uint8_t Table_Det_42_dBm_L	;
+  uint8_t Table_Det_43_dBm_H	;   uint8_t Table_Det_43_dBm_L	;
+  uint8_t Table_Det_44_dBm_H	;   uint8_t Table_Det_44_dBm_L	;
+  uint8_t Table_Det_45_dBm_H	;   uint8_t Table_Det_45_dBm_L	;
+  uint8_t Table_Det_46_dBm_H	;   uint8_t Table_Det_46_dBm_L	;
+  uint8_t Table_Det_47_dBm_H	;   uint8_t Table_Det_47_dBm_L	;
+  uint8_t Table_Det_48_dBm_H	;   uint8_t Table_Det_48_dBm_L	;
+  uint8_t Table_Det_49_dBm_H	;   uint8_t Table_Det_49_dBm_L	;
+  uint8_t Table_Det_50_dBm_H	;   uint8_t Table_Det_50_dBm_L	;
+  uint8_t Table_Det_51_dBm_H	;   uint8_t Table_Det_51_dBm_L	;
+  uint8_t Table_Det_52_dBm_H	;   uint8_t Table_Det_52_dBm_L	;
+  uint8_t Table_Det_53_dBm_H	;   uint8_t Table_Det_53_dBm_L	;
+  uint8_t Table_Det_54_dBm_H	;   uint8_t Table_Det_54_dBm_L	;
+  uint8_t Table_Det_55_dBm_H	;   uint8_t Table_Det_55_dBm_L	;
+  uint8_t Table_Det_56_dBm_H	;   uint8_t Table_Det_56_dBm_L	;
+  uint8_t Table_Det_57_dBm_H	;   uint8_t Table_Det_57_dBm_L	;
+  uint8_t Table_Det_58_dBm_H	;   uint8_t Table_Det_58_dBm_L	;
+  uint8_t Table_Det_59_dBm_H	;   uint8_t Table_Det_59_dBm_L	;
+  uint8_t Table_Det_60_dBm_H	;   uint8_t Table_Det_60_dBm_L	;
 }DET_TABLEUL_st;
 
 typedef struct{
 
-  uint16_t Table_10_Temp;
-  uint16_t Table_15_Temp;
-  uint16_t Table_20_Temp;
-  uint16_t Table_25_Temp;
-  uint16_t Table_30_Temp;
-  uint16_t Table_35_Temp;
-  uint16_t Table_40_Temp;
-  uint16_t Table_45_Temp;
-  uint16_t Table_50_Temp;
-  uint16_t Table_55_Temp;
+  uint8_t Table_10_Temp_H;   uint8_t Table_10_Temp_L;
+  uint8_t Table_15_Temp_H;   uint8_t Table_15_Temp_L;
+  uint8_t Table_20_Temp_H;   uint8_t Table_20_Temp_L;
+  uint8_t Table_25_Temp_H;   uint8_t Table_25_Temp_L;
+  uint8_t Table_30_Temp_H;   uint8_t Table_30_Temp_L;
+  uint8_t Table_35_Temp_H;   uint8_t Table_35_Temp_L;
+  uint8_t Table_40_Temp_H;   uint8_t Table_40_Temp_L;
+  uint8_t Table_45_Temp_H;   uint8_t Table_45_Temp_L;
+  uint8_t Table_50_Temp_H;   uint8_t Table_50_Temp_L;
+  uint8_t Table_55_Temp_H;   uint8_t Table_55_Temp_L;
 }TEMP_TABLE_st;
 typedef enum{
   Bluecell_DET_UL1_ADC_INDEX_H = 0,

Bluecell_Inc/eeprom.h

@@ -13,38 +13,62 @@
 #define EEPROM_Block0_ADDRESS             EEPROM_M24C08_ID
 #define EEPROM_ATT_BASE					  0x0000
 
-#define EEPROM_ATT_DL1_TABLE_ADDRESDS	  EEPROM_ATT_BASE               + (sizeof(ATT_TABLE_st)            * 2)
-#define EEPROM_ATT_DL2_TABLE_ADDRESDS	  EEPROM_ATT_DL1_TABLE_ADDRESDS + (sizeof(ATT_TABLE_st)            * 2)
-#define EEPROM_ATT_DL3_TABLE_ADDRESDS	  EEPROM_ATT_DL2_TABLE_ADDRESDS + (sizeof(ATT_TABLE_st)            * 2)
-#define EEPROM_ATT_DL4_TABLE_ADDRESDS	  EEPROM_ATT_DL3_TABLE_ADDRESDS + (sizeof(ATT_TABLE_st)            * 2)
+#if 1 // PYJ.2020.04.25_BEGIN -- 
+#define EEPROM_WINDOW_STATUS_ADDRESDS	 ((EEPROM_ATT_BASE + (sizeof(BLUESTATUS_st) + 20)) & 0xFFFF) //96byte
+#define EEPROM_ATT_DL1_TABLE_ADDRESDS	 (( EEPROM_WINDOW_STATUS_ADDRESDS  + (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)
+#define EEPROM_ATT_UL1_TABLE_ADDRESDS	 (( EEPROM_ATT_DL4_TABLE_ADDRESDS  + (sizeof(ATT_TABLE_st))  )    & 0xFFFF)
+#define EEPROM_ATT_UL2_TABLE_ADDRESDS	 (( EEPROM_ATT_UL1_TABLE_ADDRESDS  + (sizeof(ATT_TABLE_st))  )    & 0xFFFF)
+#define EEPROM_ATT_UL3_TABLE_ADDRESDS	 (( EEPROM_ATT_UL2_TABLE_ADDRESDS  + (sizeof(ATT_TABLE_st))  )    & 0xFFFF)
+#define EEPROM_ATT_UL4_TABLE_ADDRESDS	 (( EEPROM_ATT_UL3_TABLE_ADDRESDS  + (sizeof(ATT_TABLE_st))  )    & 0xFFFF)//128
+#define EEPROM_DET_DL1_TABLE_ADDRESDS	 (( EEPROM_ATT_UL4_TABLE_ADDRESDS  + (sizeof(DET_TABLEDL_st)+ 2))    & 0xFFFF)
+#define EEPROM_DET_DL2_TABLE_ADDRESDS	 (( EEPROM_DET_DL1_TABLE_ADDRESDS  + (sizeof(DET_TABLEDL_st)+ 2))    & 0xFFFF)
+#define EEPROM_DET_DL3_TABLE_ADDRESDS	 (( EEPROM_DET_DL2_TABLE_ADDRESDS  + (sizeof(DET_TABLEDL_st)+ 2))    & 0xFFFF)
+#define EEPROM_DET_DL4_TABLE_ADDRESDS	 (( EEPROM_DET_DL3_TABLE_ADDRESDS  + (sizeof(DET_TABLEDL_st)+ 2))    & 0xFFFF)
+#define EEPROM_DET_UL1_TABLE_ADDRESDS	 (( EEPROM_DET_DL4_TABLE_ADDRESDS  + (sizeof(DET_TABLEUL_st) + 4))     & 0xFFFF)
+#define EEPROM_DET_UL2_TABLE_ADDRESDS	 (( EEPROM_DET_UL1_TABLE_ADDRESDS  + (sizeof(DET_TABLEUL_st)+ 4))     & 0xFFFF)
+#define EEPROM_DET_UL3_TABLE_ADDRESDS	 (( EEPROM_DET_UL2_TABLE_ADDRESDS  + (sizeof(DET_TABLEUL_st)+ 4))     & 0xFFFF)
+#define EEPROM_DET_UL4_TABLE_ADDRESDS	 (( EEPROM_DET_UL3_TABLE_ADDRESDS  + (sizeof(DET_TABLEUL_st)+ 4))     & 0xFFFF)
+#define EEPROM_TEMP_DL1_TABLE_ADDRESDS	 (( EEPROM_DET_UL4_TABLE_ADDRESDS  + (sizeof(TEMP_TABLE_st)+12))     & 0xFFFF)
+#define EEPROM_TEMP_DL2_TABLE_ADDRESDS	 (( EEPROM_TEMP_DL1_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)+12))     & 0xFFFF)
+#define EEPROM_TEMP_DL3_TABLE_ADDRESDS	 (( EEPROM_TEMP_DL2_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)+12))     & 0xFFFF)
+#define EEPROM_TEMP_DL4_TABLE_ADDRESDS	 (( EEPROM_TEMP_DL3_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)+12))     & 0xFFFF)
+#define EEPROM_TEMP_UL1_TABLE_ADDRESDS	 (( EEPROM_TEMP_DL4_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)+12))     & 0xFFFF)
+#define EEPROM_TEMP_UL2_TABLE_ADDRESDS	 (( EEPROM_TEMP_UL1_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)+12))     & 0xFFFF)
+#define EEPROM_TEMP_UL3_TABLE_ADDRESDS	 (( EEPROM_TEMP_UL2_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)+12))     & 0xFFFF)
+#define EEPROM_TEMP_UL4_TABLE_ADDRESDS	 (( EEPROM_TEMP_UL3_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)+12))     & 0xFFFF)
+#else
+#define EEPROM_WINDOW_STATUS_ADDRESDS	 ((EEPROM_ATT_BASE + (sizeof(BLUESTATUS_st))) & 0xFFFF) //96byte
+#define EEPROM_ATT_DL1_TABLE_ADDRESDS	 (( EEPROM_WINDOW_STATUS_ADDRESDS  + (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)
+#define EEPROM_ATT_UL1_TABLE_ADDRESDS	 (( EEPROM_ATT_DL4_TABLE_ADDRESDS  + (sizeof(ATT_TABLE_st))  )    & 0xFFFF)
+#define EEPROM_ATT_UL2_TABLE_ADDRESDS	 (( EEPROM_ATT_UL1_TABLE_ADDRESDS  + (sizeof(ATT_TABLE_st))  )    & 0xFFFF)
+#define EEPROM_ATT_UL3_TABLE_ADDRESDS	 (( EEPROM_ATT_UL2_TABLE_ADDRESDS  + (sizeof(ATT_TABLE_st))  )    & 0xFFFF)
+#define EEPROM_ATT_UL4_TABLE_ADDRESDS	 (( EEPROM_ATT_UL3_TABLE_ADDRESDS  + (sizeof(ATT_TABLE_st))  )    & 0xFFFF)//128
+#define EEPROM_DET_DL1_TABLE_ADDRESDS	 (( EEPROM_ATT_UL4_TABLE_ADDRESDS  + (sizeof(DET_TABLEDL_st)))    & 0xFFFF)
+#define EEPROM_DET_DL2_TABLE_ADDRESDS	 (( EEPROM_DET_DL1_TABLE_ADDRESDS  + (sizeof(DET_TABLEDL_st)))    & 0xFFFF)
+#define EEPROM_DET_DL3_TABLE_ADDRESDS	 (( EEPROM_DET_DL2_TABLE_ADDRESDS  + (sizeof(DET_TABLEDL_st)))    & 0xFFFF)
+#define EEPROM_DET_DL4_TABLE_ADDRESDS	 (( EEPROM_DET_DL3_TABLE_ADDRESDS  + (sizeof(DET_TABLEDL_st)))    & 0xFFFF)
+#define EEPROM_DET_UL1_TABLE_ADDRESDS	 (( EEPROM_DET_DL4_TABLE_ADDRESDS  + (sizeof(DET_TABLEUL_st)))     & 0xFFFF)
+#define EEPROM_DET_UL2_TABLE_ADDRESDS	 (( EEPROM_DET_UL1_TABLE_ADDRESDS  + (sizeof(DET_TABLEUL_st)))     & 0xFFFF)
+#define EEPROM_DET_UL3_TABLE_ADDRESDS	 (( EEPROM_DET_UL2_TABLE_ADDRESDS  + (sizeof(DET_TABLEUL_st)))     & 0xFFFF)
+#define EEPROM_DET_UL4_TABLE_ADDRESDS	 (( EEPROM_DET_UL3_TABLE_ADDRESDS  + (sizeof(DET_TABLEUL_st)))     & 0xFFFF)
+#define EEPROM_TEMP_DL1_TABLE_ADDRESDS	 (( EEPROM_DET_UL4_TABLE_ADDRESDS  + (sizeof(TEMP_TABLE_st)))     & 0xFFFF)
+#define EEPROM_TEMP_DL2_TABLE_ADDRESDS	 (( EEPROM_TEMP_DL1_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)))     & 0xFFFF)
+#define EEPROM_TEMP_DL3_TABLE_ADDRESDS	 (( EEPROM_TEMP_DL2_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)))     & 0xFFFF)
+#define EEPROM_TEMP_DL4_TABLE_ADDRESDS	 (( EEPROM_TEMP_DL3_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)))     & 0xFFFF)
+#define EEPROM_TEMP_UL1_TABLE_ADDRESDS	 (( EEPROM_TEMP_DL4_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)))     & 0xFFFF)
+#define EEPROM_TEMP_UL2_TABLE_ADDRESDS	 (( EEPROM_TEMP_UL1_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)))     & 0xFFFF)
+#define EEPROM_TEMP_UL3_TABLE_ADDRESDS	 (( EEPROM_TEMP_UL2_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)))     & 0xFFFF)
+#define EEPROM_TEMP_UL4_TABLE_ADDRESDS	 (( EEPROM_TEMP_UL3_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)))     & 0xFFFF)
+
+#endif // PYJ.2020.04.25_END -- 
 
-#define EEPROM_ATT_UL1_TABLE_ADDRESDS	  EEPROM_ATT_DL4_TABLE_ADDRESDS + (sizeof(ATT_TABLE_st)            * 2)
-#define EEPROM_ATT_UL2_TABLE_ADDRESDS	  EEPROM_ATT_UL1_TABLE_ADDRESDS + (sizeof(ATT_TABLE_st)            * 2)
-#define EEPROM_ATT_UL3_TABLE_ADDRESDS	  EEPROM_ATT_UL2_TABLE_ADDRESDS + (sizeof(ATT_TABLE_st)            * 2)
-#define EEPROM_ATT_UL4_TABLE_ADDRESDS	  EEPROM_ATT_UL3_TABLE_ADDRESDS + (sizeof(ATT_TABLE_st)            * 2)
 
-#define EEPROM_DET_DL1_TABLE_ADDRESDS	  EEPROM_ATT_UL4_TABLE_ADDRESDS + (sizeof(DET_TABLEDL_st)          * 2)
-#define EEPROM_DET_DL2_TABLE_ADDRESDS	  EEPROM_DET_DL1_TABLE_ADDRESDS + (sizeof(DET_TABLEDL_st)          * 2)
-#define EEPROM_DET_DL3_TABLE_ADDRESDS	  EEPROM_DET_DL2_TABLE_ADDRESDS + (sizeof(DET_TABLEDL_st)          * 2)
-#define EEPROM_DET_DL4_TABLE_ADDRESDS	  EEPROM_DET_DL3_TABLE_ADDRESDS + (sizeof(DET_TABLEDL_st)          * 2)
-
-#define EEPROM_DET_UL1_TABLE_ADDRESDS	  EEPROM_DET_DL4_TABLE_ADDRESDS + (sizeof(DET_TABLEUL_st)          * 2)
-#define EEPROM_DET_UL2_TABLE_ADDRESDS	  EEPROM_DET_UL1_TABLE_ADDRESDS + (sizeof(DET_TABLEUL_st)          * 2)
-#define EEPROM_DET_UL3_TABLE_ADDRESDS	  EEPROM_DET_UL2_TABLE_ADDRESDS + (sizeof(DET_TABLEUL_st)          * 2)
-#define EEPROM_DET_UL4_TABLE_ADDRESDS	  EEPROM_DET_UL3_TABLE_ADDRESDS + (sizeof(DET_TABLEUL_st)          * 2)
-
-#define EEPROM_TEMP_DL1_TABLE_ADDRESDS	  EEPROM_DET_UL4_TABLE_ADDRESDS + (sizeof(TEMP_TABLE_st)           * 2)
-#define EEPROM_TEMP_DL2_TABLE_ADDRESDS	  EEPROM_TEMP_DL1_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)          * 2)
-#define EEPROM_TEMP_DL3_TABLE_ADDRESDS	  EEPROM_TEMP_DL2_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)          * 2)
-#define EEPROM_TEMP_DL4_TABLE_ADDRESDS	  EEPROM_TEMP_DL3_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)          * 2)
-
-#define EEPROM_TEMP_UL1_TABLE_ADDRESDS	  EEPROM_TEMP_DL4_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)          * 2)
-#define EEPROM_TEMP_UL2_TABLE_ADDRESDS	  EEPROM_TEMP_UL1_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)          * 2)
-#define EEPROM_TEMP_UL3_TABLE_ADDRESDS	  EEPROM_TEMP_UL2_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)          * 2)
-#define EEPROM_TEMP_UL4_TABLE_ADDRESDS	  EEPROM_TEMP_UL3_TABLE_ADDRESDS +( sizeof(TEMP_TABLE_st)          * 2)
-
-
-#define EEPROM_WINDOW_STATUS_ADDRESDS	  EEPROM_TEMP_UL4_TABLE_ADDRESDS +( sizeof(BLUESTATUS_st)          * 2)
 
 #define MAKE_ADDRESS(_addr, _e2)            ((uint8_t)EEPROM_M24C08_ADDR | \
                                              ((_e2) ? EEPROM_M24C08_ADDR_E2 : 0) | \
@@ -58,8 +82,8 @@
 
 #define EEPROM_M24C08_BYTE_ADDR_H           0x06
 
-HAL_StatusTypeDef EEPROM_M24C08_Read(uint16_t devid,uint16_t Address,uint16_t* data,uint8_t size);
-HAL_StatusTypeDef EEPROM_M24C08_write(uint16_t devid,uint16_t Address,uint16_t* data,uint8_t size);
+HAL_StatusTypeDef EEPROM_M24C08_Read(uint8_t devid,uint16_t Address,uint8_t* data,uint16_t size);
+HAL_StatusTypeDef EEPROM_M24C08_write(uint8_t devid,uint16_t Address,uint8_t* data,uint16_t size);
 
 HAL_StatusTypeDef EEPROM_M24C08_ByteRead(uint16_t devid,uint16_t Address,uint8_t* data,uint8_t size);
 HAL_StatusTypeDef EEPROM_M24C08_Bytewrite(uint16_t devid,uint16_t Address,uint8_t* data,uint8_t size);

Bluecell_Src/Bluecell_operate.c

@@ -76,19 +76,74 @@ typedef struct{
 extern ALL_PE43711_st ALL_ATT;
 BLUESTATUS_st bluecell_Currdatastatus;
 BLUESTATUS_st bluecell_Prevdatastatus;
+double TableAtteGuarantee(uint8_t* Table,double AttenValue);
+uint8_t PE43711_Calc(uint8_t* Table,uint8_t high_bit,uint8_t low_bit);
+uint8_t PE43711_Calc_NoTable(uint8_t high_bit,uint8_t low_bit);
+double PE43711_Double(uint8_t high_bit,uint8_t low_bit);
 
-uint8_t PE43711_Calc(uint8_t high_bit,uint8_t low_bit){
+
+
+uint8_t PE43711_Calc(uint8_t* Table,uint8_t high_bit,uint8_t low_bit){
+    uint8_t tmp_h = high_bit,tmp_l = low_bit;
+    double ret = 0;
+    uint8_t val = 0;
+    ret = PE43711_Double(high_bit,low_bit);
+//    printf("ret1 : %f \r\n",ret); // 2
+    ret = TableAtteGuarantee(Table,ret);//Table Guarantee
+//    printf("ret2 : %f \r\n",ret);
+    val = PE43711_DataToHexConvert(ret);
+}
+uint8_t PE43711_Calc_NoTable(uint8_t high_bit,uint8_t low_bit){
+    uint16_t tmp_h = high_bit,tmp_l = low_bit;
+    double ret = 0;
+    uint8_t val = 0;
+    ret = PE43711_Double(high_bit,low_bit);
+
+    val = PE43711_DataToHexConvert(ret);
+
+}
+double PE43711_Double(uint8_t high_bit,uint8_t low_bit){
     uint16_t tmp_h = 0,tmp_l = 0;
     double ret = 0;
     uint8_t val = 0;
     tmp_h = high_bit;
     tmp_l = low_bit;
-    ret += ((tmp_h << 8) & 0xFF00);
+    ret = ((tmp_h << 8) & 0xFF00);
     ret += (tmp_l & 0x00FF);
+    if((((tmp_h << 8) & 0xFF00) & 0xF000) == 0xF000){
+//        printf("minus Calc Start\r\n");
+        ret = 0xFFFF - ret;
+//        printf("0xFFFF - %x\r\n",ret);
+        ret += 0x01;
+        ret = ret - (2*ret);
+//        printf("ret :  %x\r\n",ret);        
+    }
+//    printf("%s 1: ret : %x\r\n",__func__,ret);
     ret /= 100;
-    val = PE43711_DataToHexConvert(ret);
+//    printf("%s 2: ret : %f\r\n",__func__,ret);
+    return ret;
 
 }
+uint8_t GuaranteeData[256];
+double TableAtteGuarantee(uint8_t* Table,double AttenValue){
+    double ret = 0;
+    double ref = 0;
+    uint8_t cnt = 0;
+    for(double ref = 0; ref < AttenValue; ref += 0.5){
+        cnt++;       
+    }
+    
+    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]);
+//    printf("ret3 : %f \r\n",ret); //1
+    ret += AttenValue;
+//    printf("ret4 : %f \r\n",ret);
+    return ret;
+
+}
+
 
 void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      uint8_t val = 0;
@@ -96,7 +151,8 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      ||Curr.ATT_DL1_L != Prev.ATT_DL1_L){
         bluecell_Prevdatastatus.ATT_DL1_H = bluecell_Currdatastatus.ATT_DL1_H;
         bluecell_Prevdatastatus.ATT_DL1_L = bluecell_Currdatastatus.ATT_DL1_L;
-        val = PE43711_Calc(Curr.ATT_DL1_H,Curr.ATT_DL1_L);
+        
+        val = PE43711_Calc(&Att_DL1.Table_0_0_dBm_H,Curr.ATT_DL1_H,Curr.ATT_DL1_L);
 //        printf("%d val = %x \r\n",__LINE__,val);
         PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);
     }
@@ -105,7 +161,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      ||(Curr.ATT_DL2_L != Prev.ATT_DL2_L)){
         bluecell_Prevdatastatus.ATT_DL2_H = bluecell_Currdatastatus.ATT_DL2_H;
         bluecell_Prevdatastatus.ATT_DL2_L = bluecell_Currdatastatus.ATT_DL2_L;
-        val = PE43711_Calc(Curr.ATT_DL2_H,Curr.ATT_DL2_L);
+        val = PE43711_Calc(&Att_DL2.Table_0_0_dBm_H,Curr.ATT_DL2_H,Curr.ATT_DL2_L);
 //        printf("%d val = %x \r\n",__LINE__,val);
         PE43711_atten_ctrl(ALL_ATT.ATT_DL2,val);
     }
@@ -114,7 +170,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      ||Curr.ATT_DL3_L != Prev.ATT_DL3_L){
         bluecell_Prevdatastatus.ATT_DL3_H = bluecell_Currdatastatus.ATT_DL3_H;
         bluecell_Prevdatastatus.ATT_DL3_L = bluecell_Currdatastatus.ATT_DL3_L;
-        val = PE43711_Calc(Curr.ATT_DL3_H,Curr.ATT_DL3_L);
+        val = PE43711_Calc(&Att_DL3.Table_0_0_dBm_H,Curr.ATT_DL3_H,Curr.ATT_DL3_L);
 //        printf("%d val = %x \r\n",__LINE__,val);
         PE43711_atten_ctrl(ALL_ATT.ATT_DL3,val);
     }
@@ -125,7 +181,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      ||Curr.ATT_DL4_L != Prev.ATT_DL4_L){
         bluecell_Prevdatastatus.ATT_DL4_H = bluecell_Currdatastatus.ATT_DL4_H;
         bluecell_Prevdatastatus.ATT_DL4_L = bluecell_Currdatastatus.ATT_DL4_L;
-        val = PE43711_Calc(Curr.ATT_DL4_H,Curr.ATT_DL4_L);
+        val = PE43711_Calc(&Att_DL4.Table_0_0_dBm_H,Curr.ATT_DL4_H,Curr.ATT_DL4_L);
 //        printf("%d val = %x \r\n",__LINE__,val);
         PE43711_atten_ctrl(ALL_ATT.ATT_DL4,val);
     }
@@ -135,7 +191,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      ||Curr.ATT_UL1_L != Prev.ATT_UL1_L){
         bluecell_Prevdatastatus.ATT_UL1_H = bluecell_Currdatastatus.ATT_UL1_H;
         bluecell_Prevdatastatus.ATT_UL1_L = bluecell_Currdatastatus.ATT_UL1_L;
-        val = PE43711_Calc(Curr.ATT_UL1_H,Curr.ATT_UL1_L);
+        val = PE43711_Calc(&Att_UL1.Table_0_0_dBm_H,Curr.ATT_UL1_H,Curr.ATT_UL1_L);
 //        printf("%d val = %x \r\n",__LINE__,val);
         PE43711_atten_ctrl(ALL_ATT.ATT_UL1,val);
     }
@@ -143,7 +199,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      ||Curr.ATT_UL2_L != Prev.ATT_UL2_L){
         bluecell_Prevdatastatus.ATT_UL2_H = bluecell_Currdatastatus.ATT_UL2_H;
         bluecell_Prevdatastatus.ATT_UL2_L = bluecell_Currdatastatus.ATT_UL2_L;
-        val = PE43711_Calc(Curr.ATT_UL2_H,Curr.ATT_UL2_L);
+        val = PE43711_Calc(&Att_UL2.Table_0_0_dBm_H,Curr.ATT_UL2_H,Curr.ATT_UL2_L);
 //        printf("%d val = %x \r\n",__LINE__,val);
         PE43711_atten_ctrl(ALL_ATT.ATT_UL2,val);
     }
@@ -153,7 +209,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
         bluecell_Prevdatastatus.ATT_UL3_H = bluecell_Currdatastatus.ATT_UL3_H;
         bluecell_Prevdatastatus.ATT_UL3_L = bluecell_Currdatastatus.ATT_UL3_L;
         
-        val = PE43711_Calc(Curr.ATT_UL3_H,Curr.ATT_UL3_L);
+        val = PE43711_Calc(&Att_UL3.Table_0_0_dBm_H,Curr.ATT_UL3_H,Curr.ATT_UL3_L);
 //        printf("%d val = %x \r\n",__LINE__,val);
         PE43711_atten_ctrl(ALL_ATT.ATT_UL3,val);
     }
@@ -162,7 +218,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
         bluecell_Prevdatastatus.ATT_UL4_H = bluecell_Currdatastatus.ATT_UL4_H;
         bluecell_Prevdatastatus.ATT_UL4_L = bluecell_Currdatastatus.ATT_UL4_L;
         
-        val = PE43711_Calc(Curr.ATT_UL4_H,Curr.ATT_UL4_L);
+        val = PE43711_Calc(&Att_UL4.Table_0_0_dBm_H,Curr.ATT_UL4_H,Curr.ATT_UL4_L);
 //        printf("%d val = %x \r\n",__LINE__,val);
         PE43711_atten_ctrl(ALL_ATT.ATT_UL4,val);
     }
@@ -174,7 +230,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      
         bluecell_Prevdatastatus.ATT_ALC1_H = bluecell_Currdatastatus.ATT_ALC1_H;
         bluecell_Prevdatastatus.ATT_ALC1_L = bluecell_Currdatastatus.ATT_ALC1_L;
-        val = PE43711_Calc(Curr.ATT_ALC1_H,Curr.ATT_ALC1_L);
+        val = PE43711_Calc(&Att_UL1.Table_0_0_dBm_H,Curr.ATT_ALC1_H,Curr.ATT_ALC1_L);
 //        val = PE43711_DataToHexConvert(ret);
 //        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);
 
@@ -183,7 +239,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      ||Curr.ATT_ALC2_L != Prev.ATT_ALC2_L){
         bluecell_Prevdatastatus.ATT_ALC2_H = bluecell_Currdatastatus.ATT_ALC2_H;
         bluecell_Prevdatastatus.ATT_ALC2_L = bluecell_Currdatastatus.ATT_ALC2_L;
-        val = PE43711_Calc(Curr.ATT_ALC2_H,Curr.ATT_ALC2_L);
+        val = PE43711_Calc(&Att_UL2.Table_0_0_dBm_H,Curr.ATT_ALC2_H,Curr.ATT_ALC2_L);
 
 //        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);
 
@@ -192,17 +248,17 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      ||Curr.ATT_ALC3_L != Prev.ATT_ALC3_L){
         bluecell_Prevdatastatus.ATT_ALC3_H = bluecell_Currdatastatus.ATT_ALC3_H;
         bluecell_Prevdatastatus.ATT_ALC3_L = bluecell_Currdatastatus.ATT_ALC3_L;
-        val = PE43711_Calc(Curr.ATT_ALC3_H,Curr.ATT_ALC3_L);
+        val = PE43711_Calc(&Att_UL3.Table_0_0_dBm_H,Curr.ATT_ALC3_H,Curr.ATT_ALC3_L);
 
 //        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);
 
     }
     if(Curr.ATT_ALC4_H != Prev.ATT_ALC4_H
      ||Curr.ATT_ALC4_L != Prev.ATT_ALC4_L){
-        printf("Curr.ATT_ALC4_H : %x Curr.ATT_ALC4_L : %x\r\n",Curr.ATT_ALC4_H,Curr.ATT_ALC4_L);
+//        printf("Curr.ATT_ALC4_H : %x Curr.ATT_ALC4_L : %x\r\n",Curr.ATT_ALC4_H,Curr.ATT_ALC4_L);
         bluecell_Prevdatastatus.ATT_ALC4_H = bluecell_Currdatastatus.ATT_ALC4_H;
         bluecell_Prevdatastatus.ATT_ALC4_L = bluecell_Currdatastatus.ATT_ALC4_L;
-        val = PE43711_Calc(Curr.ATT_ALC4_H,Curr.ATT_ALC4_L);
+        val = PE43711_Calc(&Att_UL4.Table_0_0_dBm_H,Curr.ATT_ALC4_H,Curr.ATT_ALC4_L);
 
 //        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);
 
@@ -213,7 +269,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      ||Curr.ATT_AGC1_L != Prev.ATT_AGC1_L){
         bluecell_Prevdatastatus.ATT_AGC1_H = bluecell_Currdatastatus.ATT_AGC1_H;
         bluecell_Prevdatastatus.ATT_AGC1_L = bluecell_Currdatastatus.ATT_AGC1_L;
-        val = PE43711_Calc(Curr.ATT_AGC1_H,Curr.ATT_AGC1_L);
+        val = PE43711_Calc(&Att_DL1.Table_0_0_dBm_H,Curr.ATT_AGC1_H,Curr.ATT_AGC1_L);
 
 //        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);
 
@@ -222,7 +278,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      ||Curr.ATT_AGC2_L != Prev.ATT_AGC2_L){
         bluecell_Prevdatastatus.ATT_AGC2_H = bluecell_Currdatastatus.ATT_AGC2_H;
         bluecell_Prevdatastatus.ATT_AGC2_L = bluecell_Currdatastatus.ATT_AGC2_L;
-        val = PE43711_Calc(Curr.ATT_AGC2_H,Curr.ATT_AGC2_L);
+        val = PE43711_Calc(&Att_DL2.Table_0_0_dBm_H,Curr.ATT_AGC2_H,Curr.ATT_AGC2_L);
 
 //        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);
 
@@ -231,7 +287,7 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      ||Curr.ATT_AGC3_L != Prev.ATT_AGC3_L){
         bluecell_Prevdatastatus.ATT_AGC3_H = bluecell_Currdatastatus.ATT_AGC3_H;
         bluecell_Prevdatastatus.ATT_AGC3_L = bluecell_Currdatastatus.ATT_AGC3_L;
-        val = PE43711_Calc(Curr.ATT_AGC3_H,Curr.ATT_AGC3_L);
+        val = PE43711_Calc(&Att_DL3.Table_0_0_dBm_H,Curr.ATT_AGC3_H,Curr.ATT_AGC3_L);
 
 //        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);
 
@@ -240,16 +296,13 @@ void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){
      ||Curr.ATT_AGC4_L != Prev.ATT_AGC4_L){
         bluecell_Prevdatastatus.ATT_AGC4_H = bluecell_Currdatastatus.ATT_AGC4_H;
         bluecell_Prevdatastatus.ATT_AGC4_L = bluecell_Currdatastatus.ATT_AGC4_L;
-        val = PE43711_Calc(Curr.ATT_AGC4_H,Curr.ATT_AGC4_L);
+        val = PE43711_Calc(&Att_DL4.Table_0_0_dBm_H,Curr.ATT_AGC4_H,Curr.ATT_AGC4_L);
 
 //        PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val);
 
     }
 #endif // PYJ.2020.04.21_END -- 
      
-}
-void Bluecell_DataCopy(){
-
 }
 
 typedef enum{
@@ -307,13 +360,13 @@ TEMP_TABLE_st Temp_UL1;
 TEMP_TABLE_st Temp_UL2;
 TEMP_TABLE_st Temp_UL3;
 TEMP_TABLE_st Temp_UL4;
-void Bluecell_StructCopyFunction(uint16_t* dst,uint8_t* src,uint8_t size){
-  for(int i = 0; i < size; i++){
+void Bluecell_StructCopyFunction(uint16_t* dst,uint8_t* src,uint16_t size){
+  for(int i = 0; i < size / 2; i++){
     dst[i]  = ((src[i * 2] << 8) & 0xFF00);
     dst[i]  += src[i * 2 + 1] & 0x00FF;
   }
 }
-void Bluecell_StructCpy(uint8_t* dst,uint8_t* src,uint8_t size){
+void Bluecell_StructCpy(uint8_t* dst,uint8_t* src,uint16_t size){
   for(int i = 0; i < size; i++){
     dst[i]  = src[i];
   }
@@ -342,7 +395,7 @@ OneByteToTwoByte ConvertTo1Byte(uint16_t data){
 
 void Bluecell_Struct2byteCopyFunction(uint8_t* dst,uint16_t* src,uint8_t size){
   OneByteToTwoByte convert;
-  for(int i = 0; i < size; i++){
+  for(int i = 0; i < (size / 2); i++){
     convert = ConvertTo1Byte(src[i]);
     dst[i * 2]      = convert.High_bit;
     dst[i * 2 + 1]  = convert.Low_bit;
@@ -350,121 +403,152 @@ void Bluecell_Struct2byteCopyFunction(uint8_t* dst,uint16_t* src,uint8_t size){
 }
 void Bluecell_structprintf(uint8_t* dst,uint8_t size){
   for(int i = 0; i < size; i++){
-    printf("%x ",dst[i]);
+    printf("Index[%d]%x \r\n",i,dst[i]);
   }
 }
 
+
+uint8_t DataWrite[512] = {0,};
+uint8_t DataRead[512] = {0,};
+void Bluecell_DataCopy(uint8_t* dst,uint8_t* src,uint16_t size){
+    for(int i = 0; i < size; i++){
+      dst[i] = src[i];
+    }
+
+}
 void Bluecell_TableLoad(uint8_t* data){
     uint8_t tabletype = data[BLUECELL_DATA];
 //    OneByteToTwoByte data;
 //    printf("%s : %x \r\n",__func__,tabletype);
-
     switch(tabletype){
         case Bluecell_Table_ATT_DL1: 
-          EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_BASE,1),&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
-          Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-          Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
-          data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
-          break;
-        case Bluecell_Table_ATT_UL1: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
+            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));
             data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
-        break;
+          break;
         case Bluecell_Table_ATT_DL2: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
+            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));
             data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
             break;
-        case Bluecell_Table_ATT_UL2: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
+        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));
             data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
             break;
-        case Bluecell_Table_ATT_DL3: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
+        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));
             data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
             break;
-        case Bluecell_Table_ATT_UL3: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
+        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));
+            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));
             data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
             break;
-        case Bluecell_Table_ATT_DL4: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
+        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));
             data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
             break;
         case Bluecell_Table_ATT_UL4: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st)/ 2);
+            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));
             data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3;
             break;
         case Bluecell_Table_DET_DL1: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_DL1.Table_Det5_dBm,sizeof(DET_TABLEDL_st)/ 2);
+            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));
             data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3;
             break;
-        case Bluecell_Table_DET_UL1: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_UL1.Table_Det_15_dBm,sizeof(DET_TABLEUL_st)/ 2);
-            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
-            break;
         case Bluecell_Table_DET_DL2: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_DL2.Table_Det5_dBm,sizeof(DET_TABLEDL_st)/ 2);
+            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;
-            break;
-        case Bluecell_Table_DET_UL2: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_UL2.Table_Det_15_dBm,sizeof(DET_TABLEUL_st)/ 2);
-            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
-
             break;
         case Bluecell_Table_DET_DL3: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_DL3.Table_Det5_dBm,sizeof(DET_TABLEDL_st)/ 2);
+            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;
             break;
-        case Bluecell_Table_DET_UL3: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_UL3.Table_Det_15_dBm,sizeof(DET_TABLEUL_st)/ 2);
-            data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3;
-            break;
         case Bluecell_Table_DET_DL4: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_DL4.Table_Det5_dBm,sizeof(DET_TABLEDL_st)/ 2);
+            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;
             break;
+        case Bluecell_Table_DET_UL1: 
+            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;
+            break;
+        case Bluecell_Table_DET_UL2: 
+            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;
+        
+            break;
+        case Bluecell_Table_DET_UL3: 
+            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;
+            break;
         case Bluecell_Table_DET_UL4: 
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Det_UL4.Table_Det_15_dBm,sizeof(DET_TABLEUL_st)/ 2);
+            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;
 
             break;
         case Bluecell_Table_TEMP_DL1:
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_DL1.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
+            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
+            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
             data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
 
             break;
-        case Bluecell_Table_TEMP_UL1:
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_UL1.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
+        case Bluecell_Table_TEMP_DL2:
+            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL1_TABLE_ADDRESDS),&Temp_DL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
+            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
             data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
 
             break;
-        case Bluecell_Table_TEMP_DL2:
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_DL2.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
+        case Bluecell_Table_TEMP_DL3:
+            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&Temp_DL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
+            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
             data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
 
             break;
-        case Bluecell_Table_TEMP_UL2:
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_UL2.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
-            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
+        case Bluecell_Table_TEMP_DL4:
+            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL3_TABLE_ADDRESDS),&Temp_DL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
+            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
+        data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
 
+        break;
+        case Bluecell_Table_TEMP_UL1:
+            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
+            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
+            data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
+        
             break;
-        case Bluecell_Table_TEMP_DL3:
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_DL3.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
+        case Bluecell_Table_TEMP_UL2:
+            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
+            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
             data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
-
+        
             break;
         case Bluecell_Table_TEMP_UL3:
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_UL3.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
+            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL2_TABLE_ADDRESDS),&Temp_UL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
+            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
             data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
-
+        
             break;
-        case Bluecell_Table_TEMP_DL4:
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_DL4.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
-        data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
-
-        break;
         case Bluecell_Table_TEMP_UL4:
-            Bluecell_Struct2byteCopyFunction(&data[BLUECELL_DATA + 1],&Temp_UL4.Table_10_Temp,sizeof(TEMP_TABLE_st)/ 2);
+            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL3_TABLE_ADDRESDS),&Temp_UL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );   
+            Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st));
             data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3;
 
             break;
@@ -479,126 +563,116 @@ void Bluecell_TableSave(uint8_t* data){
     //printf("%s : %x \r\n",__func__,tabletype);
     switch(tabletype){
         case Bluecell_Table_ATT_DL1: 
-            Bluecell_StructCopyFunction(&Att_DL1.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);
-//            printf("%x\r\n",Att_DL1.Table_0_0_dBm);   
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_BASE,1),&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-//            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_BASE,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-//            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_BASE,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-//            EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_ATT_BASE,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
-//         
-//            EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
-//            printf("%x\r\n",Att_DL1.Table_0_0_dBm);        
-//            EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
-        break;
+            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));
+//            printf("ADDRESS : %d \r\n",EEPROM_WINDOW_STATUS_ADDRESDS );
+//            Bluecell_structprintf(&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st));
+            break;
+            
         case Bluecell_Table_ATT_DL2: 
-            Bluecell_StructCopyFunction(&Att_DL2.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_DL1_TABLE_ADDRESDS,1),&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st));
+            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) );
+//            printf("ADDRESS : %d \r\n",EEPROM_ATT_DL1_TABLE_ADDRESDS );
+
             break;
+            
         case Bluecell_Table_ATT_DL3: 
-            Bluecell_StructCopyFunction(&Att_DL3.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_DL2_TABLE_ADDRESDS,1),&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));
+            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));
             break;
+            
         case Bluecell_Table_ATT_DL4: 
-            Bluecell_StructCopyFunction(&Att_DL4.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_DL3_TABLE_ADDRESDS,1),&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));
+            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));
             break;
 
             
         case Bluecell_Table_ATT_UL1: 
-            Bluecell_StructCopyFunction(&Att_UL1.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_DL4_TABLE_ADDRESDS,1),&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
+            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));
             break;
         case Bluecell_Table_ATT_UL2: 
-            Bluecell_StructCopyFunction(&Att_UL2.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_UL1_TABLE_ADDRESDS,1),&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st));
+            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));
             break;
         case Bluecell_Table_ATT_UL3: 
-            Bluecell_StructCopyFunction(&Att_UL3.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_UL2_TABLE_ADDRESDS,1),&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));
+            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));
             break;
         case Bluecell_Table_ATT_UL4: 
-            Bluecell_StructCopyFunction(&Att_UL4.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st) / 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_UL3_TABLE_ADDRESDS,1),&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));
+            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));
             break;
         case Bluecell_Table_DET_DL1: 
-
-
-
-        
-            Bluecell_StructCopyFunction(&Det_DL1.Table_Det5_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_UL4_TABLE_ADDRESDS,1),&Det_DL1.Table_Det5_dBm,sizeof(DET_TABLEDL_st));
+            Bluecell_DataCopy(&Det_DL1.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL4_TABLE_ADDRESDS),&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
             break;
         case Bluecell_Table_DET_DL2: 
-            Bluecell_StructCopyFunction(&Det_DL2.Table_Det5_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_DL1_TABLE_ADDRESDS,1),&Det_DL2.Table_Det5_dBm,sizeof(DET_TABLEDL_st));
+            
+            Bluecell_DataCopy(&Det_DL2.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL1_TABLE_ADDRESDS),&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
             break;
         case Bluecell_Table_DET_DL3: 
-            Bluecell_StructCopyFunction(&Det_DL3.Table_Det5_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_DL2_TABLE_ADDRESDS,1),&Det_DL3.Table_Det5_dBm,sizeof(DET_TABLEDL_st));
+            Bluecell_DataCopy(&Det_DL3.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL2_TABLE_ADDRESDS),&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
         case Bluecell_Table_DET_DL4: 
-            Bluecell_StructCopyFunction(&Det_DL4.Table_Det5_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_DL3_TABLE_ADDRESDS,1),&Det_DL4.Table_Det5_dBm,sizeof(DET_TABLEDL_st));
+            Bluecell_DataCopy(&Det_DL4.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL3_TABLE_ADDRESDS),&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));
             break;
-
-
-
             
         case Bluecell_Table_DET_UL1: 
-            Bluecell_StructCopyFunction(&Det_UL1.Table_Det_15_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_DL4_TABLE_ADDRESDS,1),&Det_UL1.Table_Det_15_dBm,sizeof(DET_TABLEUL_st));            
+            Bluecell_DataCopy(&Det_UL1.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL4_TABLE_ADDRESDS),&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));            
             break;
         case Bluecell_Table_DET_UL2: 
-            Bluecell_StructCopyFunction(&Det_UL2.Table_Det_15_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_UL1_TABLE_ADDRESDS,1),&Det_UL2.Table_Det_15_dBm,sizeof(DET_TABLEUL_st));            
+            Bluecell_DataCopy(&Det_UL2.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL1_TABLE_ADDRESDS),&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));            
         break;
-    case Bluecell_Table_DET_UL3: 
-            Bluecell_StructCopyFunction(&Det_UL3.Table_Det_15_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_UL2_TABLE_ADDRESDS,1),&Det_UL3.Table_Det_15_dBm,sizeof(DET_TABLEUL_st));            
+        case Bluecell_Table_DET_UL3: 
+            Bluecell_DataCopy(&Det_UL3.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL2_TABLE_ADDRESDS),&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));            
             break;
         case Bluecell_Table_DET_UL4: 
-            Bluecell_StructCopyFunction(&Det_UL4.Table_Det_15_dBm,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_UL3_TABLE_ADDRESDS,1),&Det_UL4.Table_Det_15_dBm,sizeof(DET_TABLEUL_st));            
-
+            Bluecell_DataCopy(&Det_UL4.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL3_TABLE_ADDRESDS),&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));            
             break;
-
-
-
-            
         case Bluecell_Table_TEMP_DL1:
-            Bluecell_StructCopyFunction(&Temp_DL1.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_DET_UL4_TABLE_ADDRESDS,1),&Temp_DL1.Table_10_Temp,sizeof(TEMP_TABLE_st));                    
+            Bluecell_DataCopy(&Temp_DL1.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                    
             break;
         case Bluecell_Table_TEMP_DL2:
-            Bluecell_StructCopyFunction(&Temp_DL2.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_DL1_TABLE_ADDRESDS,1),&Temp_DL2.Table_10_Temp,sizeof(TEMP_TABLE_st));                    
+            Bluecell_DataCopy(&Temp_DL2.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL1_TABLE_ADDRESDS),&Temp_DL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                    
+
 
             break;
         case Bluecell_Table_TEMP_DL3:
-            Bluecell_StructCopyFunction(&Temp_DL3.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_DL2_TABLE_ADDRESDS,1),&Temp_DL3.Table_10_Temp,sizeof(TEMP_TABLE_st));                    
-
+            Bluecell_DataCopy(&Temp_DL3.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&Temp_DL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                    
+            
             break;
         case Bluecell_Table_TEMP_DL4:
-            Bluecell_StructCopyFunction(&Temp_DL4.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_DL3_TABLE_ADDRESDS,1),&Temp_DL4.Table_10_Temp,sizeof(TEMP_TABLE_st));                    
-
+            Bluecell_DataCopy(&Temp_DL4.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL3_TABLE_ADDRESDS),&Temp_DL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                    
             break;
         case Bluecell_Table_TEMP_UL1:
-            Bluecell_StructCopyFunction(&Temp_UL1.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_DL4_TABLE_ADDRESDS,1),&Temp_UL1.Table_10_Temp,sizeof(TEMP_TABLE_st));                            
+            Bluecell_DataCopy(&Temp_UL1.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                            
+            EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                                    
+            Bluecell_structprintf(&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st));        
             break;
         case Bluecell_Table_TEMP_UL2:
-            Bluecell_StructCopyFunction(&Temp_UL2.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_UL1_TABLE_ADDRESDS,1),&Temp_UL2.Table_10_Temp,sizeof(TEMP_TABLE_st));                            
+            Bluecell_DataCopy(&Temp_UL2.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                            
             break;
         case Bluecell_Table_TEMP_UL3:
-            Bluecell_StructCopyFunction(&Temp_UL3.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_UL2_TABLE_ADDRESDS,1),&Temp_UL3.Table_10_Temp,sizeof(TEMP_TABLE_st));                            
+            Bluecell_DataCopy(&Temp_UL3.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL2_TABLE_ADDRESDS),&Temp_UL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                            
             break;
         case Bluecell_Table_TEMP_UL4:
-            Bluecell_StructCopyFunction(&Temp_UL4.Table_10_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)/ 2);    
-            EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_UL3_TABLE_ADDRESDS,1),&Temp_UL4.Table_10_Temp,sizeof(TEMP_TABLE_st));                                
+            Bluecell_DataCopy(&Temp_UL4.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
+            EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL3_TABLE_ADDRESDS),&Temp_UL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st));                                
             break;
     }
         
@@ -868,7 +942,7 @@ bool Bluecell_Operate(uint8_t* data){
         DataStatusSet();
         Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
         Txdata[Txdata[BLUECELL_LENGTH] + 1] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]);
-#if 1 // PYJ.2020.04.22_BEGIN -- 
+#if 0 // PYJ.2020.04.22_BEGIN -- 
         for(int i = 0 ; i < Txdata[BLUECELL_LENGTH] + 3; i++ ){
             printf("%x ",Txdata[i]);
         }
@@ -878,8 +952,8 @@ bool Bluecell_Operate(uint8_t* data){
         break;
     case Bluecell_StatusSave:
 //        printf("Copy Complete");
-        EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_TEMP_UL4_TABLE_ADDRESDS,1),&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
-        Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
+        EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL4_TABLE_ADDRESDS),&DataWrite[0],sizeof(BLUESTATUS_st));
+        Bluecell_StructCpy(&Txdata[0],&DataWrite[0],sizeof(BLUESTATUS_st));
         Txdata[Txdata[BLUECELL_LENGTH] + 1] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]);
         Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st));        
         break;
@@ -1051,75 +1125,113 @@ bool MBIC_Operate(uint8_t* data){
 
 extern volatile uint32_t ADC1_Average_value[4];
 extern volatile uint32_t ADC3_Average_value[5];
+uint16_t ADC1Ret[4];
+uint16_t ADC3Ret[5];
 
 void ADC_Check(void){
     static uint8_t Cnt = 0;
     double Volt_Calc_val = 3.3 / 4095;
-    uint16_t ret = 0;
+    double ret = 0;
 //    if(AdcTimerCnt > 10){
     
-    if(adc3cnt > 100){
-        for(int i = 0; i < 6; i++){
-            ADC3value[i] = ADC3_Average_value[i] / adc3cnt;
+    if(adc3cnt >= 100){
+        for(int i = 0; i < 5; i++){
+            ADC3Ret[i] = ADC3_Average_value[i] / adc3cnt;
+            ADC3_Average_value[i] = 0;
+//            printf("ADC3value[%d] : %d        UL4 : %f\r\n",i,ADC3value[i],ret * Volt_Calc_val);
+            
         }
         adc3cnt = 0;
         bluecell_Currdatastatus.DET_DL1_IN_H 
-            = (uint16_t)((ADC3value[1] & 0xFF00) >> 8);
+            = ((ADC3Ret[1] & 0xFF00) >> 8);
         bluecell_Currdatastatus.DET_DL1_IN_L 
-            = (uint16_t)((ADC3value[1] & 0x00FF));
+            = ((ADC3Ret[1] & 0x00FF));
         
 
         bluecell_Currdatastatus.DET_DL2_IN_H 
-            = (uint16_t)((ADC3value[2] & 0xFF00) >> 8);
+            = ((ADC3Ret[2] & 0xFF00) >> 8);
         bluecell_Currdatastatus.DET_DL2_IN_L 
-            = (uint16_t)((ADC3value[2] & 0x00FF) );
+            = ((ADC3Ret[2] & 0x00FF) );
 
             
         bluecell_Currdatastatus.DET_DL3_IN_H 
-            = (uint16_t)((ADC3value[3] & 0xFF00) >> 8);
+            = ((ADC3Ret[3] & 0xFF00) >> 8);
         bluecell_Currdatastatus.DET_DL3_IN_L 
-            = (uint16_t)((ADC3value[3] & 0x00FF) );
+            = ((ADC3Ret[3] & 0x00FF) );
 
             
         bluecell_Currdatastatus.DET_DL4_IN_H 
-            = (uint16_t)((ADC3value[4] & 0xFF00) >> 8);
+            = ((ADC3Ret[4] & 0xFF00) >> 8);
         bluecell_Currdatastatus.DET_DL4_IN_L 
-            = (uint16_t)((ADC3value[4] & 0x00FF) );
+            = ((ADC3Ret[4] & 0x00FF) );
+
+            
         bluecell_Currdatastatus.DET_UL4_IN_H 
-            = (uint16_t)((ADC3value[0] & 0xFF00) >> 8);
+            = ((ADC3Ret[0] & 0xFF00) >> 8);
         bluecell_Currdatastatus.DET_UL4_IN_L 
-            = (uint16_t)((ADC3value[0] & 0x00FF) );
+            = ((ADC3Ret[0] & 0x00FF) );
+
+#if 0 // PYJ.2020.04.26_BEGIN -- 
+        ret = (ADC3Ret[0]) * Volt_Calc_val;
+        printf("ADC3Ret[0] : %d        UL4 : %f\r\n",ADC3Ret[0],ret);
+        ret = (ADC3Ret[1]) * Volt_Calc_val;
+        printf("ADC3Ret[1] : %d        DL1 : %f\r\n",ADC3Ret[1],ret);
+        ret = (ADC3Ret[2]) * Volt_Calc_val;
+        printf("ADC3Ret[2] : %d        DL2 : %f\r\n",ADC3Ret[2],ret);
+        ret = (ADC3Ret[3]) * Volt_Calc_val;
+        printf("ADC3Ret[3] : %d        DL3 : %f\r\n",ADC3Ret[3],ret);
+        ret = (ADC3Ret[4]) * Volt_Calc_val;
+        printf("ADC3Ret[4] : %d        DL4 : %f\r\n",ADC3Ret[4],ret);
+#endif // PYJ.2020.04.26_END -- 
+
+
+
+
+
     }
-    if(adc1cnt > 100){ 
-        for(int i = 0; i < 5; i++){
-            ADC1value[i] = ADC1_Average_value[i] / adc1cnt;
+    if(adc1cnt >= 100){ 
+        for(int i = 0; i < 4; i++){
+            ADC1Ret[i] = ADC1_Average_value[i] / adc1cnt;
+            ADC1_Average_value[i] = 0;
         }
         adc1cnt = 0;
         bluecell_Currdatastatus.DET_UL1_IN_H 
-            = (uint16_t)((ADC1value[0] & 0xFF00) >> 8);
+            = ((ADC1Ret[0] & 0xFF00) >> 8);
         bluecell_Currdatastatus.DET_UL1_IN_L 
-            = (uint16_t)((ADC1value[0] & 0x00FF) );
+            = ((ADC1Ret[0] & 0x00FF) );
 
             
         bluecell_Currdatastatus.DET_UL2_IN_H 
-            = (uint16_t)((ADC1value[1] & 0xFF00) >> 8);
+            = ((ADC1Ret[1] & 0xFF00) >> 8);
         bluecell_Currdatastatus.DET_UL2_IN_L 
-            = (uint16_t)((ADC1value[1] & 0x00FF) );
+            = ((ADC1Ret[1] & 0x00FF) );
 
             
         bluecell_Currdatastatus.DET_UL3_IN_H 
-            = (uint16_t)((ADC1value[2] & 0xFF00) >> 8);
+            = ((ADC1Ret[2] & 0xFF00) >> 8);
         bluecell_Currdatastatus.DET_UL3_IN_L 
-            = (uint16_t)((ADC1value[2] & 0x00FF) );
+            = ((ADC1Ret[2] & 0x00FF) );
 
             
 
             
         bluecell_Currdatastatus.DET_TEMP_H  
-            =(uint16_t)((ADC1value[3] & 0xFF00) >> 8);
+            =((ADC1Ret[3] & 0xFF00) >> 8);
         bluecell_Currdatastatus.DET_TEMP_L  
-            =(uint16_t)((ADC1value[3] & 0x00FF) );
-       
+            =((ADC1Ret[3] & 0x00FF) );
+
+
+#if 0 // PYJ.2020.04.26_BEGIN -- 
+                ret = (ADC1Ret[0]) * Volt_Calc_val;
+                printf("ADC1Ret[0] : %d        UL1 : %f\r\n",ADC1Ret[0],ret);
+                ret = (ADC1Ret[1]) * Volt_Calc_val;
+                printf("ADC1Ret[1] : %d        UL2 : %f\r\n",ADC1Ret[1],ret);
+                ret = (ADC1Ret[2]) * Volt_Calc_val;
+                printf("ADC1Ret[2] : %d        UL3 : %f\r\n",ADC1Ret[2],ret);
+                ret = (ADC1Ret[3]) * Volt_Calc_val;
+                printf("ADC1Ret[3] : %d        TEMP : %f\r\n",ADC1Ret[3],ret);
+#endif // PYJ.2020.04.26_END -- 
+
     }
 #if 0 // PYJ.2020.04.22_BEGIN -- 
     if(Cnt >= 250){

Bluecell_Src/eeprom.c

@@ -8,57 +8,66 @@
 #include "eeprom.h"
 #include "Bluecell_operate.h"
 #include "stm32f1xx_hal.h"
+#include "stm32f1xx_hal_gpio.h"
+
 /* Includes ------------------------------------------------------------------*/   
 HAL_StatusTypeDef EEPROM_M24C08_ByteRead(uint16_t devid,uint16_t Address,uint8_t* data,uint8_t size);
 
 
 
+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_ByteRead(EEPROM_M24C08_ID,EEPROM_ATT_BASE,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
-//    printf("%x\r\n",Att_DL1.Table_0_0_dBm);
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_ATT_DL1_TABLE_ADDRESDS,&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_ATT_DL2_TABLE_ADDRESDS,&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
-    EEPROM_M24C08_ByteRead(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_WINDOW_STATUS_ADDRESDS,&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) );
+//    printf("%x\r\n",Att_DL1.Table_0_0_dBm_H);
+    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_ByteRead(EEPROM_M24C08_ID,EEPROM_ATT_DL4_TABLE_ADDRESDS,&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_ATT_UL1_TABLE_ADDRESDS,&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_ATT_UL2_TABLE_ADDRESDS,&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
-    EEPROM_M24C08_ByteRead(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_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_ByteRead(EEPROM_M24C08_ID,EEPROM_ATT_UL4_TABLE_ADDRESDS,&Det_DL1.Table_Det5_dBm,sizeof(DET_TABLEDL_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_DET_DL1_TABLE_ADDRESDS,&Det_DL2.Table_Det5_dBm,sizeof(DET_TABLEDL_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_DET_DL2_TABLE_ADDRESDS,&Det_DL3.Table_Det5_dBm,sizeof(DET_TABLEDL_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_DET_DL3_TABLE_ADDRESDS,&Det_DL4.Table_Det5_dBm,sizeof(DET_TABLEDL_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) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_DL2_TABLE_ADDRESDS,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_DL3_TABLE_ADDRESDS,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
 
 
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_DET_DL4_TABLE_ADDRESDS,&Det_UL1.Table_Det_15_dBm,sizeof(DET_TABLEUL_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_DET_UL1_TABLE_ADDRESDS,&Det_UL2.Table_Det_15_dBm,sizeof(DET_TABLEUL_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_DET_UL2_TABLE_ADDRESDS,&Det_UL3.Table_Det_15_dBm,sizeof(DET_TABLEUL_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_DET_UL3_TABLE_ADDRESDS,&Det_UL4.Table_Det_15_dBm,sizeof(DET_TABLEUL_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_DL4_TABLE_ADDRESDS,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL1_TABLE_ADDRESDS,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL2_TABLE_ADDRESDS,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL3_TABLE_ADDRESDS,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
 
 
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_DET_UL4_TABLE_ADDRESDS,&Temp_DL1.Table_10_Temp,sizeof(TEMP_TABLE_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_TEMP_DL1_TABLE_ADDRESDS,&Temp_DL2.Table_10_Temp,sizeof(TEMP_TABLE_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_TEMP_DL2_TABLE_ADDRESDS,&Temp_DL3.Table_10_Temp,sizeof(TEMP_TABLE_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_TEMP_DL3_TABLE_ADDRESDS,&Temp_DL4.Table_10_Temp,sizeof(TEMP_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL4_TABLE_ADDRESDS,&Temp_DL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL1_TABLE_ADDRESDS,&Temp_DL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL2_TABLE_ADDRESDS,&Temp_DL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL3_TABLE_ADDRESDS,&Temp_DL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
 
 
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_TEMP_DL4_TABLE_ADDRESDS,&Temp_UL1.Table_10_Temp,sizeof(TEMP_TABLE_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_TEMP_UL1_TABLE_ADDRESDS,&Temp_UL2.Table_10_Temp,sizeof(TEMP_TABLE_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_TEMP_UL2_TABLE_ADDRESDS,&Temp_UL3.Table_10_Temp,sizeof(TEMP_TABLE_st) );
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_TEMP_UL3_TABLE_ADDRESDS,&Temp_UL4.Table_10_Temp,sizeof(TEMP_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL4_TABLE_ADDRESDS,&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL1_TABLE_ADDRESDS,&Temp_UL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL2_TABLE_ADDRESDS,&Temp_UL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL3_TABLE_ADDRESDS,&Temp_UL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st) );
 
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_TEMP_UL4_TABLE_ADDRESDS,&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st) );
-    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);        
-    
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL4_TABLE_ADDRESDS,&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st) );
+//    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("EEPROM INIT COMPLETE\r\n");
 
 }
@@ -93,62 +102,77 @@ void eepromtest(){
 }
 #endif // PYJ.2020.04.23_END -- 
 
+#define MAXEEPROM_LENG 32
 
-
-HAL_StatusTypeDef EEPROM_M24C08_Read(uint16_t devid,uint16_t Address,uint16_t* data,uint8_t size){
+HAL_StatusTypeDef EEPROM_M24C08_Read(uint8_t devid,uint16_t Address,uint8_t* data,uint16_t size){
    HAL_StatusTypeDef ret = HAL_ERROR;
-#if 0 // PYJ.2020.04.23_BEGIN -- 
-   for(uint16_t i = 0; i < size / 2; i++){
-//       ret = HAL_I2C_Mem_Read(&hi2c2, devid,(Address + (i * 2)), I2C_MEMADD_SIZE_16BIT, &data[i], 2, 512);
+   uint16_t sizecnt = 0,sizeremain = 0; 
+   uint16_t addrees_inc = 0;
+//   ret = HAL_I2C_Mem_Read(&hi2c2, devid | ((Address & 0x0300) >> 7),((Address )),  I2C_MEMADD_SIZE_8BIT, &data[0], size, 1024);
+
+   ret = HAL_I2C_Mem_Read(&hi2c2, devid ,((Address )),  I2C_MEMADD_SIZE_16BIT, &data[0], size, 1024);
+//      EEPROM24XX_Load( Address,data, size);
 
-//       printf("READdata[%d] : %x \r\n",i,data[i]);
-       if(ret == HAL_ERROR){
-         printf("Read ERR\r\n");
-       }
-     HAL_Delay(10);
-#else
-//      ret = HAL_I2C_Mem_Read(&hi2c2, devid,Address, I2C_MEMADD_SIZE_16BIT, data, size, 512);
-////       printf("READdata[%d] : %x \r\n",i,data[i]);
-//      if(ret == HAL_ERROR){
-//        printf("Read ERR\r\n");
-//      }
-//    HAL_Delay(10);
-    ret = HAL_I2C_Mem_Read(&hi2c2, devid, Address, I2C_MEMADD_SIZE_16BIT, data, size, 512);
       if(ret == HAL_ERROR)
             printf("Write ERR\r\n");
-
-    HAL_Delay(10);
-     return ret; 
-
-
-#endif // PYJ.2020.04.23_END -- 
+        else
+        HAL_Delay(20);
 
     return ret;   
 }
-HAL_StatusTypeDef EEPROM_M24C08_write(uint16_t devid,uint16_t Address,uint16_t* data,uint8_t size){
+HAL_StatusTypeDef EEPROM_M24C08_write(uint8_t devid,uint16_t Address,uint8_t* data,uint16_t size){
     HAL_StatusTypeDef ret = HAL_ERROR;
-#if 0 // PYJ.2020.04.23_BEGIN -- 
-    for(int i = 0; i < size / 2; i++){
-        ret = HAL_I2C_Mem_Write(&hi2c2, devid,(Address + (i * 2)),  I2C_MEMADD_SIZE_16BIT, &data[i], 2, 512);
-        if(ret == HAL_ERROR)
-            printf("Write ERR\r\n");
-//        printf("Writedata[%d] : %x \r\n",i,data[i]);
-        HAL_Delay(10);
-    }
+    uint8_t sizecnt = 0,sizeremain = 0; 
+    uint16_t addrees_inc = 0;
+    sizecnt = size /MAXEEPROM_LENG;
+    sizeremain = size % MAXEEPROM_LENG;
+    addrees_inc = 0;
+#if 0 // PYJ.2020.04.25_BEGIN -- 
+       for(int i = 0 ; i <sizecnt; i++ ){
+            addrees_inc = i * 16;
+            ret = HAL_I2C_Mem_Write(&hi2c2, devid | (((Address  + addrees_inc) & 0x0300) >> 7),((Address + addrees_inc)) ,  I2C_MEMADD_SIZE_8BIT, &data[addrees_inc], 16, 1024);
+            if(ret == HAL_ERROR)
+                printf("Write ERR\r\n");
+            else
+                HAL_Delay(20);
+       }
+       addrees_inc += 16;
+           ret = HAL_I2C_Mem_Write(&hi2c2, devid | (((Address  + addrees_inc) & 0x0300) >> 7),((Address + addrees_inc)) ,  I2C_MEMADD_SIZE_8BIT, &data[addrees_inc], sizeremain, 1024);
+            //       EEPROM24XX_Save( Address,data, size);
+            if(ret == HAL_ERROR)
+                printf("Write ERR\r\n");
+            else
+                HAL_Delay(20);
 #else
-//    ret = HAL_I2C_Mem_Write(&hi2c2, devid,Address,  I2C_MEMADD_SIZE_16BIT, data, size, 1024);
-//    if(ret == HAL_ERROR)
-//        printf("Write ERR\r\n");
-////        printf("Writedata[%d] : %x \r\n",i,data[i]);
-//    HAL_Delay(10);
-     ret = HAL_I2C_Mem_Write(&hi2c2, devid, Address,  I2C_MEMADD_SIZE_16BIT, data, size, 512);
-       if(ret == HAL_ERROR)
-             printf("Write ERR\r\n");
-
-     HAL_Delay(10);
+//    printf("size : %d sizecnt = %d sizeremain : %d\r\n",size,sizecnt,sizeremain);
+    if(sizecnt > 0){
+        for(int i = 0 ; i < sizecnt; i++ ){
+             addrees_inc = i * MAXEEPROM_LENG;
+             ret = HAL_I2C_Mem_Write(&hi2c2, devid  ,((Address + addrees_inc) & 0xFFFF) ,  I2C_MEMADD_SIZE_16BIT, &data[addrees_inc], MAXEEPROM_LENG, 1024);
+
+             if(ret == HAL_ERROR)
+                 printf("Write ERR\r\n");
+             else
+                 HAL_Delay(20);
+        }
+        addrees_inc += MAXEEPROM_LENG;
+    }
 
+//    printf("Remain Data Index : %d \r\n",sizeremain);
+    
+    if(sizeremain > 0){
+         printf("Remain Data Write Start ");
+        for(int i = 0; i < sizeremain; i++){
+            ret = HAL_I2C_Mem_Write(&hi2c2, devid  ,((Address + addrees_inc + i)& 0xFFFF) ,  I2C_MEMADD_SIZE_16BIT, &data[addrees_inc + i], 1, 1024);
+         //       EEPROM24XX_Save( Address,data, size);
+         if(ret == HAL_ERROR)
+             printf("Write ERR\r\n");
+         else
+             HAL_Delay(20);
+        }
+    }
 
-#endif // PYJ.2020.04.23_END -- 
+#endif // PYJ.2020.04.25_END -- 
     return ret;
 }
 
@@ -158,37 +182,316 @@ HAL_StatusTypeDef EEPROM_M24C08_write(uint16_t devid,uint16_t Address,uint16_t*
 
 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");
+            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);
-        HAL_Delay(7);
     }
+#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
+	{
+	}
+}
+//##########################################################################
+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;  
+}
 
+ 
 
+  
 
 
 

Inc/stm32f1xx_it.h

@@ -61,8 +61,6 @@ void DMA1_Channel4_IRQHandler(void);
 void DMA1_Channel5_IRQHandler(void);
 void ADC1_2_IRQHandler(void);
 void TIM2_IRQHandler(void);
-void I2C2_EV_IRQHandler(void);
-void I2C2_ER_IRQHandler(void);
 void USART1_IRQHandler(void);
 void USART2_IRQHandler(void);
 void ADC3_IRQHandler(void);

STM32F103ZET_JDASMBIC.ioc

@@ -170,8 +170,6 @@ NVIC.DMA2_Channel4_5_IRQn=true\:0\:0\:false\:true\:true\:8\:false\:true
 NVIC.DebugMonitor_IRQn=true\:0\:0\:false\:false\:true\:false\:false
 NVIC.ForceEnableDMAVector=true
 NVIC.HardFault_IRQn=true\:0\:0\:false\:false\:true\:false\:false
-NVIC.I2C2_ER_IRQn=true\:0\:0\:false\:true\:true\:5\:true\:true
-NVIC.I2C2_EV_IRQn=true\:0\:0\:false\:true\:true\:4\:true\:true
 NVIC.MemoryManagement_IRQn=true\:0\:0\:false\:false\:true\:false\:false
 NVIC.NonMaskableInt_IRQn=true\:0\:0\:false\:false\:true\:false\:false
 NVIC.PendSV_IRQn=true\:0\:0\:false\:false\:true\:false\:false
@@ -425,7 +423,7 @@ ProjectManager.StackSize=0x400
 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_I2C2_Init-I2C2-false-HAL-true,5-MX_USART1_UART_Init-USART1-false-HAL-true,6-MX_ADC1_Init-ADC1-false-HAL-true,7-MX_ADC3_Init-ADC3-false-HAL-true,8-MX_USART2_UART_Init-USART2-false-HAL-true,9-MX_TIM6_Init-TIM6-false-HAL-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_CRC_Init-CRC-false-HAL-true
 RCC.ADCFreqValue=14000000
 RCC.ADCPresc=RCC_ADCPCLK2_DIV4
 RCC.AHBFreq_Value=56000000

Src/main.c

@@ -77,13 +77,13 @@ volatile uint32_t LDTimerCnt = 0;
 void SystemClock_Config(void);
 static void MX_GPIO_Init(void);
 static void MX_DMA_Init(void);
-static void MX_I2C2_Init(void);
 static void MX_USART1_UART_Init(void);
 static void MX_ADC1_Init(void);
 static void MX_ADC3_Init(void);
 static void MX_USART2_UART_Init(void);
 static void MX_TIM6_Init(void);
 static void MX_CRC_Init(void);
+static void MX_I2C2_Init(void);
 static void MX_NVIC_Init(void);
 /* USER CODE BEGIN PFP */
 
@@ -113,24 +113,76 @@ uint8_t adc3cnt = 0 ;
 void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
 {
 //?��?��?�� 코드 ?��?��
-//만약 ?��?�� adc?���?? �???��?�� ?�� ?��?���?? ?��?���?? ?��?��?? 같이 조건�?? ?��?��
+//諤嵸烄 ?嚙踝蕭?嚙踝蕭 adc?嚙踝蕭嚙??? 嚙????嚙踝蕭?嚙踝蕭 ?嚙踝蕭 ?嚙踝蕭?嚙踝蕭嚙??? ?嚙踝蕭?嚙踝蕭嚙??? ?嚙踝蕭?嚙踝蕭?? 穈軤𦚯 魽國探嚙??? ?嚙踝蕭?嚙踝蕭
 
     if(hadc->Instance == hadc1.Instance)
     {
-        for(int i = 0; i < 5; i++){
-            ADC1_Average_value[i] += ADC1value[i]  ;
+        if(adc1cnt < 100){
+            for(int i = 0; i < 4; i++){
+                ADC1_Average_value[i] += ADC1value[i]  ;
+            }
+            adc1cnt++;
         }
-        adc1cnt++;
     }
     if(hadc->Instance == hadc3.Instance)
     {
-        for(int i = 0; i < 6; i++){
-            ADC3_Average_value[i] += ADC3value[i]  ;
+        if(adc3cnt < 100){
+            for(int i = 0; i < 5; i++){
+                ADC3_Average_value[i] += ADC3value[i]  ;
+            }
+            adc3cnt++;
         }
-        adc3cnt++;
     }
 
 }
+#if 0 // PYJ.2020.04.24_BEGIN -- 
+void HAL_I2C_MspInit(I2C_HandleTypeDef* i2cHandle)
+{
+
+  GPIO_InitTypeDef GPIO_InitStruct;
+  if(i2cHandle->Instance==I2C1)
+  {
+  /* USER CODE BEGIN I2C1_MspInit 0 */
+	__HAL_RCC_I2C1_CLK_ENABLE();
+  /* USER CODE END I2C1_MspInit 0 */
+  
+    /**I2C1 GPIO Configuration    
+    PB6     ------> I2C1_SCL
+    PB7     ------> I2C1_SDA 
+    */
+    GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+    /* Peripheral clock enable */
+    __HAL_RCC_I2C1_CLK_ENABLE();
+  /* USER CODE BEGIN I2C1_MspInit 1 */
+
+  /* USER CODE END I2C1_MspInit 1 */
+  }
+  else if(i2cHandle->Instance==I2C2)
+  {
+  /* USER CODE BEGIN I2C2_MspInit 0 */
+	__HAL_RCC_I2C2_CLK_ENABLE();
+  /* USER CODE END I2C2_MspInit 0 */
+  
+    /**I2C2 GPIO Configuration    
+    PB10     ------> I2C2_SCL
+    PB11     ------> I2C2_SDA 
+    */
+    GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+    /* Peripheral clock enable */
+    __HAL_RCC_I2C2_CLK_ENABLE();
+  /* USER CODE BEGIN I2C2_MspInit 1 */
+
+  /* USER CODE END I2C2_MspInit 1 */
+  }
+#endif // PYJ.2020.04.24_END -- 
 
 #if 0 // PYJ.2020.04.23_BEGIN -- 
 uint8_t eepdata[100];
@@ -153,52 +205,71 @@ void eepromtest(){
 uint8_t i2ctest[10] = {22,};
 uint8_t i2cTestData[1] = {44};
 #endif // PYJ.2020.04.23_END -- 
-uint16_t eepromtestarray[1024];
-uint16_t eepromtestReadarray[1024];
+uint8_t eepromtestarray[1024 * 3];
+uint8_t eepromtestReadarray[1024 * 3];
 uint8_t eepromtestarray1[EEPROM_WINDOW_STATUS_ADDRESDS];
 uint8_t eepromtestReadarray1[EEPROM_WINDOW_STATUS_ADDRESDS];
-
+#define TESTINDEX  sizeof(TEMP_TABLE_st) 
 void EEPROMTEST_J(){
-    int aa = 256;
-    for(int i = 0; i< 512; i++)
-        eepromtestarray[i] = i;
-    EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID,MAKE_ADDRESS(EEPROM_ATT_BASE     ,1),&eepromtestarray[0],0xFF);
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,MAKE_ADDRESS(EEPROM_ATT_BASE      ,1),&eepromtestReadarray[0],0xFF);
-//    EEPROM_M24C08_ByteRead(0xa0|0x01 ),MAKE_ADDRESS(EEPROM_ATT_BASE + 150,0),&eepromtestReadarray[150],150);
-    for(int i = 0; i< 128; i++)
-        printf("index [%d]: %d \r\n",i,eepromtestReadarray[i]);
-    EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID,MAKE_ADDRESS(EEPROM_ATT_BASE + aa    ,1),&eepromtestarray[128],0xFF);
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,MAKE_ADDRESS(EEPROM_ATT_BASE  + aa       ,1),&eepromtestReadarray[128],0xFF);
-    for(int i = 128; i< 256; i++)
-        printf("index [%d]: %d \r\n",i,eepromtestReadarray[i]);
-    EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID,MAKE_ADDRESS(EEPROM_ATT_BASE + aa * 2    ,1),&eepromtestarray[256],0xFF);
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,MAKE_ADDRESS(EEPROM_ATT_BASE  + aa * 2       ,1),&eepromtestReadarray[256],0xFF);
-    for(int i = 256; i< 384; i++)
-        printf("index [%d]: %d \r\n",i,eepromtestReadarray[i]);
-#if 0 // PYJ.2020.04.23_BEGIN -- 
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_DL2_TABLE_ADDRESDS,0),&eepromtestReadarray[0],EEPROM_WINDOW_STATUS_ADDRESDS);
-    for(int i = 0; i< EEPROM_WINDOW_STATUS_ADDRESDS; i++)
-        printf("%d ",eepromtestReadarray[i]);
-       printf("\r\n");    
-    EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID ,MAKE_ADDRESS(EEPROM_ATT_DL3_TABLE_ADDRESDS,0),&eepromtestReadarray[0],EEPROM_WINDOW_STATUS_ADDRESDS);
-    for(int i = 0; i< EEPROM_WINDOW_STATUS_ADDRESDS; i++)
-        printf("%d ",eepromtestReadarray[i]);
-           printf("\r\n");
-#endif // PYJ.2020.04.23_END -- 
+#if 1 // PYJ.2020.04.25_BEGIN -- 
+      for(int i = 0; i< TESTINDEX; i++)
+          eepromtestarray[i] = i;
+      printf("Value %x\r\n",eepromtestarray[1]);
+    
+//        EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&eepromtestarray[0],TESTINDEX);   
+          EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&eepromtestarray[0],sizeof(TEMP_TABLE_st));                            
+          EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&eepromtestReadarray[0],sizeof(TEMP_TABLE_st));                                    
+
+//        EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&eepromtestReadarray[0],TESTINDEX);   
+    
+        for(int i = 0; i< TESTINDEX; i++)
+            printf("%d ",eepromtestReadarray[i]);
+               printf("\r\n");
+#endif // PYJ.2020.04.25_END -- 
+
 
 }
 #if 1 // PYJ.2020.04.23_BEGIN -- 
 void eepromtest_j1(){
-  for(int i = 0; i< 128; i++)
+uint8_t ret  = 0;
+  for(int i = 0; i < 128; i++)
       eepromtestarray[i] = i;
-
-  EEPROM_M24C08_write(EEPROM_M24C08_ID ,0,eepromtestarray,128);
-
-  EEPROM_M24C08_Read(EEPROM_M24C08_ID ,0,eepromtestReadarray,128);
-  
-   for(int i = 0; i< 128; i++)
-       printf("%d ",eepromtestReadarray[i]);
-          printf("\r\n");
+  printf("Value %x\r\n",eepromtestarray[1]);
+  printf("Address Start %x\r\n",EEPROM_WINDOW_STATUS_ADDRESDS);
+
+#if 0 // PYJ.2020.04.25_BEGIN -- 
+  EEPROM_M24C08_write(EEPROM_M24C08_ID ,
+                      (EEPROM_ATT_BASE),
+                      &eepromtestarray[0],
+                      TESTINDEX);
+
+                      
+//  EEPROM_M24C08_write(EEPROM_M24C08_ID ,
+//                     (EEPROM_ATT_DL1_TABLE_ADDRESDS),
+//                     &eepromtestarray[sizeof(ATT_TABLE_st)],
+//                      sizeof(ATT_TABLE_st));
+
+   EEPROM_M24C08_Read(EEPROM_M24C08_ID ,
+                      EEPROM_ATT_BASE             ,
+                      &eepromtestReadarray[0],
+                      TESTINDEX);
+#endif // PYJ.2020.04.25_END -- 
+//    EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&eepromtestarray[0],sizeof(TEMP_TABLE_st));                    
+    //    EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&eepromtestReadarray[0],sizeof(TEMP_TABLE_st) );           
+#if 0 // PYJ.2020.04.25_BEGIN -- 
+    EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS),&eepromtestarray[0],sizeof(ATT_TABLE_st) );
+
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS),&eepromtestReadarray[0],sizeof(ATT_TABLE_st) );
+#else
+    EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS & 0xFFFF),eepromtestarray,128 );
+
+    EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS & 0xFFFF),eepromtestReadarray,128 );
+
+#endif // PYJ.2020.04.25_END -- 
+
+    for(int i = 0; i< 128 ; i++)
+        printf("%x ",eepromtestReadarray[i]);
+           printf("\r\n");
 
 }
 #endif // PYJ.2020.04.23_END -- 
@@ -250,13 +321,13 @@ int main(void)
   /* Initialize all configured peripherals */
   MX_GPIO_Init();
   MX_DMA_Init();
-  MX_I2C2_Init();
   MX_USART1_UART_Init();
   MX_ADC1_Init();
   MX_ADC3_Init();
   MX_USART2_UART_Init();
   MX_TIM6_Init();
   MX_CRC_Init();
+  MX_I2C2_Init();
 
   /* Initialize interrupts */
   MX_NVIC_Init();
@@ -265,13 +336,11 @@ int main(void)
   while(!(HAL_ADCEx_Calibration_Start(&hadc1)==HAL_OK));
   HAL_ADC_Start_DMA(&hadc3, (uint16_t*)ADC3value, 5);
   HAL_ADC_Start_DMA(&hadc1, (uint16_t*)ADC1value, 4);
-
   InitUartQueue(&TerminalQueue);
   setbuf(stdout, NULL);
   PE43711_PinInit();
-//  EEPROM_M24C08_Init();
-//  Bluecell_DataInit();
-
+  EEPROM_M24C08_Init();
+  Bluecell_DataInit();
 #if 0 // PYJ.2020.04.22_BEGIN -- 
   EEPROM_M24C08_write(0xA0,0,i2cTestData,1);
   printf("i2c Test Data1 %d\r\n",i2ctest[0]);
@@ -283,14 +352,17 @@ int main(void)
 
   /* Infinite loop */
   /* USER CODE BEGIN WHILE */
-    uint16_t ret = 0;
-
+//    uint16_t ret = 0;
 //    EEPROMTEST_J();
+//    eepromtest_j1();
+//        eepromtest_j1();
+
+
     
     
 
 
-    printf("Project Start\r\n");
+  printf("Project Start\r\n");
   while (1)
   {
 //	  HAL_GPIO_TogglePin(GPIOG,GPIO_PIN_14);
@@ -362,12 +434,6 @@ static void MX_NVIC_Init(void)
   /* DMA1_Channel5_IRQn interrupt configuration */
   HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 0, 0);
   HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
-  /* I2C2_EV_IRQn interrupt configuration */
-  HAL_NVIC_SetPriority(I2C2_EV_IRQn, 0, 0);
-  HAL_NVIC_EnableIRQ(I2C2_EV_IRQn);
-  /* I2C2_ER_IRQn interrupt configuration */
-  HAL_NVIC_SetPriority(I2C2_ER_IRQn, 0, 0);
-  HAL_NVIC_EnableIRQ(I2C2_ER_IRQn);
   /* USART1_IRQn interrupt configuration */
   HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);
   HAL_NVIC_EnableIRQ(USART1_IRQn);
@@ -575,6 +641,7 @@ static void MX_I2C2_Init(void)
   hi2c2.Instance = I2C2;
   hi2c2.Init.ClockSpeed = 400000;
   hi2c2.Init.DutyCycle = I2C_DUTYCYCLE_2;
+  
   hi2c2.Init.OwnAddress1 = 0;
   hi2c2.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
   hi2c2.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;

Src/stm32f1xx_hal_msp.c

@@ -355,9 +355,6 @@ void HAL_I2C_MspDeInit(I2C_HandleTypeDef* hi2c)
     */
     HAL_GPIO_DeInit(GPIOB, EEPROM_SCL_Pin|EEPROM_SDA_Pin);
 
-    /* I2C2 interrupt DeInit */
-    HAL_NVIC_DisableIRQ(I2C2_EV_IRQn);
-    HAL_NVIC_DisableIRQ(I2C2_ER_IRQn);
   /* USER CODE BEGIN I2C2_MspDeInit 1 */
 
   /* USER CODE END I2C2_MspDeInit 1 */

Src/stm32f1xx_it.c

@@ -60,7 +60,6 @@ extern DMA_HandleTypeDef hdma_adc1;
 extern DMA_HandleTypeDef hdma_adc3;
 extern ADC_HandleTypeDef hadc1;
 extern ADC_HandleTypeDef hadc3;
-extern I2C_HandleTypeDef hi2c2;
 extern TIM_HandleTypeDef htim6;
 extern DMA_HandleTypeDef hdma_usart1_rx;
 extern DMA_HandleTypeDef hdma_usart1_tx;
@@ -278,34 +277,6 @@ void TIM2_IRQHandler(void)
   /* USER CODE END TIM2_IRQn 1 */
 }
 
-/**
-  * @brief This function handles I2C2 event interrupt.
-  */
-void I2C2_EV_IRQHandler(void)
-{
-  /* USER CODE BEGIN I2C2_EV_IRQn 0 */
-
-  /* USER CODE END I2C2_EV_IRQn 0 */
-  HAL_I2C_EV_IRQHandler(&hi2c2);
-  /* USER CODE BEGIN I2C2_EV_IRQn 1 */
-
-  /* USER CODE END I2C2_EV_IRQn 1 */
-}
-
-/**
-  * @brief This function handles I2C2 error interrupt.
-  */
-void I2C2_ER_IRQHandler(void)
-{
-  /* USER CODE BEGIN I2C2_ER_IRQn 0 */
-
-  /* USER CODE END I2C2_ER_IRQn 0 */
-  HAL_I2C_ER_IRQHandler(&hi2c2);
-  /* USER CODE BEGIN I2C2_ER_IRQn 1 */
-
-  /* USER CODE END I2C2_ER_IRQn 1 */
-}
-
 /**
   * @brief This function handles USART1 global interrupt.
   */