1. API 부팅 메모리 주소 변경

2.EEPROM 에서 Table Length 정하도록 수정
3.

Bluecell_Inc/Bluecell_operate.h

@@ -632,6 +632,18 @@ typedef enum{
 	ULO_P3_ATT_Accuracy_Table_Number = 0x52,
 	ULO_P4_ATT_Accuracy_Table_Number = 0x53,
 }MBIC_Table_Number;
+#define ATTENTABLEDLUL_LENGTH 64
+#define ATTENTABLEDET_DL_LENGTH 31
+#define ATTENTABLEDET_UL_LENGTH 46
+
+#define ATTENTABLE_TEMP_LENGTH 10
+
+#define ATTENTABLEDL_REF   0
+#define ATTENTABLEUL_REF   0
+#define ATTENTABLEDET_DL_REF 5
+#define ATTENTABLEDET_UL_REF -15
+#define ATTENTABLE_TEMP_REF  -10
+
 #define UNIT_TYPE_MBIC 0x01
 /*FLAG BIT START */
 #define ENVIRONMENT_TEMPHIGH 0x80

Bluecell_Src/Bluecell_operate.c

@@ -1353,6 +1353,33 @@ void MBIC_TableDataCopy(uint8_t* dst,uint8_t* src,uint16_t size){
     dst[MBIC_TableIndex_Number] = dst[MBIC_TableIndex_Number];
 //    printf("\r\dst[MBIC_TableIndex_Number] : %d \r\n",dst[MBIC_TableIndex_Number]);   
     dst[MBIC_TableIndex_Ref] = UNIT_TYPE_MBIC;    // Check
+    
+
+//    Att_DL1.Table_Length  = ATTENTABLEDLUL_LENGTH;
+//    Att_DL2.Table_Length  = ATTENTABLEDLUL_LENGTH;
+//    Att_DL3.Table_Length  = ATTENTABLEDLUL_LENGTH;
+//    Att_DL4.Table_Length  = ATTENTABLEDLUL_LENGTH;
+//    Att_UL1.Table_Length  = ATTENTABLEDLUL_LENGTH;
+//    Att_UL2.Table_Length  = ATTENTABLEDLUL_LENGTH;
+//    Att_UL3.Table_Length  = ATTENTABLEDLUL_LENGTH;
+//    Att_UL4.Table_Length  = ATTENTABLEDLUL_LENGTH;
+//    Det_DL1.Table_Length  = ATTENTABLEDET_DL_LENGTH;
+//    Det_DL2.Table_Length  = ATTENTABLEDET_DL_LENGTH;
+//    Det_DL3.Table_Length  = ATTENTABLEDET_DL_LENGTH;
+//    Det_DL4.Table_Length  = ATTENTABLEDET_DL_LENGTH;
+//    Det_UL1.Table_Length  = ATTENTABLEDET_UL_LENGTH;
+//    Det_UL2.Table_Length  = ATTENTABLEDET_UL_LENGTH;
+//    Det_UL3.Table_Length  = ATTENTABLEDET_UL_LENGTH;
+//    Det_UL4.Table_Length  = ATTENTABLEDET_UL_LENGTH;
+//    Temp_DL1.Table_Length = ATTENTABLE_TEMP_LENGTH;
+//    Temp_DL2.Table_Length = ATTENTABLE_TEMP_LENGTH;
+//    Temp_DL3.Table_Length = ATTENTABLE_TEMP_LENGTH;
+//    Temp_DL4.Table_Length = ATTENTABLE_TEMP_LENGTH;
+//    Temp_UL1.Table_Length = ATTENTABLE_TEMP_LENGTH;
+//    Temp_UL2.Table_Length = ATTENTABLE_TEMP_LENGTH;
+//    Temp_UL3.Table_Length = ATTENTABLE_TEMP_LENGTH;
+//    Temp_UL4.Table_Length = ATTENTABLE_TEMP_LENGTH;  
+    
     if(dst[MBIC_TableIndex_Number] >= DLI_P1_ATT_Accuracy_Table_Number
      &&dst[MBIC_TableIndex_Number] <= ULO_P4_ATT_Accuracy_Table_Number ){
         dst[MBIC_TableIndex_Length] = size;   //
@@ -1554,105 +1581,107 @@ void Bluecell_TableSave(uint8_t* data,uint8_t type){
             Bluecell_DataCopy(&Att_DL1.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_BASE)              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_BASE)              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
+
+            printf("Function : %s Line %d \r\n",__func__,__LINE__);
             break;
-        case DLI_P2_ATT_Accuracy_Table_Number: 
+        case DLI_P2_ATT_Accuracy_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Att_DL2.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL1_TABLE_ADDRESDS),&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL1_TABLE_ADDRESDS),&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
 
 //            printf("ADDRESS : %d \r\n",EEPROM_ATT_DL1_TABLE_ADDRESDS );
             break;
