|
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 /* Base address of the Flash sectors Bank 1 */
|
|
|
57 #define ADDR_FLASH_SECTOR_0 ((uint32_t)0x08000000) /* Base @ of Sector 0, 16 Kbytes */
|
|
|
58 #define ADDR_FLASH_SECTOR_1 ((uint32_t)0x08004000) /* Base @ of Sector 1, 16 Kbytes */
|
|
|
59 #define ADDR_FLASH_SECTOR_2 ((uint32_t)0x08008000) /* Base @ of Sector 2, 16 Kbytes */
|
|
|
60 #define ADDR_FLASH_SECTOR_3 ((uint32_t)0x0800C000) /* Base @ of Sector 3, 16 Kbytes */
|
|
|
61 #define ADDR_FLASH_SECTOR_4 ((uint32_t)0x08010000) /* Base @ of Sector 4, 64 Kbytes */
|
|
|
62 #define ADDR_FLASH_SECTOR_5 ((uint32_t)0x08020000) /* Base @ of Sector 5, 128 Kbytes */
|
|
|
63 #define ADDR_FLASH_SECTOR_6 ((uint32_t)0x08040000) /* Base @ of Sector 6, 128 Kbytes */
|
|
|
64 #define ADDR_FLASH_SECTOR_7 ((uint32_t)0x08060000) /* Base @ of Sector 7, 128 Kbytes */
|
|
|
65 #define ADDR_FLASH_SECTOR_8 ((uint32_t)0x08080000) /* Base @ of Sector 8, 128 Kbytes */
|
|
|
66 #define ADDR_FLASH_SECTOR_9 ((uint32_t)0x080A0000) /* Base @ of Sector 9, 128 Kbytes */
|
|
|
67 #define ADDR_FLASH_SECTOR_10 ((uint32_t)0x080C0000) /* Base @ of Sector 10, 128 Kbytes */
|
|
|
68 #define ADDR_FLASH_SECTOR_11 ((uint32_t)0x080E0000) /* Base @ of Sector 11, 128 Kbytes */
|
|
|
69
|
|
|
70 /* Base address of the Flash sectors Bank 2 */
|
|
|
71 #define ADDR_FLASH_SECTOR_12 ((uint32_t)0x08100000) /* Base @ of Sector 0, 16 Kbytes */
|
|
|
72 #define ADDR_FLASH_SECTOR_13 ((uint32_t)0x08104000) /* Base @ of Sector 1, 16 Kbytes */
|
|
|
73 #define ADDR_FLASH_SECTOR_14 ((uint32_t)0x08108000) /* Base @ of Sector 2, 16 Kbytes */
|
|
|
74 #define ADDR_FLASH_SECTOR_15 ((uint32_t)0x0810C000) /* Base @ of Sector 3, 16 Kbytes */
|
|
|
75 #define ADDR_FLASH_SECTOR_16 ((uint32_t)0x08110000) /* Base @ of Sector 4, 64 Kbytes */
|
|
|
76 #define ADDR_FLASH_SECTOR_17 ((uint32_t)0x08120000) /* Base @ of Sector 5, 128 Kbytes */
|
|
|
77 #define ADDR_FLASH_SECTOR_18 ((uint32_t)0x08140000) /* Base @ of Sector 6, 128 Kbytes */
|
|
|
78 #define ADDR_FLASH_SECTOR_19 ((uint32_t)0x08160000) /* Base @ of Sector 7, 128 Kbytes */
|
|
|
79 #define ADDR_FLASH_SECTOR_20 ((uint32_t)0x08180000) /* Base @ of Sector 8, 128 Kbytes */
|
|
|
80 #define ADDR_FLASH_SECTOR_21 ((uint32_t)0x081A0000) /* Base @ of Sector 9, 128 Kbytes */
|
|
|
81 #define ADDR_FLASH_SECTOR_22 ((uint32_t)0x081C0000) /* Base @ of Sector 10, 128 Kbytes */
|
|
|
82 #define ADDR_FLASH_SECTOR_23 ((uint32_t)0x081E0000) /* Base @ of Sector 11, 128 Kbytes */
|
|
|
83
|
|
|
84 #define SECTOR_SIZE_128KB ((uint32_t)0x00020000)
|
|
|
85
|
|
|
86 #define FLASH_FW_START_ADDR ADDR_FLASH_SECTOR_6
|
|
|
87 #define FLASH_FW_END_ADDR (ADDR_FLASH_SECTOR_12 - 1)
|
|
|
88
|
|
|
89 #define FLASH_FW2_START_ADDR ADDR_FLASH_SECTOR_12
|
|
|
90 #define FLASH_FW2_END_ADDR (ADDR_FLASH_SECTOR_22 + SECTOR_SIZE_128KB - 1)
|
|
|
91
|
|
|
92 /* Private variables ---------------------------------------------------------*/
|
|
|
93
|
|
|
94 static FLASH_EraseInitTypeDef EraseInitStruct; /*Variable used for Erase procedure*/
|
|
|
95
|
|
|
96 uint32_t FirstSector = 0, NbOfSectors = 0, Address = 0;
|
|
|
97 uint32_t SectorError = 0;
|
|
|
98 __IO uint32_t data32 = 0 , MemoryProgramStatus = 0;
|
|
|
99
|
|
|
100
|
|
|
101
|
|
|
102 /* Private function prototypes -----------------------------------------------*/
|
|
|
103 //static void firmware_Error_Handler(HAL_StatusTypeDef reason);
|
|
|
104 static uint32_t GetSector(uint32_t Address);
|
|
|
105 uint8_t hardware_programm_sub(uint8_t *buffer64, uint8_t length, uint32_t startAddress);
|
|
|
106
|
|
|
107 /* Exported functions --------------------------------------------------------*/
|
|
|
108
|
|
|
109 const SHardwareData* hardwareDataGetPointer(void)
|
|
|
110 {
|
|
|
111 return (SHardwareData*)HARDWAREDATA_ADDRESS;
|
|
|
112 }
|
|
|
113
|
|
|
114 uint8_t hardware_programmPrimaryBluetoothNameSet(void)
|
|
|
115 {
|
|
|
116 uint8_t data = 0xF0;
|
|
|
117 return hardware_programm_sub(&data, 1, HARDWAREDATA_ADDRESS + 7);
|
|
|
118 }
|
|
|
119
|
|
|
120
|
|
|
121 uint8_t hardware_programmSecondaryBluetoothNameSet(void)
|
|
|
122 {
|
|
|
123 uint8_t data = 0xF0;
|
|
|
124 return hardware_programm_sub(&data, 1, HARDWAREDATA_ADDRESS + 52 + 7);
|
|
|
125 }
|
|
|
126
|
|
|
127
|
|
|
128 uint8_t hardware_programmProductionData(uint8_t *buffer52)
|
|
|
129 {
|
|
|
130 buffer52[7] = 0xFF;// production_bluetooth_name_set
|
|
|
131 return hardware_programm_sub(buffer52, 52, HARDWAREDATA_ADDRESS);// check base_bootloader.c of OSTC4bootloader code and settings.h
|
|
|
132 }
|
|
|
133
|
|
|
134
|
|
|
135 uint8_t hardware_programmSecondarySerial(uint8_t *buffer12)
|
|
|
136 {
|
|
|
137 buffer12[7] = 0xFF;// secondary_bluetooth_name_set
|
|
|
138 return hardware_programm_sub(buffer12, 12, HARDWAREDATA_ADDRESS + 52);
|
|
|
139 }
|
|
|
140
|
|
|
141
|
|
|
142 uint8_t hardware_programm_sub(uint8_t *buffer, uint8_t length, uint32_t startAddress)
|
|
|
143 {
|
|
|
144 HAL_StatusTypeDef answer;
|
|
|
145
|
|
|
146 uint32_t ptr = 0;
|
|
|
147 uint8_t data8;
|
|
|
148
|
|
|
149 // test empty
|
|
|
150 Address = startAddress;
|
|
|
151 for(int i=0;i<length;i++)
|
|
|
152 {
|
|
|
153 if((*(uint8_t *)Address != 0xFF) && (buffer[i] != 0xFF))
|
|
|
154 return 0xE0;
|
|
|
155 Address = Address + 1;
|
|
|
156 }
|
|
|
157
|
|
|
158 // start programming
|
|
|
159 HAL_FLASH_Unlock();
|
|
|
160
|
|
|
161 Address = startAddress;
|
|
|
162 ptr = 0;
|
|
|
163 answer = HAL_OK;
|
|
|
164 while (ptr < length)
|
|
|
165 {
|
|
|
166 if(buffer[ptr] != 0xFF)
|
|
|
167 {
|
|
|
168 answer = HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, Address, buffer[ptr]);
|
|
|
169 }
|
|
|
170 if (answer == HAL_OK)
|
|
|
171 {
|
|
|
172 Address = Address + 1;
|
|
|
173 ptr++;
|
|
|
174 }
|
|
|
175 else
|
|
|
176 {
|
|
|
177 HAL_FLASH_Lock();
|
|
|
178 return answer;
|
|
|
179 }
|
|
|
180 }
|
|
|
181 HAL_FLASH_Lock();
|
|
|
182
|
|
|
183 /* Check if the programmed data is OK
|
|
|
184 MemoryProgramStatus = 0: data programmed correctly
|
|
|
185 MemoryProgramStatus != 0: number of words not programmed correctly ******/
|
|
|
186 Address = startAddress; // check base_bootloader.c of OSTC4bootloader code
|
|
|
187 MemoryProgramStatus = 0x0;
|
|
|
188
|
|
|
189 ptr = 0;
|
|
|
190 while(ptr < length)
|
|
|
191 {
|
|
|
192 data8 = *(__IO uint8_t*)Address;
|
|
|
193
|
|
|
194 if((buffer[ptr] != 0xFF) && (data8 != buffer[ptr]))
|
|
|
195 {
|
|
|
196 MemoryProgramStatus++;
|
|
|
197 }
|
|
|
198
|
|
|
199 Address = Address + 1;
|
|
|
200 ptr++;
|
|
|
201 }
|
|
|
202
|
|
|
203 /* Check if there is an issue to program data */
|
|
|
204 if (MemoryProgramStatus == 0)
|
|
|
205 {
|
|
|
206 return HAL_OK;
|
|
|
207 }
|
|
|
208 else
|
|
|
209 {
|
|
|
210 return 0xEE;
|
|
|
211 }
|
|
|
212 }
|
|
|
213
|
|
|
214
|
|
|
215 uint8_t firmware2_variable_upperpart_eraseFlashMemory(uint32_t length, uint32_t offset)
|
|
|
216 {
|
|
|
217 uint32_t startAddress, endAddress;
|
|
|
218
|
|
|
219 // HAL_StatusTypeDef answer;
|
|
|
220 HAL_FLASH_Unlock();
|
|
|
221
|
|
|
222 startAddress = FLASH_FW2_START_ADDR + offset;
|
|
|
223 endAddress = startAddress + length;
|
|
|
224
|
|
|
225 if(endAddress > FLASH_FW2_END_ADDR)
|
|
|
226 endAddress = FLASH_FW2_END_ADDR;
|
|
|
227
|
|
|
228 FirstSector = GetSector(startAddress);
|
|
|
229 NbOfSectors = GetSector(endAddress) - FirstSector + 1;
|
|
|
230
|
|
|
231 EraseInitStruct.TypeErase = FLASH_TYPEERASE_SECTORS;
|
|
|
232 EraseInitStruct.VoltageRange = FLASH_VOLTAGE_RANGE_1;
|
|
|
233 EraseInitStruct.Sector = FirstSector;
|
|
|
234 EraseInitStruct.NbSectors = NbOfSectors;
|
|
|
235
|
|
|
236 return HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError);
|
|
|
237 }
|
|
|
238
|
|
|
239
|
|
|
240 uint8_t firmware2_variable_upperpart_programFlashMemory(uint32_t length, uint32_t offset, uint8_t *pBuffer1, uint32_t pBuffer1Size, uint8_t *pBuffer2)
|
|
|
241 {
|
|
|
242 HAL_StatusTypeDef answer;
|
|
|
243 uint32_t ptr = 0;
|
|
|
244 uint32_t length1, length2;
|
|
|
245
|
|
|
246 if((pBuffer2) && (length > pBuffer1Size))
|
|
|
247 {
|
|
|
248 length1 = pBuffer1Size;
|
|
|
249 length2 = length - length1;
|
|
|
250 }
|
|
|
251 else
|
|
|
252 {
|
|
|
253 length1 = length;
|
|
|
254 length2 = 0;
|
|
|
255 }
|
|
|
256
|
|
|
257 Address = FLASH_FW2_START_ADDR + offset;
|
|
|
258
|
|
|
259 ptr = 0;
|
|
|
260 while ((Address <= FLASH_FW2_END_ADDR) && (ptr < length1))
|
|
|
261 {
|
|
|
262 answer = HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, Address, pBuffer1[ptr]);
|
|
|
263 if (answer == HAL_OK)
|
|
|
264 {
|
|
|
265 Address = Address + 1;
|
|
|
266 ptr++;
|
|
|
267 }
|
|
|
268 else
|
|
|
269 {
|
|
|
270 return answer;
|
|
|
271 }
|
|
|
272 }
|
|
|
273 ptr = 0;
|
|
|
274 while ((Address <= FLASH_FW2_END_ADDR) && (ptr < length2))
|
|
|
275 {
|
|
|
276 answer = HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, Address, pBuffer2[ptr]);
|
|
|
277 if (answer == HAL_OK)
|
|
|
278 {
|
|
|
279 Address = Address + 1;
|
|
|
280 ptr++;
|
|
|
281 }
|
|
|
282 else
|
|
|
283 {
|
|
|
284 return answer;
|
|
|
285 }
|
|
|
286 }
|
|
|
287 HAL_FLASH_Lock();
|
|
|
288
|
|
|
289 Address = FLASH_FW2_START_ADDR + offset;;
|
|
|
290 MemoryProgramStatus = 0x0;
|
|
|
291
|
|
|
292 ptr = 0;
|
|
|
293 while ((Address <= FLASH_FW2_END_ADDR) && (ptr < length1))
|
|
|
294 {
|
|
|
295 data32 = *(__IO uint8_t*)Address;
|
|
|
296
|
|
|
297 if (data32 != pBuffer1[ptr])
|
|
|
298 {
|
|
|
299 MemoryProgramStatus++;
|
|
|
300 }
|
|
|
301
|
|
|
302 Address = Address + 1;
|
|
|
303 ptr++;
|
|
|
304 }
|
|
|
305 ptr = 0;
|
|
|
306 while ((Address <= FLASH_FW2_END_ADDR) && (ptr < length2))
|
|
|
307 {
|
|
|
308 data32 = *(__IO uint8_t*)Address;
|
|
|
309
|
|
|
310 if (data32 != pBuffer2[ptr])
|
|
|
311 {
|
|
|
312 MemoryProgramStatus++;
|
|
|
313 }
|
|
|
314
|
|
|
315 Address = Address + 1;
|
|
|
316 ptr++;
|
|
|
317 }
|
|
|
318
|
|
|
319 if (MemoryProgramStatus == 0)
|
|
|
320 {
|
|
|
321 return HAL_OK;
|
|
|
322 }
|
|
|
323 else
|
|
|
324 {
|
|
|
325 return 0xEE;
|
|
|
326 }
|
|
|
327 }
|
|
|
328
|
|
|
329 uint8_t firmware_eraseFlashMemory(void)
|
|
|
330 {
|
|
|
331 // HAL_StatusTypeDef answer;
|
|
|
332 /* Unlock the Flash to enable the flash control register access *************/
|
|
|
333 HAL_FLASH_Unlock();
|
|
|
334
|
|
|
335 /* Erase the user Flash area
|
|
|
336 (area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR) ***********/
|
|
|
337
|
|
|
338 /* Get the 1st sector to erase */
|
|
|
339 FirstSector = GetSector(FLASH_FW_START_ADDR);
|
|
|
340 /* Get the number of sector to erase from 1st sector*/
|
|
|
341 NbOfSectors = GetSector(FLASH_FW_END_ADDR) - FirstSector + 1;
|
|
|
342
|
|
|
343 /* Fill EraseInit structure*/
|
|
|
344 EraseInitStruct.TypeErase = FLASH_TYPEERASE_SECTORS;
|
|
|
345 EraseInitStruct.VoltageRange = FLASH_VOLTAGE_RANGE_1;
|
|
|
346 EraseInitStruct.Sector = FirstSector;
|
|
|
347 EraseInitStruct.NbSectors = NbOfSectors;
|
|
|
348
|
|
|
349 /* Note: If an erase operation in Flash memory also concerns data in the data or instruction cache,
|
|
|
350 you have to make sure that these data are rewritten before they are accessed during code
|
|
|
351 execution. If this cannot be done safely, it is recommended to flush the caches by setting the
|
|
|
352 DCRST and ICRST bits in the FLASH_CR register. */
|
|
|
353 return HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError);
|
|
|
354 }
|
|
|
355
|
|
|
356 uint8_t firmware_programFlashMemory(uint8_t *pBuffer1, uint32_t length1)//, uint8_t *pBuffer2, uint32_t length2)
|
|
|
357 {
|
|
|
358 HAL_StatusTypeDef answer;
|
|
|
359
|
|
|
360 /* Program the user Flash area word by word
|
|
|
361 (area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR) ***********/
|
|
|
362
|
|
|
363 uint32_t ptr = 0;
|
|
|
364
|
|
|
365 Address = FLASH_FW_START_ADDR;
|
|
|
366
|
|
|
367 ptr = 0;
|
|
|
368 while ((Address <= FLASH_FW_END_ADDR) && (ptr < length1))
|
|
|
369 {
|
|
|
370 answer = HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, Address, pBuffer1[ptr]);
|
|
|
371 if (answer == HAL_OK)
|
|
|
372 // if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, DATA_32) == HAL_OK)
|
|
|
373 {
|
|
|
374 Address = Address + 1;//4;
|
|
|
375 ptr++;
|
|
|
376 }
|
|
|
377 else
|
|
|
378 {
|
|
|
379 return answer;
|
|
|
380 }
|
|
|
381 }
|
|
|
382 /* same for pBuffer2
|
|
|
383 ptr = 0;
|
|
|
384 while ((Address < FLASH_FW_END_ADDR) && (ptr < length2))
|
|
|
385 {
|
|
|
386
|
|
|
387 if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, Address, pBuffer2[ptr]) == HAL_OK)
|
|
|
388 {
|
|
|
389 Address = Address + 1;
|
|
|
390 ptr++;
|
|
|
391 }
|
|
|
392 else
|
|
|
393 {
|
|
|
394 firmware_Error_Handler();
|
|
|
395 }
|
|
|
396 }
|
|
|
397 */
|
|
|
398 /* Lock the Flash to disable the flash control register access (recommended
|
|
|
399 to protect the FLASH memory against possible unwanted operation) *********/
|
|
|
400 HAL_FLASH_Lock();
|
|
|
401
|
|
|
402 /* Check if the programmed data is OK
|
|
|
403 MemoryProgramStatus = 0: data programmed correctly
|
|
|
404 MemoryProgramStatus != 0: number of words not programmed correctly ******/
|
|
|
405 Address = FLASH_FW_START_ADDR;
|
|
|
406 MemoryProgramStatus = 0x0;
|
|
|
407
|
|
|
408 ptr = 0;
|
|
|
409 while ((Address <= FLASH_FW_END_ADDR) && (ptr < length1))
|
|
|
410 {
|
|
|
411 data32 = *(__IO uint8_t*)Address;
|
|
|
412
|
|
|
413 if (data32 != pBuffer1[ptr])
|
|
|
414 {
|
|
|
415 MemoryProgramStatus++;
|
|
|
416 }
|
|
|
417
|
|
|
418 Address = Address + 1;//4;
|
|
|
419 ptr++;
|
|
|
420 }
|
|
|
421 /* same for pBuffer2
|
|
|
422 ptr = 0;
|
|
|
423 while ((Address < FLASH_FW_END_ADDR) && (ptr < length2))
|
|
|
424 {
|
|
|
425 data32 = *(__IO uint32_t*)Address;
|
|
|
426
|
|
|
427 if (data32 != pBuffer2[ptr])
|
|
|
428 {
|
|
|
429 MemoryProgramStatus++;
|
|
|
430 }
|
|
|
431
|
|
|
432 Address = Address + 1;//4;
|
|
|
433 ptr++;
|
|
|
434 }
|
|
|
435 */
|
|
|
436 /* Check if there is an issue to program data */
|
|
|
437 if (MemoryProgramStatus == 0)
|
|
|
438 {
|
|
|
439 return HAL_OK;
|
|
|
440 /* No error detected. Switch on LED3 */
|
|
|
441 }
|
|
|
442 else
|
|
|
443 {
|
|
|
444 return 0xEE;
|
|
|
445 }
|
|
|
446
|
|
|
447
|
|
|
448 }
|
|
|
449
|
|
|
450 /* Private functions ---------------------------------------------------------*/
|
|
|
451
|
|
|
452 /**
|
|
|
453 * @brief Gets the sector of a given address
|
|
|
454 * @param None
|
|
|
455 * @retval The sector of a given address
|
|
|
456 */
|
|
|
457 static uint32_t GetSector(uint32_t Address)
|
|
|
458 {
|
|
|
459 uint32_t sector = 0;
|
|
|
460
|
|
|
461 if((Address < ADDR_FLASH_SECTOR_1) && (Address >= ADDR_FLASH_SECTOR_0))
|
|
|
462 {
|
|
|
463 sector = FLASH_SECTOR_0;
|
|
|
464 }
|
|
|
465 else if((Address < ADDR_FLASH_SECTOR_2) && (Address >= ADDR_FLASH_SECTOR_1))
|
|
|
466 {
|
|
|
467 sector = FLASH_SECTOR_1;
|
|
|
468 }
|
|
|
469 else if((Address < ADDR_FLASH_SECTOR_3) && (Address >= ADDR_FLASH_SECTOR_2))
|
|
|
470 {
|
|
|
471 sector = FLASH_SECTOR_2;
|
|
|
472 }
|
|
|
473 else if((Address < ADDR_FLASH_SECTOR_4) && (Address >= ADDR_FLASH_SECTOR_3))
|
|
|
474 {
|
|
|
475 sector = FLASH_SECTOR_3;
|
|
|
476 }
|
|
|
477 else if((Address < ADDR_FLASH_SECTOR_5) && (Address >= ADDR_FLASH_SECTOR_4))
|
|
|
478 {
|
|
|
479 sector = FLASH_SECTOR_4;
|
|
|
480 }
|
|
|
481 else if((Address < ADDR_FLASH_SECTOR_6) && (Address >= ADDR_FLASH_SECTOR_5))
|
|
|
482 {
|
|
|
483 sector = FLASH_SECTOR_5;
|
|
|
484 }
|
|
|
485 else if((Address < ADDR_FLASH_SECTOR_7) && (Address >= ADDR_FLASH_SECTOR_6))
|
|
|
486 {
|
|
|
487 sector = FLASH_SECTOR_6;
|
|
|
488 }
|
|
|
489 else if((Address < ADDR_FLASH_SECTOR_8) && (Address >= ADDR_FLASH_SECTOR_7))
|
|
|
490 {
|
|
|
491 sector = FLASH_SECTOR_7;
|
|
|
492 }
|
|
|
493 else if((Address < ADDR_FLASH_SECTOR_9) && (Address >= ADDR_FLASH_SECTOR_8))
|
|
|
494 {
|
|
|
495 sector = FLASH_SECTOR_8;
|
|
|
496 }
|
|
|
497 else if((Address < ADDR_FLASH_SECTOR_10) && (Address >= ADDR_FLASH_SECTOR_9))
|
|
|
498 {
|
|
|
499 sector = FLASH_SECTOR_9;
|
|
|
500 }
|
|
|
501 else if((Address < ADDR_FLASH_SECTOR_11) && (Address >= ADDR_FLASH_SECTOR_10))
|
|
|
502 {
|
|
|
503 sector = FLASH_SECTOR_10;
|
|
|
504 }
|
|
|
505 else if((Address < ADDR_FLASH_SECTOR_12) && (Address >= ADDR_FLASH_SECTOR_11))
|
|
|
506 {
|
|
|
507 sector = FLASH_SECTOR_11;
|
|
|
508 }
|
|
|
509 else if((Address < ADDR_FLASH_SECTOR_13) && (Address >= ADDR_FLASH_SECTOR_12))
|
|
|
510 {
|
|
|
511 sector = FLASH_SECTOR_12;
|
|
|
512 }
|
|
|
513 else if((Address < ADDR_FLASH_SECTOR_14) && (Address >= ADDR_FLASH_SECTOR_13))
|
|
|
514 {
|
|
|
515 sector = FLASH_SECTOR_13;
|
|
|
516 }
|
|
|
517 else if((Address < ADDR_FLASH_SECTOR_15) && (Address >= ADDR_FLASH_SECTOR_14))
|
|
|
518 {
|
|
|
519 sector = FLASH_SECTOR_14;
|
|
|
520 }
|
|
|
521 else if((Address < ADDR_FLASH_SECTOR_16) && (Address >= ADDR_FLASH_SECTOR_15))
|
|
|
522 {
|
|
|
523 sector = FLASH_SECTOR_15;
|
|
|
524 }
|
|
|
525 else if((Address < ADDR_FLASH_SECTOR_17) && (Address >= ADDR_FLASH_SECTOR_16))
|
|
|
526 {
|
|
|
527 sector = FLASH_SECTOR_16;
|
|
|
528 }
|
|
|
529 else if((Address < ADDR_FLASH_SECTOR_18) && (Address >= ADDR_FLASH_SECTOR_17))
|
|
|
530 {
|
|
|
531 sector = FLASH_SECTOR_17;
|
|
|
532 }
|
|
|
533 else if((Address < ADDR_FLASH_SECTOR_19) && (Address >= ADDR_FLASH_SECTOR_18))
|
|
|
534 {
|
|
|
535 sector = FLASH_SECTOR_18;
|
|
|
536 }
|
|
|
537 else if((Address < ADDR_FLASH_SECTOR_20) && (Address >= ADDR_FLASH_SECTOR_19))
|
|
|
538 {
|
|
|
539 sector = FLASH_SECTOR_19;
|
|
|
540 }
|
|
|
541 else if((Address < ADDR_FLASH_SECTOR_21) && (Address >= ADDR_FLASH_SECTOR_20))
|
|
|
542 {
|
|
|
543 sector = FLASH_SECTOR_20;
|
|
|
544 }
|
|
|
545 else if((Address < ADDR_FLASH_SECTOR_22) && (Address >= ADDR_FLASH_SECTOR_21))
|
|
|
546 {
|
|
|
547 sector = FLASH_SECTOR_21;
|
|
|
548 }
|
|
|
549 else if((Address < ADDR_FLASH_SECTOR_23) && (Address >= ADDR_FLASH_SECTOR_22))
|
|
|
550 {
|
|
|
551 sector = FLASH_SECTOR_22;
|
|
|
552 }
|
|
|
553 else/*(Address < FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_23))*/
|
|
|
554 {
|
|
|
555 sector = FLASH_SECTOR_23;
|
|
|
556 }
|
|
|
557
|
|
|
558 return sector;
|
|
|
559 }
|
|
|
560
|
|
|
561 /*
|
|
|
562 static void firmware_Error_Handler(HAL_StatusTypeDef reason)
|
|
|
563 {
|
|
|
564 static HAL_StatusTypeDef last_reason = HAL_OK;
|
|
|
565
|
|
|
566 last_reason = reason;
|
|
|
567 while(1)
|
|
|
568 {
|
|
|
569 }
|
|
|
570 }
|
|
|
571 */
|
