blue pill, programmation avec Arduino IDE

Dans cet article j'explique comment installer ArduinoIDE sur Ubuntu et comment le configurer pour l'utilisation avec la carte blue pill.

Arduio a fait ses début avec des cartes de développement basé sur des µC Atmel AVR mais ajourd'hui le support pour d'autre µC a été ajouté entre autre pour les µC à coeur ARM Cortex M. La carte blue pill utilise un µC stm32f103c8t6 avec un CPU Cortex M3.

Les références utilisées pour l'écriture de cet article sont les suivantes:

• Set up STM32 "blue pill" for Arduino IDE
• STM32duino boot loader
• STM32duino wiki
• Téléchargement de ArduinoIDE

Installation de ArduinoIDE

1. Téléchargez la version d'ArduinoIDE qui convient à votre système. Mon Système est en Ubuntu 16.04 64 bits.
2. Il s'agit d'une archive TAR zippée. On la place dans le dossier où on veut installer le programme. Par exemple

   
   mkdir ~/ArduinoIDE
   tar -xzf arduino-1.8.5-linux64.tar.xz
   

   Il y a maintenant un dossier ~/ArduinoIDE/arduino-1.8.5
3. Allez dans le dossier ~/ArduinoIDE/arduino-1.8.5. Il faut rendre le fichier install.sh exécutable

   
   chmod +x intall.sh
   

4. Exécutez le programme d'installation qui va créer un raccourci sur votre bureau.

   
   ./install.sh
   

5. S'il y a une erreur au démarrage de l'IDE, examinez le contenu dans un éditeur de texte.

   
   gedit ~/Bureau/arduino-arduinoide.desktop
   

   
   Mon raccourci ne fonctionnais pas car il y avait un espace dans le chemin de l'exécutable. Pour corriger j'ai simplement mis le chemin au complet entre guillemets comme on le voie dans la capture d'écran.
6. Une fois l'IDE démarré on ajoute l'URL qui va permettre à l'IDE de télécharger les librairies de STM32duino.
   Allez dans le menu Fichier - Préférences ajoutez http://dan.drown.org/stm32duino/package_STM32duino_index.json dans le champ URL de gestionnaire de cartes supplémentaires et refermez la fenêtre.
   
7. Allez dans le menu Outils - Type de carte - gestionnaire de carte. Il faut sélectionner la dernière version de STM32F1xx/GD32F1xx
   
   Après avoir fait l'installation revenez sélectionné le même item dans la liste et cliquez sur le bouton mise à jour pour être certain d'avoir la dernière version installlée.

Installation du boot loader

En réalité le boot loader n'est pas nécessaire car l'environnement ArduinoIDE permet de programmer la carte en utilisant le programmeur stlink/v2. Je vais quand d'écrire l'installation du boot loader.

1. Clonez le dépôt https://github.com/rogerclarkmelbourne/STM32duino-bootloader sur votre ordinateur

   
   cd ~/Téléchargements
   git clone https://github.com/rogerclarkmelbourne/STM32duino-bootloader
   

   Il y a un dossier binaries dans le dépôt où se trouve plusieurs fichiers .bin

   
   cd ~/Téléchargements/STM32duino-bootloader/binaries
   

   J'ai installé le fichier generic_boot20_pc13.bin car sur la carte blue pill que j'ai la LED verte est branchée à PC13.
2. Pour programmer le boot loader il faut mettre le cavalier boot0 sur la carte blue pill à la position 1. La commande à exécuter est la suivante.

   
   st-flash --reset write generic_boot20_pc13.bin 0x8000000
   

   
   S'il n'y a pas d'erreur remettez le cavalier boot0 à sa position initiale et pesez sur le bouton reset de la carte. Au démarrage la LED verte clignote rapidement puis lentement 5 fois.
3. Il faut maintenant débrancher le programmeur stlink/v2, remettre le cavalier boot0 à la position 0 et brancher la carte au PC avec un cable USB. Un périphérique ttyACM0 devrait maintenant être visible dans le dossier /dev.

Premier projet

