Flash 주소 변경 / Table Write 시 Load 하도록 수정 / Flash Init 추가 /

Bluecell_Inc/Bluecell_operate.h

@@ -604,6 +604,7 @@ enum DATATYPE
     BLuecell_ATT_ALC2,
     BLuecell_ATT_ALC3,
     BLuecell_ATT_ALC4,   
+    Bluecell_BankSelect,
 };
 typedef enum{    
 	DLI_P1_Level_Table_Number = 0x00,

Bluecell_Inc/flash.h

@@ -11,23 +11,23 @@
 #include "main.h"
 #include "CRC.h"
 
-#define FLASH_USER_BANK_NUM ((uint32_t)0x08005000) - 150
+#define FLASH_USER_BANK_NUM ((uint32_t)0x08008000) - 150
 
-#define FLASH_MBICUSER_START_ADDR (uint32_t)((0x08005000) - 128)
+#define FLASH_MBICUSER_START_ADDR (uint32_t)((0x08008000) - 128)
 #define FLASH_MBICUSER_END_ADDR FLASH_MBICUSER_START_ADDR + ((uint32_t)0xFFFF)
 
 
-#define FLASH_USER_START_ADDR ((uint32_t)0x08005000)
+#define FLASH_USER_START_ADDR ((uint32_t)0x08008000)
 #define FLASH_USER_END_ADDR     FLASH_USER_START_ADDR + ((uint32_t)0x000FFFF)   /* End @ of user Flash area */
-#define APPLICATION_ADDRESS     (uint32_t)0x08005000      /* Start user code address: ADDR_FLASH_PAGE_8 */
+#define APPLICATION_ADDRESS     (uint32_t)0x08008000      /* Start user code address: ADDR_FLASH_PAGE_8 */
 #define BOOTLOADER_ADDRESS     (uint32_t)0x08000000      /* Start user code address: ADDR_FLASH_PAGE_8 */
 
 
 
-#define FLASH_USER_BANK1_START_ADDR ((uint32_t)0x08025000)
+#define FLASH_USER_BANK1_START_ADDR ((uint32_t)0x08028000)
 #define FLASH_USER_BANK1_END_ADDR FLASH_USER_BANK1_START_ADDR + ((uint32_t)0x1FF80)   /* End @ of user Flash area */
 
-#define FLASH_USER_BANK2_START_ADDR ((uint32_t)0x08045000)
+#define FLASH_USER_BANK2_START_ADDR ((uint32_t)0x08048000)
 #define FLASH_USER_BANK2_END_ADDR FLASH_USER_BANK2_START_ADDR + ((uint32_t)0x1FF80)
 
 

Bluecell_Src/Bluecell_operate.c

@@ -25,7 +25,7 @@ extern void Uart1_Data_Send(uint8_t* data,uint16_t size);
 extern HAL_StatusTypeDef EEPROM_M24C08_Zerowrite(uint8_t devid,uint16_t Address);
 extern uint8_t Chksum_Create(uint8_t *data);
 extern uint16_t CRC16_Generate(uint8_t* buf_ptr, int len);
-extern void MBIC_APIFLASH_Func(uint8_t* data,uint32_t size);
+extern uint8_t MBIC_APIFLASH_Func(uint8_t* data,uint32_t size);
 
 /***************************************************************************************/
 /*                                  Extern Valuable                                    */
@@ -1539,100 +1539,124 @@ void Bluecell_TableSave(uint8_t* data,uint8_t type){
         case DLI_P1_ATT_Accuracy_Table_Number: 
             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) );
             break;
         case DLI_P2_ATT_Accuracy_Table_Number: 
             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: 
             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: 
             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: 
             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: 
             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: 
             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: 
             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: 
             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: 
             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: 
             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: 
             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: 
             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: 
             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: 
             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: 
             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:
             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:
             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:
             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:
             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:
             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));                                    
             break;
         case ULO_P2_ATT_Temp_guarantee_Table_Number:
             Bluecell_DataCopy(&Temp_UL2.Table_1_Temp,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st));
             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:
             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:
             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));                                        
             break;
     }
     