-        case DLI_P3_ATT_Accuracy_Table_Number: 
+        case DLI_P3_ATT_Accuracy_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Att_DL3.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL2_TABLE_ADDRESDS),&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL2_TABLE_ADDRESDS),&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             break;
-        case DLI_P4_ATT_Accuracy_Table_Number: 
+        case DLI_P4_ATT_Accuracy_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Att_DL4.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL3_TABLE_ADDRESDS),&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL3_TABLE_ADDRESDS),&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));        
             break;
-        case ULO_P1_ATT_Accuracy_Table_Number: 
+        case ULO_P1_ATT_Accuracy_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Att_UL1.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL4_TABLE_ADDRESDS),&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL4_TABLE_ADDRESDS),&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st));        
             break;
-        case ULO_P2_ATT_Accuracy_Table_Number: 
+        case ULO_P2_ATT_Accuracy_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Att_UL2.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL1_TABLE_ADDRESDS),&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL1_TABLE_ADDRESDS),&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st));        
             break;
-        case ULO_P3_ATT_Accuracy_Table_Number: 
+        case ULO_P3_ATT_Accuracy_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Att_UL3.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL2_TABLE_ADDRESDS),&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL2_TABLE_ADDRESDS),&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st));        
             break;
-        case ULO_P4_ATT_Accuracy_Table_Number: 
+        case ULO_P4_ATT_Accuracy_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Att_UL4.Table_0_0_dBm,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL3_TABLE_ADDRESDS),&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL3_TABLE_ADDRESDS),&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st));
             break;
-        case DLI_P1_Level_Table_Number: 
+        case DLI_P1_Level_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             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));
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL4_TABLE_ADDRESDS),&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));        
             break;
-        case DLI_P2_Level_Table_Number: 
+        case DLI_P2_Level_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             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));
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL1_TABLE_ADDRESDS),&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));        
             break;
-        case DLI_P3_Level_Table_Number: 
+        case DLI_P3_Level_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             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));
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL2_TABLE_ADDRESDS),&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));        
             break;
-        case DLI_P4_Level_Table_Number: 
+        case DLI_P4_Level_Table_Number:printf("Function : %s Line %d \r\n",__func__,__LINE__); 
             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));
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL3_TABLE_ADDRESDS),&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st));        
             break;
-        case ULO_P1_Level_Table_Number: 
+        case ULO_P1_Level_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             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));            
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL4_TABLE_ADDRESDS),&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));            
             break;
-        case ULO_P2_Level_Table_Number: 
+        case ULO_P2_Level_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             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));            
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL1_TABLE_ADDRESDS),&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));                    
         break;
-        case ULO_P3_Level_Table_Number: 
+        case ULO_P3_Level_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             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));            
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL2_TABLE_ADDRESDS),&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));                    
             break;
-        case ULO_P4_Level_Table_Number: 
+        case ULO_P4_Level_Table_Number: printf("Function : %s Line %d \r\n",__func__,__LINE__);
             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));            
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL3_TABLE_ADDRESDS),&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st));                    
             break;
-        case DLI_P1_ATT_Temp_guarantee_Table_Number:
+        case DLI_P1_ATT_Temp_guarantee_Table_Number:printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Temp_DL1.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st));                    
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st));                            
             break;
-        case DLI_P2_ATT_Temp_guarantee_Table_Number:
+        case DLI_P2_ATT_Temp_guarantee_Table_Number:printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Temp_DL2.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL1_TABLE_ADDRESDS),&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st));                    
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL1_TABLE_ADDRESDS),&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st));                            
             break;
-        case DLI_P3_ATT_Temp_guarantee_Table_Number:
+        case DLI_P3_ATT_Temp_guarantee_Table_Number:printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Temp_DL3.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st));                    
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st));                            
             break;
