Compiling & Flashing
This section describes how to go from TouchGFX application code to executing program, that is how to compile and flash in a specific setup.
Compiling TouchGFX Applications
When compiling a TouchGFX application, there are two options; compiling for the PC simulator or compiling for the target hardware.
Compiling for PC Simulator
There are two options for compiling projects for the PC Simulator; GCC and Visual Studio.
Both of these options are always available, since they are generated by TouchGFX Designer.
GCC
The makefile is located at <touchgfx_application_root_folder>/simulator/gcc/Makefile
TouchGFX includes a MinGW environment, that comes preinstalled with a GCC compiler and GNU Make, making it easy to execute the generated Makefile for the PC simulator.
The TouchGFX Environment can be launched either from C:/TouchGFX/4.18.0/env/MinGW/msys/1.0/msys.bat
or from the shortcut added to the Windows start menu, named "TouchGFX x.y.z Environment" where x, y and z describe the version number.
After launching the TouchGFX Environment and navigating to the TouchGFX Application root folder, the simple command below can be executed to produce a simulator.exe file.
make -f simulator/gcc/Makefile
The simulator executable can then be launched from the TouchGFX Environment with the following command.
./build/bin/simulator.exe
The PC Simulator can also be compiled and launched from TouchGFX Designer, by using the Run Simulator command.
Visual Studio
To compile the PC Simulator using Visual Studio, simply open the generated solution file located at <touchgfx_application_root_folder>/simulator/msvs/Application.sln
using Visual Studio.
The PC Simulator can be launched directly from Visual Studio, enabling code debugging.
Note
Compiling for Target Hardware
Compiling projects for STM32 Evaluation Kits is quite simple for TouchGFX Board Setup based applications.
Each TouchGFX Board Setup contains project files for GCC, STM32CubeIDE, IAR and Keil:
- GCC:
<project_root_folder>/gcc/MakeFile
- STM32CubeIDE:
<project_root_folder>/STM32CubeIDE/.cproject
- IAR:
<project_root_folder>/EWARM/Project.eww
- Keil:
<project_root_folder>/MDK-ARM/<STM32_evaluation_kit_name>.uvprojx
The active tool chain is set from STM32CubeMX and is set to STM32CubeIDE by default. Please note that all project files are not present at the same time. The generated project file depends on the selected tool chain in STM32CubeMX
TouchGFX includes a MinGW environment, that comes preinstalled with the GNU Embedded tool-chain for Arm and GNU Make, making it easy to execute the included Makefile for the target hardware.
The TouchGFX Environment can be launched either from C:/TouchGFX/4.18.0/env/MinGW/msys/1.0/msys.bat
or from the shortcut added to the Windows start menu "TouchGFX x.y.z Environment"
After launching the TouchGFX Environment and navigating to the project root folder, the simple command below can be executed to compile the project for the target hardware.
make -f gcc/Makefile
Note
Flashing STM32 Evaluation Kits
Flashing projects to STM32 Evaluation Kits is quite simple with projects based on a premade TouchGFX Board Setup.
Each project, when built, produces a binary that can be flashed by either ST Link Utility or STM32CubeProgrammer.
Therefore these tools must be installed to proceed with flashing.
It is suggested to install these tools to their default location.
- ST Link Utility default install location:
C:/Program Files (x86)/STMicroelectronics/STM32 ST-LINK Utility/ST-LINK Utility
- STM32CubeProgrammer default install location:
C:/Program Files/STMicroelectronics/STM32Cube/STM32CubeProgrammer
Note
GCC & TouchGFX Designer
The Makefile included with an TouchGFX Board Setup located at <project_root_folder>/gcc/MakeFile
has a built-in flash command, as shown below, that uses either ST Link Utility or STM32CubeProgrammer (depending on the TBS) to flash the STM32 Evaluation Kit.
You can start the flashing from the command-line using the same command as TouchGFX Designer uses:
make -f gcc/Makefile flash
You can also use the desktop version of the flash tools to
flash the boards with the generated .hex files. The .hex file is
located at <project_root_folder>/TouchGFX/build/bin/target.hex
Flashing the internal flash only
Many development boards and products use two flashes. The internal flash of the micro controller and an external flash. Typically, the internal flash contains the code and small/often used data, whereas the external flash contains large data items like images, videos and fonts.
In many situations, you need to flash both flashes at the same time as the program in the internal flash contains addresses pointing to the data in the external flash. But in some cases it is possible to flash the internal flash without flashing the external flash, for example when you have made small modifications to the application code (like changing the color or position of a Box). In this case, all the data in the external flash is unmodified and there is no need to flash it again. This can reduce the flash time considerably if you have a large set of images.
However, you need to be sure that the content for the external flash has not changed since you wrote the external flash last time. If it has, and you do not flash it again, you will see strange behavior. In this case: flash both the internal and external flash.
make -f gcc/Makefile intflash
The .hex file for the internal flash is located at:
<project_root_folder>/TouchGFX/build/bin/intflash.hex
.
Linker script
The intflash make target first compiles and links the application. It
then flashes the intflash.hex
file. This file is produced after the
linking step by removing the ExternalFlashSection
, TextFlashSection
,
and FontFlashSection
sections from the application elf
file. This is
done using the following command:
arm-none-eabi-objcopy -O ihex --remove-section=ExtFlashSection --remove-section=FontFlashSection --remove-section=TextFlashSection target.elf intflash.hex
The result of this command is a hex-file containing only the data that is located in the internal flash. This will only work if the linker script only puts the three aforementioned sections into the external flash. The gcc linker script for the TouchGFX Board Setups typically looks like:
... /* Details skipped */
MEMORY
{
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 320K
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 1024K
QUADSPI (r) : ORIGIN = 0x90000000, LENGTH = 16M
SDRAM (xrw) : ORIGIN = 0xC0000000, LENGTH = 8M
}
SECTIONS
{
... /* Sections for RAM, Flash, SDRAM */
ExtFlashSection :
{
*(ExtFlashSection ExtFlashSection.*)
*(.gnu.linkonce.r.*)
. = ALIGN(0x4);
} >QUADSPI
FontFlashSection :
{
*(FontFlashSection FontFlashSection.*)
*(.gnu.linkonce.r.*)
. = ALIGN(0x4);
} >QUADSPI
TextFlashSection :
{
*(TextFlashSection TextFlashSection.*)
*(.gnu.linkonce.r.*)
. = ALIGN(0x4);
} >QUADSPI
}
The linker script first defines 4 memory regions: RAM
, FLASH
, QUADSPI
,
and SDRAM
. The QUADSPI
region is the external flash. The 3 sections
ExtFlashSection
, FontFlashSection
, and TextFlashSections
are linked
into the QUADSPI
region. Nothing else is put into the QUADSPI
region. This is the reason that we can produce a hex file for the internal
flash by removing these 3 section from the target.elf
file, which
contains everything. If the linker script also puts other data into the
external flash, we would need to remove that data also to end up with
the internal flash content only.
If you build your target elf
file using other makefiles or compilers,
you can reuse the technique above to create a hex file for the
internal flash and flash it from TouchGFX Designer or the command-line.
TouchGFX Designer Configuration
The TouchGFX Board Setup provides the configuration for TouchGFX Designer to be able to flash projects via the Run Target Command. The command used by TouchGFX Designer to flash can be seen and overridden in the Build Section of the Config View in TouchGFX Designer.
STM32CubeIDE
TouchGFX Board Setups provide support for flashing project compiled with STM32CubeIDE, by using the .elf file output by STM32CubeIDE, with the STM32CubeProgrammer.
The .elf file is located at <project_root_folder>/STM32CubeIDE/Debug/<STM32_evaluation_kit_name>.elf
e.g. C:/TouchGFXProjects/MyApplication/STM32CubeIDE/Debug/STM32F746G_DISCO.elf
IAR
The TouchGFX Board Setups provide support for flashing project compiled with IAR, by using the .hex file output by IAR, with the STM32CubeProgrammer.
The .hex file is located at <project_root_folder>/EWARM/<STM32_evaluation_kit_name>/Exe/<STM32_evaluation_kit_name>.hex
e.g. C:/TouchGFXProjects/MyApplication/EWARM/STM32F469I-DISCO/STM32F469I-DISCO.hex
Keil
The TouchGFX Board Setups provide support for flashing project compiled with Keil, by using the .hex file output by Keil, with the STM32CubeProgrammer.
The .hex file is located at <project_root_folder>/MDK-ARM/<STM32_evaluation_kit_name>/<STM32_evaluation_kit_name>.hex
e.g. C:/TouchGFXProjects/MyApplication/MDK-ARM/STM32F469I-DISCO/STM32F469I-DISCO.hex
Flashing Custom Hardware
If instead what needs to be flashed is custom hardware, and not a predefined hardware setup like an STM32 Evaluation Kit, you can still use STM32CubeProgrammer. STM32CubeProgrammer does not necessarily come with a flash loading mechanism for your specific external memory. It is however possible to create a custom flash loader. Read the user manual on developing customized loaders for your external memory to find more info.