Utilisation du SDK mbed sur un tout petit microcontrôleur LPC810

Magazine
Marque
Open Silicium
Numéro
17
|
Mois de parution
janvier 2016
|
Domaines


Résumé
Le microcontrôleur LPC810 de NXP est un cortex-M0+ disponible en petit boîtier DIP8. Avec ses 30 MHz, 1 Ko de RAM, 4 Ko de Flash et son faible coût de 1€, il se veut une alternative 32-bit aux ATtiny. Nous allons utiliser le SDK mbed de ARM et l'exemple MBED_BLINKY pour explorer sa mise en œuvre.

Body

lpc800_dip8

1. SDK mbed et LPC810, la rencontre

Le SDK mbed est une bibliothèque open source développée par ARM fournissant une API indépendante du hardware, simplifiant ainsi la programmation de votre microcontrôleur préféré. ARM propose le mbed Compiler, un IDE en ligne déjà présenté dans Hackable n°3, mais ne proposant qu'un sous-ensemble des plateformes supportées par le SDK mbed.

Une plateforme mbed Enabled doit avoir une interface USB, proposant un périphérique mass-storage pour reflasher le microcontrôleur, l'accès au port série, et une interface générique de debug CMSIS-DAP. Vous trouverez la liste des plateformes mbed Enabled sur https://developer.mbed.org/platforms/ et plus d'informations sur le « mbed HDK Handbook » sur https://developer.mbed.org/handbook/mbed-HDK#cmsis-dap-interface.

La plateforme mbed Enabled la plus proche du LPC810 est la « NXP LPC800-MAX », avec un LPC812 : 4 Ko de RAM et 16 Ko de Flash. Bien que ces deux microcontrôleurs soient de la même famille, les binaires compilés pour le LPC812 ne pourront être utilisés sur le LPC810 parce que la stack est placée à la fin de la RAM, bien au-delà de ce que supporte le LPC810.

Nous allons donc devoir sortir des sentiers battus et nous passer (des limitations) de l'IDE en ligne : c'est tout un univers de plateformes atypiques qui devient accessible ! Il est bon de noter qu'il ne suffit souvent que de petits changements pour pouvoir supporter une nouvelle plateforme si le microcontrôleur est supporté.

2. Mon premier build

2.1 Installation du cross-compilateur

Commençons par installer le cross-compilateur (toolchain) « bare-metal » pour les processeurs arm. Les utilisateurs de distributions Debian et dérivées pourront installer le paquet gcc-arm-none-eabi. Les autres distributions fournissent peut-être un paquet équivalent, ou peuvent télécharger une version « Bare-metal toolchain for Cortex-R/M » de Linaro depuis https://www.linaro.org/downloads/ (il y a même une version Windows...).

2.2 Récupération du SDK mbed

Il faut ensuite récupérer la dernière version depuis le dépôt officiel sur GitHub :

cyprien@linux-dev:~/hk$ git clone https://github.com/mbedmicro/mbed.git

Cloning into 'mbed'...

remote: Counting objects: 52343, done.

remote: Compressing objects: 100% (19/19), done.

remote: Total 52343 (delta 7), reused 0 (delta 0), pack-reused 52324

Receiving objects: 100% (52343/52343), 31.29 MiB | 3.25 MiB/s, done.

Resolving deltas: 100% (34451/34451), done.

Checking connectivity... done.

Checking out files: 100% (5638/5638), done.

cyprien@linux-dev:~/hk$

Le SDK mbed requiert python 2.7, et l'outil python-setuptools. J'avoue tout de suite que j'avais sauté cette étape, mais elle est documentée dans mbed/docs/BUILDING.md et permet sûrement d'éviter de tomber sur des erreurs python lors de l'exécution des scripts mbed. L'installation des modules python pour mbed peut alors se faire :

cyprien@linux-dev:~/hk/mbed$ sudo python setup.py install

running install

running bdist_egg

[ . . . ]

Finished processing dependencies for mbed-tools==0.1.14

2.3 Extraction du test MBED_BLINKY

Le SDK est prévu pour être compilé pour une plateforme donnée, et de compiler des programmes de tests. Il est même possible d'automatiser l'exécution de ces tests sur une plateforme mbed Enabled connectée sur la machine. Mais pour plus de flexibilité, nous allons utiliser la fonction d'exportation pour obtenir une archive ne contenant que les fichiers nécessaires pour le LPC810, la toolchain GCC pour ARM, et le programme de test MBED_BLINKY :