-        case DLI_P4_ATT_Temp_guarantee_Table_Number:
+        case DLI_P4_ATT_Temp_guarantee_Table_Number:printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Temp_DL4.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL3_TABLE_ADDRESDS),&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st));                    
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL3_TABLE_ADDRESDS),&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st));                            
             break;
-        case ULO_P1_ATT_Temp_guarantee_Table_Number:
+        case ULO_P1_ATT_Temp_guarantee_Table_Number:printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Temp_UL1.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st));                            
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st));                                    
@@ -1662,12 +1691,12 @@ void Bluecell_TableSave(uint8_t* data,uint8_t type){
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st));                            
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st));                                    
             break;
-        case ULO_P3_ATT_Temp_guarantee_Table_Number:
+        case ULO_P3_ATT_Temp_guarantee_Table_Number:printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Temp_UL3.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL2_TABLE_ADDRESDS),&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st));                            
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL2_TABLE_ADDRESDS),&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st));                                    
             break;
-        case ULO_P4_ATT_Temp_guarantee_Table_Number:
+        case ULO_P4_ATT_Temp_guarantee_Table_Number:printf("Function : %s Line %d \r\n",__func__,__LINE__);
             Bluecell_DataCopy(&Temp_UL4.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
             EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL3_TABLE_ADDRESDS),&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st));                                
             EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL3_TABLE_ADDRESDS),&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st));                                        
@@ -1849,6 +1878,7 @@ void MBIC_TableLoad(uint8_t* data,uint8_t type){
             data[MBIC_PAYLOADSTART + MBIC_TableIndex_Length] = Temp_UL4.Table_Length;                
             break;
     }
+    
      printf("\rLoad MBIC_TableIndex_Number : %x \r\n",data[MBIC_PAYLOADSTART + MBIC_TableIndex_Number]);
     
 }
@@ -2469,6 +2499,16 @@ bool Bluecell_Operate(uint8_t* data){
 		break;
     case ATT_TableSet:
         Bluecell_TableSave(data, data[BLUECELL_DATA]);
+        Bluecell_TableLoad(data, data[BLUECELL_DATA]);
+        data[BLUECELL_TYPE] = ATT_TableGet;
+        Crcret = CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH_L]);
+        data[data[BLUECELL_LENGTH_L] + 1] = ((Crcret & 0xFF00) >> 8);
+        data[data[BLUECELL_LENGTH_L] + 2] = (Crcret & 0x00FF);
+        data[data[BLUECELL_LENGTH_L] + 3] = 0xEB;
+        
+        Bluecell_StructCpy(&Txdata[0],&data[0],data[BLUECELL_LENGTH_L] + 4);
+        Uart1_Data_Send(&Txdata[0], Txdata[BLUECELL_LENGTH_L] + 4);        
+        break;
     case ATT_TableGet:
         Bluecell_TableLoad(data, data[BLUECELL_DATA]);
         data[BLUECELL_TYPE] = ATT_TableGet;
@@ -2567,6 +2607,25 @@ bool Bluecell_Operate(uint8_t* data){
             bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & ALARM_ULO_SHUTDOWN_P3,
             bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN & ALARM_ULO_SHUTDOWN_P4
         );
+        printf("DLI HIGH Threas High Hold 1: %d 2:  %d 3: %d 4: %d\r\n",
+            bluecell_Currdatastatus.ALARM_DLI_Level & ALARM_DLI_P1_LEVEL_HIGH,
+            bluecell_Currdatastatus.ALARM_DLI_Level & ALARM_DLI_P2_LEVEL_HIGH,
+            bluecell_Currdatastatus.ALARM_DLI_Level & ALARM_DLI_P3_LEVEL_HIGH,
+            bluecell_Currdatastatus.ALARM_DLI_Level & ALARM_DLI_P4_LEVEL_HIGH
+        );        
+
+        printf("DLI LOW Threas High Hold 1: %d 2:  %d 3: %d 4: %d\r\n",
+            bluecell_Currdatastatus.ALARM_DLI_Level & ALARM_DLI_P1_LEVEL_LOW,
+            bluecell_Currdatastatus.ALARM_DLI_Level & ALARM_DLI_P2_LEVEL_LOW,
+            bluecell_Currdatastatus.ALARM_DLI_Level & ALARM_DLI_P3_LEVEL_LOW,
+            bluecell_Currdatastatus.ALARM_DLI_Level & ALARM_DLI_P4_LEVEL_LOW
+        );              
+        printf("ULO HIGH Threas High Hold 1: %d 2:  %d 3: %d 4: %d\r\n",
+            bluecell_Currdatastatus.ALARM_ULO_Level & ALARM_ULO_P1_LEVEL_HIGH,
+            bluecell_Currdatastatus.ALARM_ULO_Level & ALARM_ULO_P2_LEVEL_HIGH,
+            bluecell_Currdatastatus.ALARM_ULO_Level & ALARM_ULO_P3_LEVEL_HIGH,
+            bluecell_Currdatastatus.ALARM_ULO_Level & ALARM_ULO_P4_LEVEL_HIGH
+        );        
         printf("===================END=======================\r\n");
 
 //        printf("Level DL Alarm %d \r\n");
