DESEMBRE 2022

MINI
PROJE
T
AVANCÉ
ARCHIT DE
ECTUR
PROCESSEU
E
R
Institut supérieur d'informatique et multimédia
Gabes

Présenté par
Khandoudi Amina
 2

I.
Introduction:
Mbed Studio est un IDE gratuit pour le développement
d'applications et de bibliothèques Mbed OS, comprenant toutes
les dépendances et tous les outils dont vous avez besoin
dans un seul package afin que vous puissiez créer, compiler et
déboguer vos programmes Mbed sur le bureau.
 3

Qu’est-ce qu’un IDE ?

Un IDE, pour integrated development environment, ou EDI en

français (Environnement de Développement Intégré) est un
ensemble d’outils proposés pour aider les programmeurs
dans leur travail.
Il comporte (souvent) :
un éditeur de texte destiné à la programmation
un compilateur pour transformer le code écrit en langage
de haut niveau vers du code assembleur
un éditeur de liens, qui permet de compacter dans un
même fichier binaire l’ensemble des fonctions utiles au
projet
un débogueur en ligne, qui permet d’exécuter ligne par
ligne le programme en cours de construction
Certains environnements sont dédiés à un langage de
programmation en particulier ou/et à une cible
particulière (microprocesseur généraliste ou
microcontroleur).

Keil Studio. Il est dédié aux microcontrôleurs de type ARM-M qui

se code en C et C++. Il est intégralement en ligne. Il est
disponible sur la plateforme MBED.
 4

II. Comment créer un projet

sous MBED ?

J'ai utilisé une carte Nucleo L476RG de ST Microelectronics

pour ce projet.
Pour cela il est nécessaire de créer un compte. Cette étape
est nécessaire et prendra littéralement 2 minutes.

1. Création d’un compte

Pour créer un compte, rendez-vous sur la page Keil

Studio. Cliquez ensuite sur “Sign Up“. Effectuez ensuite
les étapes suivantes :
Remplir le formulaire avec les données
demandées. retournez sur la page de Keil Studio.
Utilisez à présent votre email et mot de passe afin de
vous connecter.

Après avoir créé votre compte, j'ai retrouvé sur une interface
qui ressemble à la fenêtre suivante.
 5

En haut, une barre d’outils nécessaire au développeur,

permettant de créer de nouveaux projets et de paramétrer le
compilateur et l’interface.
A gauche, le workspace (ou espace de travail). Cet espace
est l’arborescence de chacun de vos projets, vous pouvez
déplacer des fichiers, en ajouter, en modifier etc.
Au centre, la fenêtre principale, qui contient la partie édition
du code (lorsqu’un projet est créé et un fichier source
ouvert). Cette partie va permettre d’écrire du code dans
chaque fichier ouvert. En bas à droite, une console
rassemblant les messages importants : erreur de compilation,
état de la RAM et de la mémoire Flash…
 6

2. Création d’un
projet
Partir d’un projet nouveau
Afin de pouvoir réaliser une application embarquée, il faut
avant tout créer un nouveau projet dans cette interface.
Dans la barre d’outils, cliquez sur File / New / MBED Project

j' obtient alors la fenêtre suivante :

J'ai Sélectionné alors le type de projet mbed-os-example-

blinky- baremetal dans la section MBED 6 et j'ai donné
comme un nom à mon projet dans la zone Project Name
"test".
J'ai décoché la case Initialize this project as a Git repository.
 7

Modifier le fichier de configuration mbed_app.json

Les composants STM32 sont des microcontrôleurs de haute
performance, prévus pour fonctionner en temps réel à l’aide
de système d’exploitation du même type. Cependant la
programmation de tels environnements requiert des
connaissances élévées dans ce domaine. Afin de faciliter leur
programmation, nous allons devoir modifier le fichier de
configuration mbed_app.json (présent dans les projets
MBED) afin de ne pas utiliser la partie “temps réel” du
système d’exploitation proposé par MBED.