1. Lancez ArduinoIDE Il faut maintenant sélectionner le type de carte, la variante ainsi que le méthode de téléversement (i.e. Upload method)
   • Type de carte: Generic STM32F103 series
   • Variant: STM32F103C8 (20K RAM, 64K Flash)
   • Upload Method: STM32duino bootloader
2. Comme premier projet nous allons sélectionner dans Fichier - exemples - A_STM32_Examples - digital - Blink
   Puisque sur ma carte la LED verte est sur PC13 J'ai du modifié l'exemple en remplaçant PB1 par PC13
   
3. Dans la barre d'outils d'ArduinoIDE cliquez sur le bouton crochet pour compiler le programme. Les messages s'affiche en bas dans la fenêtre en noir.
4. Si le programme a compiler correctement pressez le bouton reset de la carte blue pill et dans la barre d'outils cliquez sur la flèche téléverser pour programmer la carte.

Problème sur mon ordinateur ça ne fonctionne pas. Voici le message d'erreur qui apparaît dans la fenêtre du bas d'ArduinoIDE.

Failed to open serial device.
No DFU capable USB device found

Et la commande dmesg rapporte l'erreur suivante:

[ 7356.893978] cdc_acm 2-1.7:1.0: ttyACM0: USB ACM device
[ 7363.474986] usb 2-1.7: USB disconnect, device number 21
[ 7363.477217] cdc_acm 2-1.7:1.0: failed to set dtr/rts

Mes recherche m'ont conduit à ceci et à celà. Il semblerais donc que d'utiliser ce bootloader ne fonctionne pas! J'en arrive donc à la deuxième méthode qui fonctionne très bien.

Utiliser le programmeur STLINK/V2 avec ArduinoIDE

D'abord je désinstalle le bootloader en mettant le cavalier boot0 à 1 en en rebranchant le programmeur.

st-flash erase

Ensuite:

1. Débranchez le fil 3v3 du programmeur côté de la carte blue pill
2. Remettez le cavalier boot0 à 0.
3. Brancher le cable USB à l'autre bout de la carte et au PC. Maintenant la carte est alimentée par le cable USB.
4. Dans le menu Outils - Upload Method: sélectionnez STLINK
5. Cliquez pour téléverser Blink à nouveau. Bingo ça fonctionne!

Donc maintenant on utilise STLINK/V2 pour programmer la carte blue pill et le cable USB lui sert simple à communiquer avec le Terminal sériel disponible dans Outils - Moniteur série.

L'exemple Fichier - exemples - A_STM32_Examples - General - InternalTempSensor fait la lecture de la sonde de température et envoie des informations au Moniteur Serie. Encore une fois j'ai du adapter cet exemple à la carte blue pill /* Re: http://leaflabs.com/docs/hardware Arduino 1.6.0rc1 modifications by m. ray burnette Sketch uses 31,608 bytes (29%) of program storage space. Maximum is 108,000 bytes. Global variables use 3,752 bytes of dynamic memory. PUBLIC DOMAIN EXAMPLE */ /* * Modified by PICATOUT, 2018/08/23 for blue pill * * Lecture de la sonde de température ainsi que * de la broche 15 (PA5) et envoie de l'information * sur le port sériel. * Intervalle de lecture 1 seconde. */ //#include <stdio.h> #include <libmaple/adc.h> #define LED_PIN PC13 // blue pill LED verte #define A_RANDOM_ANALOG_PIN PA5 // correspond à la broche 15 #define UC_TEMP 16 // canal sonde température interne µC void setup_temperature_sensor() { adc_reg_map *regs = ADC1->regs; // 3. Set the TSVREFE bit in the ADC control register 2 (ADC_CR2) to wake up the // temperature sensor from power down mode. Do this first 'cause according to // the Datasheet section 5.3.21 it takes from 4 to 10 uS to power up the sensor. regs->CR2 |= ADC_CR2_TSVREFE; // 2. Select a sample time of 17.1 μs // set channel 16 sample time to 239.5 cycles // 239.5 cycles of the ADC clock (72MHz/6=12MHz) is over 17.1us (about 20us), but no smaller // sample time exceeds 17.1us. regs->SMPR1 = (0b111 << (3*6)); // set channel 16, the temp. sensor } void setup(void) { // Set up the LED to blink pinMode(LED_PIN, OUTPUT); // set up an analog input. We want to test and make sure other analog reads don't screw this up. pinMode(A_RANDOM_ANALOG_PIN, INPUT_ANALOG); // wait for serial monitor to be connected. while (!Serial) { digitalWrite(LED_PIN,!digitalRead(LED_PIN));// Turn the LED from off to on, or on to off delay(100); // fast blink } // init temp sensor setup_temperature_sensor(); // announce start up if(Serial) Serial.println("Moniteur temperature uC"); } // // once per second perform a standard analog read and read the temperature sensor // the analog read is to test whether our messing with the temp sensor will screw up analog reads // or visa versa. // Also compute and display the time each operation takes. // void loop(void) { uint16 temp_sense, analog_pin; char buf[64]; float volt; analog_pin = analogRead(A_RANDOM_ANALOG_PIN); volt=analog_pin/4095*3.3; temp_sense = adc_read(ADC1, UC_TEMP); if(Serial) { sprintf(buf,"temp: %d, broche 15 (PA5) %G volt" , temp_sense, volt); Serial.println(buf); } digitalWrite(LED_PIN,!digitalRead(LED_PIN));// Turn the LED from off to on, or on to off delay(1000); }