@@ -2906,7 +2965,9 @@ bool Bluecell_Operate(uint8_t* data){
   }
   
   if(datatype != Bluecell_StatusReq
-  && datatype != Bluecell_LED_TEST)
+  && datatype != Bluecell_LED_TEST
+  && datatype != ATT_TableSet
+  && datatype != ATT_TableGet)
   {
       Bluecell_StructCpy(&DataWrite[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
       EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS),&DataWrite[0],sizeof(BLUESTATUS_st));
@@ -4400,6 +4461,7 @@ bool MBIC_Operate(uint8_t* data){
         /*Table Get */
 //            data[MBIC_PAYLOADSTART + 1] //Reserve Data
         //protocolTableLoadReplay:
+       
 
         switch(data[MBIC_PAYLOADSTART + 2]){
         	case DLI_P1_Level_Table_Number                 :
@@ -7144,28 +7206,37 @@ void DLI_ShutdownAlarmCheck(){
 
 }
 #else
+typedef enum{
+    DL_Shutdown_H = 0,
+    DL_Shutdown_L, 
+};
 
-void DL_Shutdown_Operate(uint8_t index,uint8_t* path,uint8_t* retrycnt){
+void DL_Shutdown_Operate(uint8_t index,uint8_t* path,uint8_t* retrycnt,uint8_t* ShutdownAlarm,uint8_t* MainAtten){
     GPIO_TypeDef *Port;
     uint16_t Pin;
+    uint8_t AlarmFlag = 0;
 
 
     switch(index){
         case DET_Alarm_DL1_Shutdown_Index:
             Port = PATH_EN_DL1_GPIO_Port;
             Pin = PATH_EN_DL1_Pin;
+            AlarmFlag = ALARM_DLI_SHUTDOWN_P1;
             break;
         case DET_Alarm_DL2_Shutdown_Index:
             Port = PATH_EN_DL2_GPIO_Port;
-            Pin = PATH_EN_DL2_Pin;            
+            Pin = PATH_EN_DL2_Pin;   
+            AlarmFlag = ALARM_DLI_SHUTDOWN_P2;
             break;
         case DET_Alarm_DL3_Shutdown_Index:
             Port = PATH_EN_DL3_GPIO_Port;
-            Pin = PATH_EN_DL3_Pin;             
+            Pin = PATH_EN_DL3_Pin;       
+            AlarmFlag = ALARM_DLI_SHUTDOWN_P3;
             break;
         case DET_Alarm_DL4_Shutdown_Index:            
             Port = PATH_EN_DL4_GPIO_Port;
-            Pin = PATH_EN_DL4_Pin;             
+            Pin = PATH_EN_DL4_Pin;        
+            AlarmFlag = ALARM_DLI_SHUTDOWN_P4;
             break;
     }
     if(MBIC_DL_ShutdownCount[index] < 3
@@ -7184,30 +7255,30 @@ void DL_Shutdown_Operate(uint8_t index,uint8_t* path,uint8_t* retrycnt){
         && DL_PathUserHandl[index] == false){
         HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_SET);//CLOCK
         *path = true;            
-        bluecell_Prevdatastatus.ATT_DL1_H = 0xFF;
-        bluecell_Prevdatastatus.ATT_DL1_L = 0xFF;
+        MainAtten[DL_Shutdown_H] = 0xFF;
+        MainAtten[DL_Shutdown_L] = 0xFF;
         CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); 
     }                  
     if(DET_DL_Shutdown_On_AlarmTimerCnt[index] >= MBIC_ON_SHUTDOWN_MAINTAIN_SEC)
     {
         /*Shutdown 5sec Alarm*/
         HAL_GPIO_WritePin(Port,Pin,GPIO_PIN_RESET);//CLOCK      
-        printf("SHUTDOWN ON DL %d\r\n",index + 1);
+//        printf("SHUTDOWN ON DL %d\r\n",index + 1);
         *path = false;
         (*retrycnt)++;
         DET_DL_Shutdown_On_AlarmTimerCnt[index] = 0;
         
         if((*retrycnt) >= RETRYCNT_MAX){
             (*retrycnt) = RETRYCNT_MAX;
-            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P1;
-            bluecell_Currdatastatus.DLI_Shutdown_Alarm1       = true;
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= AlarmFlag;
+            *ShutdownAlarm       = true;
         }
     }
     else{
         if(DET_DL_Shutdown_Off_AlarmTimerCnt[index] >= MBIC_OFF_MAINTAIN_SEC
             && (*retrycnt) != RETRYCNT_MAX){
-            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P1;
-            bluecell_Currdatastatus.DLI_Shutdown_Alarm1       = false;            
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~AlarmFlag;
+            *ShutdownAlarm       = false;            
         }
     } 
 
@@ -7226,16 +7297,24 @@ void DLI_ShutdownAlarmCheck()
         /***************************************************************************************************************/  
         DL_Shutdown_Operate(DET_Alarm_DL1_Shutdown_Index,
                                 &bluecell_Currdatastatus.ATT_DL1_PATH,
-                                &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1);
+                                &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1,
+                                &bluecell_Currdatastatus.DLI_Shutdown_Alarm1,
+                                &bluecell_Prevdatastatus.ATT_DL1_H);
         DL_Shutdown_Operate(DET_Alarm_DL2_Shutdown_Index,
                                 &bluecell_Currdatastatus.ATT_DL2_PATH,
-                                &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2);
+                                &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2,
+                                &bluecell_Currdatastatus.DLI_Shutdown_Alarm2,
+                                &bluecell_Prevdatastatus.ATT_DL2_H);
         DL_Shutdown_Operate(DET_Alarm_DL3_Shutdown_Index,
                                 &bluecell_Currdatastatus.ATT_DL3_PATH,
-                                &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3);
+                                &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3,
+                                &bluecell_Currdatastatus.DLI_Shutdown_Alarm3,
+                                &bluecell_Prevdatastatus.ATT_DL3_H);
         DL_Shutdown_Operate(DET_Alarm_DL4_Shutdown_Index,
                                 &bluecell_Currdatastatus.ATT_DL4_PATH,
-                                &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4);
+                                &bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4,
+                                &bluecell_Currdatastatus.DLI_Shutdown_Alarm4,
+                                &bluecell_Prevdatastatus.ATT_DL4_H);
         
         
         