@@ -2034,6 +2058,7 @@ bool Bluecell_Operate(uint8_t* data){
   int16_t tempdata = 0;
   int16_t CurrAtten = 0;
   uint8_t i = 0;
+  uint16_t Crcret = 0;
   switch(datatype){
     case BLUECELL_SOFTWARERESET:
         NVIC_SystemReset();
@@ -2048,6 +2073,7 @@ bool Bluecell_Operate(uint8_t* data){
         printf("bluecell_Currdatastatus.ATT_DL1_L : %x\r\n",bluecell_Currdatastatus.ATT_DL1_L);  
         CurrAtten = bluecell_Currdatastatus.ATT_DL1_H << 8 | bluecell_Currdatastatus.ATT_DL1_L;
         printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
+        DL_PrevIwillgiveAtten[AGC_Alarm_DL1_Index] = 0;
         /*
             Atten Ctrl Function
         */
@@ -2060,7 +2086,7 @@ bool Bluecell_Operate(uint8_t* data){
         printf("bluecell_Currdatastatus.ATT_DL2_L : %x\r\n",bluecell_Currdatastatus.ATT_DL2_L);        
         CurrAtten = bluecell_Currdatastatus.ATT_DL2_H << 8 | bluecell_Currdatastatus.ATT_DL2_L;
         printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
-        
+        DL_PrevIwillgiveAtten[AGC_Alarm_DL2_Index] = 0;
 
         /*
             Atten Ctrl Function
@@ -2072,6 +2098,7 @@ bool Bluecell_Operate(uint8_t* data){
         bluecell_Currdatastatus.ATT_DL3_L = data[BLUECELL_DATA + i++];
         CurrAtten = bluecell_Currdatastatus.ATT_DL3_H << 8 | bluecell_Currdatastatus.ATT_DL3_L;
         printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
+        DL_PrevIwillgiveAtten[AGC_Alarm_DL3_Index] = 0;
 
         /*
             Atten Ctrl Function
@@ -2083,7 +2110,7 @@ bool Bluecell_Operate(uint8_t* data){
         bluecell_Currdatastatus.ATT_DL4_L = data[BLUECELL_DATA + i++];
         CurrAtten = bluecell_Currdatastatus.ATT_DL4_H << 8 | bluecell_Currdatastatus.ATT_DL4_L;
         printf("LINE : %d Curr ATTEN : %d \r\n",__LINE__,CurrAtten);
-
+        DL_PrevIwillgiveAtten[AGC_Alarm_DL4_Index] = 0;    
         /*
             Atten Ctrl Function
         */
@@ -2159,6 +2186,7 @@ bool Bluecell_Operate(uint8_t* data){
 //		printf("ret : %f ,tmp %f \r\n",ret,tmp );
 		break;
 	case ATT_DL1_PATH 		 :
+#if 0 // PYJ.2020.06.27_BEGIN -- 
         if(data[BLUECELL_DATA]==0){
             HAL_GPIO_WritePin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin,GPIO_PIN_RESET);//CLOCK        
             printf("ATT_DL1_PATH OFF\r\n");
@@ -2173,6 +2201,22 @@ bool Bluecell_Operate(uint8_t* data){
             printf("ATT_DL1_PATH ON\r\n");
         }
         bluecell_Currdatastatus.ATT_DL1_PATH = data[BLUECELL_DATA];
+#else
+        bluecell_Currdatastatus.ATT_DL1_PATH = data[BLUECELL_DATA]; 
+        bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 = 0;
+        bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count1 = 0xFF;
+        if(data[BLUECELL_DATA]==0){
+            HAL_GPIO_WritePin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin,GPIO_PIN_RESET);//CLOCK        
+            DL_PathUserHandl[0] = true;
+        }
+        else{
+            bluecell_Prevdatastatus.ATT_DL1_H = 0xFF;
+            bluecell_Prevdatastatus.ATT_DL1_L =0xFF;
+            DL_PathUserHandl[0] = false;                    
+            HAL_GPIO_WritePin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin,GPIO_PIN_SET);//CLOCK
+        }                
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+#endif // PYJ.2020.06.27_END -- 
 	
 
 		break;
@@ -2204,6 +2248,7 @@ bool Bluecell_Operate(uint8_t* data){
 //		printf("Function : %s Line %d \r\n",__func__,__LINE__);
 		break;
 	case ATT_DL2_PATH		 :
+#if 0 // PYJ.2020.06.27_BEGIN -- 
         if(data[BLUECELL_DATA]==0){
             HAL_GPIO_WritePin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin,GPIO_PIN_RESET);//CLOCK
             bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 = 0;            
@@ -2215,6 +2260,23 @@ bool Bluecell_Operate(uint8_t* data){
             CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         }
         bluecell_Currdatastatus.ATT_DL2_PATH = data[BLUECELL_DATA];
+#else
+        bluecell_Currdatastatus.ATT_DL2_PATH = data[BLUECELL_DATA]; 
+        bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 = 0;
+        bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count2 = 0xFF;
+        if(data[BLUECELL_DATA]==0){
+            HAL_GPIO_WritePin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin,GPIO_PIN_RESET);//CLOCK        
+            DL_PathUserHandl[1] = true;
+        }
+        else{
+            bluecell_Prevdatastatus.ATT_DL2_H = 0xFF;
+            bluecell_Prevdatastatus.ATT_DL2_L =0xFF;
+            DL_PathUserHandl[1] = false;                    
+            HAL_GPIO_WritePin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin,GPIO_PIN_SET);//CLOCK
+        }                
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+#endif // PYJ.2020.06.27_END -- 
 //		printf("Function : %s Line %d \r\n",__func__,__LINE__);
 		break;
 
@@ -2245,6 +2307,7 @@ bool Bluecell_Operate(uint8_t* data){
 //		printf("Function : %s Line %d \r\n",__func__,__LINE__);
 		break;
 	case ATT_DL3_PATH :
+#if 0 // PYJ.2020.06.27_BEGIN -- 
         if(data[BLUECELL_DATA]==0){
             HAL_GPIO_WritePin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin,GPIO_PIN_RESET);//CLOCK
             bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = 0;
@@ -2256,6 +2319,23 @@ bool Bluecell_Operate(uint8_t* data){
             CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         }
         bluecell_Currdatastatus.ATT_DL3_PATH = data[BLUECELL_DATA];
+#else
+        bluecell_Currdatastatus.ATT_DL3_PATH = data[BLUECELL_DATA]; 
+        bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = 0;
+        bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count3 = 0xFF;
+        if(data[BLUECELL_DATA]==0){
+            HAL_GPIO_WritePin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin,GPIO_PIN_RESET);//CLOCK        
+            DL_PathUserHandl[2] = true;
+        }
+        else{
+            bluecell_Prevdatastatus.ATT_DL3_H = 0xFF;
+            bluecell_Prevdatastatus.ATT_DL3_L =0xFF;
+            DL_PathUserHandl[2] = false;                    
+            HAL_GPIO_WritePin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin,GPIO_PIN_SET);//CLOCK
+        }                
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+#endif // PYJ.2020.06.27_END -- 
 //		printf("Function : %s Line %d \r\n",__func__,__LINE__);
 		break;
 	case ATT_UL3_PATH :
@@ -2299,6 +2379,7 @@ bool Bluecell_Operate(uint8_t* data){
 //		printf("Function : %s Line %d \r\n",__func__,__LINE__);
 		break;
 	case ATT_UL4_PATH:
+#if 0 // PYJ.2020.06.27_BEGIN -- 
         if(data[BLUECELL_DATA]==0){
             HAL_GPIO_WritePin(PATH_EN_UL4_GPIO_Port,PATH_EN_UL4_Pin,GPIO_PIN_RESET);//CLOCK
             bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 = 0;
@@ -2310,6 +2391,23 @@ bool Bluecell_Operate(uint8_t* data){
             CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         }
         bluecell_Currdatastatus.ATT_UL4_PATH = data[BLUECELL_DATA];
+#else
+        bluecell_Currdatastatus.ATT_DL4_PATH = data[BLUECELL_DATA]; 
+        bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 = 0;
+        bluecell_Prevdatastatus.DLI_Shutdown_Retry_Count4 = 0xFF;
+        if(data[BLUECELL_DATA]==0){
+            HAL_GPIO_WritePin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin,GPIO_PIN_RESET);//CLOCK        
+            DL_PathUserHandl[3] = true;
+        }
+        else{
+            bluecell_Prevdatastatus.ATT_DL4_H = 0xFF;
+            bluecell_Prevdatastatus.ATT_DL4_L =0xFF;
+            DL_PathUserHandl[3] = false;                    
+            HAL_GPIO_WritePin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin,GPIO_PIN_SET);//CLOCK
+        }                
+        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
+
+#endif // PYJ.2020.06.27_END -- 
 //		printf("Function : %s Line %d \r\n",__func__,__LINE__);
 		break;
 	case ATT_SelfTest4 :
@@ -2328,9 +2426,9 @@ bool Bluecell_Operate(uint8_t* data){
     case ATT_TableGet:
         Bluecell_TableLoad(data, data[BLUECELL_DATA]);
         data[BLUECELL_TYPE] = ATT_TableGet;
-
-        data[data[BLUECELL_LENGTH_L] + 1] = ((CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH_L]) & 0xFF00) >> 8);
-        data[data[BLUECELL_LENGTH_L] + 2] = CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH_L]) & 0x00FF;        
+        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);
@@ -2698,6 +2796,11 @@ bool Bluecell_Operate(uint8_t* data){
         CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
         break;
+    case Bluecell_BankSelect:
+        bluecell_Currdatastatus.CPU_Bank_Select = data[BLUECELL_DATA + i++];
+        printf("bluecell_Currdatastatus.CPU_Bank_Select : %d \r\n",bluecell_Currdatastatus.CPU_Bank_Select);
+        break;
+           
   }
   
   if(datatype != Bluecell_StatusReq
@@ -3843,6 +3946,7 @@ bool MBIC_Operate(uint8_t* data){
             case  DLI_Gain_Atten1                         :
                 bluecell_Currdatastatus.ATT_DL1_H = data[MBIC_PAYLOADSTART + 3]; 
                 bluecell_Currdatastatus.ATT_DL1_L = data[MBIC_PAYLOADSTART + 4]; 
+                DL_PrevIwillgiveAtten[AGC_Alarm_DL1_Index] = 0;
                 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);              
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
@@ -3850,6 +3954,7 @@ bool MBIC_Operate(uint8_t* data){
             case  DLI_Gain_Atten2                         :
                 bluecell_Currdatastatus.ATT_DL2_H = data[MBIC_PAYLOADSTART + 3]; 
                 bluecell_Currdatastatus.ATT_DL2_L = data[MBIC_PAYLOADSTART + 4]; 
+                DL_PrevIwillgiveAtten[AGC_Alarm_DL2_Index] = 0;
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
                 printf("bluecell_Currdatastatus.ATT_DL2_H : %x\r\n",bluecell_Currdatastatus.ATT_DL2_H);
                 printf("bluecell_Currdatastatus.ATT_DL2_L : %x\r\n",bluecell_Currdatastatus.ATT_DL2_L); 
@@ -3858,12 +3963,14 @@ bool MBIC_Operate(uint8_t* data){
             case  DLI_Gain_Atten3                         :
                 bluecell_Currdatastatus.ATT_DL3_H = data[MBIC_PAYLOADSTART + 3]; 
                 bluecell_Currdatastatus.ATT_DL3_L = data[MBIC_PAYLOADSTART + 4]; 
+                DL_PrevIwillgiveAtten[AGC_Alarm_DL3_Index] = 0;
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
                 break;
             case  DLI_Gain_Atten4                         :
                 bluecell_Currdatastatus.ATT_DL4_H = data[MBIC_PAYLOADSTART + 3]; 
                 bluecell_Currdatastatus.ATT_DL4_L = data[MBIC_PAYLOADSTART + 4]; 
+                DL_PrevIwillgiveAtten[AGC_Alarm_DL4_Index] = 0;
                 CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 
                 break;
@@ -5448,6 +5555,28 @@ void ALC_Package_Operate(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st
 
 
 }
+void UL_Curr_Level(uint8_t*ULO_ADC_Level,uint8_t* ULO_Level,DET_TABLEUL_st*      UL_Table,uint8_t TableIndex){
+double ret = 0;
+double ResdBm = 0;
+int16_t ResultData = 0;
+
+
+    ret  =  ((ULO_ADC_Level[ULO_ALC_H] << 8 | ULO_ADC_Level[ULO_ALC_L]) * 0.001);
+    /*Curr UL Value*/
+    ResdBm = AutoControl_ADC_Compare(ret,&UL_Table->Table_Det_15_dBm_H,UL_Table->Table_Length * 2,&ALC_Table_ref[TableIndex].DET_UL_0);
+    //ret 현재 Voltage 값 출력
+    //ret 에 따른 현재 DBM 구현
+    ResultData = ResdBm;
+    ULO_Level[ULO_ALC_H] = (ResultData & 0xFF00) >> 8;
+    ULO_Level[ULO_ALC_L] = (ResultData & 0x00FF);
+//    printf("============ALC_OFF======START================\r\n");
+//    printf("Current UL ADC VALUE : %f \r\n",ret);
+//    printf("ResdBm : UL1 : %f \r\n",ResdBm);
+//    printf("ResdBm  : %x /////  bluecell_Currdatastatus.ULO_Level1_H : %x \r\n",ResultData,ULO_Level[ULO_ALC_H]);
+//    printf("ResdBm  : %x /////  bluecell_Currdatastatus.ULO_Level1_L : %x \r\n",ResultData,ULO_Level[ULO_ALC_L]);            
+//    printf("==================END================\r\n");
+}
+
 void ALC_Function(){ //DL 
     //double Volt_Calc_val = 3.3 / 4095;
     //double tempret = 0;
@@ -5939,7 +6068,7 @@ void ALC_Function(){ //DL
 #endif // PYJ.2020.05.22_END -- 
             ALCTimerCnt = 0;
         }else{
-#if 1 // PYJ.2020.06.21_BEGIN -- 
+#if 0 // PYJ.2020.06.21_BEGIN -- 
             ALC_Table = &ALC_Table_ref[ALC_Table_UL1_Ref_Index].DET_UL_0;
             ret  = bluecell_Currdatastatus.ULO_P1_Level1_H << 8;
             ret += bluecell_Currdatastatus.ULO_P1_Level1_L;   
@@ -5961,10 +6090,28 @@ void ALC_Function(){ //DL
             printf("ResdBm  : %x /////  bluecell_Currdatastatus.ULO_Level1_L : %x \r\n",ResultData,bluecell_Currdatastatus.ULO_Level1_L);            
             printf("==================END================\r\n");
 #endif // PYJ.2020.06.20_END -- 
+#else
+            UL_Curr_Level(&bluecell_Currdatastatus.ULO_P1_Level1_H,
+                          &bluecell_Currdatastatus.ULO_Level1_H,
+                          &Det_UL1.Table_Det_15_dBm_H,
+                           ALC_Alarm_UL1_Index);
+            UL_Curr_Level(&bluecell_Currdatastatus.ULO_P2_Level2_H,
+                          &bluecell_Currdatastatus.ULO_Level2_H,
+                          &Det_UL2.Table_Det_15_dBm_H,
+                           ALC_Alarm_UL2_Index);
+            UL_Curr_Level(&bluecell_Currdatastatus.ULO_P3_Level3_H,
+                          &bluecell_Currdatastatus.ULO_Level3_H,
+                          &Det_UL3.Table_Det_15_dBm_H,
+                           ALC_Alarm_UL3_Index);
+            UL_Curr_Level(&bluecell_Currdatastatus.ULO_P4_Level4_H,
+                          &bluecell_Currdatastatus.ULO_Level4_H,
+                          &Det_UL4.Table_Det_15_dBm_H,
+                           ALC_Alarm_UL4_Index);            
+
 
 #endif // PYJ.2020.06.21_END -- 
 
-#if 1 // PYJ.2020.06.22_BEGIN -- 
+#if 0 // PYJ.2020.06.22_BEGIN -- 
             ret  = bluecell_Currdatastatus.ULO_P2_Level2_H << 8;
             ret += bluecell_Currdatastatus.ULO_P2_Level2_L;   
             ret *= 0.001;
@@ -5994,7 +6141,7 @@ void ALC_Function(){ //DL
 #endif // PYJ.2020.06.21_END -- 
 
 #if 1 // PYJ.2020.06.20_BEGIN -- 
-#if 1 // PYJ.2020.06.21_BEGIN -- 
+#if 0 // PYJ.2020.06.21_BEGIN -- 
             ALC_Table = &ALC_Table_ref[ALC_Table_UL3_Ref_Index].DET_UL_0;
 
             ret  = bluecell_Currdatastatus.ULO_P3_Level3_H << 8;
@@ -6006,14 +6153,6 @@ void ALC_Function(){ //DL
             ResultData = ResdBm;
             bluecell_Currdatastatus.ULO_Level3_H = ((int16_t)ResultData & 0xFF00) >> 8;
             bluecell_Currdatastatus.ULO_Level3_L = ((int16_t)ResultData & 0x00FF);
-#if 0 // PYJ.2020.06.21_BEGIN -- 
-                        printf("=========ALC_OFF=========START================\r\n");
-                        printf("Current UL ADC VALUE : %f \r\n",ret);
-                        printf("ResdBm : UL3 : %f \r\n",ResdBm);
-                        printf("ResdBm  : %x /////  bluecell_Currdatastatus.ULO_Level3_H : %x \r\n",ResultData,bluecell_Currdatastatus.ULO_Level3_H);
-                        printf("ResdBm  : %x /////  bluecell_Currdatastatus.ULO_Level3_L : %x \r\n",ResultData,bluecell_Currdatastatus.ULO_Level3_L);            
-                        printf("==================END================\r\n");
-#endif // PYJ.2020.06.21_END --             
 #if 0 // PYJ.2020.06.21_BEGIN -- 
             printf("=========ALC_OFF=========START================\r\n");
             printf("Current UL ADC VALUE : %f \r\n",ret);
@@ -6021,7 +6160,7 @@ void ALC_Function(){ //DL
             printf("ResdBm  : %x /////  bluecell_Currdatastatus.ULO_Level3_H : %x \r\n",ResultData,bluecell_Currdatastatus.ULO_Level3_H);
             printf("ResdBm  : %x /////  bluecell_Currdatastatus.ULO_Level3_L : %x \r\n",ResultData,bluecell_Currdatastatus.ULO_Level3_L);            
             printf("==================END================\r\n");
-#endif // PYJ.2020.06.21_END -- 
+#endif // PYJ.2020.06.21_END --             
 
 #if 1 // PYJ.2020.06.22_BEGIN -- 
             ALC_Table = &ALC_Table_ref[ALC_Table_UL4_Ref_Index].DET_UL_0;
@@ -6036,6 +6175,15 @@ void ALC_Function(){ //DL
             bluecell_Currdatastatus.ULO_Level4_H = ((int16_t)ResultData & 0xFF00) >> 8;
             bluecell_Currdatastatus.ULO_Level4_L = ((int16_t)ResultData & 0x00FF);            
 #endif // PYJ.2020.06.22_END -- 
+#if 0 // PYJ.2020.06.21_BEGIN -- 
+            printf("=========ALC_OFF=========START================\r\n");
+            printf("Current UL ADC VALUE : %f \r\n",ret);
+            printf("ResdBm : U4 : %f \r\n",ResdBm);
+            printf("ResdBm  : %x /////  bluecell_Currdatastatus.ULO_Level4_H : %x \r\n",ResultData,bluecell_Currdatastatus.ULO_Level4_H);
+            printf("ResdBm  : %x /////  bluecell_Currdatastatus.ULO_Level4_L : %x \r\n",ResultData,bluecell_Currdatastatus.ULO_Level4_L);            
+            printf("==================END================\r\n");
+#endif // PYJ.2020.06.21_END --  
+
 #endif // PYJ.2020.06.21_END -- 
 #endif // PYJ.2020.06.20_END -- 
 
@@ -6093,12 +6241,12 @@ void AGC_Alarm_Check(uint8_t Path_Index,double AGC_Det,uint8_t* AGC_Table,uint16
 
 }
 typedef enum{
-    DLI_ALC_H = 0,
-    DLI_ALC_L,
+    DLI_AGC_H = 0,
+    DLI_AGC_L,
 };
 
-#if 0 // PYJ.2020.06.27_BEGIN -- 
-void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tableindex,uint8_t* DLI_ADC_Level,uint8_t* DLI_Level,uint8_t,DET_TABLEDL_st* DL_Table){
+#if 1 // PYJ.2020.06.27_BEGIN -- 
+void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tableindex,uint8_t* DLI_ADC_Level,uint8_t* DLI_Level,DET_TABLEDL_st* DL_Table){
         double ret = 0;
         int8_t ResdBm = 0;
         
@@ -6108,17 +6256,17 @@ void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tablei
         int16_t IwillgiveAtten = 0;
         int16_t ResultData = 0;
         int8_t* AGC_Table;// = &AGC_Table_ref[MBIC_Table_DL1_INDEX].DET_DL_0;
-
-
-        
+        Limitdata = Threshold[DLI_AGC_H] << 8;
+        Limitdata += Threshold[DLI_AGC_L];
+        Limitdata *= 0.1; 
 
         AGC_Table = &AGC_Table_ref[Tableindex].DET_DL_0;
-        ret  = DLI_ADC_Level[DLI_ALC_H] << 8;
-        ret += DLI_ADC_Level[DLI_ALC_L];   
+        ret  = DLI_ADC_Level[DLI_AGC_H] << 8;
+        ret += DLI_ADC_Level[DLI_AGC_L];
         ret *= 0.001;
         ResdBm = (int8_t)Bluecell_TestPro(AGC_AutoControl_ADC_Compare(ret,&DL_Table->Table_Det5_dBm_H,DL_Table->Table_Length * 2,AGC_Table));
-        DLI_Level[DLI_ALC_H] = ((int16_t)ResdBm & 0xFF00) >> 8;
-        DLI_Level[DLI_ALC_L] = ((int16_t)ResdBm & 0x00FF);
+        DLI_Level[DLI_AGC_H] = ((int16_t)ResdBm & 0xFF00) >> 8;
+        DLI_Level[DLI_AGC_L] = ((int16_t)ResdBm & 0x00FF);
         for(i = 0; i < sizeof(AGC_dBm_t); i++){
             if(AGC_Table[i] == ResdBm)
                 break;
@@ -6126,20 +6274,20 @@ void AGC_Package_Operate(uint8_t* Threshold,uint8_t* DL_MainAtten,uint8_t Tablei
         IwillgiveAtten = AGC_Calc(Limitdata,ResdBm);
         IwillgiveAtten *= -1;
 //        printf("==================================\r\n");
-//        printf("Current DL1 ADC VALUE : %f \r\n",ret);
-//        printf("ResdBm : DL1 : %d \r\n",ResdBm);
-//        printf("I WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten);            
-//        printf("AGC  : %d\r\n",Limitdata);            
+//        printf("Current DL% ADC VALUE : %f \r\n",Tableindex+1,ret);
+//        printf("ResdBm : DL% : %d \r\n",Tableindex+1,ResdBm);
+//        printf("I WILL GIVE YOU ATTEN  : %d\r\n",IwillgiveAtten);
+//        printf("AGC  : %d\r\n",Limitdata);
 
 
         if(ResdBm > Limitdata &&  DL_PrevIwillgiveAtten[Tableindex] > IwillgiveAtten){
 //            printf("IwillgiveAtten : %d \r\n",IwillgiveAtten);
             DL_PrevIwillgiveAtten[Tableindex] = IwillgiveAtten;
-            IwillgiveAtten = (DL_AGC_StartAtten[Tableindex]/10) + IwillgiveAtten;
+            IwillgiveAtten = (DL_AGC_StartAtten[Tableindex]*0.1) + IwillgiveAtten;
 //            printf("WILLATTEN RET : %d \r\n",IwillgiveAtten);
-            AGC_Alarm_Check(AGC_Alarm_DL1_Index,ret,&Det_DL1.Table_Det5_dBm_H,IwillgiveAtten);
-            DL_MainAtten[DLI_ALC_H] = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
-            DL_MainAtten[DLI_ALC_L] = (((IwillgiveAtten * 10) & 0x00FF));     
+            AGC_Alarm_Check(AGC_Alarm_DL1_Index,ret,&DL_Table->Table_Det5_dBm_H,IwillgiveAtten);
+            DL_MainAtten[DLI_AGC_H] = (((IwillgiveAtten * 10) & 0xFF00) >> 8) ;
+            DL_MainAtten[DLI_AGC_L] = (((IwillgiveAtten * 10) & 0x00FF));     
             CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         }
 
@@ -6234,6 +6382,7 @@ void AGC_Function(){//DL
        bluecell_Currdatastatus.ATT_DL2_L = (((IwillgiveAtten * 10) & 0x00FF));     
        CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
 #endif // PYJ.2020.06.23_END -- 
+#if 0 // PYJ.2020.06.27_BEGIN -- 
         AGC_Table = &AGC_Table_ref[MBIC_Table_DL1_INDEX].DET_DL_0;
         ret  = bluecell_Currdatastatus.DLI_P1_Level1_H << 8;
         ret += bluecell_Currdatastatus.DLI_P1_Level1_L;   
@@ -6264,6 +6413,35 @@ void AGC_Function(){//DL
             bluecell_Currdatastatus.ATT_DL1_L = (((IwillgiveAtten * 10) & 0x00FF));     
             CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         }
+#else
+    AGC_Package_Operate(&bluecell_Currdatastatus.DLI_AGC_Threshold_H,
+                        &bluecell_Currdatastatus.ATT_DL1_H,
+                        AGC_Alarm_DL1_Index,
+                        &bluecell_Currdatastatus.DLI_P1_Level1_H,
+                        &bluecell_Currdatastatus.DLI_Level1_H,
+                        &Det_DL1.Table_Det5_dBm_H                        );
+    AGC_Package_Operate(&bluecell_Currdatastatus.DLI_AGC_Threshold_H,
+                        &bluecell_Currdatastatus.ATT_DL2_H,
+                        AGC_Alarm_DL2_Index,
+                        &bluecell_Currdatastatus.DLI_P2_Level2_H,
+                        &bluecell_Currdatastatus.DLI_Level2_H,
+                        &Det_DL2.Table_Det5_dBm_H                        );
+    AGC_Package_Operate(&bluecell_Currdatastatus.DLI_AGC_Threshold_H,
+                    &bluecell_Currdatastatus.ATT_DL3_H,
+                    AGC_Alarm_DL3_Index,
+                    &bluecell_Currdatastatus.DLI_P3_Level3_H,
+                    &bluecell_Currdatastatus.DLI_Level3_H,
+                    &Det_DL3.Table_Det5_dBm_H                        );
+    AGC_Package_Operate(&bluecell_Currdatastatus.DLI_AGC_Threshold_H,
+                    &bluecell_Currdatastatus.ATT_DL4_H,
+                    AGC_Alarm_DL4_Index,
+                    &bluecell_Currdatastatus.DLI_P4_Level4_H,
+                    &bluecell_Currdatastatus.DLI_Level4_H,
+                    &Det_DL4.Table_Det5_dBm_H                        );    
+
+
+#endif // PYJ.2020.06.27_END -- 
+#if 0 // PYJ.2020.06.27_BEGIN -- 
         AGC_Table = &AGC_Table_ref[MBIC_Table_DL2_INDEX].DET_DL_0;
         ret  = bluecell_Currdatastatus.DLI_P2_Level2_H << 8;
         ret += bluecell_Currdatastatus.DLI_P2_Level2_L;   
@@ -6359,6 +6537,7 @@ void AGC_Function(){//DL
             bluecell_Currdatastatus.ATT_DL4_L = (((IwillgiveAtten * 10) & 0x00FF));     
             CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus);
         }
+#endif // PYJ.2020.06.27_END -- 
 
 
 
@@ -6864,6 +7043,7 @@ void DLI_ShutdownAlarmCheck()
         {
             /*Shutdown 5sec Alarm*/
             HAL_GPIO_WritePin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin,GPIO_PIN_RESET);//CLOCK      
+            printf("SHUTDOWN ON DL 1\r\n");
             bluecell_Currdatastatus.ATT_DL1_PATH = false;
             bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1++;
             DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index] = 0;
@@ -6911,6 +7091,7 @@ void DLI_ShutdownAlarmCheck()
         {
         
             /*Shutdown 5sec Alarm*/
+                    printf("SHUTDOWN ON DL 2\r\n");
             HAL_GPIO_WritePin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin,GPIO_PIN_RESET);//CLOCK      
             bluecell_Currdatastatus.ATT_DL2_PATH = false;
              printf("DL SHUTDOWN RECOVERY OPERATE PATH OFF\r\n");
@@ -6957,6 +7138,7 @@ void DLI_ShutdownAlarmCheck()
         if(DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL3_Shutdown_Index] >= MBIC_ON_SHUTDOWN_MAINTAIN_SEC)
         {
             /*Shutdown 5sec Alarm*/
+                    printf("SHUTDOWN ON DL 3\r\n");
             HAL_GPIO_WritePin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin,GPIO_PIN_RESET);//CLOCK      
             bluecell_Currdatastatus.ATT_DL3_PATH = false;
             bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3++;
@@ -7003,7 +7185,8 @@ void DLI_ShutdownAlarmCheck()
         if(DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL4_Shutdown_Index] >= MBIC_ON_SHUTDOWN_MAINTAIN_SEC)
         {
             /*Shutdown 5sec Alarm*/
-            HAL_GPIO_WritePin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin,GPIO_PIN_RESET);//CLOCK      
+            HAL_GPIO_WritePin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin,GPIO_PIN_RESET);//CLOCK   
+            printf("SHUTDOWN ON DL 4\r\n");
             bluecell_Currdatastatus.ATT_DL4_PATH = false;
             bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4++;
             DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL4_Shutdown_Index] = 0;

Bluecell_Src/MBIC_Bootloader.c

@@ -18,7 +18,7 @@ extern __IO bool EraseInit;
 
 extern uint8_t Bank_Flash_write(uint8_t* data,uint32_t StartBankAddress);
 extern void MBIC_DataErase_Func(uint8_t bank_num);
-extern void MBIC_APIFLASH_Func(uint8_t* data,uint32_t size);
+extern uint8_t MBIC_APIFLASH_Func(uint8_t* data,uint32_t size,uint8_t bank_num);
 extern void MBIC_DataBankWrite(uint8_t BankNum);
 
 
@@ -211,7 +211,21 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
     uint32_t TotalFrame = 0;
     uint32_t CurrFrame = 0;
     
+    uint16_t DataLength = 0;
+    uint16_t Crcret = 0;
+    uint16_t RecvCrc = 0;
     uint32_t i = 0 ;
+    uint32_t FirmFile_Length  = 0;
+    uint32_t  CurrApiAddress = 0,Bank1Address=0,Bank2Address = 0;
+    uint8_t BankNum = 0;
+    static bool CRCERR = false;
+    CurrApiAddress = FLASH_MBICUSER_START_ADDR;
+    Bank1Address = FLASH_USER_BANK1_START_ADDR;
+    Bank2Address = FLASH_USER_BANK2_START_ADDR;
+
+    uint8_t* Currdata = (uint8_t*)CurrApiAddress;
+    uint8_t* Bank1data = (uint8_t*)Bank1Address;
+    uint8_t* Bank2data = (uint8_t*)Bank2Address;    
 #if 0 // PYJ.2020.06.04_BEGIN -- 
     uint8_t dataTest[1024] = {
       0x4A,0x54,0x2D,0x4E,0x52,0x44,0x41,0x53,0x20,0x20,0x00,0x00,
@@ -225,9 +239,7 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
     };
-    
 #endif // PYJ.2020.06.04_END -- 
-    
 
 //    printf("RX");
 //    for(int i = 0; i < 128; i++)
@@ -236,6 +248,7 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
         case MBIC_Notice_REQ:
             printf("MBIC DOWNLOAD REQUEST \r\n");
             cmd = MBIC_Notice_RSP;
+            CRCERR = false;
             /*TOTAL FRAME NUMBER*/
             data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 0];
             data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 1];        
@@ -256,7 +269,8 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
            
 //            MBIC_DataBankWrite(1);
             //if()
-            MBIC_DataErase_Func(bluecell_Currdatastatus.CPU_Bank_Select);
+//            MBIC_DataErase_Func(bluecell_Currdatastatus.CPU_Bank_Select);
+//            HAL_Delay(10);
 //            printf("ccc\r\n");
         break;
         case MBIC_Download_DATA_REQ:
@@ -264,6 +278,10 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
                         |data[MBIC_PAYLOADSTART + 1] << 16
                         |data[MBIC_PAYLOADSTART + 2] << 8
                         |data[MBIC_PAYLOADSTART + 3] << 0;
+            CurrFrame = data[MBIC_PAYLOADSTART + 4] << 24
+                        |data[MBIC_PAYLOADSTART + 5] << 16
+                        |data[MBIC_PAYLOADSTART + 6] << 8
+                        |data[MBIC_PAYLOADSTART + 7] << 0; 
 //            MBIC_FileDataCheck(data);
             cmd = MBIC_Download_DATA_RSP;
             /*TOTAL FRAME NUMBER*/
@@ -293,7 +311,20 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
 #endif // PYJ.2020.06.24_END -- 
 //            printf("Data End\r\n");
 //            Bank_Flash_write(data,FLASH_USER_BANK1_START_ADDR);
-              MBIC_APIFLASH_Func(&data[MBIC_PAYLOADSTART + 12],Curr_Download_DataIndex - Prev_Download_DataIndex);
+              if(Currdata[MBIC_BOOT_VERSION + 3] == Bank1data[MBIC_BOOT_VERSION + 3]){
+                BankNum = HFR_BANK2;
+              }else{
+                BankNum = HFR_BANK1;
+              }
+              MBIC_APIFLASH_Func(&data[MBIC_PAYLOADSTART + 12],Curr_Download_DataIndex - Prev_Download_DataIndex,BankNum);
+              printf("Bank1data[MBIC_BOOT_MARK] : %d \r\n",Bank1data[MBIC_BOOT_MARK]);
+              if(BankNum == HFR_BANK1)
+                  Crcret = CRC16_Generate(&Bank1data[MBIC_BOOT_MARK], TotalFrame);
+              else
+                Crcret = CRC16_Generate(&Bank2data[MBIC_BOOT_MARK], TotalFrame);
+                printf("CurrFrame : %d ,FirmFile_Length : %x \r\n",CurrFrame,TotalFrame);
+                printf("FILE CRC RET : %x \r\n",Crcret);              
+
 //            HAL_Delay(100);
             Prev_Download_DataIndex  = Curr_Download_DataIndex + 1;
             break;
@@ -301,62 +332,63 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
             EraseInit = true;
             cmd = MBIC_Download_Confirm_RSP;
             /*TOTAL FRAME NUMBER*/
-            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 0];
-            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 1];        
-            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 2];
-            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 3];        
+            if(BankNum == HFR_BANK1){
+                FirmFile_Length = (Bank1data[MBIC_BOOT_LENGTH + 0] << 24)
+                                | Bank1data[MBIC_BOOT_LENGTH + 1] << 16
+                                | Bank1data[MBIC_BOOT_LENGTH + 2] << 8
+                                | Bank1data[MBIC_BOOT_LENGTH + 3];
+                Crcret = CRC16_Generate(&Bank1data[MBIC_BOOT_MARK], FirmFile_Length);
+            }
+            else if(BankNum == HFR_BANK2){
+                 FirmFile_Length = (Bank2data[MBIC_BOOT_LENGTH + 0] << 24)
+                                | Bank2data[MBIC_BOOT_LENGTH + 1] << 16
+                                | Bank2data[MBIC_BOOT_LENGTH + 2] << 8
+                                | Bank2data[MBIC_BOOT_LENGTH + 3];           
+                Crcret = CRC16_Generate(&Bank2data[MBIC_BOOT_MARK], FirmFile_Length);
+            }
+            RecvCrc = data[MBIC_PAYLOADSTART] << 8 | data[MBIC_PAYLOADSTART + 1];
+
+            printf("FirmFile_Length : %x \r\n",FirmFile_Length);
+            printf("FILE CRC RET : %x \r\n",Crcret);
+        
+            data[MBIC_PAYLOADSTART + index++] = ((Crcret & 0xFF00) >> 8);
+            data[MBIC_PAYLOADSTART + index++] = ((Crcret & 0x00FF));
+            if(Crcret != RecvCrc){
+                CRCERR = true;
+                printf("CRC ERROR : MBIC : %x / MDOC : %x \r\n",Crcret,RecvCrc);
+                data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 2] = 0;
+            }else{
+                CRCERR = false;
+                printf("CRC Success : MBIC : %x / MDOC : %x \r\n",Crcret,RecvCrc);
+                data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 2] = 1;
+            }
+            
+            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 3] = 0;        
             /*DOWNLOAD OPTION*/        
