iot_water_monitor_v2
Dependencies: easy-connect-v16 Watchdog FP MQTTPacket RecordType-v-16 watersenor_and_temp_code
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 }
Generated on Tue Jul 12 2022 20:06:04 by 1.7.2