Bluecell_Src/eeprom.c

@@ -24,19 +24,51 @@ extern BLUESTATUS_st bluecell_Currdatastatus;
 
 
 uint8_t testdata[120];
-#define ATTENTABLEDLUL_LENGTH 64
-#define ATTENTABLEDET_DL_LENGTH 31
-#define ATTENTABLEDET_UL_LENGTH 46
 
-#define ATTENTABLE_TEMP_LENGTH 10
-
-#define ATTENTABLEDL_REF   0
-#define ATTENTABLEUL_REF   0
-#define ATTENTABLEDET_DL_REF 5
-#define ATTENTABLEDET_UL_REF -15
-#define ATTENTABLE_TEMP_REF  -10
+typedef enum{
+    Test_DL1 = 0,
+    Test_DL2 = 0,
+    Test_DL3 = 0,
+    Test_DL4 = 0,    
+};
+typedef enum{
+    Test_UL1 = 0,
+    Test_UL2 = 0,
+    Test_UL3 = 0,
+    Test_UL4 = 0,    
+};
 void EEPROM_M24C08_Init(void){
     uint8_t* data = 0;
+    int16_t DL_Main_Atten[4] = {0,};
+    int16_t DL_Offset_Atten[4] = {0,};
+
+    int16_t UL_Main_Atten[4] = {0,};
+    int16_t UL_Offset_Atten[4] = {0,};
+    int16_t UL_ALC_Atten[4] = {0,};
+
+    int16_t DL_High_ThreasHold = 0;
+    int16_t DL_Low_ThreasHold = 0;
+
+    int16_t UL_Hihh_ThreasHold = 0;
+
+    bool DL_Path[4] = {0,};
+
+    bool UL_Path[4] = {0,};    
+
+    bool ALC_Path = 0;        
+    bool AGC_Path = 0;            
+
+    bool DL_shutdown_Path = 0;
+    bool UL_shutdown_Path = 0;
+
+    int16_t DL_Shutdown_ThreadHold = 0;        
+    int16_t UL_Shutdown_ThreadHold = 0; 
+
+//    DL_High_ThreasHold = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
+//    ALC_TEMP[0] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
+//    ALC_TEMP[1] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L;
+//    ALC_TEMP[2] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L;
+//    ALC_TEMP[3] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_WINDOW_STATUS_ADDRESDS,&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st) );
 
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE              ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
@@ -55,8 +87,13 @@ void EEPROM_M24C08_Init(void){
     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) );
 
