blue pill, programmation en C

Dans cet article j'explique comment programmer la carte blue pill sans autre outils que ceux fournis par l'open source gnu-arm-none-eabi. Cet article est une adaptation de l'article en anglais produit par Jacob Mossberg. Même si l'article original réfère à une carte STM32-H103 et un programmeur ARM-USB-OCD-H, les outils logiciels et la procédure sont les même pour la carte blue pill et le programmeur STLINK/V2 que j'utilise.

Installation des outils logiciels

• Les utilitaires pour travailler avec les fichiers binaires. Sur mon système la version la plus récente est 2.26.1

  
  sudo apt install binutils-arm-none-eabi
  

• Le compilateur GCC. Sur mon système la version la plus récente est 5.4.0

  
  sudo apt install gcc-arm-none-eabi
  

• Le débogueur. Sur mon système la version la plus récente est 7.11.1

  
  sudo apt install gdb-arm-none-eabi
  

Jacobs Mossberg mentionne aussi la possibilité d'utiliser la toolchain fournie par ARM.

Compiler le programme exemple

Téléchargez les 3 fichiers exemples fournis par Jacobs Mossberg.

• Le code d'initialisation du µC startup.c
• Le fichier pour le linker stm32.ld
• Finalement le fichier makefile.
• Dans mon dépôt blue_pill dans le dossier C il y a les fichiers blink.c et stm32f103c8.h que je vais utiliser comme programme de démonstration.

compiler le programme.

1. J'ai modifié le fichier makefile
2. Sur la ligne de commande à partir du dossier contenant les fichiers sources il suffit de faire la commande:

   
   make build
   

   pour créer le fichier blink.bin
3. La commande suivante suppose que la carte blue pill est branchée au stlink/v2 et que ce dernier est branché au PC.

   
   st-flash write blink.bin 0x8000000
   

Sitôt l'opération complétée la LED verte devrait clignoter à environ 1 cycle par seconde. Essayez le bouton reset de la carte si ça ne fonctionne pas d’ambler.

Déboguer un programme avec gdb et stlink/v2

Le programme est déjà déboguer mais on va supposer qu'il ne l'est pas et on va le recompiler pour le débogage avec la commande

make build_debug
st-flash write blink.bin 0x8000000

La différence entre la version débogage est que le compilateur n'optimise pas le code et le fichier blink.elf contient toute l'information qui permet à gdb de faire le lien entre les lignes du code source et le code exécuté sur le µC. Si vous utilisez une version non debug de blink.elf, gdb va afficher le message [ no source code available ].

Séance de débogage

Dans la console déjà ouverte on lance:

st-util

Il faut ouvrir une 2ième console de commande (maximisez la fenêtre) et dans cette nouvelle console lancez gdb. Par défaut st-util utilise le port 4242 il faut donc configurer gdb pour qu'il utilise aussi ce port.

arm-none-eabi-gdb -tui --eval-command="target remote localhost:4242" blink.elf

Les commandes les plus utiles sont les suivantes:

• hbreak arg, pour créer un point d'arrêt matériel. Comme argument on peut utiliser le nom d'une fonction ou un numéro de ligne.
  exemples:

  
  (gdb) hbreak main
  (gdb) hbreak main.c:29
  

• continue ou c, pour relancer l'exécution. S'il n'y a pas de point d'arrêt faire <CTRL-c> pour arrêter l'exécution.
• step ou s, pour exécuter une seule ligne de code.
• next ou n, même chose que step mais saute les appels de fonctions.
• layout regs, pour ouvrir une fenêtre qui affiche le contenu des registres du CPU.
• print var, pour imprimer le contenu d'une variable.
• delete, pour supprimer les points d'arrêt.
• clear no|nom, pour supprimer un point d'arrêt par le numéro de ligne no ou le nom de la fonction.

Une meilleure version de blink

Cette version de blink est loin d'être idéale car elle utilise une boucle de code pour le délais. Ce qui fait que le délais varie en fonction de l'optimisation du code par le compilateur et aussi avec la fréquence du clock. Pour améliorer le programme on va utiliser une minuterie et pourquoi pas brancher la sortie PC13 à un PWM ainsi une fois l'initialisation complétée le µC n'aura plus rien à faire. Au va profiter de l'occasion pour configurer le clock à 72 Mhz en utilisant l'oscillateur externe et le PLL au lieu de l'oscillateur interne.

2018-09-01