Pour cela, j'ai modifié le contenu du fichier mbed_app.json

à la racine du projet par le code suivant :
 8

Associer une carte Nucléo

Afin de pouvoir compiler le projet pour le bon

microcontroleur, il faut préciser la cible à l’IDE. Pour cela,
dans la partie Target Hardware, dans la zone de recherche,
on tape L476RG.On sélectionne ensuite la carte NUCLEO-
L476RG.
 9

3. La carte de prototypage
Nucléo
La carte de développement que nous allons utiliser est une
carte Nucléo-L476RG, conçue par ST MicroElectronics
(société franco- italienne – ex Thomson Semiconducteurs).
Cette carte est équipée d'un microcontrôleur Arm Cortex M4
STM32L476RGT6 à très faible consommation dans un boîtier
LQFP64. Cette carte de développement vous permet de créer
et d'évaluer facilement des prototypes. Le microcontrôleur
offre plusieurs modes d'économie d'énergie qui vous aideront
à concevoir des prototypes avec des limitations de la
consommation d'énergie.
 10

Caractéristiques principales
Elle possède les éléments suivants
:
Processeur : STM32L476RGT6 /
ARM®32-bit Cortex®-M4 CPU
Fréquence maximale : 80 MHz
Alimentation : 3.3 V
Mémoire programme : 1 MB
Flash Mémoire données :128 KB
SRAM Ressources :
Entrées/Sorties Numériques : 51, dont 1 LED présente
sur la carte (sortie D13 ou PA_5) et un bouton-
poussoir (entrée PC_13)
ADC 12 bits / 5 MHz (x 3)
DAC 12 bits / 2
canaux Timers
Interruptions
externes
Communications
: SPI / I2C
USART / UART /
CAN
USB OTG Full
Speed
 1
1
3. Broches du microcontroleur et
connecteurs
Pour accéder aux broches de la carte, il existe deux
types de connecteurs différents :
Connecteurs compatibles Arduino
Uno Connecteurs ST Morpho
(specifiques)
L’ensemble des broches peuvent être configurées
indépendamment en entrée ou en sortie
numérique.
Ces broches sont regroupées en ports d’entrées/sorties nommés
Px (où x est une lettre de A à G – par exemple le port A se
nomme PA). Chacune des broches d’un port sont ensuite
désignées par un nombre de 0 à 15 (par exemple, la broche 3
du port B s’appelle PB_3).

Broches spécifiques des cartes Nucléo

La broche PA_5 par exemple est reliée à une LED nommée
LED1. On peut alors utiliser l’une ou l’autre des dénominations
pour accéder à cette ressource.
La broche PC_13 est reliée à un bouton-poussoir nommé
USER_BUTTON.
N.B. Ces deux broches permettent de tester rapidement toute
la chaîne de développement (IDE, programmation…) sans
avoir à cabler quoi que ce soit d’autre que le cable USB
reliant l’ordinateur à la carte Nucléo.
 12
Les broches PA_2 et PA_3 sont respectivement les broches
USBTX et USBRX permettant de transmettre selon le
protocole RS232 (voir tutoriel xxx) des informations de la
carte vers le PC (et inversement). Ce sont ces deux canaux
qu’utilisent également la console série pour le débogage.

Connecteurs Arduino
Ces connecteurs sont compatibles avec les cartes
d’extensions Arduino Uno (ou shields). Les noms
des entrées/sorties sont équivalentes à celles
d’Arduino.
Par exemple, D13 est une broche numérique qui pourra
être configurée en entrée ou en sortie.
 13
D’autres fonctionnalités de ces broches sont listées
également à côté de leurs noms sur l’image précédente.
Par exemple, la broche D11 (numérotation Arduino)
correspond à la broche physique PA_7 du composant, qui
peut être configurée comme : une sortie PWM, la sortie MOSI
de la liaison SPI1, une entrée analogique…

Sur la zone de gauche, il est également possible d’accéder à

des entrées analogiques, numérotées de A0 à A5, et à une
zone d’alimentation : GND (masse), 5V, 3.3V.

