在stm32cubeide中创建不同版本的.bin文件

Question

Context

I'm currently working on a firmware for a STM32F411CEU6, using STM32CubeIDE, I'm going to be programming several UC's, everyone of them is going to have an ID (a 32 bit unsigned number), this number is static and it will never be change in his lifespan, we are a small team but maybe we will have to program a few hundred of these devices, so changing the value associated whit that ID in the code manually will be kinda exhausting, and time consuming, so, my question is:

¿Is there a way to compile different versions of firmware so it generate several.bin files, each one whit the only difference that this single constant change?

¿Is there a way to automate this process?

What have I thought

I have thought on defining this constant (and other constants if I have to) on a header file, then use something like Python to make different versions of the code, but then I would have to open every project or workspace and still have to compile and produce every.binfile manually, ¿Is there a way to produce the.bin file from python (using the STM32CubeIDE), or something like that?

Additional information

• Working on a STM32F411CEU6
• Using STM32CubeIDE
• I have basic knowledge in python C++
• Medium-advance knowledge in C

Thanks in advance! Any help would be very much appreciated

Answer 1

If using a hex file is an option, you could avoiding the need for re-compilation like so:

1. Reserve some flash space outside of your program (optionally configure the linker script to make sure no data is placed in that section).
2. Use a python script to generate intel hex data with the required ID placed in the reserved location.
3. Simply concatenate the two hex files and program as usual. I tested this with STM32 ST-LINK Utility / STM32CubeProgrammer.

To generate the hex data, you can use the intelhex package. For example:

import struct
from intelhex import IntelHex
from io import StringIO

ID_FLASH_ADDRESS = 0x8020000

hex_data = StringIO()
ih = IntelHex()
ih.puts(ID_FLASH_ADDRESS, struct.pack('<I', chip_id))
# Output data to variable
ih.write_hex_file(hex_data)

# Get the data
hex_data.getvalue().encode('utf-8')

Notes:

• See the struct documentation for the meaning of '<I' .
• I output the data to a variable, but you could also write directly to a file. See intelhex documentation .

Answer 2

Here are a few ideas.

1. The STM32F411 chip is pre-programmed (by STMicro at the factory) with a 96-bit unique device ID. Perhaps you can use the device's unique ID for your purposes rather than creating and assigning your own ID value. See Section 24.1 of the reference manual . This seems much safer than trying to create and manage a different bin file for each ID value.

2. If you really want your own custom ID value, then program the ID value separately from the firmware bin file so that you don't need to create/manage different bin files for each unit. Write the program so that the ID value is at a know fixed address in ROM. Use the linker scatter file to reserve that address for the ID value. Program the ROM of each unit in two steps, the bin file and the ID value.

3. If you really want to incorporate the ID value into the bin file then you can use a tool such as srec_cat.exe to concatenate bin (also hex or srec) files. It's very versatile and you should study the man page. One example of how you could use this tool is this: In the source code for your program, declare your unique ID value a constant pointer to a constant value located at a fixed address in ROM beyond the end of the ROM consumed by the bin file. Build the bin file like normal. Then run srec_cat.exe to concatenate the unique ID value to the bin file with the appropriate offset. You could write a script to do this repeatedly for each unique ID value. Perhaps this script runs as a post-build action from the IDE. This solution could work but it seems like a maintenance nightmare to ensure the right bin file gets programmed onto the right device.