cyprien@linux-dev:~/hk$ cd mbed/

cyprien@linux-dev:~/hk/mbed$ python workspace_tools/project.py -m LPC810 -i gcc_arm -n MBED_BLINKY

[WARNING] Using default settings. Define your settings in the file "workspace_tools/private_settings.py" or in "./mbed_settings.py"

Copy: test_env.h

. . .

Copy: main.cpp

Successful exports:

  * LPC810::gcc_arm     /home/cyprien/hk/mbed/build/export/MBED_BLINKY_gcc_arm_LPC810.zip

Sans paramètre, cette commande vous donnera la liste exhaustive des tests, chaînes de compilations et MCU supportés. Attention toutefois, toutes les toolchains ne sont pas supportées par tous les MCU, et le support de GCC pour les LPC810/812 n'est arrivé que récemment. Pour plus d'informations concernant les scripts existant, vous pouvez vous référer au document BUILDING.md cité plus haut.

Décompressons maintenant l'archive et regardons rapidement ce qu'elle nous réserve :

cyprien@linux-dev:~/hk/mbed$ cd ..

cyprien@linux-dev:~/hk$ unzip -x mbed/build/export/MBED_BLINKY_gcc_arm_LPC810.zip

Archive:  /home/cyprien/hk/mbed/build/export/MBED_BLINKY_gcc_arm_LPC810.zip

  inflating: MBED_BLINKY/GettingStarted.htm  

  inflating: MBED_BLINKY/Makefile    

  inflating: MBED_BLINKY/main.cpp

[ . . .]

  inflating: MBED_BLINKY/mbed/hal/serial_api.h  

cyprien@linux-dev:~/hk$ cd MBED_BLINKY/

cyprien@linux-dev:~/hk/MBED_BLINKY$ ls

env  GettingStarted.htm  main.cpp  Makefile  mbed

2.4 Compilation

Le Makefile indique l'étape suivante :

cyprien@linux-dev:~/hk/MBED_BLINKY$ make

arm-none-eabi-gcc -mcpu=cortex-m0plus -mthumb  -c -x assembler-with-cpp -o

mbed/targets/cmsis/TARGET_NXP/TARGET_LPC81X/TOOLCHAIN_GCC_ARM/startup_LPC81X.o

mbed/targets/cmsis/TARGET_NXP/TARGET_LPC81X/TOOLCHAIN_GCC_ARM/startup_LPC81X.S

[ . . . ]

*****

***** You must modify vector checksum value in *.bin and *.hex files.

*****

arm-none-eabi-objcopy -O binary MBED_BLINKY.elf MBED_BLINKY.bin

arm-none-eabi-size  MBED_BLINKY.elf

   text    data     bss     dec     hex filename

   3504     192     228    3924     f54 MBED_BLINKY.elf

cyprien@linux-dev:~/hk/MBED_BLINKY$ ls -l MBED_BLINKY.bin

-rwxr-xr-x 1 cyprien dialout 3696 Sep  6 13:54 MBED_BLINKY.bin

Votre premier exemple mbed est prêt à être flashé ! Notez la taille du binaire, 3696 octets, uniquement pour faire clignoter une LED. Il n'y a plus beaucoup d'espace libre pour faire des choses intéressantes...

Le résultat de la compilation nous met en garde qu'il nous faudra changer la somme de contrôle des vecteurs dans le fichier binaire. Au démarrage, la ROM va vérifier si le « vector checksum » est correct. Si incorrect, le code entrera en mode programmation. La plupart des outils permettant la reprogrammation de ces microcontrôleurs calculent ce checksum à la volée.

2.5 Outil de flashage

Mais comment flasher ce binaire si on utilise directement le microcontrôleur, sans l'interface de programmation mbed ? La famille des LPC se programme via le port série en utilisant le code « In-System Programming » en ROM lorsque la pin 5 nISP est à l'état bas lors de la mise sous tension. J'utilise l'outil lpctools de Nathaël Pajani (Techno Innov), disponible en paquet debian, ou sur le dépôt git http://git.techno-innov.fr/?p=lpctools.