-            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 4];
-            Download_Option = data[MBIC_PAYLOADSTART + 4];
-            /*DOWNLOAD DELAY REQUEST*/
-            data[MBIC_PAYLOADSTART + index++] = 3;
-            /*DOWNLOAD Reserve*/
-            data[MBIC_PAYLOADSTART + index++] = 0;
-            data[MBIC_PAYLOADSTART + index++] = 0;
+            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 4] = 0;
             data[MBIC_PAYLOADSTART + index++] = 0;
             data[MBIC_PAYLOADSTART + index++] = 0;
             data[MBIC_PAYLOADSTART + index++] = 0;
-            data[MBIC_PAYLOADSTART + index++] = 0;  
+
         break;
         case MBIC_Complete_Notice_REQ_REQ:
             cmd = MBIC_Complete_Notice_RSP;
-            /*TOTAL FRAME NUMBER*/
-            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 0];
-            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 1];        
-            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 2];
-            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 3];        
-            /*DOWNLOAD OPTION*/        
-            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 4];
-            Download_Option = data[MBIC_PAYLOADSTART + 4];
-            /*DOWNLOAD DELAY REQUEST*/
-            data[MBIC_PAYLOADSTART + index++] = 3;
-            /*DOWNLOAD Reserve*/
-            data[MBIC_PAYLOADSTART + index++] = 0;
-            data[MBIC_PAYLOADSTART + index++] = 0;
-            data[MBIC_PAYLOADSTART + index++] = 0;
-            data[MBIC_PAYLOADSTART + index++] = 0;
-            data[MBIC_PAYLOADSTART + index++] = 0;
-            data[MBIC_PAYLOADSTART + index++] = 0;  
+            if(CRCERR == false){
+                data[MBIC_PAYLOADSTART + index++] = 1;  
+            }else{
+                data[MBIC_PAYLOADSTART + index++] = 0;  
+            }
+                data[MBIC_PAYLOADSTART + index++] = 1;              
             break;
         case MBIC_Reboot_Notice_REQ:
             cmd = MBIC_Reboot_Notice_RSP;
             /*TOTAL FRAME NUMBER*/
             data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 0];