Voici une capture d'écran du Moniteur série. Le moniteur série doit-être configuré à 115200 BAUD.

---

retour à blue pill (introduction)

blue pill (introduction)

Il y a 1 peu plus d'un an j'ai découvert l'existence d'une carte de développement très économique basée sur un µC STM32F103C8T6. Il s'agit d'un µC 32 bits Cortex M3. Suite à la lecture de l'article suivant sur hackaday, j'en ai commander 5 sur ebay.ca. Cette carte a étée bâptisée blue pill.

Cet article est le premier d'une série sur la programmation de la blue pill en utilisant différents outils.

• Programmation en utilisant Arduino IDE.
• Programmation en C en utilisant les outils GNU arm-none-eabi.
• Programmation en utilisant MECRISP Forth.
• Programmation en utilisant la plateforme WEB mbed.
• J'ai créé un dépôt sur github pour cet série d'articles.

Pré-requis

Je travaille sous Ubuntu 16.04 LTS les descriptions que je vais faire sont donc pour cette plateforme. Ça devrait aussi être valide pour une autre distribution Linux basé sur Debian-Linux.

Dans cette première partie je vais décrire comment installer les outils de développement qui seront nécessaires pour les prochains articles.

Blue pill

Voici la schématique de la carte blue pill

Sur les cartes que j'ai en main la résistance R10 a une valeur de 10k au lieu des 4k7 montré sur cette schématique. Ce sera à prendre en considération lorsque viendra le temps d'utiliser cette carte avec Ardruino IDE.

Discription des broches

STM32F103C8T6

Voici les principales caractéristiques du µC qui est installé sur cette carte.

• Coeur ARM Cortex M3, Fsys maximale 72Mhz.
• Mémoire flash 64Ko
• Mémoire RAM 20Ko
• 3 timers usage général et 1 avancé.
• 2 SPI
• 2 I²C
• 3 USART
• 1 USB
• 1 CAN
• 37 GPIO
• 2 ADC 10 canaux résolution 12 bits
• datasheet

STLINK-V2

Pour programmer la carte il faut un programmeur STLINK-V2. Heureusement un clone de ce programmeur est aussi disponible sur ebay.ca à petit prix.

Installation des outils logiciels.

Pour les étapes d'installation logicielle vous devez être membre du groupe sudo car des privilèges root sont requis pour certaines étapes.

utilitaire ST-LINK

Les utilitaires ST-LINK sont disponibles en open-source sur https://github.com/texane/stlink.
Étapes à suivre à partir de la ligne de commande i.e. sous Ubuntu on fait <CTRL>-<ALT>-T pour ouvrir la console de comamdes.