Techno-Innov propose les LPC810 à 1€ pièce, mais aussi des LPC812 (20 pins, 4 Ko de RAM et 16 Ko de Flash) et des kits d'initiation à la soudure avec ces processeurs. Le LPC812 en TSSOP20 pourra être soudé sur un adaptateur DIP20 et être utilisé sur une plaque d'expérimentation. Bien sûr, les binaires générés par l'IDE mbed pourront directement être utilisés ! À trouver sur http://boutique.techno-innov.fr/.

3. Mon premier montage

blinky

Fig. 1 : Montage correspondant au test MBED_BLINKY. Notez bien que le LPC810 n'accepte que du 3.3V !

Le programme de test fait clignoter une LED connectée au LPC8120. Il s'agit de la LED1, définie comme étant le GPIO P0_2.

Le bouton poussoir ne sert qu'à entrer en mode programmation et peut être remplacé par un fil à ne brancher que lorsque nécessaire. Appuyez sur le bouton ou connectez la pin 5 à la masse pendant que vous connectez l'adaptateur USB série sur votre ordinateur. Vous devez voir dans vos logs l'apparition d'un périphérique ttyUSB0, que vous allez utiliser flasher le LPC810 :

cyprien@linux-dev:~/hk/MBED_BLINKY$ lpcprog -d /dev/ttyUSB0 -c flash MBED_BLINKY.bin

Device session openned.

Part ID 0x00008100 found on line 18

Flash now all blank.

Checksum check OK

Flash size : 4096, trying to flash 15 blocks of 256 bytes : 3840

Writing started, 15 blocks of 256 bytes ...

cyprien@linux-dev:~/hk/MBED_BLINKY$