-
+    uint8_t* tmpdata;
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_DL4_TABLE_ADDRESDS,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
+    tmpdata = &Det_UL1.Table_Det_15_dBm_H;
+    for(int i =0; i < sizeof(DET_TABLEUL_st) ; i++){
+        printf("[%d]%f \r\n",i,(tmpdata[i * 2] << 8 | tmpdata[i*2+1])*0.001);
+    }
+    printf("");
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL1_TABLE_ADDRESDS,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
 //    data = &Det_UL2.Table_Det_15_dBm_H;
 //    for(int i = 0; i < sizeof(DET_TABLEUL_st) ; i ++ ){
@@ -80,7 +117,47 @@ void EEPROM_M24C08_Init(void){
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL1_TABLE_ADDRESDS,&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st) );
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL2_TABLE_ADDRESDS,&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL3_TABLE_ADDRESDS,&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );
+
+#if 0 // PYJ.2020.06.28_BEGIN -- 
+    DL_Main_Atten[Test_DL1] = (bluecell_Currdatastatus.ATT_DL1_H << 8) | bluecell_Currdatastatus.ATT_DL1_L;
+    DL_Main_Atten[Test_DL2] = bluecell_Currdatastatus.ATT_DL2_H << 8 | bluecell_Currdatastatus.ATT_DL2_L;
+    DL_Main_Atten[Test_DL3] = bluecell_Currdatastatus.ATT_DL3_H << 8 | bluecell_Currdatastatus.ATT_DL3_L;
+    DL_Main_Atten[Test_DL4] = bluecell_Currdatastatus.ATT_DL4_H << 8 | bluecell_Currdatastatus.ATT_DL4_L;
+
+    DL_Offset_Atten[Test_DL1] = bluecell_Currdatastatus.bluecell_User_DL1_H << 8 | bluecell_Currdatastatus.bluecell_User_DL1_L;
+    DL_Offset_Atten[Test_DL2] = bluecell_Currdatastatus.bluecell_User_DL2_H << 8 | bluecell_Currdatastatus.bluecell_User_DL2_L;
+    DL_Offset_Atten[Test_DL3] = bluecell_Currdatastatus.bluecell_User_DL3_H << 8 | bluecell_Currdatastatus.bluecell_User_DL3_L;
+    DL_Offset_Atten[Test_DL4] = bluecell_Currdatastatus.bluecell_User_DL4_H << 8 | bluecell_Currdatastatus.bluecell_User_DL4_L;
     