-            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 1];        
-            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 2];
-            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 3];        
+            data[MBIC_PAYLOADSTART + index++] = 0;        
             /*DOWNLOAD OPTION*/        
+            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 2];
+            data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 3];            
             data[MBIC_PAYLOADSTART + index++] = data[MBIC_PAYLOADSTART + 4];
-            Download_Option = data[MBIC_PAYLOADSTART + 4];
-            /*DOWNLOAD DELAY REQUEST*/
-            data[MBIC_PAYLOADSTART + index++] = 3;
-            /*DOWNLOAD Reserve*/
-            data[MBIC_PAYLOADSTART + index++] = 0;
-            data[MBIC_PAYLOADSTART + index++] = 0;
-            data[MBIC_PAYLOADSTART + index++] = 0;
-            data[MBIC_PAYLOADSTART + index++] = 0;
-            data[MBIC_PAYLOADSTART + index++] = 0;
-            data[MBIC_PAYLOADSTART + index++] = 0;          
             break;
         default:
             return;
@@ -368,6 +400,11 @@ void MBIC_Bootloader_FirmwareUpdate(uint8_t* data){
         MBIC_Resp[i] = data[i];
     }
 //	HAL_UART_Transmit_DMA(&huart1, data,22 + 3 + index);
+    DataLength = 22 + 3 + index;
+     Crcret =CRC16_Generate(&data[MBIC_PAYLOADSTART], DataLength - 25);
+    MBIC_Resp[(DataLength - 1) - 2] = (Crcret & 0xFF00) >> 8;  
+    MBIC_Resp[(DataLength - 1) - 1] = (Crcret & 0x00FF);       
+    
     
     Uart1_Data_Send(MBIC_Resp ,22 + 3 + index);
 }