1. Installer les outils de développement gcc et binutils.
   sudo apt install gcc binutils
2. Installer l'utilitaire cmake.
   sudo apt install cmake
3. Installer libusb-dev
   sudo apt install libusb-dev
4. Cloner le dépôt https://github.com/texane/stlink.
   J'ai créé un dossier ~/Documents/blue pill dans lequel j'ai cloné le dépôt:
   git clone https://github.com/texane/stlink
5. Lancer cmake à partir du dossier stlink pour créer les fichiers de configurations utilisés par make. N'oubliez pas le point après cmake pour indiquer à cmake qu'il travaille à partir du répertoire courant.
   cmake .
6. Lancer make
   make
7. Lancer make install. Utilisez sudo car les privilèges root sont requis.
   sudo make install.
   Les utilitaires sont installés dans /usr/local
8. Modifier /etc/ld.so.conf pour indiquer le chemin des librairies utilisées par st-link. Utilisez votre éditeur de texte préféré et ajouter à la fin du fichier /etc/ld.so.conf la ligne /usr/local/lib et sauvegarder. sudo est requis.
   sudo gedit /etc/ld.so.conf
   cat /etc/ld.so.conf
   include /etc/ld.so.conf.d/*.conf
   /usr/local/lib
   
   On recharge la configuration avec la commande.
   $ sudo ldconfig
9. Maintenant branchez le programmeur ST LINK v2 dans un port USB. Faites la commande
   $ lsusb
   Bus 002 Device 007: ID 0483:3748 STMicroelectronics ST-LINK/V2
   Bus 002 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub
   Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
   Bus 001 Device 004: ID 0461:0010 Primax Electronics, Ltd HP PR1101U / Primax PMX-KPR1101U Keyboard
   Bus 001 Device 003: ID 0000:0538
   Bus 001 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub
   Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
   
   Assurez-vous que votre système a bien détecter le programmeur identifié par STMicroelectronics ST-LINK/V2

Branchement de la carte blue pill

Le programmeur viens avec un petit cable à 4 fils. Les connections sont bien identifiées sur le programmeur et sur le connecteur à 4 broches qui dépassent au bout de la carte blue pill.

broche programmeur	broche carte
GND (4)	GND
3v3 (8)	3v3
SWCLK (6)	SWCLK
SWDIO (2)	SWIO

Maintenant on va essayer l'utilitaire st-info avec l'option --probe qui devrait nous afficher les informations sur le programmeur et la µC qui y est branché.

$ st-info --probe
Found 1 stlink programmers
serial: 483f6e066772574857351967
openocd: "\x48\x3f\x6e\x06\x67\x72\x57\x48\x57\x35\x19\x67"
flash: 65536 (pagesize: 1024)
sram: 20480
chipid: 0x0410
descr: F1 Medium-density device
$

On obtient les informations sur le µC branché au programmeur c'est bon signe, on devrait pouvoir le programmer en utilisant st-flash

Nous avons donc complété la première étape de cette série d'articles dans le prochain article nous allons voir comment programmer la blue pill à partir de l'environnement Arduino IDE.

blue pill, programmation avec mbed

mbed.com est une plateforme de développement en ligne pour les µC à base de CPU Cortex-M. Dans cet article j'explique comment utiliser cette plateforme pour programmer la carte blue pill. L'utilisation de cette plateforme est gratuite mais il faut s'enregistrer en créant un compte.

Configuration

1. Créer un compte.
2. Lorsque votre session est ouverte cliquez sur le bouton compiler
   
3. Dans la fenêtre de L'IDE en haut à droite il y a un texte qui indique la plateforme sélectionnée pour le projet en cours. Il faut cliquez sur ce nom pour ouvrir la fenêtre qui permet de sélectionner la carte désirée.
   
4. Dans cette fenêtre cliquez sur add board. Un nouvel onglet va s'ouvrir dans votre navigateur. Avec la liste de toutes les cartes disponibles. La carte blue pill ne fait pas parti du lot mais on va choisir la carte qui si rapproche le plus. Dans la liste Target vendor cochez STMicroelectronics. Dans la liste des cartes cliquez sur NUCLEO_F103RB
   
5. Sur cette page en défilant vers le bas vous verrez à droite un bouton add to your Mbed Compiler sur lequel vous devez cliquez pour ajouter cette carte à votre environnement de développement. C'est tout ce qu'il y a à faire. Notez que la carte NUCLEO-F130RB utilise un µC différent de la carte blue pill. Il s'agit du stm32f103RBT6. Les différences sont
   • Emballage LQFP64 au lieu de LQFP48
   • 128Ko de flash au lieu de 64Ko
   • 51 E/S au lieu de 37
   • 16 canaux ADC au lieu de 10

Importer des programmes et librairies

Il y a sur le site de mbed de nombreux programmes et librairies qui sont déjà configurés pour la carte blue pill ou pour le µC STM32F103C8T6.

1. Cliquez sur le bouton import
2. Sélectionnez l'onglet programs dans la nouvelle vue.
3. Dans la fenêtre search entrez blue pill et cliquez le bouton search. Voici la liste que j'obtiens
   
   Encore mieux si je fais une recherche sur le nom du µC STM32F103C8T6.
   
   18 pages!
4. Dans la liste obtenue avec search blue pill j'ai sélectionné STM32F103C8T6_Hello pour l'importer.
   
5. Dans la fenêtre import program cliquez sur le bouton import.

Cliquez sur Compile. Lorsque la compilation est terminée la fenêtre de sauvegarde s'ouvre pour vous permettre de sauvegarder le fichier binaire sur votre ordinateur.

st-flash write STM32F103C8T6_Hello.bin 0x8000000

Et ça fonctionne du premier coup.

---

retour à l'introduction

blue pill, MECRISP Forth

MECRISP est un Forth développé par Matthias Koch originalement pour les µC MSP430 mais a été depuis porté sur de nombreuses plateformes. Dans cet article j'installe MECRISP sur une carte blue pill et le met à l'essaie.

Les références utilisées pour cet article sont les suivantes.

• Moving Forth with Mecrisp-Stellaris and Embello (en anglais).
• MECRISP sur sourceforge (en anglais).
• hackaday-Forth, version augmentée de MECRISP selon l'article mentionné dans la première référence (en anglais).
• STM32F1xx technical reference manual, RM0008 (en anglais).
• STM32F103x8 datasheet, DS5319 (en anglais).

Installation de MECRISP sur la carte blue pill

Le projet MECRISP est sur sourceforge. Il faut télécharger le fichier https://sourceforge.net/projects/mecrisp/files/mecrisp-stellaris-2.4.4.tar.gz/download et le décompresser.

$ tar -zxf mecrisp-stellaris-2.4.4.tar.gz

Vous devriez lire le fichier README qui se trouve dans le répertoire racine de MECRISP. Il contient des informations utiles comme une brève description de chaque mot du vocabulaire de base.
On va dans le répertoire contenant les fichiers du stm32f103

$ cd mecrisp-stellaris-2.4.4/stm32f103
$ ls
1w.fs lcd-ptinting.fs si4432_spi.fs
font16x30.fs mecrisp-stellaris-stm32f103.bin si-test.fs
lcd-base.fs mecrisp-stellaris-stm32f103.hex stm32f103.fs
lcd-graphics.fs precompiled

Le fichier mecrisp-stellaris-stm32f103.bin est celui qu'on va utiliser pour programmer la carte blue pill en utilisant l'utilitaire st-flash avec la commande write.

st-flash write mecrisp-stellaris-stm32f103.bin 0x8000000
st-flash 1.4.0-47-gae717b9-dirty
2018-08-13T16:57:12 INFO usb.c: -- exit_dfu_mode
2018-08-13T16:57:12 INFO common.c: Loading device parameters....
2018-08-13T16:57:12 INFO common.c: Device connected is: F1 Medium-density device, id 0x20036410
2018-08-13T16:57:12 INFO common.c: SRAM size: 0x5000 bytes (20 KiB), Flash: 0x10000 bytes (64 KiB) in pages of 1024 bytes
2018-08-13T16:57:12 INFO common.c: Attempting to write 15696 (0x3d50) bytes to stm32 address: 134217728 (0x8000000)
Flash page at addr: 0x08003c00 erased
2018-08-13T16:57:12 INFO common.c: Finished erasing 16 pages of 1024 (0x400) bytes
2018-08-13T16:57:12 INFO common.c: Starting Flash write for VL/F0/F3/F1_XL core id
2018-08-13T16:57:12 INFO flash_loader.c: Successfully loaded flash loader in sram
16/16 pages written
2018-08-13T16:57:13 INFO common.c: Starting verification of write complete
2018-08-13T16:57:13 INFO common.c: Flash written and verified! jolly good!

Il n'y a pas de message d'erreur tout semble avoir fonctionné. il s'agit maintenant de connecter la carte blue pill à un adapteur USB-RS232 car l'interface utilisateur de MECRISP est un terminal RS-232.

Utilisation de MECRISP FORTH

Pour voir la liste des mots du dictionnaire MECRISP consultez le fichier README. En plus des mots commun à toutes les plateformes il y a une section pour chaque µC pour les mots spécifiques à chacun.

Au démarrage MECRISP compile les nouveaux mots dans la mémoire RAM. Donc à la réinitialisation les nouvelles définitions sont perdues. Une fois qu'une définition est testée on peu la redéfinir en mémoire flash. Le mot compiletoflash permet de compiler en mémoire flash. Le mot compiletoram permet de revenir à la compilation en mémoire RAM. Pour savoir si la compilation à lieu en mémoire RAM il y a le mot compiletoram? qui retourne -1 si c'est le cas sinon retourne zéro.

branchement de la carte au port sériel.

Il n'y a que 4 fils à brancher.

description
GND commun de l'alimentation
3v3 alimentation pour la carte et l'adapteur RS-232
TX broche A9 de la carte va à RX de l'adapteur RS-232
RX broche A10 de la carte va à TX de l'adapteur RS-232.

mon installation de base

J'utilise minicom pour la communication entre le PC et la carte. Ouvrons un terminal et lançons minicom.

$ minicom -D/dev/ttyS0 -b115200

L'option -D indique quel port sériel utilisé pour la communication avec la carte blue pill.
L'option -b indique la vitesse de communication, soit 115200 BAUD.

Bienvenue avec minicom 2.7

OPTIONS: I18n
Compilé le Feb 7 2016, 13:37:27.
Port /dev/ttyS0, 09:32:44

Tapez CTRL-A Z pour voir l'aide concernant les touches spéciales

En mettant la carte blue pill sous tension la ligne suivante apparaît dans la fenêtre terminal.

Mecrisp-Stellaris 2.4.4 for STM32F103 by Matthias Koch

Il n'y a pas d'invite de commande en Forth on a donc simplement le curseur qui clignote au début de la ligne. En tapant la touche <ENTER> au terminal le message suivant s'affiche.

ok.

ok. n'est pas une invite de commande c'est un message de confirmation que la dernière commande a été interprétée sans erreur. Encore une fois le curseur clignote au début de la ligne suivante. Forth est toujours prêt à recevoir une nouvelle commande après que le message ok. a été affiché. S'il se produit une erreur un message est affiché à l'écran et l'interpréteur est réinitialisé en vidant les piles.
exemple:

567 .ok
\ voyons l'état de la pile .ok
.s Stack: [1 ] 42  TOS: 567  *>                                             
 ok.                                                                            
\  le nombre 567 a ete empile  ok.                                              
xyz xyz not found.                                                              
\ xyz n'est pas un mot reconnu  ok.                                             
.s Stack: [0 ]  TOS: 567  *>                                                    
 ok.                                                                            
\ la pile est vide

Le mot .s sert à afficher le contenu de la pile de arguments. Comme on le voie lorsqu'on entre un entier il est simplement déposé au sommet de la pile. TOS signifit Top Of Stack, i.e. Sommet de la pile. Sur la première ligne j'ai saisi 567 et cet entier a été déposé au sommet de la pile.

Sur la deuxième ligne j'ai saisi xyz. L'interpréteur de commande n'a pas trouvé ce mot dans le dictionnaire, il affiche donc le message not found et vide les piles. Notez que TOS indique toujours 567. Cependant .s indique bien que la pile contient [ 0 ] éléments. La façon dont la commande .s travaille peu prêter à confusion. .s affiche toujours un élément de trop. Cet élément est le contenu de la mémoire RAM pointé par le pointeur de pile lorsque la pile est vide. Ainsi dans la première utilisation de .s le nombre 42 est indiqué alors qu'il ne fait pas partir des arguments disponibles. Dans le deuxième appel .s indique 567 au sommet alors que la pile est vide. Il faut considérer ça comme un bogue de la commande .s.

Maintenant on va créer un programme pour faire clignoter la LED verte qui est sur la carte. Cette LED est branchée sur PC15. C'est à dire le port C bit 15.

\ les constantes pour les addresse des SFR tel 
\ que trouvé dans manuel de référence du STM32F103C8t6                                                          
$40011000 constant gpioc_crl  ok.                                               
$40011004 constant gpioc_crh  ok.                                               
$40011010 constant gpioc_bsrr  ok.                                              
$40011014 constant gpioc_brr  ok.                                               
$44644444 gpioc_crh !  ok.                                                      
: led_on ( -- ) \ allume led verte  ok.                                         
  13 pwr2 gpioc_brr ! ;  ok.                                                    
: led_off ( -- ) \ eteint led verte  ok.                                        
  13 pwr2 gpioc_bsrr ! ;  ok.                                                   
: delay ( u -- ) \ busy loop  ok.                                               
  1000 * 0 do i drop loop ;  ok.                                                
: blink ( speed -- ) \ clignote led verte jusqu'a touche enfoncee  ok.
  begin led_on dup delay led_off dup delay key? until key 2drop ;  ok.          
100 blink  ok.                                                                  
50 blink  ok.                                                                   

Je suis curieux de savoir comment MECRISP configure le system clock En consultant le manuel de référence on trouve 2 registres pour la configuration du clock, Clock Control Register rcc_cr et Clock Configuration Register rcc_cfgr Je vais définir les constantes pour ces registres et le mot prt-field pour voir le contenu binaire d'un champ du registre.

$40021000 constant rcc-base-adr \ adresse de base rcc  ok.                      
rcc-base-adr constant rcc-cr \ offset 0  ok.                                    
rcc-base-adr 4 + constant rcc-cfgr \ offset 4  ok.                              
rcc-cfgr @ h. 0  ok.                                                            
rcc-cr @ h. 4A83  ok.                                                           

Les valeurs affichées pour rcc-cr et rcc-cfgr sont les valeurs à la réinitialisation du µC donc MECRISP ne confugure par le clock ce qui signifie que blue pill avec MECRISP fonctionne en utilisant l'oscillateur interne avec une fréquence de Fclock de 8 Mhz.

Un brin de Folie

Travailler directement dans minicom n'est pas pratique en autre pour corriger les erreurs ou inclure des fichiers source Forth. Heureusement Jean-Claude Wippler auteur du blog Jeelabs a créer une console sérielle pour nous faciliter la tâche. Cette console s'appelle Folie. Nous allons donc l'installer et l'utiliser à la place de minicom.

Des binaires de l'application sont disponible ici.

1. Téléchargé le fichier folie-linux-x64.gz
2. dézipper le fichier
3. rendre le fichier exécutable
4. créer un lien dans mon dossier ~/bin avec un nom plus court.
5. Se déplacer dans le dossier mecrisp-Stellaris qui contient le fichier stm32f103.fs
6. Lancer folie en indiquant le port sériel utilisé.

gunzip folie-linux-x64.gz
chmod +x folie-linux-x64
ln  "/home/jacques/Documents/blue pill/mecrisp/folie-linux-x64"
 /home/jacques/bin
cd "~/Documents/blue pill/mecrisp/mecrisp-*/stm32f103"
folie -p /dev/ttyS0
ok.

