Introduction `
a la programmation des micro-contrˆ
oleurs -TP 1
26 f´evrier 2015
Table des mati`
eres
1 Introduction 2
2 Le micro-contrˆoleur Arduino 2
3 La d´emarche de r´ealisation d’un programme 4
4 Prise en main 4
4.1 Structure du programme . . . 4
4.2 Le fameux ”Hello Word” . . . 5
4.3 Les diff´erents types et les pr´ecautions qui vont avec . . . 5
4.4 Elements de syntaxe . . . 6
4.4.1 Boucle for . . . 6
4.4.2 Boucle while . . . 6
4.4.3 Structure conditionnelle if . . . 6
4.5 Affection des Entr´ees/Sorties . . . 7
4.6 Lire les entr´ees . . . 7
4.7 Imposer une tension en sortie . . . 7
4.8 Quelques programmes de base . . . 8
4.8.1 Le ”Led Blink” . . . 8
4.8.2 Variation de luminosit´e d’une Led . . . 8
5 Mini-projet : R´ealisation d’un radar de recul 9 5.1 Introduction . . . 9
5.2 Objectif . . . 9
5.2.1 D´eroulement du mini-projet . . . 9
5.2.2 Montage . . . 10
5.2.3 Pour ceux qui sont en avance . . . 10 A Description du fonctionnement du module Ultrason ”HCSR04” 11
1
Introduction
De nombreux syst`emes industriels sont automatiques, et `a ce titre, ils ex´ecutent des tˆaches plus ou moins complexes de mani`ere autonome. Chacune de ces tˆaches peuvent tr`es souvent ˆetre d´ecompos´ees en tˆaches ´el´ementaires que l’on peut d´ecrire (comme nous l’avons vu en d´ebut d’ann´ee) par une chaˆıne fonctionnelle comme le montre la figure 1 :
Figure 1 – Chaˆıne fonctionnelle (IBD)
Dans ce TP ( et ceux qui vont suivre), on s’int´eresse plus particuli`erement aux composants de la chaˆıne d’information, et notamment `a la mani`ere dont l’unit´e de traitement g`ere les ordres et informations.
2
Le micro-contrˆ
oleur Arduino
Les unit´es de traitement existent sous diff´erentes formes. Les micro-contrˆoleurs en font partie. Leurs coˆuts et les fonc-tionnalit´es qu’ils proposent d´ependent du cahier des charge du syst`eme `a concevoir. Pour des raisons de coˆuts et de simplicit´e de manipulation, nous utiliserons une carte de type Arduino. Le site officiel www.arduino.cc propose de multiples ressources sur les produits Arduino. La carte de ”base” est la carte Ar-duino Uno. Cette carte est fond´ee sur un micro-contrˆoleur ATMega328 cadenc´e `a 16 MHz. Les connecteurs situ´es sur les bords ext´erieurs du circuit imprim´e permettent d’enficher une
s´erie de modules compl´ementaires. Cette carte peut se programmer avec le logiciel Arduino, grˆace `a un cordon de connexion USB1.
1. Attention, si vous d´esirez achetez une carte (pour les TIPE par exemple), il faut acheter ´egalement le cordon !
Les entr´ees/sorties de la carte Arduino sont d´etaill´ees sur la figure 2.
Figure 2 – Entr´ees-Sorties de la carte Arduino Uno Cette carte dispose :
— d’un micro-contrˆoleur ATMega328,
— de 14 broches num´eriques d’entr´ees/sorties (dont 6 peuvent ˆetre utilis´ees en sorties PWM2),
— de 6 entr´ees analogiques (qui peuvent ´egalement ˆetre utilis´ees en broches entr´ees/sorties num´eriques),
— d’un quartz 16MHz (horloge de cadencement),
— d’une connexion USB (avec son contrˆoleur associ´e) qui permet la programmation du micro-contrˆoleur ainsi que l’alimentation de la carte,
— d’un connecteur d’alimentation jack (n´ecessaire si le cordon USB est d´econnect´e apr`es programmation),
— d’un connecteur ICSP(programmation ”in-circuit”), — et d’un bouton de r´einitialisation (reset).
3
La d´
emarche de r´
ealisation d’un programme
La carte Arduino est une carte programmable, `a volont´e, `a cela prˆet que le langage de base n’est malheureusement pas Python, mais le langage Arduino (un mix entre le langage C et C++). La syntaxe est bien plus lourde que celle offerte par Python, mais aussi bien plus rigoureuse. La d´emarche de conception d’un programme est donn´ee ci dessous :
1. On utilise le logiciel Arduino pour ´ecrire son programme
2. On t´el´echarge (t´el´e-verse) le programme dans la carte (il y a une ´etape de compilation) 3. Le programme ´etant t´el´echarg´e, la carte fonctionne en autonomie si elle a sa propre source d’´energie, ou reste connect´ee au PC sinon, ou si une communication avec le PC est pr´evue (via la liaison s´erie par exemple)
4
Prise en main
Activit´e 1. Brancher la carte Arduino `a l’ordinateur puis d´emarrer le logiciel Arduino en cliquant sur l’icˆone suivante :
Une fois le logiciel d´emarr´e, aller dans Outils,Type de carte puis v´erifier que Arduino Uno est bien coch´e (le cocher sinon). Ensuite, v´erifier que la carte est bien reconnue en allant dans Outils, Port. La carte est reconnue si un port est affich´e, par exemple ”Com 3 ”.
4.1 Structure du programme
A l’ouverture du logiciel, on peut remarquer qu’un bout de code est d´ej`a fourni : void setup() {
// put your setup code here, to run once: }
setup() est une fonction de type void, c’est `a dire que cette fonction ne renvoie rien. On dit que c’est une proc´edure. Tout le code compris entre les accolades ne sera ex´ecut´e qu’une seule fois.
Ensuite, on rencontre : void loop() {
// put your main code here, to run repeatedly: }
C’est aussi une proc´edure (typ´ee void ). Elle contiendra le code principal. Le corps de cette proc´edure sera ex´ecut´ee en boucle.
4.2 Le fameux ”Hello Word”
On d´esire afficher, sur l’´ecran de l’ordinateur, une seule fois ”Hello Word”. Dans ce cas, la carte communique avec le PC. On utilisera la communication s´erie RS2323 Une nouvelle liaison s´erie (plus rigoureusement un nouvel objet de communication s´erie RS232) s’initia-lise dans le setup avec Serial.begin(115200) ;4. Ensuite, pour afficher un message, on utilise l’instruction Serial.println(”Hello World !”) ;
Activit´e 2. Cr´eer le r´epertoire suivant Utilisateurs/Documents/Arduino/Nom Pr´enom. En-suite, sous Arduino, cr´eer le programme suivant :
void setup() {
Serial.begin(115200);
Serial.println("Hello World!"); }
void loop() {
// put your main code here, to run repeatedly: }
Une fois le code cr´e´e, cliquer sur l’icˆone de v´erification du code :
T´el´everer ensuite le programme dans la carte, puis s´electionner Outils/Moniteur s´erie. Si tout se passe bien, le message apparaˆıt.
4.3 Les diff´erents types et les pr´ecautions qui vont avec
Contrairement `a Python, Arduino requiert qu’on lui renseigne un type `a chaque variable cr´e´ee. Par exemple, si on veut cr´eer une variable a, dont est sˆur qu’elle est enti`ere et comprise entre 0 et 255, alors on pourra ´ecrire :
byte a=20;
Si on affecte la valeur 300 `a a, on peut observer ce qu’il se passe : void setup() { Serial.begin(115200); byte a=300; Serial.println(a); } void loop() { }
3. En fait, c’est une liaison s´erie ´emul´ee, via le cˆable USB, pour tous renseignements concernant la liaison s´erie, se r´ef´erer `a http ://fr.wikipedia.org/wiki/Communication s´erie
4. Le d´ebit de communication (en bits par seconde) sera proportionnel `a 115200. D’autres d´ebits sont accept´es. Pour plus d’information, consulter http ://fr.wikipedia.org/wiki/Baud (mesure)
Le programme renvoie 44 : il y a eu un d´epassement de capacit´e de la variable. Il faut donc ˆetre tr`es vigilant sur le type utilis´e. Bien heureusement, on peut stocker dans une variable de tr`es ”grandes” valeurs, cependant elles prendront plus de place en m´emoire5. Les types les plus utilis´es sont regroup´es dans le tableau suivant :
Type de variable Intervalle Commentaires boolean True ou False Occupe 1 octet en m´emoire.
char Caract`ere ASCII Occupe 1 octet en m´emoire. String mots Occupe 1 octet/caract`ere.
byte [0 ;255] Repr´esentation partielle de N+ Occupe 1 octet en m´emoire. int [-32,768 ;32,767] Repr´esentation partielle de N
Occupe 2 octets en m´emoire. unsigned int [0 ;65535] Repr´esentation partielle de N+
Occupe 2 octets en m´emoire. long [-2 147 483 648 ;2 147 483 647] Repr´esentation partielle de N Occupe 4 octets en m´emoire. unsigned long [0 ;4 294 967 295] Repr´esentation partielle de N+
Occupe 4 octets en m´emoire. float [−3, 4028235.1038;3, 4028235.1038] Repr´esentation partielle de R Occupe 4 octets en m´emoire.
4.4 Elements de syntaxe 4.4.1 Boucle for for(int i=0;i<=10;i++){ //corps de la boucle } for(int i=10;i>=0;i--){ //corps de la boucle } 4.4.2 Boucle while int i=10; while(i>=0){ //corps de la boucle i--; } 4.4.3 Structure conditionnelle if int a=0; int b=2;
5. Il est fortement conseill´e de consulter r´eguli`erement la r´ef´erence arduino situ´ee ici :http ://ar-duino.cc/en/Reference/HomePage
if(a==b){ Serial.println("a=b"); } else if(a>b){ Serial.println("a>b"); } else{ Serial.println("a<b"); }
On remarquera qu’il faut terminer chaque instruction par un ” ;”.
4.5 Affection des Entr´ees/Sorties
Les affectations des entr´ees/sorties sont `a placer dans la proc´edure setup. Pour affecter une entr´ee sur une broche :
pinMode(8,INPUT) //Affectation de la broche 8 (logique) en tant qu’entr´ee. pinMode(A0,INPUT) //Affectation de la broche A0 (analogique) en tant qu’entr´ee. pinMode(8,OUTPUT) //Affectation de la broche 8 (logique) en tant que sortie.
pinMode(9,OUTPUT) //Affectation de la broche 9 (sortie PWM car marqu´ee par le symbole // ~ sur la carte) en tant que sortie.
4.6 Lire les entr´ees
Lorsqu’une broche ”digitale” ou logique est configur´ee en entr´ee, il est possible de r´ecup´erer la valeur correspondante en entr´ee de cette broche via :
digitalRead(numero_de_broche)
Cette fonction renvoie 1 si la tension en entr´ee de la broche est sup´erieur `a 3V, et 0 si la tension est inf´erieure.
Il est possible de lire une tension sur une broche analogique, via un convertisseur analogi-que/num´erique, en appelant la fonction :
analogRead(numero_de_broche)
La tension lue doit varier entre 0 et 5V. La valeur renvoy´ee est un entier contenu entre 0 et 1023.
4.7 Imposer une tension en sortie
Sur une broche logique configur´ee en sortie, on peut imposer soit 0V soit 5V via : digitalWrite(LOW) //impose 5V
digitaleWrite(HIGH)// impose 0V
Certaines broches sp´eciales configur´ees en sortie, et suivies du symbole ˜, peuvent d´elivrer une tension moyenne variable grˆace `a la fonction :
analogWrite(val)
avec val une valeur enti`ere comprise entre 0 et 255. Si val=0, la valeur moyenne vaut 0V, si val=255, la valeur moyenne vaut 5V. La sortie est obtenue par modulation de largeur d’impulsion (MLI ou PWM en anglais). Son ´etude sera r´ealis´ee plus tard.
4.8 Quelques programmes de base
4.8.1 Le ”Led Blink”
On souhaite r´ealiser un programme, associ´e `a un montage, qui fait clignoter une LED `a intervalles de temps r´eguliers. Le circuit est donn´e ci-contre6.
Activit´e 3. R´ealiser le montage suivant avec le mat´eriel `a disposition, puis proposer un programme qui permet de faire clignoter la LED en permanence toutes les 500 ms (LED allum´ee pendant 250 ms, LED ´eteinte pendant 250 ms.) On pourra utili-ser la fonction delay() (consulter la r´ef´erence ar-duino7) . Am´eliorer ensuite le programme pour qu’il affiche sur le terminal l’´etat de la LED (al-lum´ee ou ´eteinte).
4.8.2 Variation de luminosit´e d’une Led
On souhaite r´ealiser un programme, associ´e `a un montage, qui fait varier la luminosit´e d’une LED, `a partir d’un potentiom`etre, dont le fonctionnement est donn´e figure 3.
Figure 3 – Principe de fonctionnement d’un potentiom`etre rotatif
Activit´e 4. R´ealiser le montage suivant avec le mat´eriel `a disposition, puis proposer un programme qui af-fiche la valeur lue en sortie du potentiom`etre. Activit´e 5. Compl´eter le programme pour que la luminosit´e
de la led varie avec la rotation du potentiom`etre. On rappelle que la fonction analogRead renvoie des valeurs comprises entre 0 et 1023, alors que la fonction analogWrite ne prend que les valeurs comprises entre 0 et 255 en argument. On pourra utiliser la fonction map pour r´egler le probl`eme.
6. se r´ef`erer `a http ://fr.wikipedia.org/wiki/Diode %C3%A9lectroluminescente pour la polarit´e d’une LED 7. ici : http ://arduino.cc/en/Reference/HomePage
5
Mini-projet : R´
ealisation d’un radar de recul
5.1 Introduction
Figure 4 – Radar de recul Les radars de recul pour les v´ehicules automobiles sont
des syst`emes d’assistance qui avertissent de la pr´esence d’un obstacle `a l’arri`ere du v´ehicule, lors d’une op´eration de marche arri`ere. Les principaux constituants de ce type de syst`eme sont :
— Les capteurs `a ultrasons, compos´es d’´emetteurs et de r´ecepteurs
— Le calculateur, qui estime la distance entre l’obstacle et l’arri`ere du v´ehicule, `a partir des informations d´elivr´ees par les capteurs `a ultrasons
— un syst`eme d’´emission sonore qui avertit le conducteur.
Habituellement, un bip sonore est ´emis lorsque la distance obstacle/v´ehicule devient inf´erieure `a une distance limite, puis, plus l’obstacle se rapproche, plus la fr´equence des bips est ´elev´ee, jusqu’`a devenir une ´emission sonore continue lorsque le v´ehicule est tr`es proche de l’obstacle.
5.2 Objectif
L’objectif de ce mini-projet est de reconstituer un radar de recul automobile. Le mat´eriel mis `a disposition est le suivant :
— Une carte Arduino-Uno et son cˆable USB — Un capteur `a ultrason de r´ef´erence hc-sr04 — Un buzzer
— Une plaque d’exp´erimentation (ou breadboard) — Des cˆables de type jumper
Le cahier des charges est le suivant :
Le syst`eme con¸cu devra ´emettre un son, fonction de la distance entre un obstacle et le capteur `
a ultrasons. Ce son sera constitu´e d’une succession de bips d’une dur´ee de 30 ms), puis d’un silence d’une dur´ee T. Cette dur´ee T diminue avec la distance. on note d la distance entre le capteur et l’objet et on impose :
— T=800 ms si 40 cm < d ≤ 50 cm — T=600 ms si 30 cm < d ≤ 40 cm — T=400 ms si 20 cm < d ≤ 30 cm — T=200 ms si 10 cm < d ≤ 20 cm — T=0 ms si d ≤ 10 cm 5.2.1 D´eroulement du mini-projet
— La description du capteur `a ultrason est donn´ee en annexe : la premi`ere chose `a faire est de bien comprendre son fonctionnement.
— R´efl´echir `a un programme qui permette d’afficher, sur le moniteur s´erie, la distance en cm entre l’objet et le capteur (on testera avec une surface ”suffisamment” plane (type cahier, feuille, etc . . .)).
— Faire un autre programme, distinct du pr´ec´edent, pour faire fonctionner le buzzer fourni. Il est conseill´e d’utiliser la fonction tone et noTone (voir la r´ef´erence Arduino).
Attention : une fois le principe de fonctionnement du buzzer compris, arrˆeter les tests, et ne pas jouer avec . . .
— Enfin, r´eunir les deux codes pr´ec´edents pour la r´ealisation finale. 5.2.2 Montage
Afin de sauvegarder le mat´eriel, seul le montage est impos´e. Il est fourni sur la figure ci-dessous :
Figure 5 – Montage retenu pour le mini-projet
5.2.3 Pour ceux qui sont en avance
Am´eliorer le syst`eme pr´ec´edent en y ajoutant une LED RGB : la couleur de la LED varie en fonction de la distance mesur´ee. On cherchera sur internet les informations li´ees au fonctionnement de ce type de LED, et on utilisera le montage suivant :
Annexe1
A
Description du fonctionnement du module Ultrason ”HCSR04”
Les caract´eristiques techniques du module ultrason sont : — Tension d’alimentation : 5V CC.
— Consommation en utilisation 15mA. — Gamme de distance : 2 cm `a 5 m. — R´esolution 0,3 cm.
— Angle de mesure < 15˚.
Il faut envoyer une impulsion niveau haut (`a + 5V) pendant au moins 10µs sur la broche ”Trig Input”. Cela d´eclenche la mesure. En retour, la sortie ”Echo” (ou ”Output”) va fournir une impulsion de + 5V dont la dur´ee
correspond au temps mis par le son, pour faire un aller et retour, entre le transmetteur (rep´er´e T sur le capteur) et le r´ecepteur (rep´er´e R sur le capteur). La figure suivante montre la s´equence de fonctionnement du capteur.
Figure 7 – S´equence de fonctionnement du capteur hc-sr04
En langage arduino, il est possible de mesurer la largeur d’une impulsion grˆace `a la fonction pulsIn (consulter la r´ef´erence).