Bluecell_Src/eeprom.c

@@ -36,9 +36,11 @@ uint8_t testdata[120];
 #define ATTENTABLEDET_UL_REF -15
 #define ATTENTABLE_TEMP_REF  -10
 void EEPROM_M24C08_Init(void){
+    uint8_t* data = 0;
     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) );
+
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL1_TABLE_ADDRESDS,&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL2_TABLE_ADDRESDS,&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL3_TABLE_ADDRESDS,&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
@@ -56,7 +58,15 @@ void EEPROM_M24C08_Init(void){
 
     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) );
+//    data = &Det_UL2.Table_Det_15_dBm_H;
+//    for(int i = 0; i < sizeof(DET_TABLEUL_st) ; i ++ ){
+//        printf("[%d] %x \r\n",i,data[i]);       
+//    }    
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL2_TABLE_ADDRESDS,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
+//    data = &Det_UL3.Table_Det_15_dBm_H;
+//    for(int i = 0; i < sizeof(DET_TABLEUL_st) ; i ++ ){
+//        printf("[%d] %x \r\n",i,data[i]);       
+//    }    
     EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL3_TABLE_ADDRESDS,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
 
 
@@ -94,9 +104,9 @@ void EEPROM_M24C08_Init(void){
     bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2 = 0;        
     bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3 = 0;            
     bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 = 0;        
-    bluecell_Currdatastatus.CPUVERSION1 =  0;
-    bluecell_Currdatastatus.CPUVERSION2 = 0;
-    bluecell_Currdatastatus.CPUVERSION3 = 6;
+//    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;

Bluecell_Src/flash.c

@@ -42,18 +42,7 @@ void Flash_InitRead() // ?占쏙옙湲고븿?占쏙옙
     uint8_t* Bank1data = (uint8_t*)Bank1Address;
     uint8_t* Bank2data = (uint8_t*)Bank2Address;
 
-    
-    
     printf("Flash Init \r\n");
-    for(int i = 0; i < 6; i++){
-        if(Currdata[MBIC_BOOT_CREATION_TIME + i] != Bank1data[MBIC_BOOT_CREATION_TIME + i]){
-            ret = HFR_BANK2;
-            printf("MBIC BANK2 Booting \r\n");
-            break;
-        }else{
-            ret = HFR_BANK1;
-        }
-    }
     uint8_t* pdata;
     bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime1 = Bank1data[MBIC_BOOT_CREATION_TIME + 0];
     bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime2 = Bank1data[MBIC_BOOT_CREATION_TIME + 1];
@@ -66,13 +55,6 @@ void Flash_InitRead() // ?占쏙옙湲고븿?占쏙옙
     bluecell_Currdatastatus.CPU_Bank1_Image_Version2 = Bank1data[MBIC_BOOT_VERSION + 1];
     bluecell_Currdatastatus.CPU_Bank1_Image_Version3 = Bank1data[MBIC_BOOT_VERSION + 2];
 
-    pdata = &bluecell_Currdatastatus.CPU_Bank1_Image_Name;
-    printf("BANK1 IMAGE NAME : ");
-    for(int i = 0 ; i< 32; i++){
-        pdata[i] = Bank1data[MBIC_BOOT_FILENAME + i];
-        printf("%c",pdata[i]);
-    }
-    printf("\r\n");
 
 
     bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime1 = Bank2data[MBIC_BOOT_CREATION_TIME + 0];
@@ -86,6 +68,36 @@ void Flash_InitRead() // ?占쏙옙湲고븿?占쏙옙
     bluecell_Currdatastatus.CPU_Bank2_Image_Version2 = Bank2data[MBIC_BOOT_VERSION + 1];
     bluecell_Currdatastatus.CPU_Bank2_Image_Version3 = Bank2data[MBIC_BOOT_VERSION + 2];
 
+
+    
+    
+    bluecell_Currdatastatus.CPUVERSION1 = Currdata[MBIC_BOOT_VERSION + 0];
+    bluecell_Currdatastatus.CPUVERSION2 = Currdata[MBIC_BOOT_VERSION + 1];
+    bluecell_Currdatastatus.CPUVERSION3 = Currdata[MBIC_BOOT_VERSION + 2];
+    
+    if(bluecell_Currdatastatus.CPUVERSION1 == Bank1data[MBIC_BOOT_VERSION + 0]
+    &&bluecell_Currdatastatus.CPUVERSION1 == Bank1data[MBIC_BOOT_VERSION + 1]
+    &&bluecell_Currdatastatus.CPUVERSION1 == Bank1data[MBIC_BOOT_VERSION + 2]){
+        bluecell_Currdatastatus.CPU_Current_Bank = HFR_BANK1_SEL;
+    }else if(bluecell_Currdatastatus.CPUVERSION1 == Bank2data[MBIC_BOOT_VERSION + 0]
+    &&bluecell_Currdatastatus.CPUVERSION1 == Bank2data[MBIC_BOOT_VERSION + 1]
+    &&bluecell_Currdatastatus.CPUVERSION1 == Bank2data[MBIC_BOOT_VERSION + 2]){
+        bluecell_Currdatastatus.CPU_Current_Bank = HFR_BANK2_SEL;
+    }
+    printf("Curr Version : %02x.%02x.%02x \r\n",bluecell_Currdatastatus.CPUVERSION1,bluecell_Currdatastatus.CPUVERSION2,bluecell_Currdatastatus.CPUVERSION3);
+    printf("Bank1data Version : %02x.%02x.%02x \r\n", Bank1data[MBIC_BOOT_VERSION + 0], Bank1data[MBIC_BOOT_VERSION + 1], Bank1data[MBIC_BOOT_VERSION + 2]);
+    printf("Bank2data Version : %02x.%02x.%02x \r\n", Bank2data[MBIC_BOOT_VERSION + 0], Bank2data[MBIC_BOOT_VERSION + 1], Bank2data[MBIC_BOOT_VERSION + 2]);
+    pdata = &bluecell_Currdatastatus.CPU_Bank1_Image_Name;
+
+    
+    printf("BANK1 IMAGE NAME : ");
+    for(int i = 0 ; i< 32; i++){
+        pdata[i] = Bank1data[MBIC_BOOT_FILENAME + i];
+        printf("%c",pdata[i]);
+    }
+    printf("\r\n");
+
+    
     pdata = & bluecell_Currdatastatus.CPU_Bank2_Image_Name;
     printf("BANK2 IMAGE NAME : ");
     for(int i = 0 ; i< 32; i++){
@@ -94,20 +106,6 @@ void Flash_InitRead() // ?占쏙옙湲고븿?占쏙옙
     }
     printf("\r\n");
 
-    
-    
-   if(bluecell_Currdatastatus.CPUVERSION2 != 0){
-        bluecell_Currdatastatus.CPUVERSION1 = Currdata[MBIC_BOOT_VERSION + 0] = 0;
-        bluecell_Currdatastatus.CPUVERSION2 = Currdata[MBIC_BOOT_VERSION + 1] = 0;
-        bluecell_Currdatastatus.CPUVERSION3 = Currdata[MBIC_BOOT_VERSION + 2] = 5;
-   }else{
-        bluecell_Currdatastatus.CPUVERSION1 = Currdata[MBIC_BOOT_VERSION + 0] = 0;
-        bluecell_Currdatastatus.CPUVERSION2 = Currdata[MBIC_BOOT_VERSION + 1] = 0;
-        bluecell_Currdatastatus.CPUVERSION3 = Currdata[MBIC_BOOT_VERSION + 2] = 5;
-   }
-
-    
-
     printf("20%d Y / %d M / %d D / %d H / %d M / %d S  \r\n",
         Currdata[MBIC_BOOT_CREATION_TIME + 0],
         Currdata[MBIC_BOOT_CREATION_TIME + 1],
@@ -116,8 +114,7 @@ void Flash_InitRead() // ?占쏙옙湲고븿?占쏙옙
         Currdata[MBIC_BOOT_CREATION_TIME + 4],
         Currdata[MBIC_BOOT_CREATION_TIME + 5]        
     );
-    bluecell_Currdatastatus.CPU_Current_Bank = ret;
-    
+
     printf("MBIC BANK %d Booting \r\n",bluecell_Currdatastatus.CPU_Current_Bank);    
 
     
@@ -442,24 +439,21 @@ void MBIC_DataErase_Func(uint8_t bank_num){
     if(bank_num == HFR_BANK2){
         EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
         EraseInitStruct.PageAddress = FLASH_USER_BANK2_START_ADDR;
-        EraseInitStruct.NbPages     = (FLASH_USER_BANK2_END_ADDR - FLASH_USER_BANK2_START_ADDR) / FLASH_PAGE_SIZE;
+        EraseInitStruct.NbPages     = ((FLASH_USER_BANK2_END_ADDR - FLASH_USER_BANK2_START_ADDR) / FLASH_PAGE_SIZE) + 1;
         MBIC_Address = FLASH_USER_BANK2_START_ADDR;
         printf("I will download Bank2 \r\n");
         printf("Erase BANK 2 \r\n");
     }else{
         EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
         EraseInitStruct.PageAddress = FLASH_USER_BANK1_START_ADDR;
-        EraseInitStruct.NbPages     = (FLASH_USER_BANK1_END_ADDR - FLASH_USER_BANK1_START_ADDR) / FLASH_PAGE_SIZE;
+        EraseInitStruct.NbPages     = ((FLASH_USER_BANK1_END_ADDR - FLASH_USER_BANK1_START_ADDR) / FLASH_PAGE_SIZE) + 1;
         MBIC_Address = FLASH_USER_BANK1_START_ADDR;
         printf("I will download Bank1 \r\n");        
         printf("Erase BANK 1 \r\n");        
     }
-        EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
-        EraseInitStruct.PageAddress = FLASH_USER_BANK2_START_ADDR;
-        EraseInitStruct.NbPages     = (FLASH_USER_BANK2_END_ADDR - FLASH_USER_BANK2_START_ADDR) / FLASH_PAGE_SIZE;
-        MBIC_Address = FLASH_USER_BANK2_START_ADDR;    
 #endif // PYJ.2020.06.24_END -- 
         printf("NbPages : %x \r\n",EraseInitStruct.NbPages );
+        printf("EraseInitStruct.PageAddress : %x \r\n",EraseInitStruct.PageAddress);
 
         printf("Erase Start\r\n");
         if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
@@ -483,17 +477,45 @@ void MBIC_DataErase_Func(uint8_t bank_num){
     }
 
 }
+uint8_t BuildTimeCheck(){
+    uint32_t  CurrApiAddress = 0,Bank1Address=0,Bank2Address = 0;
+    uint32_t i = 0;
+    uint8_t ret = 0;
+    CurrApiAddress = FLASH_MBICUSER_START_ADDR;
+    Bank1Address = FLASH_USER_BANK1_START_ADDR;
+    Bank2Address = FLASH_USER_BANK2_START_ADDR;
 
+    uint8_t* Currdata = (uint8_t*)CurrApiAddress;
+    uint8_t* Bank1data = (uint8_t*)Bank1Address;
+    uint8_t* Bank2data = (uint8_t*)Bank2Address;
+    for(int i = 0 ; i < 6; i++){
+        if(Bank1data[MBIC_BOOT_CREATION_TIME + i] == Currdata[MBIC_BOOT_CREATION_TIME + i]){
+            ret = HFR_BANK1;
+        }else{
+            ret = HFR_BANK2;
+        }
+    }
+    return ret;
+}
 
-void MBIC_APIFLASH_Func(uint8_t* data,uint32_t size){
-
+uint8_t MBIC_APIFLASH_Func(uint8_t* data,uint32_t size,uint8_t bank_num){
+    static FLASH_EraseInitTypeDef EraseInitStruct;
     static uint32_t PAGEError = 0;
     static uint32_t DownloadIndex;
     static __IO uint32_t data32 = 0 , MemoryProgramStatus = 0;
     int dataindex = 0;
     uint32_t writedata = 0;
     HAL_FLASH_Unlock();
-    
+    uint32_t  CurrApiAddress = 0,Bank1Address=0,Bank2Address = 0;
+    uint32_t i = 0;
+    uint8_t ret = 0;
+    CurrApiAddress = FLASH_MBICUSER_START_ADDR;
+    Bank1Address = FLASH_USER_BANK1_START_ADDR;
+    Bank2Address = FLASH_USER_BANK2_START_ADDR;
+
+    uint8_t* Currdata = (uint8_t*)CurrApiAddress;
+    uint8_t* Bank1data = (uint8_t*)Bank1Address;
+    uint8_t* Bank2data = (uint8_t*)Bank2Address;
     /* Erase the user Flash area
       (area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR) ***********/
     
@@ -523,6 +545,71 @@ void MBIC_APIFLASH_Func(uint8_t* data,uint32_t size){
         EraseInit = true;
         printf("Erase End\r\n");
     }
+#else
+    if(EraseInit == false){
+#if 0 // PYJ.2020.06.24_BEGIN -- 
+        EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
+        EraseInitStruct.PageAddress = FLASH_USER_BANK1_START_ADDR;
+        printf("PageAddress : %x \r\n",FLASH_USER_BANK1_START_ADDR);
+//        EraseInitStruct.NbPages     = ((FLASH_USER_BANK1_START_ADDR + ((uint32_t)0xFFFF)) - FLASH_USER_BANK1_START_ADDR) / FLASH_PAGE_SIZE;
+        EraseInitStruct.NbPages     = (FLASH_USER_BANK1_START_ADDR - ((uint32_t)0xFFFF)) / FLASH_PAGE_SIZE;
+#else
+    ret = bluecell_Currdatastatus.CPU_Current_Bank;
+    if(bank_num == HFR_AUTO_SEL){
+        if(ret == HFR_BANK2)
+            bank_num = HFR_BANK1;
+        else
+            bank_num = HFR_BANK2;
+    }else{
+        if(ret == HFR_BANK2)
+            bank_num = HFR_BANK1;
+        else
+            bank_num = HFR_BANK2;
+
+    }
+    printf("Curr Bank BANK %d I will download Bank2 \r\n",ret,bank_num);
+    
+
+    if(bank_num == HFR_BANK2){
+        EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
+        EraseInitStruct.PageAddress = FLASH_USER_BANK2_START_ADDR;
+        EraseInitStruct.NbPages     = ((FLASH_USER_BANK2_END_ADDR - FLASH_USER_BANK2_START_ADDR) / FLASH_PAGE_SIZE) + 1;
+        MBIC_Address = FLASH_USER_BANK2_START_ADDR;
+        printf("I will download Bank2 \r\n");
+        printf("Erase BANK 2 \r\n");
+    }else{
+        EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
+        EraseInitStruct.PageAddress = FLASH_USER_BANK1_START_ADDR;
+        EraseInitStruct.NbPages     = ((FLASH_USER_BANK1_END_ADDR - FLASH_USER_BANK1_START_ADDR) / FLASH_PAGE_SIZE) + 1;
+        MBIC_Address = FLASH_USER_BANK1_START_ADDR;
+        printf("I will download Bank1 \r\n");        
+        printf("Erase BANK 1 \r\n");        
+    }
+#endif // PYJ.2020.06.24_END -- 
+        printf("NbPages : %x \r\n",EraseInitStruct.NbPages );
+        printf("EraseInitStruct.PageAddress : %x \r\n",EraseInitStruct.PageAddress);
+
+        printf("Erase Start\r\n");
+        if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
+        {
+          /*
+            Error occurred while page erase.
+            User can add here some code to deal with this error.
+            PAGEError will contain the faulty page and then to know the code error on this page,
+            user can call function 'HAL_FLASH_GetError()'
+          */
+          /* Infinite loop */
+          while (1)
+          {
+            /* Make LED2 blink (100ms on, 2s off) to indicate error in Erase operation */
+            printf("HAL_FLASHEx_Erase Error\r\n");
+            HAL_Delay(2000);
+          }
+        }
+        EraseInit = true;
+        printf("Erase End\r\n");
+    }
+
 #endif // PYJ.2020.06.24_END -- 
     /* Program the user Flash area word by word
       (area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR) ***********/
@@ -566,10 +653,10 @@ void MBIC_APIFLASH_Func(uint8_t* data,uint32_t size){
        }
        else
        {
-         while (1)
-         {
            printf("HAL_FLASH_Program Error\r\n");
-         }
+           printf("Flash Failed %x \r\n",MBIC_Address);
+           if(downindex / 64)
+                HAL_Delay(5);
        }
      }
 
@@ -578,7 +665,7 @@ void MBIC_APIFLASH_Func(uint8_t* data,uint32_t size){
     /* Lock the Flash to disable the flash control register access (recommended
        to protect the FLASH memory against possible unwanted operation) *********/
     HAL_FLASH_Lock();
-    
+    return bank_num;
     /* Check if the programmed data is OK
         MemoryProgramStatus = 0: data programmed correctly
         MemoryProgramStatus != 0: number of words not programmed correctly ******/

Bluecell_Src/uart.c

@@ -150,11 +150,11 @@ void Uart1_Data_Send(uint8_t* data,uint16_t size){
   //HAL_UART_Transmit_IT(&hTerminal, &data[0],size);
 //    printf("data[278] : %x \r\n",data[278]);
 ////    HAL_Delay(1);   
-    printf("\r\n [TX] : {");
-    for(int i = 0; i< size; i++)
-        printf(",0x%02x ",data[i]);
-    printf("};\r\n\tCOUNT : %d \r\n",size);
-    printf("\r\n");
+//    printf("\r\n [TX] : {");
+//    for(int i = 0; i< size; i++)
+//        printf(",0x%02x ",data[i]);
+//    printf("};\r\n\tCOUNT : %d \r\n",size);
+//    printf("\r\n");
     
 }
 

STM32F103ZET_JDASMBIC.elf.launch

@@ -57,5 +57,5 @@
 </listAttribute>
 <stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#13;&#10;&lt;memoryBlockExpressionList context=&quot;reserved-for-future-use&quot;/&gt;&#13;&#10;"/>
 <stringAttribute key="process_factory_id" value="org.eclipse.cdt.dsf.gdb.GdbProcessFactory"/>
-<stringAttribute key="saved_expressions&lt;seperator&gt;Unknown" value="uart_buf,0x08005000,0x8005000"/>
+<stringAttribute key="saved_expressions&lt;seperator&gt;Unknown" value="uart_buf,0x08005000,0x8005000,Bank2data"/>
 </launchConfiguration>

STM32F103ZE_FLASH.ld

@@ -61,8 +61,8 @@ _Min_Stack_Size = 0x400; /* required amount of stack */
 /* Specify the memory areas */
 MEMORY
 {
-RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 64K
-FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 512K
+RAM (xrw)      : ORIGIN = 0x20002800, LENGTH = 54K
+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. */