J'utilise geany comme éditeur. Geany reconnais les fichiers avec l'extension .fs comme étant des fichiers Forth et fait la coloration de la syntaxe. J'ai créer le fichier picatout.fs avec quelques définitions de mon cru.

\ some definitions by PICATOUT \ revision 2018-08-28 \ STM32C8T6 flash size $10000 constant FLASHSIZE \ how many flash bytes free : flash-free ( -- u ) FLASHSIZE compiletoram? if compiletoflash here - compiletoram else here - then ; \ how many RAM bytes free : ram-free ( -- u ) flashvar-here compiletoram? if here - else compiletoram here - compiletoflash then ; \ power of 2 : pwr2 ( u -- 2^u ) 1 swap lshift ; \ print in binary : bin. base @ swap binary u. swap base ! ; \ extract bit field \ u1 integer to extract from \ p 0-31 position \ w 1-31 field width : bitfield ( u1 p w -- u2 ) >r rshift r> pwr2 mod ; \ how many definitions in dictionary : wc ( -- u ) 0 dictionarystart begin swap 1+ swap dictionarynext until drop ;

Je vais d'abord compiler de fichier dans la mémoire RAM pour le tester et lorsque les erreurs seront corrigées je le compilerai dans la mémoire flash. Il suffit de faire la commande:

