Mercurial > public > ostc4
annotate OtherSources/firmwareEraseProgram.c @ 1068:3c3fb9f4edc4 Icon_Integration
Increase version number for testing
| author | heinrichsweikamp |
|---|---|
| date | Tue, 17 Feb 2026 12:22:47 +0100 |
| parents | a7ed4eb3142b |
| children |
| rev | line source |
|---|---|
| 5 | 1 /** |
| 2 ****************************************************************************** | |
| 3 * @file firmwareEraseProgram.c | |
| 36 | 4 * @author heinrichs weikamp gmbh |
| 5 | 5 * @version V0.0.1 |
| 6 * @date 05-May-2015 | |
| 7 * @version V0.0.1 | |
| 8 * @since 05-May-2015 | |
| 9 * @brief erase and program the STM32F4xx internal FLASH memory | |
| 10 * | |
| 11 @verbatim | |
| 12 ============================================================================== | |
| 13 ##### How to use ##### | |
| 14 ============================================================================== | |
| 15 ADDR_FLASH_SECTOR_0 to/with ADDR_FLASH_SECTOR_5 (256KB) is used for this bootloader | |
| 16 | |
| 17 ADDR_FLASH_SECTOR_23 is blocked and used for Font T48 and image_heinrichs_weikamp | |
| 18 Font T24 for button text is not blocked / protected | |
| 19 other fonts should not be used here | |
| 20 | |
| 21 | |
| 22 ============================================================================== | |
| 23 ##### From AN2557 ##### | |
| 24 STM32F10xxx In-Application programming CD00161640.pdf 2010 | |
| 25 ============================================================================== | |
| 26 User program conditions | |
| 27 The user application to be loaded into the Flash memory using IAP should be built with | |
| 28 these configuration settings: | |
| 29 1. Set the program load address at 0x08003000, using your toolchain linker file | |
| 30 2. Relocate the vector table at address 0x08003000, using the | |
| 31 "NVIC_SetVectorTable"function or the VECT_TAB_OFFSET definition inside the | |
| 32 "system_stm32f10x.c" | |
| 33 | |
| 34 can be found here system_stm32f4xx.c | |
| 35 | |
| 36 | |
| 37 @endverbatim | |
| 38 ****************************************************************************** | |
| 39 * @attention | |
| 40 * | |
| 41 * <h2><center>© COPYRIGHT(c) 2015 heinrichs weikamp</center></h2> | |
| 42 * | |
| 43 ****************************************************************************** | |
| 44 */ | |
| 45 | |
| 46 /* Includes ------------------------------------------------------------------*/ | |
| 47 #include "stm32f4xx_hal.h" | |
| 48 #include "stdio.h" | |
| 49 #include "firmwareEraseProgram.h" | |
| 50 #include "settings.h" // to access SHardwareData | |
| 51 | |
| 52 /* Exported variables --------------------------------------------------------*/ | |
| 53 | |
| 54 /* Private types -------------------------------------------------------------*/ | |
| 55 | |
| 56 /* Private variables ---------------------------------------------------------*/ | |
| 57 | |
| 58 static FLASH_EraseInitTypeDef EraseInitStruct; /*Variable used for Erase procedure*/ | |
| 59 | |
| 60 uint32_t FirstSector = 0, NbOfSectors = 0, Address = 0; | |
| 61 uint32_t SectorError = 0; | |
| 62 __IO uint32_t data32 = 0 , MemoryProgramStatus = 0; | |
| 63 | |
| 64 | |
| 65 | |
| 66 /* Private function prototypes -----------------------------------------------*/ | |
| 67 //static void firmware_Error_Handler(HAL_StatusTypeDef reason); | |
| 68 static uint32_t GetSector(uint32_t Address); | |
| 69 uint8_t hardware_programm_sub(uint8_t *buffer64, uint8_t length, uint32_t startAddress); | |
| 70 | |
| 71 /* Exported functions --------------------------------------------------------*/ | |
| 72 | |
| 73 const SHardwareData* hardwareDataGetPointer(void) | |
| 74 { | |
| 75 return (SHardwareData*)HARDWAREDATA_ADDRESS; | |
| 76 } | |
| 77 | |
| 78 uint8_t hardware_programmPrimaryBluetoothNameSet(void) | |
| 79 { | |
| 80 uint8_t data = 0xF0; | |
| 81 return hardware_programm_sub(&data, 1, HARDWAREDATA_ADDRESS + 7); | |
| 82 } | |
| 83 | |
| 84 | |
| 85 uint8_t hardware_programmSecondaryBluetoothNameSet(void) | |
| 86 { | |
| 87 uint8_t data = 0xF0; | |
| 88 return hardware_programm_sub(&data, 1, HARDWAREDATA_ADDRESS + 52 + 7); | |
| 89 } | |
| 90 | |
| 91 | |
| 92 uint8_t hardware_programmProductionData(uint8_t *buffer52) | |
| 93 { | |
| 94 buffer52[7] = 0xFF;// production_bluetooth_name_set | |
| 95 return hardware_programm_sub(buffer52, 52, HARDWAREDATA_ADDRESS);// check base_bootloader.c of OSTC4bootloader code and settings.h | |
| 96 } | |
| 97 | |
| 98 | |
| 99 uint8_t hardware_programmSecondarySerial(uint8_t *buffer12) | |
| 100 { | |
| 101 buffer12[7] = 0xFF;// secondary_bluetooth_name_set | |
| 102 return hardware_programm_sub(buffer12, 12, HARDWAREDATA_ADDRESS + 52); | |
| 103 } | |
| 104 | |
| 105 | |
| 106 uint8_t hardware_programm_sub(uint8_t *buffer, uint8_t length, uint32_t startAddress) | |
| 107 { | |
| 108 HAL_StatusTypeDef answer; | |
| 109 | |
| 110 uint32_t ptr = 0; | |
| 111 uint8_t data8; | |
| 112 | |
| 113 // test empty | |
| 114 Address = startAddress; | |
| 115 for(int i=0;i<length;i++) | |
| 116 { | |
| 117 if((*(uint8_t *)Address != 0xFF) && (buffer[i] != 0xFF)) | |
| 118 return 0xE0; | |
| 119 Address = Address + 1; | |
| 120 } | |
| 121 | |
| 122 // start programming | |
| 123 HAL_FLASH_Unlock(); | |
| 124 | |
| 125 Address = startAddress; | |
| 126 ptr = 0; | |
| 127 answer = HAL_OK; | |
| 128 while (ptr < length) | |
| 129 { | |
| 130 if(buffer[ptr] != 0xFF) | |
| 131 { | |
| 132 answer = HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, Address, buffer[ptr]); | |
| 133 } | |
| 134 if (answer == HAL_OK) | |
| 135 { | |
| 136 Address = Address + 1; | |
| 137 ptr++; | |
| 138 } | |
| 139 else | |
| 140 { | |
| 141 HAL_FLASH_Lock(); | |
| 142 return answer; | |
| 143 } | |
| 144 } | |
| 145 HAL_FLASH_Lock(); | |
| 146 | |
| 147 /* Check if the programmed data is OK | |
| 148 MemoryProgramStatus = 0: data programmed correctly | |
| 149 MemoryProgramStatus != 0: number of words not programmed correctly ******/ | |
| 150 Address = startAddress; // check base_bootloader.c of OSTC4bootloader code | |
| 151 MemoryProgramStatus = 0x0; | |
| 152 | |
| 153 ptr = 0; | |
| 154 while(ptr < length) | |
| 155 { | |
| 156 data8 = *(__IO uint8_t*)Address; | |
| 157 | |
| 158 if((buffer[ptr] != 0xFF) && (data8 != buffer[ptr])) | |
| 159 { | |
| 160 MemoryProgramStatus++; | |
| 161 } | |
| 162 | |
| 163 Address = Address + 1; | |
| 164 ptr++; | |
| 165 } | |
| 166 | |
| 167 /* Check if there is an issue to program data */ | |
| 168 if (MemoryProgramStatus == 0) | |
| 169 { | |
| 170 return HAL_OK; | |
| 171 } | |
| 172 else | |
| 173 { | |
| 174 return 0xEE; | |
| 175 } | |
| 176 } | |
| 177 | |
| 178 | |
| 179 uint8_t firmware2_variable_upperpart_eraseFlashMemory(uint32_t length, uint32_t offset) | |
| 180 { | |
| 181 uint32_t startAddress, endAddress; | |
| 182 | |
| 183 // HAL_StatusTypeDef answer; | |
| 184 HAL_FLASH_Unlock(); | |
| 185 | |
| 186 startAddress = FLASH_FW2_START_ADDR + offset; | |
| 187 endAddress = startAddress + length; | |
| 188 | |
| 189 if(endAddress > FLASH_FW2_END_ADDR) | |
| 190 endAddress = FLASH_FW2_END_ADDR; | |
| 191 | |
| 192 FirstSector = GetSector(startAddress); | |
| 193 NbOfSectors = GetSector(endAddress) - FirstSector + 1; | |
| 194 | |
| 195 EraseInitStruct.TypeErase = FLASH_TYPEERASE_SECTORS; | |
| 196 EraseInitStruct.VoltageRange = FLASH_VOLTAGE_RANGE_1; | |
| 197 EraseInitStruct.Sector = FirstSector; | |
| 198 EraseInitStruct.NbSectors = NbOfSectors; | |
| 199 | |
| 200 return HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError); | |
| 201 } | |
| 202 | |
| 203 | |
| 204 uint8_t firmware2_variable_upperpart_programFlashMemory(uint32_t length, uint32_t offset, uint8_t *pBuffer1, uint32_t pBuffer1Size, uint8_t *pBuffer2) | |
| 205 { | |
| 206 HAL_StatusTypeDef answer; | |
| 207 uint32_t ptr = 0; | |
| 208 uint32_t length1, length2; | |
| 209 | |
| 210 if((pBuffer2) && (length > pBuffer1Size)) | |
| 211 { | |
| 212 length1 = pBuffer1Size; | |
| 213 length2 = length - length1; | |
| 214 } | |
| 215 else | |
| 216 { | |
| 217 length1 = length; | |
| 218 length2 = 0; | |
| 219 } | |
| 220 | |
| 221 Address = FLASH_FW2_START_ADDR + offset; | |
| 222 | |
| 223 ptr = 0; | |
| 224 while ((Address <= FLASH_FW2_END_ADDR) && (ptr < length1)) | |
| 225 { | |
| 226 answer = HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, Address, pBuffer1[ptr]); | |
| 227 if (answer == HAL_OK) | |
| 228 { | |
| 229 Address = Address + 1; | |
| 230 ptr++; | |
| 231 } | |
| 232 else | |
| 233 { | |
| 234 return answer; | |
| 235 } | |
| 236 } | |
| 237 ptr = 0; | |
| 238 while ((Address <= FLASH_FW2_END_ADDR) && (ptr < length2)) | |
| 239 { | |
| 240 answer = HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, Address, pBuffer2[ptr]); | |
| 241 if (answer == HAL_OK) | |
| 242 { | |
| 243 Address = Address + 1; | |
| 244 ptr++; | |
| 245 } | |
| 246 else | |
| 247 { | |
| 248 return answer; | |
| 249 } | |
| 250 } | |
| 251 HAL_FLASH_Lock(); | |
| 252 | |
| 253 Address = FLASH_FW2_START_ADDR + offset;; | |
| 254 MemoryProgramStatus = 0x0; | |
| 255 | |
| 256 ptr = 0; | |
| 257 while ((Address <= FLASH_FW2_END_ADDR) && (ptr < length1)) | |
| 258 { | |
| 259 data32 = *(__IO uint8_t*)Address; | |
| 260 | |
| 261 if (data32 != pBuffer1[ptr]) | |
| 262 { | |
| 263 MemoryProgramStatus++; | |
| 264 } | |
| 265 | |
| 266 Address = Address + 1; | |
| 267 ptr++; | |
| 268 } | |
| 269 ptr = 0; | |
| 270 while ((Address <= FLASH_FW2_END_ADDR) && (ptr < length2)) | |
| 271 { | |
| 272 data32 = *(__IO uint8_t*)Address; | |
| 273 | |
| 274 if (data32 != pBuffer2[ptr]) | |
| 275 { | |
| 276 MemoryProgramStatus++; | |
| 277 } | |
| 278 | |
| 279 Address = Address + 1; | |
| 280 ptr++; | |
| 281 } | |
| 282 | |
| 283 if (MemoryProgramStatus == 0) | |
| 284 { | |
| 285 return HAL_OK; | |
| 286 } | |
| 287 else | |
| 288 { | |
| 289 return 0xEE; | |
| 290 } | |
| 291 } | |
| 292 | |
| 293 uint8_t firmware_eraseFlashMemory(void) | |
| 294 { | |
| 295 // HAL_StatusTypeDef answer; | |
| 296 /* Unlock the Flash to enable the flash control register access *************/ | |
| 297 HAL_FLASH_Unlock(); | |
| 298 | |
| 299 /* Erase the user Flash area | |
| 300 (area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR) ***********/ | |
| 301 | |
| 302 /* Get the 1st sector to erase */ | |
| 303 FirstSector = GetSector(FLASH_FW_START_ADDR); | |
| 304 /* Get the number of sector to erase from 1st sector*/ | |
| 305 NbOfSectors = GetSector(FLASH_FW_END_ADDR) - FirstSector + 1; | |
| 306 | |
| 307 /* Fill EraseInit structure*/ | |
| 308 EraseInitStruct.TypeErase = FLASH_TYPEERASE_SECTORS; | |
| 309 EraseInitStruct.VoltageRange = FLASH_VOLTAGE_RANGE_1; | |
| 310 EraseInitStruct.Sector = FirstSector; | |
| 311 EraseInitStruct.NbSectors = NbOfSectors; | |
| 312 | |
| 313 /* Note: If an erase operation in Flash memory also concerns data in the data or instruction cache, | |
| 314 you have to make sure that these data are rewritten before they are accessed during code | |
| 315 execution. If this cannot be done safely, it is recommended to flush the caches by setting the | |
| 316 DCRST and ICRST bits in the FLASH_CR register. */ | |
| 317 return HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError); | |
| 318 } | |
| 319 | |
| 320 uint8_t firmware_programFlashMemory(uint8_t *pBuffer1, uint32_t length1)//, uint8_t *pBuffer2, uint32_t length2) | |
| 321 { | |
| 322 HAL_StatusTypeDef answer; | |
| 323 | |
| 324 /* Program the user Flash area word by word | |
| 325 (area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR) ***********/ | |
| 326 | |
| 327 uint32_t ptr = 0; | |
| 328 | |
| 329 Address = FLASH_FW_START_ADDR; | |
| 330 | |
| 331 ptr = 0; | |
| 332 while ((Address <= FLASH_FW_END_ADDR) && (ptr < length1)) | |
| 333 { | |
| 334 answer = HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, Address, pBuffer1[ptr]); | |
| 335 if (answer == HAL_OK) | |
| 336 // if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, DATA_32) == HAL_OK) | |
| 337 { | |
| 338 Address = Address + 1;//4; | |
| 339 ptr++; | |
| 340 } | |
| 341 else | |
| 342 { | |
| 343 return answer; | |
| 344 } | |
| 345 } | |
| 346 /* same for pBuffer2 | |
| 347 ptr = 0; | |
| 348 while ((Address < FLASH_FW_END_ADDR) && (ptr < length2)) | |
| 349 { | |
| 350 | |
| 351 if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, Address, pBuffer2[ptr]) == HAL_OK) | |
| 352 { | |
| 353 Address = Address + 1; | |
| 354 ptr++; | |
| 355 } | |
| 356 else | |
| 357 { | |
| 358 firmware_Error_Handler(); | |
| 359 } | |
| 360 } | |
| 361 */ | |
| 362 /* Lock the Flash to disable the flash control register access (recommended | |
| 363 to protect the FLASH memory against possible unwanted operation) *********/ | |
| 364 HAL_FLASH_Lock(); | |
| 365 | |
| 366 /* Check if the programmed data is OK | |
| 367 MemoryProgramStatus = 0: data programmed correctly | |
| 368 MemoryProgramStatus != 0: number of words not programmed correctly ******/ | |
| 369 Address = FLASH_FW_START_ADDR; | |
| 370 MemoryProgramStatus = 0x0; | |
| 371 | |
| 372 ptr = 0; | |
| 373 while ((Address <= FLASH_FW_END_ADDR) && (ptr < length1)) | |
| 374 { | |
| 375 data32 = *(__IO uint8_t*)Address; | |
| 376 | |
| 377 if (data32 != pBuffer1[ptr]) | |
| 378 { | |
| 379 MemoryProgramStatus++; | |
| 380 } | |
| 381 | |
| 382 Address = Address + 1;//4; | |
| 383 ptr++; | |
| 384 } | |
| 385 /* same for pBuffer2 | |
| 386 ptr = 0; | |
| 387 while ((Address < FLASH_FW_END_ADDR) && (ptr < length2)) | |
| 388 { | |
| 389 data32 = *(__IO uint32_t*)Address; | |
| 390 | |
| 391 if (data32 != pBuffer2[ptr]) | |
| 392 { | |
| 393 MemoryProgramStatus++; | |
| 394 } | |
| 395 | |
| 396 Address = Address + 1;//4; | |
| 397 ptr++; | |
| 398 } | |
| 399 */ | |
| 400 /* Check if there is an issue to program data */ | |
| 401 if (MemoryProgramStatus == 0) | |
| 402 { | |
| 403 return HAL_OK; | |
| 404 /* No error detected. Switch on LED3 */ | |
| 405 } | |
| 406 else | |
| 407 { | |
| 408 return 0xEE; | |
| 409 } | |
| 410 | |
| 411 | |
| 412 } | |
| 413 | |
| 1017 | 414 |
| 415 uint8_t bootloader_eraseFlashMemory(void) | |
| 416 { | |
| 417 // HAL_StatusTypeDef answer; | |
| 418 /* Unlock the Flash to enable the flash control register access *************/ | |
| 419 HAL_FLASH_Unlock(); | |
| 420 | |
| 421 /* Erase the user Flash area | |
| 422 (area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR) ***********/ | |
| 423 | |
| 424 /* Get the 1st sector to erase */ | |
| 425 FirstSector = GetSector(FLASH_BOOT_START_ADDR); | |
| 426 /* Get the number of sector to erase from 1st sector*/ | |
| 427 NbOfSectors = GetSector(FLASH_BOOT_END_ADDR) - FirstSector + 1; | |
| 428 | |
| 429 /* Fill EraseInit structure*/ | |
| 430 EraseInitStruct.TypeErase = FLASH_TYPEERASE_SECTORS; | |
| 431 EraseInitStruct.VoltageRange = FLASH_VOLTAGE_RANGE_1; | |
| 432 EraseInitStruct.Sector = FirstSector; | |
| 433 EraseInitStruct.NbSectors = NbOfSectors; | |
| 434 | |
| 435 /* Note: If an erase operation in Flash memory also concerns data in the data or instruction cache, | |
| 436 you have to make sure that these data are rewritten before they are accessed during code | |
| 437 execution. If this cannot be done safely, it is recommended to flush the caches by setting the | |
| 438 DCRST and ICRST bits in the FLASH_CR register. */ | |
| 439 return HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError); | |
| 440 } | |
| 441 | |
| 442 uint8_t bootloader_programFlashMemory(uint8_t *pBuffer1, uint32_t length1, SHardwareData* pHwInfo) | |
| 443 { | |
| 444 HAL_StatusTypeDef answer; | |
| 445 | |
| 446 /* Program the user Flash area word by word | |
| 447 (area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR) ***********/ | |
| 448 | |
| 449 uint32_t index = 0; | |
| 450 Address = FLASH_BOOT_START_ADDR; | |
| 451 | |
| 452 uint8_t* pHardwareInfo = (uint8_t*) pHwInfo; | |
| 453 uint8_t tmp = 0; | |
| 454 | |
| 455 index = 0; | |
| 456 while ((Address <= FLASH_FW_END_ADDR) && (index < length1)) | |
| 457 { | |
| 458 if((Address >= HARDWAREDATA_ADDRESS) && (Address < HARDWAREDATA_ADDRESS + sizeof(SHardwareData))) | |
| 459 { | |
| 460 answer = HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, Address, *pHardwareInfo++); | |
| 461 } | |
| 462 else | |
| 463 { | |
| 464 answer = HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, Address, pBuffer1[index]); | |
| 465 } | |
| 466 if (answer == HAL_OK) | |
| 467 { | |
| 468 Address = Address + 1; | |
| 469 index++; | |
| 470 } | |
| 471 else | |
| 472 { | |
| 473 return answer; | |
| 474 } | |
| 475 } | |
| 476 /* Lock the Flash to disable the flash control register access (recommended | |
| 477 to protect the FLASH memory against possible unwanted operation) *********/ | |
| 478 HAL_FLASH_Lock(); | |
| 479 | |
| 480 /* Check if the programmed data is OK | |
| 481 MemoryProgramStatus = 0: data programmed correctly | |
| 482 MemoryProgramStatus != 0: number of words not programmed correctly ******/ | |
| 483 Address = FLASH_BOOT_START_ADDR; | |
| 484 MemoryProgramStatus = 0x0; | |
| 485 | |
| 486 index = 0; | |
| 487 pHardwareInfo = (uint8_t*) pHwInfo; | |
| 488 | |
| 489 while ((Address <= FLASH_FW_END_ADDR) && (index < length1)) | |
| 490 { | |
| 491 if((Address >= HARDWAREDATA_ADDRESS) && (Address < HARDWAREDATA_ADDRESS + sizeof(SHardwareData))) | |
| 492 { | |
| 493 tmp = *pHardwareInfo++; | |
| 494 } | |
| 495 else | |
| 496 { | |
| 497 tmp = pBuffer1[index]; | |
| 498 } | |
| 499 | |
| 500 data32 = *(__IO uint8_t*)Address; | |
| 501 if (data32 != tmp) | |
| 502 { | |
| 503 MemoryProgramStatus++; | |
| 504 } | |
| 505 | |
| 506 Address = Address + 1; | |
| 507 index++; | |
| 508 } | |
| 509 /* Check if there is an issue to program data */ | |
| 510 if (MemoryProgramStatus == 0) | |
| 511 { | |
| 512 return HAL_OK; | |
| 513 /* No error detected. Switch on LED3 */ | |
| 514 } | |
| 515 else | |
| 516 { | |
| 517 return 0xEE; | |
| 518 } | |
| 519 } | |
| 520 | |
| 521 | |
| 522 uint32_t CalcFletcher32(uint32_t startAddr, uint32_t endAddr) | |
| 523 { | |
| 524 uint16_t sum1 = 0; | |
| 525 uint16_t sum2 = 0; | |
|
1051
4b6afe5551e1
Refactors CalcFletcher32 in OtherSources/firmwareEraseProgram.c to iterate over 16-bit words via a pointer instead of an index-based loop. Removes unused variables and returns the computed 32-bit Fletcher checksum directly. (mikeller)
heinrichsweikamp
parents:
1017
diff
changeset
|
526 for (uint16_t *index = (uint16_t *)startAddr; index <= (uint16_t *)endAddr; index++) { |
|
4b6afe5551e1
Refactors CalcFletcher32 in OtherSources/firmwareEraseProgram.c to iterate over 16-bit words via a pointer instead of an index-based loop. Removes unused variables and returns the computed 32-bit Fletcher checksum directly. (mikeller)
heinrichsweikamp
parents:
1017
diff
changeset
|
527 sum1 = sum1 + *index; |
|
4b6afe5551e1
Refactors CalcFletcher32 in OtherSources/firmwareEraseProgram.c to iterate over 16-bit words via a pointer instead of an index-based loop. Removes unused variables and returns the computed 32-bit Fletcher checksum directly. (mikeller)
heinrichsweikamp
parents:
1017
diff
changeset
|
528 sum2 = (sum2 + sum1); |
| 1017 | 529 } |
|
1051
4b6afe5551e1
Refactors CalcFletcher32 in OtherSources/firmwareEraseProgram.c to iterate over 16-bit words via a pointer instead of an index-based loop. Removes unused variables and returns the computed 32-bit Fletcher checksum directly. (mikeller)
heinrichsweikamp
parents:
1017
diff
changeset
|
530 return (sum2 << 16) | sum1; |
| 1017 | 531 } |
| 532 | |
| 533 | |
| 5 | 534 /* Private functions ---------------------------------------------------------*/ |
| 535 | |
| 536 /** | |
| 537 * @brief Gets the sector of a given address | |
| 538 * @param None | |
| 539 * @retval The sector of a given address | |
| 540 */ | |
| 541 static uint32_t GetSector(uint32_t Address) | |
| 542 { | |
| 543 uint32_t sector = 0; | |
| 544 | |
| 545 if((Address < ADDR_FLASH_SECTOR_1) && (Address >= ADDR_FLASH_SECTOR_0)) | |
| 546 { | |
| 547 sector = FLASH_SECTOR_0; | |
| 548 } | |
| 549 else if((Address < ADDR_FLASH_SECTOR_2) && (Address >= ADDR_FLASH_SECTOR_1)) | |
| 550 { | |
| 551 sector = FLASH_SECTOR_1; | |
| 552 } | |
| 553 else if((Address < ADDR_FLASH_SECTOR_3) && (Address >= ADDR_FLASH_SECTOR_2)) | |
| 554 { | |
| 555 sector = FLASH_SECTOR_2; | |
| 556 } | |
| 557 else if((Address < ADDR_FLASH_SECTOR_4) && (Address >= ADDR_FLASH_SECTOR_3)) | |
| 558 { | |
| 559 sector = FLASH_SECTOR_3; | |
| 560 } | |
| 561 else if((Address < ADDR_FLASH_SECTOR_5) && (Address >= ADDR_FLASH_SECTOR_4)) | |
| 562 { | |
| 563 sector = FLASH_SECTOR_4; | |
| 564 } | |
| 565 else if((Address < ADDR_FLASH_SECTOR_6) && (Address >= ADDR_FLASH_SECTOR_5)) | |
| 566 { | |
| 567 sector = FLASH_SECTOR_5; | |
| 568 } | |
| 569 else if((Address < ADDR_FLASH_SECTOR_7) && (Address >= ADDR_FLASH_SECTOR_6)) | |
| 570 { | |
| 571 sector = FLASH_SECTOR_6; | |
| 572 } | |
| 573 else if((Address < ADDR_FLASH_SECTOR_8) && (Address >= ADDR_FLASH_SECTOR_7)) | |
| 574 { | |
| 575 sector = FLASH_SECTOR_7; | |
| 576 } | |
| 577 else if((Address < ADDR_FLASH_SECTOR_9) && (Address >= ADDR_FLASH_SECTOR_8)) | |
| 578 { | |
| 579 sector = FLASH_SECTOR_8; | |
| 580 } | |
| 581 else if((Address < ADDR_FLASH_SECTOR_10) && (Address >= ADDR_FLASH_SECTOR_9)) | |
| 582 { | |
| 583 sector = FLASH_SECTOR_9; | |
| 584 } | |
| 585 else if((Address < ADDR_FLASH_SECTOR_11) && (Address >= ADDR_FLASH_SECTOR_10)) | |
| 586 { | |
| 587 sector = FLASH_SECTOR_10; | |
| 588 } | |
| 589 else if((Address < ADDR_FLASH_SECTOR_12) && (Address >= ADDR_FLASH_SECTOR_11)) | |
| 590 { | |
| 591 sector = FLASH_SECTOR_11; | |
| 592 } | |
| 593 else if((Address < ADDR_FLASH_SECTOR_13) && (Address >= ADDR_FLASH_SECTOR_12)) | |
| 594 { | |
| 595 sector = FLASH_SECTOR_12; | |
| 596 } | |
| 597 else if((Address < ADDR_FLASH_SECTOR_14) && (Address >= ADDR_FLASH_SECTOR_13)) | |
| 598 { | |
| 599 sector = FLASH_SECTOR_13; | |
| 600 } | |
| 601 else if((Address < ADDR_FLASH_SECTOR_15) && (Address >= ADDR_FLASH_SECTOR_14)) | |
| 602 { | |
| 603 sector = FLASH_SECTOR_14; | |
| 604 } | |
| 605 else if((Address < ADDR_FLASH_SECTOR_16) && (Address >= ADDR_FLASH_SECTOR_15)) | |
| 606 { | |
| 607 sector = FLASH_SECTOR_15; | |
| 608 } | |
| 609 else if((Address < ADDR_FLASH_SECTOR_17) && (Address >= ADDR_FLASH_SECTOR_16)) | |
| 610 { | |
| 611 sector = FLASH_SECTOR_16; | |
| 612 } | |
| 613 else if((Address < ADDR_FLASH_SECTOR_18) && (Address >= ADDR_FLASH_SECTOR_17)) | |
| 614 { | |
| 615 sector = FLASH_SECTOR_17; | |
| 616 } | |
| 617 else if((Address < ADDR_FLASH_SECTOR_19) && (Address >= ADDR_FLASH_SECTOR_18)) | |
| 618 { | |
| 619 sector = FLASH_SECTOR_18; | |
| 620 } | |
| 621 else if((Address < ADDR_FLASH_SECTOR_20) && (Address >= ADDR_FLASH_SECTOR_19)) | |
| 622 { | |
| 623 sector = FLASH_SECTOR_19; | |
| 624 } | |
| 625 else if((Address < ADDR_FLASH_SECTOR_21) && (Address >= ADDR_FLASH_SECTOR_20)) | |
| 626 { | |
| 627 sector = FLASH_SECTOR_20; | |
| 628 } | |
| 629 else if((Address < ADDR_FLASH_SECTOR_22) && (Address >= ADDR_FLASH_SECTOR_21)) | |
| 630 { | |
| 631 sector = FLASH_SECTOR_21; | |
| 632 } | |
| 633 else if((Address < ADDR_FLASH_SECTOR_23) && (Address >= ADDR_FLASH_SECTOR_22)) | |
| 634 { | |
| 635 sector = FLASH_SECTOR_22; | |
| 636 } | |
| 637 else/*(Address < FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_23))*/ | |
| 638 { | |
| 639 sector = FLASH_SECTOR_23; | |
| 640 } | |
| 641 | |
| 642 return sector; | |
| 643 } | |
| 644 | |
| 645 /* | |
| 646 static void firmware_Error_Handler(HAL_StatusTypeDef reason) | |
| 647 { | |
| 648 static HAL_StatusTypeDef last_reason = HAL_OK; | |
| 649 | |
| 650 last_reason = reason; | |
| 651 while(1) | |
| 652 { | |
| 653 } | |
| 654 } | |
| 655 */ |