+
+    UL_Main_Atten[Test_UL1] = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
+    UL_Main_Atten[Test_UL2] = bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L;
+    UL_Main_Atten[Test_UL3] = bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L;
+    UL_Main_Atten[Test_UL4] = bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L;
+
+    UL_Offset_Atten[Test_UL1] = bluecell_Currdatastatus.bluecell_User_UL1_H << 8 | bluecell_Currdatastatus.bluecell_User_UL1_L;
+    UL_Offset_Atten[Test_UL2] = bluecell_Currdatastatus.bluecell_User_UL2_H << 8 | bluecell_Currdatastatus.bluecell_User_UL2_L;
+    UL_Offset_Atten[Test_UL3] = bluecell_Currdatastatus.bluecell_User_UL3_H << 8 | bluecell_Currdatastatus.bluecell_User_UL3_L;
+    UL_Offset_Atten[Test_UL4] = bluecell_Currdatastatus.bluecell_User_UL4_H << 8 | bluecell_Currdatastatus.bluecell_User_UL4_L;
+
+    UL_ALC_Atten[Test_UL1] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
+    UL_ALC_Atten[Test_UL2] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L;
+    UL_ALC_Atten[Test_UL3] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L;
+    UL_ALC_Atten[Test_UL4] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
+#endif // PYJ.2020.06.28_END -- 
+#if 0 // PYJ.2020.06.28_BEGIN -- 
+
+    for(int i = 0; i < 4; i++)
+        printf("DL       : %d \r\n",DL_Main_Atten[Test_DL1+i]);
+    for(int i = 0; i < 4; i++)
+        printf("DL Offset: %d \r\n",DL_Offset_Atten[Test_DL1+i]);
+    for(int i = 0; i < 4; i++)
+        printf("UL       : %d \r\n",UL_Main_Atten[Test_DL1+i]);
+    for(int i = 0; i < 4; i++)
+        printf("UL Offset: %d \r\n",UL_Offset_Atten[Test_DL1+i]);
+    for(int i = 0; i < 4; i++)
+        printf("UL ALC: %d \r\n",UL_ALC_Atten[Test_DL1+i]);    
+#endif // PYJ.2020.06.28_END -- 
     /*Table Initial Length Setting */
 #if 0 // PYJ.2020.06.23_BEGIN -- 
         printf("Init Temp_UL3 Length : %d \r\n",Temp_UL3.Table_Length);