Si vous obtenez une erreur à cette étape, il est possible que vous ayez loupé le processus de reboot, ou que vous ayez oublié de déconnecter un terminal du port série (oui, ça m'arrive très souvent!). Retentez votre chance.

Si vous avez utilisé un fil pour entrer en mode programmation, c'est le moment de le retirer. Provoquez alors un redémarrage en débranchant et rebranchant l'adaptateur USB, puis observez la LED clignoter. Félicitations !

Mises en garde habituelles :

  • la tension d'alimentation du LPC810 est de 3.3V. Le LPC810 n'est pas tolérant au 5V. Il ne faut donc utiliser que des convertisseurs USB série fournissant du 3.3V ;
  • seules les pins P0_2 et P0_3 du LPC810 (ainsi que P0_7 et P0_13 sur un LPC812) supportent un courant jusqu'à 20mA (idéal pour les LED), et il faudra se limiter à 4 mA pour les autres pins.

4. mbed et les 4 petits kilos...

Faire clignoter une LED, c'est un peu le Hello World du maker. En mbed, cela donne :

#include "mbed.h"

DigitalOut myled(LED1);

int main() {

    while(1) {

        myled = 1;

        wait(0.2);

        myled = 0;

        wait(0.2);

    }   

}

Le code se trouve dans le fichier main.cpp. Ajoutons un petit message dans la boucle, puis compilons à nouveau :

#include "mbed.h"

DigitalOut myled(LED1);

int main() {

    while(1) {

        puts("Hello World!");

        myled = 1;

        wait(0.2);

        myled = 0;

        wait(0.2);

    }   

}

cyprien@linux-dev:~/hk/MBED_BLINKY$ make

[ . . . ]

/usr/lib/gcc/arm-none-eabi/4.8/../../../arm-none-eabi/bin/ld: MBED_BLINKY.elf section `.text' will not fit in region `FLASH'

/usr/lib/gcc/arm-none-eabi/4.8/../../../arm-none-eabi/bin/ld: region RAM overflowed with stack

/usr/lib/gcc/arm-none-eabi/4.8/../../../arm-none-eabi/bin/ld: region `FLASH' overflowed by 2464 bytes

collect2: error: ld returned 1 exit status

Makefile:64: recipe for target 'MBED_BLINKY.elf' failed

make: *** [MBED_BLINKY.elf] Error 1

Aïe ! Nous venons de déborder de la flash, avec un simple puts(). Nous sommes coincés, et il serait tentant de conclure dès maintenant par « mbed c'est uniquement pour les gros microcontrôleurs ». Pas si vite ! Regardons ce qu'est mbed et ce que l'on peut faire.

On peut énumérer ainsi les différentes couches du SDK mbed :

  • les registres d'accès au matériel, c'est le mapping mémoire des périphériques du microcontrôleur, généralement fourni par le vendeur du microcontrôleur ;
  • l'implémentation CMSIS-CORE, qui donne accès aux fonctionnalités des cœurs Cortex-M sous une interface générique, fournie par ARM ;
  • l'implémentation de la couche d'abstraction mbed, qui fournit l'accès aux périphériques (GPIO, port série, timers...) via une API indépendante du matériel ;
  • l'interface et l'implémentation de la mbed API.

Vous l'aurez sans doute remarqué, le code de test utilise la classe C++ DigitalOut. Celle-ci fait partie de la mbed API. Elle utilise en interne la HAL mbed, qui est entièrement écrite en C.

5. Utilisation de la mbed HAL en C

Nous allons nous passer de la mbed ABI en C++ pour n'utiliser que la HAL C. Il faut donc renommer notre fichier main.cpp en main.c, et faire un petit make clean pour se débarrasser des fichiers de dépendances.

Modifions donc le code de notre exemple :

#include "serial_api.h"

#include "gpio_api.h"

#include "wait_api.h"

/* Déclaration des objets GPIO et port série */

gpio_t myled;

serial_t pc;

/* L'interface pour le port série ne propose pas l'équivalent de puts */

static void serial_puts(serial_t *obj, const char *msg)

{

    while(*msg) serial_putc(obj, *msg++);

    serial_putc(obj, '\n');

}


int main() {

    /* Initialisation du port série */

    serial_init(&pc, P0_4, P0_0);

    serial_baud(&pc, 115200);

    /* Initialisation du GPIO de la LED */

    gpio_init_out(&myled, LED1);

    while(1) {

        serial_puts(&pc, "Hello World!");

        gpio_write(&myled, 1);

        wait_ms(200);

        gpio_write(&myled, 0);

        wait_ms(200);

    }

    return 0;

}

Voyons ce qui a changé :

  • utilisation de wait_ms(int) plutôt que wait(float). L'utilisation de nombres entiers évite au compilateur d'ajouter le code d'émulation des nombres flottants ;
  • utilisation de l'API gpio_api.h pour faire clignoter la LED ;
  • utilisation de l'API serial_api.h pour la gestion du port série. Utiliser puts() fait inclure les fonctions de la libc pour la gestion de la sortie standard.

Voyons voir le résultat de la compilation :

cyprien@linux-dev:~/hk/MBED_BLINKY$ make

arm-none-eabi-gcc -mcpu=cortex-m0plus -mthumb  -c -x assembler-with-cpp -o

mbed/targets/cmsis/TARGET_NXP/TARGET_LPC81X/TOOLCHAIN_GCC_ARM/startup_LPC81X.o

mbed/targets/cmsis/TARGET_NXP/TARGET_LPC81X/TOOLCHAIN_GCC_ARM/startup_LPC81X.S

[ . . . ]

*****

***** You must modify vector checksum value in *.bin and *.hex files.

*****

arm-none-eabi-objcopy -O binary MBED_BLINKY.elf MBED_BLINKY.bin

arm-none-eabi-size  MBED_BLINKY.elf

   text    data     bss     dec     hex filename

   3280     192     256    3728     e90 MBED_BLINKY.elf

cyprien@linux-dev:~/hk/MBED_BLINKY$ ls -l MBED_BLINKY.bin

-rwxr-xr-x 1 cyprien dialout 3472 Sep  6 15:46 MBED_BLINKY.bin

Ça rentre ! Il ne reste plus qu'à rebooter le LPC810 en pensant bien à appuyer sur le bouton pour entrer en mode programmation, réexécuter la commande pour flasher le nouveau code, et rebooter à nouveau. Vous pourrez alors voir sur le port série le nouveau message.

Vous voilà prêts pour explorer la HAL mbed et faire preuve de créativité. Malheureusement, il ne semble pas y avoir de documentation dédiée de ces API C, et il faudra donc se contenter du code source. Vous trouverez les principaux fichiers en-tête C dans mbed/libraries/mbed/hal/ et quelques-uns dans mbed/libraries/mbed/api/.

Références


Sur le même sujet

Circuitjs simule des circuits électroniques dans votre navigateur

Magazine
Marque
Hackable
Numéro
33
|
Mois de parution
avril 2020
|
Domaines
Résumé

Aux antipodes de SPICE, circuitjs est pourtant un outil indispensable que même les débutants devraient avoir le réflexe d'utiliser avant de faire chauffer le fer à souder. Créé par Paul Falstad, il ne nécessite aucune installation, car il tourne directement en JavaScript sur votre navigateur. Son interface minimaliste est rapide à prendre en main et permet de prototyper rapidement des circuits virtuels, essentiellement dans le domaine analogique. Et il est même sous GPL.

Programmation avec le 6502 : trigonométrons !

Magazine
Marque
Hackable
Numéro
33
|
Mois de parution
avril 2020
|
Domaines
Résumé

Lors du précédent article, nous avons parcouru les différents modes d'adressage du 6502, ce qui nous a permis d'élaborer quelques algorithmes simples, notamment pour réaliser des additions ou soustractions sur des nombres entiers de plus de 8 bits et même, des multiplications. Aujourd'hui, nous allons continuer dans cette voie en nous intéressant à la division et même aux nombres décimaux (à virgule), ce qui nous permettra de mettre un pied dans le monde effrayant de la trigonométrie !

Une caméra web ESP32 pour surveiller son environnement

Magazine
Marque
Hackable
Numéro
33
|
Mois de parution
avril 2020
|
Domaines
Résumé

L'ESP32-CAM permet de très simplement et très économiquement créer une simple webcam Wi-Fi. Ceci est très pratique, mais ne présente pas réellement d'intérêt lorsqu'on compare cela à la myriade de produits clé en main similaires et disponibles à bas prix. Ce qui est plus intéressant en revanche, c’est l'opportunité d'avoir totalement la main sur les fonctionnalités embarquées et donc de pouvoir se confectionner un système répondant à un cahier des charges totalement arbitraire. Chose difficile, sinon impossible avec un produit manufacturé. Que diriez-vous de créer une webcam connectée qui affiche, en plus de l'image, des données environnementales comme la température ou l'hygrométrie ?

Un RISC-V à bas coût pour monitorer votre PC avec LCDproc

Magazine
Marque
Hackable
Numéro
33
|
Mois de parution
avril 2020
|
Domaines
Résumé

Dans un précédent Hackable, Patrice Kadionik nous présentait un montage permettant d’afficher l’état de votre ordinateur sur un petit afficheur déporté, branché à un port USB. Dans cet article, nous allons voir comment il est possible de faire la même chose avec un kit RISC-V à 4.90 $, muni d’un microcontrôleur GD32VF de la société GigaDevice. Une belle occasion de mettre en pratique un microcontrôleur RISC-V réel.

Le module du moment : bouton capacitif

Magazine
Marque
Hackable
Numéro
33
|
Mois de parution
avril 2020
|
Domaines
Résumé

Le bouton-poussoir est la forme la plus basique d'interface humaine qu'un montage puisse avoir. Ceci suppose cependant de prendre en compte bon nombre de caractéristiques mécaniques et électroniques, comme par exemple le fait de gérer les rebonds, de manière matérielle ou logicielle. Pouvoir disposer d'une telle interface sous une forme plus simple et plus « moderne » est l'objet même de ce module proposant un bouton tactile capacitif et donc, sans éléments mécaniques.

Se protéger de la rétro-ingénierie matérielle

Magazine
Marque
Hackable
Numéro
33
|
Mois de parution
avril 2020
|
Domaines
Résumé

En 2008, la rétro-ingénierie matérielle fut mise sur le devant de la scène par deux chercheurs allemands [14] qui réussirent à casser l'algorithme cryptographique propriétaire Crypto-1 de NXP (Philips), uniquement à l'aide de la rétro-ingénierie matérielle d'une puce de silicium. Cet algorithme était alors utilisé dans les puces RFID Mifare Classic qui étaient elles-mêmes utilisées massivement dans des cartes de métro ou de parking, voire dans des cartes d'accès.

Par le même auteur

Utilisation du SDK mbed sur un tout petit microcontrôleur LPC810

Magazine
Marque
Open Silicium
Numéro
17
|
Mois de parution
janvier 2016
|
Domaines
Résumé
Le microcontrôleur LPC810 de NXP est un cortex-M0+ disponible en petit boîtier DIP8. Avec ses 30 MHz, 1 Ko de RAM, 4 Ko de Flash et son faible coût de 1€, il se veut une alternative 32-bit aux ATtiny. Nous allons utiliser le SDK mbed de ARM et l'exemple MBED_BLINKY pour explorer sa mise en œuvre.