4. Programmer une carte Nucléo à l’aide

de Keil Studio (via MBED)

Tout comme les processeurs généralistes (qui équipent la

plupart des ordinateurs), les microcontrôleurs ne comprennent
que du langage de bas niveau, encore appelé assembleur.
Cependant, ces langages étant difficiles à comprendre et à
appréhender pour un être humain, il existe des programmes
qui permettent de transformer des langages dits de haut
niveau (type langage Python, C, C++) vers ces langages
machines. Ce sont les compilateurs.
 14

Le Travail demandé est de faire un programme qui contient

les étapes suivante:
Utiliser un écran LCD + 3 led (rouge, jaune, verte)
Utiliser l’environnement MBED
(compiler/simulator)
Faire clignoter les diodes par ordre (rouge puis jaune
puis verte) pendant 2 secondes chacune
L’écran LCD affichera le nom de la LED allumée

Pour une première étape j'ai esseyé de clignoter le

RGBLed. Une LED RGB est en fait trois LED , rouge, verte
et bleue à l'intérieur d'un seul boîtier. Les LED doivent
être allumées et éteintes très rapidement pour la
gradation.
Les temps d'allumage et d'extinction sont si rapides que la
vision humaine ne voit pas de scintillement sur la LED et
seulement la valeur moyenne est perçue.
Trois bits de sortie PWM seraient normalement utilisés afin
que la luminosité de chacune des trois LED puisse être
contrôlée indépendamment.

Dans les API mbed, trois PWM Output utilisé pour contrôler la
LED RGB. Une valeur PWM de 0,0 serait éteinte et 1,0
complètement allumée pour chaque LED de couleur. Cela
permet à un programme de faire varier à la fois la couleur et
le niveau de luminosité de la LED. Généralement, une LED RGB
a quatre broches. Une broche commune et une pour chacune
des trois LED.
 15

Dans la LED ci-dessous, la broche commune est la broche la

plus longue. Si les broches PWM matérielles ne sont pas
disponibles, SoftPWM peut produire des signaux PWM sur
n'importe quelle broche en utilisant un logiciel avec des
interruptions de minuterie.

Le code que j'ai utilisé pour Mbed utilisant une nouvelle

classe et trois broches de sortie PWM pour contrôler la LED
RGB:
 16

Après avoir déclaré notre pins pour les trois couleurs rouge,
vert et bleu , j'ai commencé de déclaré aussi l'afficheur LCD
pour affiché le nom du chaque couleur:
Initialisation du module SPI
Pour pouvoir utiliser l’écran LCD, il faut dans un premier
temps initialiser la liaison SPI les reliant. Pour cela, j'ai
utiliser le code suivant :

SPI est un protocole de communication commun utilisé par de

nombreux appareils différents. Par exemple, les modules de
lecteur de carte SD , les modules de lecteur de carte RFID et
les émetteurs/récepteurs sans fil 2,4 GHz utilisent tous SPI
pour communiquer avec les microcontrôleurs.

DigitalOut RS_LCD(D9); // c'est un signal nommé RS_LCD

 17

Initialisation du composant
il est nécessaire de suivre une procédure d’initialisation
propre à chacun d’entre eux.
Dans le cas de cet écran LCD, on trouve dans la
documentation technique diverses commandes que l’on peut
utiliser pour contrôler l’affichage à l’écran. En particulier, on
retrouve cette procédure d’initialisation :

la fonction d’initialisation est la

suivante :
 18

Dans cette fonction, on fait passer les signaux CS_LCD et

RS_LCD à ‘0’, pour démarrer la discussion en mode envoi de
commande à l’écran LCD. Puis on écrit la suite de commandes
nécessaires à l’initialisation, par le biais de la fonction
write(char val) de la classe SPI. La commande permettant
d’effacer l’écran LCD est plus longue que les autres, on laisse
alors 2 ms après celle-ci avant de renvoyer la commande
d’allumage de l’écran.
Pour définir la fin de la transmission, on repasse à ‘1’ les
signaux CS_LCD et RS_LCD.