J'ai terminé la version améliorée de blink. Elle est dans le dossier blink_v2. Cette version utilise le cristal externe avec le PLL pour obtenir une fréquence SYSCLK maximale de 72 Mhz. Le CPU Cortex-M3 possède un compteur interne de 24 bits incrémenté à la fréquence du clock AHB ou AHB/8. J'ai configuré se compteur pour produire un délais d'une milliseconde avec la fonction millisec() qui est appelé par la fonction delay() qui détermine la fréquence de clignotement de la LED.

Voici la nouvelle version de blink_v2.c /* * Description: démo faisant clignoté la LED verte de la carte blue pill. * Auteur: PICATOUT * Date: 2018-08-20 * Copyright Jacques Deschênes, 2018 * Licence: GPLv3 * revisions: * 2018-08-30, blink_v2 version amélioré de blink * clock HSE + PLL Fsys= 72Mhz * Utilisation du core timer pour créer un délais 1 milliseconde. * */ #include "stm32f103c8.h" #include "gen_macros.h" #include "blue_pill.h" // configure SYSCLK à la fréquence maximale de 72 Mhz // en utilisant le cristal externe (HSE) et le PLL static void set_sysclock(){ // active l'oscillateur externe RCC_CR|=1<<RCC_CR_HSEON; // attend que l'oscillateur soit prêt while (! (RCC_CR & (1<<RCC_CR_HSERDY))); // sélection PREDIV1 pour la source du PLL // multiplie la fréquence HSE par 9 // pour une fréquence maximale Fsysclk de 72 Mhz RCC_CFGR|=(PLLSRC_PREDIV1<<RCC_CFGR_PLLSRC)|(PLLMUL9<<RCC_CFGR_PLLMUL); // active le PLL RCC_CR|=1<<RCC_CR_PLLON; // Attend que le PLL soit prêt while (! (RCC_CR & (1<<RCC_CR_PLLRDY))); // ajoute délais d'accès à la mémoire flash FLASH_ACR|=WAIT_2_CY; // SélectionNE le PLL comme source pour SYSCLK RCC_CFGR|=PLL_CLK<<RCC_CFGR_SW; // La fréquence maximale pour APB1 doit-être de 36 Mhz // donc divise SYSCLK/2 RCC_CFGR|=PPRECLK_DIV2; } // configure SYSTICKS pour un cycle 1 msec // source AHB/8 // valeur reload 72Mhz/8/1000=9000 #define MSEC_DLY 9000 static void config_systicks(){ STK_LOAD=MSEC_DLY; //STK_CTRL|=1<<STK_CLKSRC; // source AHB/8 } //délais de 1 milliseconde static void millisec(){ STK_VAL=MSEC_DLY; STK_CTRL|=1<<STK_ENABLE; while (!(STK_CTRL&(1<<STK_COUNTFLAG))); STK_CTRL&=~(1<<STK_ENABLE); } #define _mask_cnf(cnf,bit) (cnf & ~(CNF_MASK<<((bit&7)*4))) #define _apply_cnf(cnf,bit,pin_cnf) (_mask_cnf(cnf,bit) | pin_cnf<<((bit&7)*4)) // PC13 mode{0:1}=10, CNF{2:3}=01 -> 6 #define PC13_CNF 6 static void port_c_setup(){ RCC_APB2ENR|=1<<GPIOC_EN; GPIOC_CRH=_apply_cnf(DEFAULT_PORT_CNF,LED_PIN,PC13_CNF); } inline static void led_on(){ GPIOC_BRR=GRN_LED; } inline static void led_off(){ GPIOC_BSRR=GRN_LED; } // délais en millisecondes inline static void delay(unsigned dly){ for (;dly;dly--)millisec(); } // pour une période de 1 seconde #define RATE 500 // millisecondes void main(void){ set_sysclock(); config_systicks(); port_c_setup(); while (1){ led_off(); delay(RATE); led_on(); delay(RATE); } }

Une autre amélioration à apporter serait d'ajouter une interruption sur le coretimer et de créer un variable globale systicks qui serait incrémmentée à l'intérieur de cette interruption à toute les milliseconde.

2018-09-03

J'ai ajouté systick_demo. Ce programme démontre comment installer une routine d'interruption. La routine d'interruption systick_int incrémente la variable ticks et décrémente la variable timer si sa valeur est non nulle. systick_int gère l'interruption du coretimer qui est programmée pour se produire à intervalle de 1 milliseconde.

2018-09-16

Je poursuis mes expérimentations de programmation bare metal de la blue pill en C. j'ai ajouté plusieurs démos dans le dépôt git

• Expérimentation avec le core timer
• Expérimentation avec les interruptions
• Expérimentation avec le RTC
• Expérimentation avec les appels systèmes.

---

retour à l'introduction