David.picard : /* En mode release */

2021-07-13T13:51:12Z

En mode release

Nouvelle page

<div>[[Accueil]] - [[Les_Groupes_ARM|ARM]]</div>
<hr/>
<div>[[Les_Groupes_ARM_:_ArmADEUS|ArmADEUS]] - [[Les_Groupes_ARM_:_STM32|Cortex M3/M4 et le STM32]] - [[Les_Groupes_ARM_:_STM32/toolchain_sous_Linux| Toolchain sous linux pour STM32]] - [[Les_Groupes_ARM_:_A13-micro|Olinuxino A13-micro]] - [[Les_Groupes_ARM_:_Raspberry_Pi|Raspberry Pi]] - [[Les_Groupes_ARM_:_Eukréa|Eukréa]] - [[Les_Groupes_ARM_:_LabVIEW|LabVIEW]] - [[Les_Groupes_ARM_:_GCC|GCC]]</div>
<hr/>

= Objectif =

Il existe de nombreuses combinaisons d'outils pour développer sur des STM32.
La méthode présentée ici n'est qu'une solution parmi d'autres.
Les outils logiciels sont tous gratuits et la plupart est libre.
L'outil matériel pour programmer (in-circuit debugger) coûte environ 12€.

Cette page explique comment programmer et débugger les STM32 sous Linux avec les outils suivants :
* Configurateur graphique [https://www.st.com/en/development-tools/stm32cubemx.html STM32CubeMX]
* Compilateur GNU GCC + débugger GNU GDB
* IDE [https://fr.wikipedia.org/wiki/Qt_Creator Qt Creator]
* [http://openocd.org/ OpenOCD], the Open On-Chip Debugger
* In-circuit debugger ST-Link V2 (par exemple celui d'une carte de démo Nucleo-64 à 10€ env.)

Cette méthode permet de compiler, programmer et débugger le code (points d'arrêt, valeur des variables, etc.).
Une fois configurée, le confort d'utilisation est excellent, a fortiori si on est familier de Qt Creator.

= Installer la toolchain =

== STM32CubeMX ==

STM32CubeMX est un logiciel pour générer le code d'initialisation : horloges, timers, interruptions, périphériques (I2C, SPI, etc.)...

Pour configurer un proxy, menu Help > Updater settings > Connection parameters.

Télécharger sur https://my.st.com (créer un compte). Extraire l'archive et lancer le programme d'
$ sudo ./SetupSTM32CubeMX-<version>.linux

Le répertoire d'installation par défaut est /usr/local/. Créer un alias (modifier <tt>PATH</tt> ne marche pas), par exemple dans <tt>~/.bashrc</tt> ou dans <tt>~/.bash_aliases</tt> :

alias stm32cubemx='/usr/local/STMicroelectronics/STM32Cube/STM32CubeMX/STM32CubeMX'

Menu Help > Install new libraries et choisir celles qui correspondent au composant sur lequel on développe.

== OpenOCD ==

=== Installation depuis le code source ===

C'est l'[http://openocd.org/about/ Open On-Chip Debugger]. Il permet de programmer le MCU et de débugger (points d'arrêt, valeur des variables), en lien avec gdb.

La version de la distribution Linux est peut-être trop ancienne pour supporter les STM32. Dans ce cas, il faut télécharger le code source et le compiler.

Installer le paquet pkg-config :

<code>$ apt-get install pkg-config</code>

Télécharger et sélectionner la dernière version stable :

<syntaxhighlight lang="Bash">
$ cd ~/opt
$ git clone git://git.code.sf.net/p/openocd/code openocd
$ cd openocd
$ git tag // lister les tags de versions
$ git checkout v0.11.0 // sélectionner la dernière version stable
</syntaxhighlight>

Compiler :

<syntaxhighlight lang="Bash">
$ ./bootstrap
$ ./configure --enable-stlink --disable-werror
$ make -j4
$ sudo make install
$ which openocd
/usr/local/bin/openocd
</syntaxhighlight>

L'option --disable-werror est nécessaire en cas d'erreur de compilation avec gcc v7+.

Mettre à jour :

<syntaxhighlight lang="Bash">
$ cd ~/opt/openocd
$ make clean // nettoyer une éventuelle version précédente
$ git pull // intégrer les derniers changements
$ git tag // lister les tags de versions
$ git checkout v0.11.0 // sélectionner la dernière version stable
$ git checkout <tag_de_la_nouvelle_version_stable>
$ make clean
</syntaxhighlight>

Puis refaire l'étape "compiler".

Pour tester, connecter soit une carte Nucleo avec les jumpers ST-Link installés, soit une carte Nucleo avec les jumpers ST-Link enlevés et connectée à une carte maison via le connecteur CN4 (SWD). Ctrl+C pour quitter).

=== Utilisation ===

'''Important :''' avant de lancer OpenOCD, il faut connecter une carte sur un port USB du PC hôte, sinon il quitte immédiatement avec le message <tt>Error: open failed</tt>.

Lancer OpenOCD dans un terminal, et le laisser tourner pendant qu'on utilise Qt Creator.
On peut se connecter au serveur OpenOCD via telnet dans un autre terminal et lui envoyer des commandes.

<syntaxhighlight lang="Bash">
$ sudo openocd -s /usr/local/share/openocd/scripts/target/ -f interface/stlink.cfg -c "transport select hla_swd" -f target/stm32l4x.cfg
Open On-Chip Debugger 0.11.0-dirty (2021-07-06-11:05)
Licensed under GNU GPL v2
For bug reports, read
http://openocd.org/doc/doxygen/bugs.html
hla_swd
Info : The selected transport took over low-level target control. The results might differ compared to plain JTAG/SWD
Info : Listening on port 6666 for tcl connections
Info : Listening on port 4444 for telnet connections
Info : clock speed 500 kHz
Info : STLINK V2J28M17 (API v2) VID:PID 0483:374B
Info : Target voltage: 3.229746
Info : stm32l4x.cpu: hardware has 6 breakpoints, 4 watchpoints
Info : starting gdb server for stm32l4x.cpu on 3333
Info : Listening on port 3333 for gdb connections
</syntaxhighlight>

Créer <tt>/usr/local/bin/oocd.sh</tt> pour lancer cette ligne de commande :

<syntaxhighlight lang="Bash">
#!/bin/bash

OOCD_DIR=/usr/local/share/openocd/scripts/target/

# Avec ST-Link V2 :
#openocd -f interface/stlink-v2.cfg -c "transport select hla_swd" -f target/stm32l4x.cfg
# Avec ST-Link V2-1 (Nucleo) :
openocd -s ${OOCD_DIR} -f interface/stlink.cfg -c "transport select hla_swd" -f target/stm32l4x.cfg
</syntaxhighlight>

Donner les permissions d'exécution au script :

<code>$ sudo chmod a+x /usr/local/bin/openocd-stm32l4x</code>

Références :
* https://www.hackster.io/yusefkarim/upload-code-to-stm32l4-using-linux-gnu-make-and-openocd-a3d4de

== gcc ==

Visiter https://launchpad.net/gcc-arm-embedded et sous "Series and milestones", choisir la version sur le graphe des branches de développement. Si les fichiers ne sont pas disponibles, un lien indique où les trouver (https://developer.arm.com/open-source/gnu-toolchain/gnu-rm). gdb fourni avec cette distribution a le support Python, requis par Qt Creator.
Extraire l'archive :

<code>$ sudo tar -xf gcc-arm-none-eabi-8-2018-q4-major-linux.tar.bz2 -C /usr/local/</code>

== Qt Creator ==

=== Plugins ===

Le menu ''Help > About plugins'' affiche une boîte de dialogue. Vérifier que les plugins suivants sont installés :
* QbsProjectManager (inutile si vous utilisez CMake)
* BareMetal

=== OpenOCD ===

Dans le menu Tools > Options > Devices > Bare metal, cliquer Add puis OpenOCD.

{| class="wikitable"
|-
! Paramètre !! Valeur
|-
| Name || OpenOCD
|-
| Startup mode || No startup
|-
| Host || localhost:3333
|-
| Init commands || set remote hardware-breakpoint-limit 6<br>
set remote hardware-watchpoint-limit 4<br>
monitor reset halt<br>
load<br>
monitor reset halt
|-
| Reset commands || monitor reset halt
|}

Dans le menu Tools > Options > Devices > Devices, créer un device avec le GDB server provider défini plus haut.

Créer un kit avec le compilateur, le debugger, le device bare metal.

=== Kit ===

* Compilateur C : <tt>arm-none-eabi-gcc</tt>
* Compilateur C++ : <tt>arm-none-eabi-g++</tt>
* Debugger : <tt>arm-none-eabi-gdb-py</tt>
* System CMake at <tt>/usr/bin/cmake</tt> ou celui fourni avec Qt, qui est souvent plus récent.

CMake configuration :

<syntaxhighlight lang="CMake">
CMAKE_CXX_COMPILER:STRING=%{Compiler:Executable:Cxx}
CMAKE_C_COMPILER:STRING=%{Compiler:Executable:C}
</syntaxhighlight>

Si au moment d'ajouter GDB, Qt Creator indique "not recognized", essayer de lancer GDB dans un terminal pour voir quelle est l'erreur.
S'il lui manque libncurses (''error while loading shared libraries: libncurses.so.5: cannot open shared object file: No such file or directory'') :

<syntaxhighlight lang="Bash">
$ sudo apt install libncurses5
</syntaxhighlight>

Puis fermer/relancer Qt Creator.

= Matériel =

== ST-Link ==

La procédure expliquée sur cette page peut être appliquée de 2 manières :
* avec une carte Nucleo64 : on programme le STM32 qui est dessus via le ST-Link de la carte connectée au PC en USB
* avec une carte Nucleo64 et une carte maison : on programme le STM32 qui est sur la carte maison via le ST-Link de la carte Nucleo64, connectée au PC en USB

Pour programmer une carte maison avec le ST-Link d'une carte [https://www.st.com/en/evaluation-tools/nucleo-l476rg.html Nucleo64], souder R9 (boîtier 0603, de 1K à 47K) et dessouder SB12 (jumper NRST, face de dessous). Enlever les 2 jumpers sur CN2, et connecter la carte maison à CN4 (SWD).

== Carte maison ==

Voici un [[:File:Stm32-stlink.pdf|schéma]] exemple pour dessiner une carte maison, programmable avec le module ST-Link présent sur une carte Nucleo64.

= Utilisation =

== Support du MCU ==

Pour choisir les options du compilateur/linker, voir dans le répertoire d'installation de GCC, le tableau dans <code>/share/doc/gcc-arm-none-eabi/readme.txt</code>, sous "Architecture options usage".

Par exemple, pour un Cortex-M4 avec une FPU (floating point processing unit), les options de GCC sont :
* soft FP : <code>-mthumb -mcpu=cortex-m4 -mfloat-abi=softfp -mfpu=fpv4-sp-d16</code>
* '''hard FP''' : <code>-mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16</code>

Les STM32L4 ont une FPU matérielle. La deuxième ligne est donc à privilégier.

'''Important :''' ces options doivent être passées à la compilation ET à l'édition de liens. Pour cela, LD ne doit pas être appelé directement, mais via le driver de GCC.

== Générer le code d'initialisation ==

STM32CubeMX permet de générer le code d'initialisation du MCU :
* fonction attribuée à chaque broche
* configuration des horloges
* configuration des interruptions
* configuration des middlewares (USB, CAN, etc.)

STM32CubeMX a un gestionnaire pour télécharger les librairies ST.
Il existe 2 types de librairies : HAL, de haut niveau, et LL (low-level) de plus bas niveau.
La première est plus simple d'utilisation, mais est moins efficace que la seconde.

STM32CubeMX propose de faire un lien vers les libraries, ou de les copier dans le projet.
La 2ème solution permet une maintenance plus facile du projet sur le long terme.

Une fois le projet configuré, on peut générer le code.
* Pour Qbs, choisir ''SW4STM32'' pour Toolchain/IDE et cocher la case ''Generate under root''.
* Pour CMake, choisir ''Makefile''.

Le code généré contient des balises BEGIN/END en commentaire (à ne surtout pas toucher !) pour insérer le code utilisateur.
Le code entre ces balises est préservé si le code est généré de nouveau avec STM32CubeMX, pour par exemple, changer une configuration.
Par exemple, pour faire clignoter la LED LD2 de la Nucleo-64 avec une période de 1 s, modifier main.c :

<syntaxhighlight lang=C>
int main(void)
{
/* some code here */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */

/* USER CODE BEGIN 3 */
HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
HAL_Delay(500);
}
/* USER CODE END 3 */

/* some code here */
}
</syntaxhighlight>

== Projet Qbs ==

Dans Qt Creator, créer un nouveau projet (non-Qt application, C application). Sélectionner le kit défini précédemment, et cliquer sur ''Configure project''. Ajouter le fichier Qbs ci-dessous au projet.

[https://doc.qt.io/qbs/ Qbs] (prononcer "cubes") est un outil fourni avec Qt Creator pour simplifier la compilation et épargner l'écriture de makefiles.
Il est appelé à disparaître car il sera remplacé par [https://cmake.org/ CMake], qui est un standard libre.
En attendant, voici un exemple de fichier Qbs à adapter.

<syntaxhighlight lang=C>
import qbs

CppApplication {
consoleApplication: true
property string family: "STM32L4xx"
property string linkerScript: "STM32L476RGTx_FLASH.ld"
cpp.positionIndependentCode: false // make sure option -fPIC is not passed to GCC

// Make sure to call the linker through GCC driver :
cpp.linkerMode: "manual" // default : "automatic"
cpp.linkerName: "gcc" // this string is appended to "<full_path_to_toolchain>/arm-none-eabi-"

// Define some symbols (GCC -D flag)
cpp.defines: [
"USE_HAL_DRIVER",
"STM32L476xx",
"__weak=__attribute__((weak))",
"__packed=__attribute__((__packed__))"
]

// Options for compilation AND linking.
cpp.driverFlags: [
// CPU
"-mcpu=cortex-m4",
"-mthumb",
"-mfpu=fpv4-sp-d16",
"-mfloat-abi=hard",
"-specs=nano.specs", // use smaller libc
]

// Compiler flags for all langages (C, C++).
cpp.commonCompilerFlags: [
// Optimizations
// "-Os",
// "-O0",
"-Og",

"-Wall",
"-fdata-sections",
"-ffunction-sections",

// For debug
"-g",
"-gdwarf-2",

"-c", // don't run the linker
// "-v" // print a whole lot of details
]

// Linker flag only i.e. understood by LD !!!
// Qbs will prepend all these flags with "-Wl," so that GCC transfers them to LD.
// Other options required for linking should be set in the driverFlags section.
cpp.linkerFlags: [
"-T"+path+"/"+linkerScript,
"-static",
"--verbose", // displays library search
"-lc",
"-lm",
"-lnosys",
"-Map="+buildDirectory+"/memory.map", // file created at the end of the link step
"--cref", // map file formatting
"--gc-sections", // fixes "undefined reference to _exit" error
]

// Include directories.
cpp.includePaths: [
"Inc",
"Drivers/CMSIS/Include",
"Drivers/CMSIS/Device/ST/"+family+"/Include",
"Drivers/STM32L4xx_HAL_Driver/Inc",
"Middlewares/ST/STM32_USB_Device_Library/Class/CDC/Inc",
"Middlewares/ST/STM32_USB_Device_Library/Core/Inc/"
]

// Source files.
files: [
"Inc/*.h",
linkerScript,
"Src/*.c",
"Drivers/CMSIS/Device/ST/"+family+"/Include/*.h",
"startup/*.s",
"Drivers/CMSIS/Device/ST/"+family+"/Source/Templates/*.c",
"Drivers/CMSIS/Include/*.h",
"Drivers/"+family+"_HAL_Driver/Inc/*.h",
"Drivers/"+family+"_HAL_Driver/Src/*.c",
"Middlewares/ST/STM32_USB_Device_Library/Class/CDC/Src/*.c",
"Middlewares/ST/STM32_USB_Device_Library/Core/Src/*.c"
]

Properties {
condition: qbs.buildVariant === "debug"
cpp.defines: outer.concat(["DEBUG=1"])
}

Group { // Properties for the produced executable
fileTagsFilter: product.type
qbs.install: true
}
}
</syntaxhighlight>

== Projet CMake ==

Si on a généré le code avec STM32CubeMX en choisissant ''Makefile'', un fichier <tt>Makefile</tt> est créé.
Ce fichier contient tout ce qu'il faut pour écrire le fichier de config de CMake, <tt>CMakeLists.txt</tt> :
* liste des .c
* liste des répertoires à inclure
* les defines pour <tt>target_compile_definitions()</tt>
* les options de compilation pour <tt>target_compile_options()</tt>

Avant de commencer, renommer <tt>Makefile</tt> en <tt>Makefile.STM32CubeMX</tt> pour éviter que la compilation du fichier CMake ne l'écrase.

Voici un <tt>CMakeLists.txt</tt>, à adapter selon le MCU, en s'aidant du Makefile généré par STM32CubeMX.

<syntaxhighlight lang="CMake">
# Board : nucleo64-stm32l476rg

cmake_minimum_required(VERSION 3.15.3)

# Skip toolchain check
# Useful if CMake fails with error "The C compiler is not able to compile a simple test program".
set(CMAKE_C_COMPILER_WORKS 1)
set(CMAKE_CXX_COMPILER_WORKS 1)

project(L4_blinky_cmake)

enable_language(C ASM)
set(CMAKE_C_STANDARD 99)
set(CMAKE_C_STANDARD_REQUIRED ON)
set(CMAKE_C_EXTENSIONS OFF)

set(STM32CUBEMX_GENERATED_FILES

"Core/Src/main.c"
"Core/Src/stm32l4xx_it.c"
"Core/Src/stm32l4xx_hal_msp.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_tim.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_tim_ex.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_uart.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_uart_ex.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_i2c.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_i2c_ex.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_rcc.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_rcc_ex.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash_ex.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash_ramfunc.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_gpio.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_dma.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_dma_ex.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_pwr.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_pwr_ex.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_cortex.c"
"Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_exti.c"
"Core/Src/system_stm32l4xx.c"

"startup_stm32l476xx.s"
)

set(EXECUTABLE ${PROJECT_NAME}.out)

add_executable(${EXECUTABLE} ${STM32CUBEMX_GENERATED_FILES})

target_include_directories(${EXECUTABLE} PRIVATE
Core/Inc
Drivers/STM32L4xx_HAL_Driver/Inc
Drivers/STM32L4xx_HAL_Driver/Inc/Legacy
Drivers/CMSIS/Device/ST/STM32L4xx/Include
Drivers/CMSIS/Include
)

target_compile_definitions(${EXECUTABLE} PRIVATE
-DUSE_HAL_DRIVER
-DSTM32L476xx
)

set(MCU
-mcpu=cortex-m4
-mthumb
-mfpu=fpv4-sp-d16
-mfloat-abi=hard
)

target_compile_options(${EXECUTABLE} PRIVATE
${MCU}

-fdata-sections
-ffunction-sections

-Wall

$<$<CONFIG:Debug>:-Og> # add -g if debug is selected
)

target_link_options(${EXECUTABLE} PRIVATE
-T${CMAKE_SOURCE_DIR}/STM32L476RGTx_FLASH.ld
${MCU}
-specs=nano.specs
-lc
-lm
-lnosys
-Wl,-Map=${PROJECT_NAME}.map,--cref
-Wl,--gc-sections # fixes "undefined reference to _exit" error
)

# Get the path to the toolchain
if(CMAKE_VERSION VERSION_LESS "3.20")
get_filename_component(TOOLCHAIN_PATH ${CMAKE_C_COMPILER} DIRECTORY)
else()
cmake_path(GET CMAKE_C_COMPILER ROOT_PATH TOOLCHAIN_PATH)
endif()
message(STATUS "Toolchain path: ${TOOLCHAIN_PATH}")

# Print executable size
add_custom_command(TARGET ${EXECUTABLE}
POST_BUILD
COMMAND echo "Target size:"
COMMAND ${TOOLCHAIN_PATH}/arm-none-eabi-size ${EXECUTABLE}
)

# Create all necessary files to flash the MCU from the command line.
# Only relevant in Release mode.
if(CMAKE_BUILD_TYPE STREQUAL "Release")
message(STATUS "Build type: Release")

# Create bin and hex file
add_custom_command(TARGET ${EXECUTABLE}
POST_BUILD
COMMAND ${TOOLCHAIN_PATH}/arm-none-eabi-objcopy -O binary ${EXECUTABLE} ${PROJECT_NAME}.bin
COMMAND ${TOOLCHAIN_PATH}/arm-none-eabi-objcopy -O ihex ${EXECUTABLE} ${PROJECT_NAME}.hex
)

# Concatenate 2 OpenOCD config files into one, into the build directory.
add_custom_command(TARGET ${EXECUTABLE}
POST_BUILD
COMMAND cat /usr/local/share/openocd/scripts/interface/stlink.cfg /usr/local/share/openocd/scripts/target/stm32l4x.cfg > ${PROJECT_NAME}.cfg
)

# Create a Bash script in the build directory to flash the MCU from the command line.
# The script must be run as ROOT !
file(WRITE "${CMAKE_BINARY_DIR}/flash.sh"
"#!/bin/bash\n\nopenocd -f ${PROJECT_NAME}.cfg -c \"init; reset halt; stm32l4x mass_erase 0; program ${PROJECT_NAME}.bin reset exit 0x08000000\""
)

# Set script permissions.
file(CHMOD "${CMAKE_BINARY_DIR}/flash.sh"
FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_WRITE GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)

endif()
</syntaxhighlight>

Référence :
* https://dev.to/younup/cmake-on-stm32-the-beginning-3766

Autres références :
* https://www.bartslinger.com/qtcreator/stm32cubemx-cmake-and-qtcreator/
* https://github.com/ObKo/stm32-cmake

== Programmer le STM32 ==

=== En mode debug ===

# Connecter la carte Nucleo-64 (avec le ST-Link V2) au PC (USB).
# Dans un terminal, lancer OpenOCD via le script écrit plus haut en tant que root.
# Dans Qt Creator
## configurer le projet en mode debug
## taper Ctrl+R (run) pour compiler, programmer, et exécuter le code sur la cible.

Et voilà !

=== En mode release ===

Bien qu'au moment de lancer le programme (Ctrl+R : flasher + exécuter) sur la cible en mode Release, Qt Creator affiche un warning "This does not seem to be a Debug build", '''le MCU est bel et bien programmé'''.

Mais on peut aussi le programmer en ligne de commande grâce à CMake et au script <tt>flash.sh</tt> généré par CMake.
Voir la doc de CMake.
Utile si on ne veut pas lancer Qt Creator.

# '''Stopper OpenOCD''' s'il est lancé dans un terminal (Ctrl+C).
# Dans Qt Creator, configurer le projet en mode release.
# Compiler (Ctrl+B).
# Ouvrir un terminal dans le '''répertoire de compilation''' (qui en général n'est pas celui du source).
# Exécuter <tt>$ sudo ./flash.sh</tt>, le script créé par CMake.

Ce script concatène 2 fichiers de config d'OpenOCD, puis efface/programme le STM32.
Il est équivalent aux 2 commandes ci-dessous.

<syntaxhighlight lang="Bash">
$ cat /usr/local/share/openocd/scripts/interface/stlink.cfg /usr/local/share/openocd/scripts/target/stm32l4x.cfg > myboard.cfg
$ sudo openocd -f myboard.cfg -c "init; reset halt; stm32l4x mass_erase 0; program L4_blinky_cmake.bin reset exit 0x08000000"
</syntaxhighlight>

= Erreurs connues =

''' ''object_file'' uses VFP register arguments, ''target'' does not'''

Incompatibilité de FPU entre le code utilisateur et les libraries liées (''-mfloat-abi=hard'' vs. ''-mfloat-abi=softfp'').

''' Le programme compile mais bloque dans un error handler.'''

Vérifier que LD n'est pas appelé directement, mais via le driver de GCC. Vérifier que la ligne de commande de GCC au moment de la compilation ET au moment de l'édition de liens contient bien les options qui définissent le MCU et la libc : <tt>-mcpu=cortex-m4, -mthumb, -mfpu=fpv4-sp-d16, -mfloat-abi=hard, -specs=nano.specs</tt>.

Les Groupes ARM : STM32/toolchain sous Linux - Historique des versions

David.picard : /* En mode release */

David.picard : /* En mode release */