Ecriture d’un caractère à l’écran

Pour afficher un caractère à l’écran, à la position du
curseur, il suffit de déclarer la classe suivante :

Déplacer le curseur
Pour déplacer le curseur à un endroit souhaité de l’écran, on
peut utiliser la commande Set DDRAM Adress.
L’écran LCD peut être vu comme un tableau linéaire de 3 x
16 octets (dont la première case commence par l’adresse
0). La première ligne est stockée dans les cases d’adresses
0 à 15, la seconde ligne est stockée dans les cases
d’adresses 16 à 31…
 19

Ainsi pour accèder à la 4ème case de la 2ème ligne, il faut

aller à la case d’adresse : (2−1)⋅16+(4−1)(2−1)⋅16+(4−1).
Le code correspondant est alors :

Ecrire une chaîne de caractères

Tout comme en C standard, les chaînes de caractères sont des
tableaux finis de caractères. Le symbole ‘\0’ existe
également et permet de délimiter la fin de chaîne de
caractères.
Pour pouvoir afficher une chaine de caractère à un endroit
particulier de l’écran, on peut alors réaliser une fonction
de la sorte :
 20

Effacer l’écran
Pour effacer l’écran, il faut faire appel à la commande de
l’écran
Clear Display :

Fonction main
Notre fonction main sera la
suivante:
 21
myRGBled.write(1.0,0.0,0.0); //affichage du couleur red
wait_us(2.0);
//affichage sur l'écran LCD
char ch[10];
sprintf(ch,
"red");
LCD_DOG_writeS
tr(ch, 3, 2);
LCD_DOG_clear(); // Pour effacer
l’écran c'est le meme pour la couleur
green: myRGBled.write(0.0,1.0,0.0);
//green
wait_us(2.0);
//
affichage
char
ch1[10];
sprintf(ch1, "green");
LCD_DOG_writeStr(ch1, 3, 2);
LCD_DOG_clear();
le couleur yellow :
myRGBled.write(1.0,0.2,0.0); //yellow = red + some
green wait_us(2.0);
//affichage char
ch2[10];
sprintf(ch2, "yellow");
LCD_DOG_writeStr(ch2, 3, 2);
LCD_DOG_clear();

Code complet :
22
23
 24

4.
Compilation
Une fois le code source écrit dans le fichier main.c, il est
indispensable de compiler le code (pour le transformer dans un
langage de bas niveau compréhensible par le microcontroleur)
par l’intermédiaire de l’icône suivante sous Keil Studio (via
MBED) :

Le compilateur compile alors l’ensemble des fichiers C

présents dans le projet (incluant les bibliothèques utilisées
par le projet). Cette étape peut prendre quelques secondes.
A la fin, si la compilation s’est bien déroulée, vous obtiendrez
un message de ce type dans la fenêtre Output (dans la
partie basse de l’interface) :
 25
Une seconde fenêtre s’ouvre alors pour vous proposer
d’enregistrer le fichier de sortie portant l’extension .bin. Ce
fichier binaire est celui qui pourra ensuite être exécuté par le
microcontroleur.

Si la compilation ne s’est pas terminée, vous obtiendrez un

message d’erreur dans la même fenêtre Output. Vous
aurez également les informations sur les erreurs qu’à
rencontrer le compilateur (erreurs de syntaxe dans le
code, erreurs de bibliothèques…).

La dernière étape est de transférer le fichier binaire fourni

par l’étape précédente sur le microcontroleur.
Dans le cas des cartes Nucléo, le programmateur, appelé ST-
Link, est présent sur une partie de la carte. Il permet en plus
à la carte Nucléo d’être reconnue comme une “simple” clef
USB. Un simple câble USB suffit alors à faire le lien entre
l’ordinateur qui a permis de compiler le programme et le
microcontroleur présent sur la deuxième partie de la carte
Nucléo.