include picatout.fs

Pour compiler le fichier. Folie ne semble interpréter les fins de lignes correctement. J'ai essayé avec des fins de lignes LF, CR et CRLF et aucune ne fonctionne correctement cependant la compilation fonctionne sans erreur même si l'affichage est défectueux. Testons les nouveaux mots.

\ combien de mots dans le dictionnaire?  ok.
wc u. 350  ok.
\ flash libre?  ok.
flash-free u. 48800  ok.
\ ram-libre?  ok.
ram-free u. 19472  ok.
\ impression en binaire  ok.
45 bin. 101101  ok.
\ extraction d'un champ  ok.
45 3 3 bitfield bin. 101  ok.
\ puissance de 2  ok.
15 pwr2 u. 32768  ok.

Les définitions fonctionnent en va les flasher.

forgetram \ efface les mots en RAM
compiletoflash \ compile en flash
include picatout.fs \ compile le fichier en flash
compiletoram \ revient à la compilation en RAM

Dans le dossier mecrisp-stallaris-2.4.4/stm32103 il y a plusieurs fichiers .fs qui peuvent-être inclus. Celui nommé stm32f103.fs contient la définitions des constantes pour toutes les adresses des registres spéciaux du stm32f103c8t6. Il y en plus de 500. Après cette inclusion, wc rapporte 852 mots et flash-free 32928 octets libres.

NOTE:
Je ne sais pas si le problème est avec mon ordinateur mais lorsque je fais une commande include dans Folie, quelque secondes après la fin de l'opération le disque dur de mon ordinateur se met à trasher et l'ordinateur ne répond plus m'obligeant à l'éteindre. C'est à 3ième fois que je recommence la section de cet article consacrée à Folie, hum!!

installation de hackaday-forth

A lieu d'installer MECRISP de base vous pouvez installer la version hackaday-forth.

1. Clonez le dépôt sur votre ordinateur
   git clone https://github.com/hexagon5un/hackaday-forth
2. Déplacez-vous dans le dossier ROMS et faites la commande:
   st-flash write mecrisp-stellaris-hackaday-edition.bin 0x8000000
   Cette version prend beaucoup plus de mémoire flash, il ne reste que 31744 octets pour les applications.
3. Lancez minicom si ce n'est pas déja fait
   

Hackdaday-forth Configure le µC pour qu'il fonctionne à sa fréquence maximale de 72 Mhz. Vous trouverez dans ce dépôt plusieurs exemples de programmes.

---

retour à l'introduction

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