@@ -107,30 +184,8 @@ void EEPROM_M24C08_Init(void){
 //    bluecell_Currdatastatus.CPUVERSION1 =  0;
 //    bluecell_Currdatastatus.CPUVERSION2 = 0;
 //    bluecell_Currdatastatus.CPUVERSION3 = 8;
-    Att_DL1.Table_Length  = ATTENTABLEDLUL_LENGTH;
-    Att_DL2.Table_Length  = ATTENTABLEDLUL_LENGTH;
-    Att_DL3.Table_Length  = ATTENTABLEDLUL_LENGTH;
-    Att_DL4.Table_Length  = ATTENTABLEDLUL_LENGTH;
-    Att_UL1.Table_Length  = ATTENTABLEDLUL_LENGTH;
-    Att_UL2.Table_Length  = ATTENTABLEDLUL_LENGTH;
-    Att_UL3.Table_Length  = ATTENTABLEDLUL_LENGTH;
-    Att_UL4.Table_Length  = ATTENTABLEDLUL_LENGTH;
-    Det_DL1.Table_Length  = ATTENTABLEDET_DL_LENGTH;
-    Det_DL2.Table_Length  = ATTENTABLEDET_DL_LENGTH;
-    Det_DL3.Table_Length  = ATTENTABLEDET_DL_LENGTH;
-    Det_DL4.Table_Length  = ATTENTABLEDET_DL_LENGTH;
-    Det_UL1.Table_Length  = ATTENTABLEDET_UL_LENGTH;
-    Det_UL2.Table_Length  = ATTENTABLEDET_UL_LENGTH;
-    Det_UL3.Table_Length  = ATTENTABLEDET_UL_LENGTH;
-    Det_UL4.Table_Length  = ATTENTABLEDET_UL_LENGTH;
-    Temp_DL1.Table_Length = ATTENTABLE_TEMP_LENGTH;
-    Temp_DL2.Table_Length = ATTENTABLE_TEMP_LENGTH;
-    Temp_DL3.Table_Length = ATTENTABLE_TEMP_LENGTH;
-    Temp_DL4.Table_Length = ATTENTABLE_TEMP_LENGTH;
-    Temp_UL1.Table_Length = ATTENTABLE_TEMP_LENGTH;
-    Temp_UL2.Table_Length = ATTENTABLE_TEMP_LENGTH;
-    Temp_UL3.Table_Length = ATTENTABLE_TEMP_LENGTH;
-    Temp_UL4.Table_Length = ATTENTABLE_TEMP_LENGTH;
+#if 1 // PYJ.2020.06.28_BEGIN -- 
+
     Att_DL1.Table_Ref = ATTENTABLEDL_REF;
     Att_DL2.Table_Ref = ATTENTABLEDL_REF;
     Att_DL3.Table_Ref = ATTENTABLEDL_REF;
@@ -188,6 +243,7 @@ void EEPROM_M24C08_Init(void){
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_UL2_TABLE_ADDRESDS,&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
       EEPROM_M24C08_write(EEPROM_M24C08_ID,EEPROM_TEMP_UL3_TABLE_ADDRESDS,&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );
 
+#endif // PYJ.2020.06.28_END -- 
 
     bluecell_Currdatastatus.ALARM_TEMP_HIGH          = 0;
     bluecell_Currdatastatus.ALARM_DLI_Level          = 0;
@@ -238,18 +294,42 @@ void eepromtest(){
 
 HAL_StatusTypeDef EEPROM_M24C08_Read(uint8_t devid,uint16_t Address,uint8_t* data,uint16_t size){
    HAL_StatusTypeDef ret = HAL_ERROR;
+   uint8_t sizecnt = 0,sizeremain = 0; 
+   uint16_t addrees_inc = 0;
+   sizecnt = size /MAXEEPROM_LENG;
+   sizeremain = size % MAXEEPROM_LENG;
+   addrees_inc = 0;
+
  //  uint16_t sizecnt = 0,
    //uint16_t 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);
+
+#if 1 // PYJ.2020.06.28_BEGIN -- 
+   ret = HAL_I2C_Mem_Read(&hi2c2, devid ,((Address )),  I2C_MEMADD_SIZE_16BIT, &data[0], size, 0xFFFF);
 //      EEPROM24XX_Load( Address,data, size);
 
       if(ret == HAL_ERROR)
             printf("Write ERR\r\n");
-//        else
-//            HAL_Delay(20);
+#else
+    if(sizecnt > 0){
+        for(int i = 0 ; i < sizecnt; i++ ){
+             addrees_inc = i * MAXEEPROM_LENG;
+             ret = HAL_I2C_Mem_Read(&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");
+             
+             HAL_Delay(20);
+        }
+        addrees_inc += MAXEEPROM_LENG;
+    }
+
+#endif // PYJ.2020.06.28_END -- 
+
+
+//    HAL_Delay(20);
 
     return ret;   
 }
@@ -285,8 +365,8 @@ HAL_StatusTypeDef EEPROM_M24C08_write(uint8_t devid,uint16_t Address,uint8_t* da
 
              if(ret == HAL_ERROR)
                  printf("Write ERR\r\n");
-             else
-                 HAL_Delay(20);
+             
+             HAL_Delay(20);
         }
         addrees_inc += MAXEEPROM_LENG;
     }
@@ -300,10 +380,11 @@ HAL_StatusTypeDef EEPROM_M24C08_write(uint8_t devid,uint16_t Address,uint8_t* da
          //       EEPROM24XX_Save( Address,data, size);
          if(ret == HAL_ERROR)
              printf("Write ERR\r\n");
-         else
-             HAL_Delay(20);
+         
+          HAL_Delay(20);
         }
     }
+    printf("EEPROM WRITE\r\n");
 
 #endif // PYJ.2020.04.25_END -- 
     return ret;
@@ -315,7 +396,7 @@ HAL_StatusTypeDef EEPROM_M24C08_Zerowrite(uint8_t devid,uint16_t Address){
     uint16_t addrees_inc = 0;
     addrees_inc = 0;
     uint8_t data[4096] = {0,};
-
+    printf("EEPROM ALL ERASE \r\n");
 
     for(int i = 0 ; i < 128; i++ ){
          addrees_inc = i * MAXEEPROM_LENG;

STM32F103ZE_FLASH.ld

@@ -62,7 +62,7 @@ _Min_Stack_Size = 0x400; /* required amount of stack */
 MEMORY
 {
 RAM (xrw)      : ORIGIN = 0x20002800, LENGTH = 54K
-FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 512K - 20K
+FLASH (rx)      : ORIGIN = 0x8008000, LENGTH = 512K - 20K
 }
 
 /* Define output sections */

Src/system_stm32f1xx.c

@@ -92,7 +92,7 @@
 /*!< Uncomment the following line if you need to relocate your vector Table in
      Internal SRAM. */ 
 /* #define VECT_TAB_SRAM */
-#define VECT_TAB_OFFSET  0x0000 /* Original Value : 0x00000000U*/ /*!< Vector Table base offset field.
+#define VECT_TAB_OFFSET  0x8000 /* Original Value : 0x00000000U*/ /*!< Vector Table base offset field.
                                   This value must be a multiple of 0x200. */