flash_programming.cpp

00001 #include "flash_programming.h"
00002 #include "stm32l4xx_hal_flash.h"
00003 
00004 uint32_t PageError = 0;
00005 
00006 FLASH_EraseInitTypeDef EraseInitStruct;
00007 
00008 uint32_t FP_GetPage(uint32_t Addr) {
00009   uint32_t page = 0;
00010   
00011   if (Addr < (FLASH_BASE + FLASH_BANK_SIZE))
00012   {
00013     /* Bank 1 */
00014     page = (Addr - FLASH_BASE) / FLASH_PAGE_SIZE;
00015   }
00016   else
00017   {
00018     /* Bank 2 */
00019     page = (Addr - (FLASH_BASE + FLASH_BANK_SIZE)) / FLASH_PAGE_SIZE;
00020   }
00021   
00022   return page;
00023 }
00024 
00025 int FP_ClearFlags() {
00026     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_PGAERR | FLASH_FLAG_OPTVERR | FLASH_FLAG_PGSERR);
00027     if((__HAL_FLASH_GET_FLAG(FLASH_FLAG_OPERR))  || (__HAL_FLASH_GET_FLAG(FLASH_FLAG_PROGERR)) || 
00028        (__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR)) || (__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGAERR))  || 
00029        (__HAL_FLASH_GET_FLAG(FLASH_FLAG_SIZERR)) || (__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGSERR))) {
00030         printf("Clear flag error\r\n");
00031         return FAILED;
00032     }    
00033     return PASSED;
00034 }
00035 
00036 uint32_t FP_ReadValue(uint32_t Addr) {
00037     uint32_t ReturnValue = *(__IO uint32_t*)Addr;
00038     return ReturnValue;
00039 }
00040 
00041 int FP_WriteRelayStates(uint8_t RelayState1, uint8_t RelayState2, uint8_t RelayState3) {
00042     uint8_t  CurrentPage = FP_GetPage(RELAY_BASE_ADDRESS);
00043     uint32_t CurrentAddress = RELAY1_ADDRESS;
00044     
00045     EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
00046     EraseInitStruct.Banks       = FLASH_BANK_1;
00047     EraseInitStruct.Page        = CurrentPage;
00048     EraseInitStruct.NbPages     = 1;      
00049     
00050     if (FP_ClearFlags() != PASSED) {
00051         return FAILED;
00052     }
00053     HAL_FLASH_Unlock();  
00054     
00055     if ((FP_ReadValue(RELAY1_ADDRESS) == RelayState1) &&
00056         (FP_ReadValue(RELAY2_ADDRESS) == RelayState2) &&
00057         (FP_ReadValue(RELAY3_ADDRESS) == RelayState3)) {
00058         printf("Relay values don't change, no need to write\r\n");
00059         HAL_FLASH_Lock();
00060         return PASSED;
00061     }
00062     if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK) {
00063         printf("Erase error, error num %d\r\n", HAL_FLASH_GetError());
00064     }  
00065     while (CurrentAddress < (RELAY3_ADDRESS + STEP_ADDRESS)) {
00066         switch (CurrentAddress) {
00067             case (RELAY1_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, RelayState1) == HAL_OK) {
00068                                         printf("Write Relay 1 State OK\r\n");
00069                                    }
00070                                    else {
00071                                         printf("Write Relay 1 State failed, error num %d\r\n", HAL_FLASH_GetError());
00072                                    }
00073             break;
00074             case (RELAY2_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, RelayState2) == HAL_OK) {
00075                                         printf("Write Relay 2 State OK\r\n");
00076                                    }
00077                                    else {
00078                                         printf("Write Relay 2 State failed, error num %d\r\n", HAL_FLASH_GetError());
00079                                    }
00080             break;
00081             case (RELAY3_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, RelayState3) == HAL_OK) {
00082                                         printf("Write Relay 3 State OK\r\n");
00083                                    }
00084                                    else {
00085                                         printf("Write Relay 3 State failed, error num %d\r\n", HAL_FLASH_GetError());
00086                                    }
00087             break;
00088             default: break;   
00089         }
00090         CurrentAddress = CurrentAddress + STEP_ADDRESS;
00091     }
00092 
00093     CurrentAddress = RELAY1_ADDRESS;
00094     while (CurrentAddress < (RELAY3_ADDRESS + STEP_ADDRESS)) {
00095         switch (CurrentAddress) {
00096             case (RELAY1_ADDRESS): if (FP_ReadValue(CurrentAddress) == RelayState1) {
00097                                     printf("Read back Relay 1 State: %d\r\n", FP_ReadValue(CurrentAddress));
00098                                  }
00099                                  else {
00100                                     printf("Write Relay 1 State failed, wrong read back value\r\n"); 
00101                                     HAL_FLASH_Lock();
00102                                     return FAILED;
00103                                  }
00104             break;
00105             case (RELAY2_ADDRESS): if (FP_ReadValue(CurrentAddress) == RelayState2) {
00106                                         printf("Read back Relay 2 State: %d\r\n", FP_ReadValue(CurrentAddress));  
00107                                     }
00108                                     else {
00109                                         printf("Write Relay 2 State failed, wrong read back value\r\n");
00110                                         HAL_FLASH_Lock();
00111                                         return FAILED;
00112                                     }
00113             break;
00114             case (RELAY3_ADDRESS): if (FP_ReadValue(CurrentAddress) == RelayState3) {
00115                                         printf("Read back Relay 3 State: %d\r\n", FP_ReadValue(CurrentAddress));  
00116                                     }
00117                                     else {
00118                                         printf("Write Relay 3 State failed, wrong read back value\r\n");
00119                                         HAL_FLASH_Lock();
00120                                         return FAILED;
00121                                     }
00122             break;
00123             default: break;   
00124         }
00125         CurrentAddress = CurrentAddress + STEP_ADDRESS;
00126     }
00127     HAL_FLASH_Lock();
00128     return PASSED;
00129 }
00130 
00131 int FP_WriteConfigValues(uint8_t Mode ,uint8_t OxyThres, uint8_t TempThres, uint32_t UploadPeriod) {
00132     uint8_t  CurrentPage    = FP_GetPage(CONF_BASE_ADDRESS);    
00133     uint32_t CurrentAddress = MODE_ADDRESS;
00134     EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
00135     EraseInitStruct.Banks       = FLASH_BANK_1;
00136     EraseInitStruct.Page        = CurrentPage;
00137     EraseInitStruct.NbPages     = 1;     
00138 
00139     if (FP_ClearFlags() != PASSED) {
00140         return FAILED;
00141     }
00142     HAL_FLASH_Unlock();  
00143     
00144     if ((FP_ReadValue(MODE_ADDRESS) == Mode) &&
00145         (FP_ReadValue(OXY_THRES_ADDRESS) == OxyThres) &&
00146         (FP_ReadValue(TEMP_THRES_ADDRESS) == TempThres) &&
00147         (FP_ReadValue(UPLOAD_PERIOD_ADDRESS) == UploadPeriod)) {
00148         printf("Configuration values don't change, no need to write\r\n");
00149         HAL_FLASH_Lock();
00150         return PASSED;
00151     }
00152     if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK) {
00153         printf("Erase error, error num %d\r\n", HAL_FLASH_GetError());
00154     }  
00155     while (CurrentAddress < (UPLOAD_PERIOD_ADDRESS + STEP_ADDRESS)) {
00156         switch (CurrentAddress) {
00157             case (MODE_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, Mode) == HAL_OK) {
00158                                     printf("Write Mode OK\r\n");
00159                                 }
00160                                 else {
00161                                     printf("Write Mode failed, error num %d\r\n", HAL_FLASH_GetError());
00162                                 }
00163             break;
00164             case (OXY_THRES_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, OxyThres) == HAL_OK) {
00165                                         printf("Write OxyThres OK\r\n");
00166                                     }
00167                                     else {
00168                                         printf("Write OxyThres failed, error num %d\r\n", HAL_FLASH_GetError());
00169                                     }
00170             break;
00171             case (TEMP_THRES_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, TempThres) == HAL_OK) {
00172                                         printf("Write TempThres OK\r\n");
00173                                     }
00174                                     else {
00175                                         printf("Write TempThres failed, error num %d\r\n", HAL_FLASH_GetError());
00176                                     }
00177             break;
00178             case (UPLOAD_PERIOD_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, UploadPeriod) == HAL_OK) {
00179                                         printf("Write UploadPeriod OK\r\n");
00180                                     }
00181                                     else {
00182                                         printf("Write UploadPeriod failed, error num %d\r\n", HAL_FLASH_GetError());
00183                                     }
00184             break;
00185             default: break;   
00186         }
00187         CurrentAddress = CurrentAddress + STEP_ADDRESS;
00188     }
00189     
00190     CurrentAddress = MODE_ADDRESS;
00191     while (CurrentAddress < (UPLOAD_PERIOD_ADDRESS + STEP_ADDRESS)) {
00192         switch (CurrentAddress) {
00193             case (MODE_ADDRESS): if (FP_ReadValue(CurrentAddress) == Mode) {
00194                                     printf("Read back Mode: %d\r\n", FP_ReadValue(CurrentAddress));
00195                                  }
00196                                  else {
00197                                     printf("Write Mode failed, wrong read back value\r\n"); 
00198                                     HAL_FLASH_Lock();
00199                                     return FAILED;
00200                                  }
00201             break;
00202             case (OXY_THRES_ADDRESS): if (FP_ReadValue(CurrentAddress) == OxyThres) {
00203                                         printf("Read back OxyThres: %d\r\n", FP_ReadValue(CurrentAddress));  
00204                                     }
00205                                     else {
00206                                         printf("Write OxyThres failed, wrong read back value\r\n");
00207                                         HAL_FLASH_Lock();
00208                                         return FAILED;
00209                                     }
00210             break;
00211             case (TEMP_THRES_ADDRESS): if (FP_ReadValue(CurrentAddress) == TempThres) {
00212                                         printf("Read back TempThres: %d\r\n", FP_ReadValue(CurrentAddress));  
00213                                     }
00214                                     else {
00215                                         printf("Write TempThres failed, wrong read back value\r\n");
00216                                         HAL_FLASH_Lock();
00217                                         return FAILED;
00218                                     }
00219             break;
00220             case (UPLOAD_PERIOD_ADDRESS): if (FP_ReadValue(CurrentAddress) == UploadPeriod) {
00221                                         printf("Read back UploadPeriod: %d\r\n", FP_ReadValue(CurrentAddress));  
00222                                     }
00223                                     else {
00224                                         printf("Write UploadPeriod failed, wrong read back value\r\n");
00225                                         HAL_FLASH_Lock();
00226                                         return FAILED;
00227                                     }
00228             break;
00229             default: break;   
00230         }
00231         CurrentAddress = CurrentAddress + STEP_ADDRESS;
00232     }
00233     HAL_FLASH_Lock();
00234     return PASSED;
00235 }
00236 
00237 int FP_WriteConfigValues(uint32_t SaturationDoVoltage) {
00238     uint8_t  CurrentPage    = FP_GetPage(SAT_DO_VOLT_ADDRESS);    
00239     uint32_t CurrentAddress = SAT_DO_VOLT_ADDRESS;
00240     EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
00241     EraseInitStruct.Banks       = FLASH_BANK_1;
00242     EraseInitStruct.Page        = CurrentPage;
00243     EraseInitStruct.NbPages     = 1;     
00244 
00245     if (FP_ClearFlags() != PASSED) {
00246         return FAILED;
00247     }
00248     HAL_FLASH_Unlock();     
00249 
00250     if ((FP_ReadValue(SAT_DO_VOLT_ADDRESS) == SaturationDoVoltage)) {
00251         printf("Configuration values doesn't change, no need to write\r\n");
00252         HAL_FLASH_Lock();
00253         return PASSED;
00254     }
00255     if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK) {
00256         printf("Erase error, error num %d\r\n", HAL_FLASH_GetError());
00257     }  
00258     if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, SaturationDoVoltage) == HAL_OK) {
00259         printf("Write SaturationDoVoltage OK\r\n");
00260     }
00261     else {
00262         printf("Write SaturationDoVoltage failed, error num %d\r\n", HAL_FLASH_GetError());
00263     }
00264     if (FP_ReadValue(CurrentAddress) == SaturationDoVoltage) {
00265         printf("Read back SaturationDoVoltage: %d\r\n", FP_ReadValue(CurrentAddress));  
00266     }
00267     else {
00268         printf("Write SaturationDoVoltage failed, wrong read back value\r\n");
00269         HAL_FLASH_Lock();
00270         return FAILED;
00271     }
00272     HAL_FLASH_Lock();
00273     return PASSED;
00274 }
00275 
00276 int FP_SetAlarmValues(uint32_t WriteTimeValue, uint8_t SetRelayState1, uint8_t SetRelayState2) {
00277     uint8_t  CurrentPage = FP_GetPage(ALRM_BASE_ADDRESS);
00278     uint32_t CurrentAddress = ALARM_TIME_ADDRESS;
00279     
00280     EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
00281     EraseInitStruct.Banks       = FLASH_BANK_1;
00282     EraseInitStruct.Page        = CurrentPage;
00283     EraseInitStruct.NbPages     = 1;      
00284     
00285     if (FP_ClearFlags() != PASSED) {
00286         return FAILED;
00287     }
00288     HAL_FLASH_Unlock();  
00289     
00290     if ((FP_ReadValue(ALARM_TIME_ADDRESS)  == WriteTimeValue) &&
00291         (FP_ReadValue(SET_RELAY_1_ADDRESS) == SetRelayState1) &&
00292         (FP_ReadValue(SET_RELAY_2_ADDRESS) == SetRelayState2)) {
00293         printf("Relay values don't change, no need to write\r\n");
00294         HAL_FLASH_Lock();
00295         return PASSED;
00296     }
00297     if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK) {
00298         printf("Erase error, error num %d\r\n", HAL_FLASH_GetError());
00299     }  
00300     while (CurrentAddress < (SET_RELAY_2_ADDRESS + STEP_ADDRESS)) {
00301         switch (CurrentAddress) {
00302             case (ALARM_TIME_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, WriteTimeValue) == HAL_OK) {
00303                                         printf("Write WriteTimeValue OK\r\n");
00304                                    }
00305                                    else {
00306                                         printf("Write WriteTimeValue failed, error num %d\r\n", HAL_FLASH_GetError());
00307                                    }
00308             break;
00309             case (SET_RELAY_1_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, SetRelayState1) == HAL_OK) {
00310                                         printf("Write SetRelayState1 OK\r\n");
00311                                    }
00312                                    else {
00313                                         printf("Write SetRelayState1 failed, error num %d\r\n", HAL_FLASH_GetError());
00314                                    }
00315             break;
00316             case (SET_RELAY_2_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, SetRelayState2) == HAL_OK) {
00317                                         printf("Write SetRelayState2 OK\r\n");
00318                                    }
00319                                    else {
00320                                         printf("Write SetRelayState2 failed, error num %d\r\n", HAL_FLASH_GetError());
00321                                    }
00322             break;
00323             default: break;   
00324         }
00325         CurrentAddress = CurrentAddress + STEP_ADDRESS;
00326     }
00327 
00328     CurrentAddress = ALARM_TIME_ADDRESS;
00329     while (CurrentAddress < (SET_RELAY_2_ADDRESS + STEP_ADDRESS)) {
00330         switch (CurrentAddress) {
00331             case (ALARM_TIME_ADDRESS): if (FP_ReadValue(CurrentAddress) == WriteTimeValue) {
00332                                     printf("Read back WriteTimeValue: %d\r\n", FP_ReadValue(CurrentAddress));
00333                                  }
00334                                  else {
00335                                     printf("Write WriteTimeValue failed, wrong read back value\r\n"); 
00336                                     HAL_FLASH_Lock();
00337                                     return FAILED;
00338                                  }
00339             break;
00340             case (SET_RELAY_1_ADDRESS): if (FP_ReadValue(CurrentAddress) == SetRelayState1) {
00341                                         printf("Read back SetRelayState1: %d\r\n", FP_ReadValue(CurrentAddress));  
00342                                     }
00343                                     else {
00344                                         printf("Write SetRelayState1 failed, wrong read back value\r\n");
00345                                         HAL_FLASH_Lock();
00346                                         return FAILED;
00347                                     }
00348             break;
00349             case (SET_RELAY_2_ADDRESS): if (FP_ReadValue(CurrentAddress) == SetRelayState2) {
00350                                         printf("Read back SetRelayState2: %d\r\n", FP_ReadValue(CurrentAddress));  
00351                                     }
00352                                     else {
00353                                         printf("Write SetRelayState2 failed, wrong read back value\r\n");
00354                                         HAL_FLASH_Lock();
00355                                         return FAILED;
00356                                     }
00357             break;
00358             default: break;   
00359         }
00360         CurrentAddress = CurrentAddress + STEP_ADDRESS;
00361     }
00362     HAL_FLASH_Lock();
00363     return PASSED;    
00364 }