Cours système embarqué sur
Arduino.
1
Schéma d'une platine Arduino Uno
2
Le microcontrôleur
C’est le cerveau de notre carte. Il va recevoir le programme que
nous allons créer et va le stocker dans sa mémoire avant de
l’exécuter. Grâce à ce programme, il va savoir faire des choses, qui
peuvent être : faire clignoter une LED, afficher des caractères sur
un écran, envoyer des données à un ordinateur, mettre en route
Il existe deux modèles d’Arduino Uno: l’un avec un
microcontrôleur de grande taille, et un autre avec un
microcontrôleur dit SMD (SMD: Surface Mounted Device, soit
composants montés en surface, en opposition aux composants qui
traversent la carte électronique et qui sont soudés du côté
opposé). D’un point de vue lutilisation, il n’y a pas de différence
entre les deux types de microcontrôleurs.
3
L’alimentation
Pour fonctionner, une carte Arduino a besoin d'une alimentation. Le
microcontrôleur fonctionnant sous 5V, la carte peut être alimentée en 5V par le
port USB ou bien par une alimentation externe qui est comprise entre 7V et 12V.
Un régulateur se charge ensuite de réduire la tension à 5V pour le bon
fonctionnement de la carte.
La connectique
A part une LED sur la broche 13, la carte Arduino ne possède pas de composants
(résistances, diodes,
moteurs...) qui peuvent être utilisés pour un programme. Il est nécessaire de les
rajouter. Mais pour cela, il faut les connecter à la carte. C'est là qu'interviennent
les connecteurs, aussi appelés broches (pins, en anglais). Sur les Arduino et sur
beaucoup de cartes compatibles Arduino, les broches se trouvent au même
endroit. Cela permet de fixer des cartes d’extension, appelée shields en les
empilant.
Exploration des broches Arduino
0 à 13 Entrées/sorties numériques
A0 à A5 Entrées/sorties analogiques
GND Terre ou masse (0V)
5V Alimentation +5V
3.3V Alimentation +3.3V
Vin Alimentation non stabilisée (= le même voltage que celui à l’entrée de la
4carte)
Introduction au code
1. Prise en compte des instructions de la partie déclarative
2. Exécution de la partie configuration ( fonction setup( ) ),
3. Exécution de la boucle sans fin ( fonction loop ( ) ): le code compris dans la
boucle sans fin est exécuté indéfiniment.
5
Le code minimal
Avec Arduino, nous devons utiliser un code minimal
lorsqu'on crée un programme. Ce code permet de diviser
le programme en deux parties.
void setup()
{
}
void loop()
{
}
6
Première fonction:
void setup()
{
}
Cette fonction setup() est appelée une seule fois lorsque le
programme commence. C'est pourquoi c'est dans
cette fonction que l'on va écrire le code qui n'a besoin d'être
exécuté qu’une seule fois. On appelle cette fonction : "fonction
d'initialisation". On y retrouvera la mise en place des différentes sorties et
quelques autres réglages.
Une fois que l'on a initialisé le programme, il faut ensuite créer
son "coeur", autrement dit le programme en lui même.
7
Deuxième fonction:
void loop()
{
}
C'est donc dans cette fonction loop() que l’on va écrire
le contenu du programme. Il faut savoir que cette
fonction est appelée en permanence, c'est-à-dire qu'elle
est exécutée une fois, puis lorsque son exécution est
terminée, on la réexécute, encore et encore. On parle
de boucle infinie.
8
Les instructions
Maintenant que nous avons vu la structure des
fonctions, regardons ce qu’elles peuvent contenir.
Les instructions sont des lignes de code qui disent
au programme : "fais ceci, fais cela..." Ce sont
donc les ordres qui seront exécutés par l’Arduino.
Il est très important de respecter exactement la
syntaxe; faute de quoi, le code ne pourra pas être
exécuté.
9
Les points virgules ;
Les points virgules terminent les instructions. Si par
exemple on dit dans notre programme : "appelle la
fonction mangerLeChat", on doit mettre un point virgule après
l'appel de cette fonction.
Lorsque le code ne fonctionne pas, c’est souvent parce qu’il
manque un point-virgule. Il faut donc être très attentif à ne
pas les oublier!
10
Les accolades { }
Les accolades sont les "conteneurs" du code du programme. Elles
sont propres aux fonctions, aux conditions et aux boucles. Les
instructions du programme sont écrites à l'intérieur de ces
accolades.
Pour ouvrir une accolade sur Mac, taper alt-8 et alt-
9 pour la fermer.
11
Les commentaires
Les commentaires sont des lignes de codes qui seront
ignorées par le programme. Elles ne servent en rien lors de
l'exécution du programme. Ils permettent d'annoter et de
commenter le programme.
Ligne unique de commentaire :
//cette ligne est un commentaire sur UNE SEULE ligne
Ligne ou paragraphe sur plusieurs lignes :
/*cette ligne est un commentaire, sur PLUSIEURS lignes
qui sera ignoré par le programme, mais pas par celui qui lit le
code ;) */
12
Les accents
Il est formellement interdit de mettre des accents en
programmation! Sauf dans les commentaires...
13
14
La ligne pinMode(13, OUTPUT); initialise la broche 13 du microcontrôleur comme sortie,
c'est-à-dire que des données seront envoyées depuis le microcontrôleur vers cette broche (on
va envoyer de l'électricité).
La ligne Serial.begin(9600); initialise le port série qui permet à l'Arduino d'envoyer et de
recevoir des informations à l'ordinateur. C'est recommandé, mais cela fonctionne aussi sans.
Avec l'instruction digitalWrite(13, HIGH);, le microcontrôleur connecte la broche D13 au
+5V ce qui a pour effet d'allumer la LED (de l'électricité sort de la broche D13).
L'instruction delay(500); indique au microcontrôleur de ne rien faire pendant 500
millisecondes, soit ½ seconde.
Avec l'instruction digitalWrite(13, LOW);, le microcontrôleur connecte la broche D13 à la
masse (Gnd) ce qui a pour effet d'éteindre la LED (on coupe l'alimentation en électricité)
.
L'instruction delay(500); indique au microcontrôleur à nouveau de ne rien faire pendant
500ms soit ½ seconde.
15
Le résultat est donc que la LED s'allume pendant ½ seconde, puis s'éteint pendant une ½
faire clignoter quatre LEDs
16
17
18
introduction aux variables
Une variable, qu'est ce que c'est ?
Imaginons un nombre dont nous devons nous souvenir. Ce
nombre est stocké dans un espace de stockage
de la mémoire vive (RAM) du microcontrôleur. Chaque
espace de stockage est identifié de manière unique.
19
Définir une variable
Prenons maintenant une variable que nous allons appeler «x».
Par exemple, si notre variable "x" ne prend que des valeurs
décimales, on utilisera les types int, long, ou char. Si maintenant la
variable "x" ne dépasse pas la valeur 64 ou 87, alors on utilisera le
type char.
20
Si à présent notre variable "x" ne prend jamais une valeur négative (-20, -
78, ...), alors on tilisera un type non-signé. C'est à dire, dans notre cas, un
char dont la valeur n'est plus de -128 à +127, mais de 0 à 255.
Voici le tableau des types non signés, on repère ces types par le mot
unsigned (de l'anglais : non-signé) qui les précède :
21
Définir les broches du microcontrôleur
Jusqu’à maintenant, nous avons identifié les broches du microcontrôleur à
l’aide de leurs numéros, comme dans l’exemple suivant: pinMode(13,
OUTPUT);.
Premièrement, définissons la broche utilisée du microcontrôleur en tant que
variable.
const int led1 = 13;
Le terme const signifie que l'on définit la variable comme étant constante. Par
conséquent, on change la nature de la variable qui devient alors constante.
Le terme int correspond à un type de variable. Dans une variable de ce type, on
peut stocker un nombre allant de -2147483648 à +2147483647, ce qui sera
suffisant! Ainsi, la broche 13 s’appellera led1.
Nous sommes donc en présence d'une variable, nommée led1, qui est en fait
une constante, qui peut prendre une valeur allant de -2147483648 à
+2147483647. Dans notre cas, cette constante est assignée au nombre 13.
22
23
Les feux de circulation
Afin de mettre en pratique l'utilisation de variables, voici un petit
exercice. On peut se baser sur le code 3 pour débuter.
L’objectif de cet exercice est de créer deux feux de circulation et
de les faire fonctionner de manière synchrone.
Voici les phases de deux feux de circulation que tu dois recréer:
24
Circuit
25
Afin de faciliter l'identification de chaque LED, nous allons
renommer les broches comme suit:
Feu 1:
LED rouge connectée sur la broche 4 et renommée R1
LED jaune connectée sur la broche 5 et renommée J1
LED verte connectée sur la broche 6 et renommée V1
Feu 2:
LED rouge connectée sur la broche 8 et renommée R2
LED jaune connectée sur la broche 9 et renommée J2
LED verte connectée sur la broche 10 et renommée V2
Enfin, nous utiliserons deux variables timer1 et timer2 pour définir
les temps d'allumages. Avant de regarder
le code à la page suivante, essaie de faire l'exercice seul.
26
27
L’incrémentation
Cela se fait grâce à ce code (var étant une variable à choix):
var++;
var++; revient à écrire : "var = var + 1;".
28
29
La ligne byte compteur; permet de créer une variable appelée compteur. Byte indique le
type de la variable, c'est-à-dire le type de données que l'on pourra stocker dans
cette variable. Comme nous l’avons déjà vu, le type byte permet de stocker
des valeurs comprises entre 0 et 255.
La ligne const int led1= 13; permet de créer une constante (une variable) nommée led1
dans laquelle on stocke la valeur 13.
La ligne for(compteur=0 ; compteur<10 ; compteur++) sert à faire varier la variable
compteur de 0 à 9 (en l'augmentant à chaque fois de 1: c'est ce que fait
l'instruction compteur++)
l'utilise souvent avec un compteur incrémentiel, qui permet de terminer une
boucle après un certain nombre de fois.
La suite, à savoir compteur=0 ; compteur<10 ; compteur++ doit être compris comme
suit: «la valeur de la variable compteur est comprise entre 0 et 9 (<10 signifie "plus
petit que 10") et ajoute un à la valeur de compteur (c’est le compteur++)».
En conclusion, cette ligne signifie:
«Au commencement, la variable compteur est égale à zéro. On va exécuter le code en
boucle. A chaque fois, on ajoute +1 à ta variable compteur, jusqu’à ce qu'on arrive à 9. A
ce moment, on s'arrête.»
30
Exemple 1: Allumer les LEDs de la broche 13 à la broche 10
avec une fonction for et une incrémentation.
Exemple 2: allumer les LEDs de la broche 13 à la broche 10
avec une fonction for et une décrémentation. Pour cela, on remplace
le ++ par un --.
31
32
PWM, variation en douceur d'une LED
Alors pour faire varier la luminosité d'une LED, on va utiliser une
fonction appelée PWM: PulseWidth Modulation, soit modulation de
largeur d'impulsions. Il s'agit de faire varier les périodes
hautes (allumé) et basses (éteint) des broches à grande
fréquence. Ainsi, lors d'un cycle de 25% en position haute et 75% en
position basse, la LED sera moins brillante que pour un cycle à
50%/50%.
33
Les broches capables de supporter du PWM sont identifiées
par un "~". Il s'agit des broches 3, 5, 6, 9, 10,11.
Par distinction, au lieu d'utiliser l'instruction DigitalWrite,
pour utiliser le PWM, on utilise AnalogWrite.
34
35
PWM, variation en douceur d'une LED
(for)
On créé donc une variable fadeValue de type int, qui stocke le
chiffre 0. Le test de la condition plus petit ou égal à 255 (fadeValue
<= 255) permet une sortie de la fonction dès qu'on atteint le
nombre 256. Enfin; et c'est la nouveauté, on ne fait pas une
incrémentation (++), mais on additionne 5 à fadeValue avec la
formule +=5.
36
37
les inputs numériques
Nous utilisons une nouvelle instruction: if ... else (si ... sinon).
C’est donc une condition.
Si (if) le bouton poussoir est pressé (digitalRead(bouton) == 1),
allumer la LED (digitalWrite(led, HIGH)), sinon (else) éteindre la
LED (digitalWrite(led, LOW)).
L’instruction == vérifie si deux expressions sont égales. Si
elles le sont, alors le résultat sera vrai (true) sinon le résultat
sera faux (false).
38
39
40
41
42
Le bargraphe
Un bargraphe est un afficheur qui indique une quantité,
provenant d'une information quelconque (niveau d'eau,
puissance sonore, etc.), sous une forme lumineuse. Le plus
souvent, on utilise des LEDs alignées en guise d'affichage.
L’objectif de cet exercice est de réaliser un bargraphe de 4
LEDs, avec deux boutons poussoirs. L’un d’eux servira à
incrémenter la valeur sur le bargraphe (à savoir augmenter le
nombre de LEDs allumées), alors que l’autre servira à le
décrémenter.
43
44
45
46
