Premier pas en Systèmes Embarqués

UE EEA4 V4

BRESSEL Mathieu mathieu.bressel@junia.com Bureau T314

DOMINE François francois.domine@junia.com Bureau T314
1
 Présentation de l’UE
• L’enseignement se décompose ainsi:
– 24h de cours/TD sur machine
– 8h de TP noté (70% de la note)
– 16h de projet (30% de la note)

• Objectifs du cours:
– Maitriser les fondamentaux d’un système embarqué: architecture des
ordinateurs, périphériques entrées/sorties, programmation et
communication
– Apprendre en faisant
2
 Présentation de l’UE
• Une UE à l’interface de divers domaines:

Automatique Informatique

Systèmes
Embarqués
Electronique Communication

Traitement
du signal
3
 Présentation de l’UE
• Contenu de l’UE:
– Introduction aux systèmes embarqués
– Programmation d’un mini-jeu
– Utilisation de capteurs/actionneurs
– Gestion du temps et des périphériques externes
– Communication série et Bluetooth
– Projet

4
 Présentation de l’UE
• Quelques applications:
– Objets connectés (sport, santé, etc.)
– Transport (automobile, aéronautique, ferroviaire)
– Robotique
– Domotique

5
 Plan du cours 1/4
1. Introduction 10
– Systèmes embarqués
– Arduino
2. Le langage Arduino 20
– Variables
– Conditions
– Boucles
– Fonctions
3. Le Mastermind 40
6
 Plan du cours 2/4
4. Les sorties numérique/analogique 43
– La led clignotante
– La led en PWM
5. Le temps 52
– Millis()
– Timer
6. Les entrées numérique/analogique 56
– Le bouton et la résistance de tirage
– L’anti-rebond
– Le potentiomètre
– Mesure de température: le LM35
7
 Plan du cours 3/4
7. Les interruptions 70
– Le bouton
– Le codeur
8. La puissance 78
– Le transistor bipolaire
– Le relais
9. Les extensions 86
– Le servo moteur
– Le bus I2C: PCF8574A

8
 Plan du cours 4/4
10. Le Bluetooth 97
11. Projet 101
– Centrale Domotique

9
Chapitre 1. Introduction

10
 1. Introduction
• C’est quoi un système embarqué ?
– Exemples de systèmes
– Point communs ?
• Architecture d’un système embarqué
• Capteurs et actionneurs
– Et la programmation alors ?
• Compilé ou interprété ?
• Quel langage ?

11
 1. Introduction
• Architecture d’un système embarqué

Mémoire Mémoire
Communication
vive morte

Capteurs Conversion CPU Conversion Actionneurs

Systèmes
IHM
auxiliaires

12
 1. Introduction
• Capteurs et actionneurs

13
 1. Introduction
• Et la programmation ?
– Langage interprété
Traduit par un interpréteur en langage machine au fur et à mesure
- Python
- Java
- HTTP, PHP, etc…
– Langage compilé
Traduit en langage machine avant exécution
- C
- C++
- C#
Le programme en langage machine est alors transféré en mémoire
14
 1. Introduction
• C’est quoi un Arduino ?
– Du matériel
– Des extensions
– Un émulateur
– Un environnement de programmation
– Un langage

15
 1. Introduction
• Les cartes Arduino et extensions (shield)

16
 1. Introduction
• Arduino Uno
14 E/S numériques (broches 0 à 13)
Les numéros précédées d’un ‘~’ peuvent être utilisées en PWM

6 entrées analogiques (broches A0 à A5)

Résolution 10 bits

Microcontroleur ATmega328 16MHz

Mémoire Flash : 32 KB; Mémoire SRAM : 2KB; Mémoire EEPROM : 1 KB
3 timers

RX TX : liaison série pour dialogue avec Host (broches 0 et 1)

SCL, SDA : bus I2C
SPI : E/S 10 à 13.

Intensité max par E/S 5V : 20mA (40 mA max). Total 200mA.

Intensité max sortie 5V : 500mA avec USB
17
 1. Introduction
• Un émulateur: TinkerCAD Circuits (http://www.tinkercad.com)

18
 1. Introduction
• L’environnement de programmation Arduino (Sketch ou croquis)

• Une grande communauté et documentation en ligne:

http://arduino.cc/
19
Chapitre 2. Le langage Arduino

20
 2. Le langage Arduino
• Structure d’un programme Arduino
• Le moniteur série
• Les variables et opérations
• Les conditions
• Les boucles
• Les fonctions

21
 2. Le langage Arduino
• Structure d’un programme Arduino
– Langage C++ (presque)
– setup(): exécuté une fois au début
• Configuration des E/S
• De la communication
• Des éventuels modules externes
• etc…
– loop(): répétée ensuite à l’infini
• Votre programme

22
 2. Le langage Arduino
• Exemple: led qui clignote
– Remarque: une instruction se fini toujours par un « ; »

23
 2. Le langage Arduino
• Exemple: led qui clignote. A vous de jouer !
– Lancer le logiciel Arduino
– Ouvrir l’exemple: fichier/exemples/01.basics/blink
– Brancher la carte sur l’USB
– Choisir sa carte: outils/type de carte
– Choix du port USB: outils/Port
– Compilation et transfert: téléverser

24
 2. Le langage Arduino
• Moniteur série:
– Permet de saisir des données à l’Arduino ou en recevoir
– Utilise le port USB (liaison série de l’Arduino, Rx/Tx)
– Initialisé dans setup(): Serial.begin(9600);
– Pour afficher une variable: Serial.print(variable);
– Idem avec saut de ligne: Serial.println(variable);
– Pour lire une variable: Serial.read();
– Idem pour une chaine de caractère: Serial.readStringUntil(‘\n’);

25
 2. Le langage Arduino
• Moniteur série: exemple à tester
void setup()
{
Serial.begin(9600);
}

void loop()
{
Serial.println("Quel est votre prenom?");
while(Serial.available()==0)
{
}

String prenom=Serial.readStringUntil('\n');
Serial.print("Bonjour ");
Serial.println(prenom);
}
26
 2. Le langage Arduino
• Les variables
– Une variable permet de donner un nom à une valeur stockée
– Doit être obligatoirement déclarée !
– Type de variable:
• bool: bouléen stocké sur 1 bit
• byte: octet stocké sur 8 bits
• char: caractère (entre apostrophes ‘ ‘)
• String: - chaine de caractères (entre guillemets « »)
• (unsigned) int: entier signé (ou non) stocké sur 16 bits
• long: deux fois plus qu’un int
• (unsigned) float: flottant signé (ou non) stocké sur 32 bits
• double: deux fois plus qu’un float
– Exemples: long vitesseLumiere=299792458;
– Pas d’espaces ni de caractères spéciaux

27
 2. Le langage Arduino
• Les variables locales vs globales
– Une variable locale n’est connu que du sous programme où elle est
déclarée
– Une variable globale est connu partout
– Dans l’exemple, LED est une variable ……globale
– Les variables locales sont à préférer:
• Economie de mémoire car elles sont détruites
après exécution du sous-programme
• Nom pouvant être réutiliser dans plusieurs
sous-programmes ou fonctions
• Si la donnée est fréquemment utilisée:
• Variable globale
28
 2. Le langage Arduino
• Opération sur les variables
– Déclaration et affectation: int toto=1;
– Affectation seule: toto=1;

– Addition: toto=1+1;
– Soustraction: int y=4-toto;
– Multiplication: long z=y*10;
– Division: long div=z/3; arrondie à l’inférieur
– Modulo: long reste=z%3; reste de la division

29
 2. Le langage Arduino
• Opération sur les variables (suite)
– Incrémentation: toto++;
– Décrémentation: toto--;
– Bascule: toto=!toto;

• Opération booléenne
– Et: &
– Ou: |
– Non: !

30
 2. Le langage Arduino
• Les conditions
– Si… if( 1er condition à tester ))
{
//Instructions à exécuter
}
– …Sinon si… else if( 2eme condition à tester ))
{
//Instructions à exécuter
}

– …Sinon else
{
//Instructions à exécuter
}

– Pas d’obligation de toutes les utiliser

31
 2. Le langage Arduino
• Multiplicité des conditions
– Et: &&
– Ou: ||
– Non: !

• Comparaison de variables
– Égalité: ==
– Inférieur – inférieur ou égal: < <=
– Supérieur – supérieur ou égal: > >=
– Différent: !=

32
 2. Le langage Arduino
• Les conditions – Exercice 2.1
1. Créer un programme qui demande l'âge de l’utilisateur
– En fonction de l'âge, le programme répondra avec « Majeur » ou
« Mineur »
– Remarque: chainedecaractere.toInt(); permet de convertir une chaine
de caractère en nombre entier
2. Désormais le programme demandera également si l’utilisateur
dispose en plus d’un véhicule
– En fonction des deux réponses, le programme dira si l’utilisateur peut
conduire

33
 2. Le langage Arduino
• Les conditions: cas de l’aiguillage
switch(toto) //selon la valeur de toto…
{
case 0 : //si toto vaut 0
//instructions à exécuter
break; //indique la fin du cas 0

case 1 : //si toto vaut 1

//instructions à exécuter
break;

default : //si toto vaut quelque chose d’autre

//instructions à exécuter
break;
}

34
 2. Le langage Arduino
• Les boucles
– Tant que…faire while(conditions à tester)
{
//Instructions à exécuter
}

– Faire…tant que do
{
//Instructions à exécuter
}
while(conditions à tester);

– Pour for(variable initiale; condition; incrément)

{
//Instructions à exécuter
}
35
 2. Le langage Arduino
• Exemple: calcul d’une moyenne
int nb_note=3;
float notes[]={12,15,13};
float somme=0;

for(int compteur=0; compteur<nb_note; compteur++)

{
somme=somme+notes[compteur];
}

float moyenne=somme/nb_note;

• Utilise d’un tableau de variable notes[](abordé plus tard)

36
 2. Le langage Arduino
• Les boucles – Exercice 2.2
1. Créer un programme qui demande à l’utilisateur de donner un chiffre
entre 1 et 10
– La question est répétée tant que le nombre donné ne correspond pas
– On ne doit pas sortir de la boucle dans ce cas
Question: boucle faire…tant que ou tant que…faire ?

2. Le programme doit ensuite compter de 1 jusqu’au chiffre donné par

l’utilisateur (boucle for)

37
 2. Le langage Arduino
• Les fonctions
– Permettent de ne pas réécrire un code utilisé de multiples fois
Type nomDeLaFonction(types et noms des variables en entrée)
{
//Instructions à exécuter
return une_variable; //du même type que la fonction
}
– Types de fonction:
• void: ne renvoie rien et donc l’instruction « return » est inutile
est appelé: sous-programme
• int: renvoie un entier, return doit donc envoyer un entier
• Etc…
– setup() et loop() sont des fonctions particulières pour Arduino
elles sont obligatoires
38
 2. Le langage Arduino
• Exemple: encore la moyenne
– Remarque: la fonction crée une copie de monNbNote nommée nbNote !
float calculMoyenne(float notes[],int nbNote)
{
float somme=0;
for(int compteur=0; compteur<nbNote; compteur++)
{
somme=somme+notes[compteur];
}

float moyenne=somme/nbNote;
return moyenne;
}

void loop()
{
float mesNotes[]={12,15,13};
int monNbNote=3;
Serial.println(calculMoyenne(mesNotes,monNbNote));
39
}
Chapitre 3. Le Mastermind

40
 3. Le Mastermind
• Règles du jeu:
– La machine tire aléatoirement 4 pions de couleurs parmi 6
– Le joueur doit trouver la bonne combinaison
– A chaque tour, le joueur propose une combinaison
– La machine donne le nombre de bien placés et mal placés
– Le joueur dispose de 8 tours seulement !

• Nous coderons les 6 couleurs avec des chiffres (1-6)

41
 3. Le Mastermind
• Tableau à 1 dimension: ex de la moyenne
– Déclaration int nb_note=3;
float notes[]={12,15,13};
– Initialisation float somme=0;
– Lecture d’un élément for(int compteur=0; compteur<nb_note; compteur++)
– Ecriture ? {
somme=somme+notes[compteur];
• notes[indice]=14; }
– Indice commence à 0 float moyenne=somme/nb_note;
• Première « case » mémoire
– Déclaration alternative:
• type nom_tab[taille_tableau];

42
Chapitre 4. Les sorties numériques/analogiques

43
 4. Les sorties numériques/analogiques
• Le breadboard:
– Permet de connecter des composants électroniques
– 4 lignes d’alimentations indépendantes (rouge: Vcc, noire: Gnd)
– Des colonnes indépendantes, séparées en leurs milieux

44
 4. Les sorties numériques/analogiques
• Le breadboard: exemple de la LED connectée en pin 12
– Une led est un composant polarisé
– Le courant la traverse de l’anode vers la cathode
– A besoin d’une résistance pour limiter le courant (20mA max)

• Tout montage doit se faire hors tension !

45
 4. Les sorties numériques/analogiques
• Le breadboard: exemple de la LED connectée en pin 12

46
 4. Les sorties numériques/analogiques
• Le breadboard: exemple de la LED
– La Led est déclarée en pin 12
– La pin 12 est déclarée en sortie

– J’écris l’état « haut » (5V) en pin 12

– J’attend 1s
– J’écris l’état « bas » (0V) en pin 12
– Accolade {/}: groupe d’instructions

47
 4. Les sorties numériques/analogiques
• Les sorties numériques – Exercice 4.1
1) Tester l’exemple de la LED, puis modifier la durée de clignotement

2) Câbler une deuxième LED et la faire clignoter deux fois plus vite

3) Faire clignoter cette deuxième LED trois fois plus vite que la première ?

48
 4. Les sorties numériques/analogiques
• Aparté: calcul de la résistance de la led
– Loi des mailles: 𝑉𝑠 = 𝑅. 𝐼 + 𝑉𝑙𝑒𝑑
𝑉𝑠−𝑉𝑙𝑒𝑑 5−1,2
Donc R = 𝐼
= 20.10−3

– R=190 Ohm -> n’existe pas

– On consulte la série E12:

– R=180 ou 220 Ohm ?

49
 4. Les sorties numériques/analogiques
• Les sorties Pulse Width Modulation (analogique):
– Permet de moduler (moyenne) une tension entre 0 et 5V
– Grace à un rapport cyclique
– analogWrite(pin, value);
– value est compris entre 0 et 255 (100%)

0,5V

2,5V

4,5V

50
 4. Les sorties numériques/analogiques
• Les sorties Pulse Width Modulation – Exercice 4.2
1) Allumer une LED avec 3 niveaux d’intensités (0-127-255)

2) Allumer la LED avec une gradation puis l’éteindre progressivement

(boucle for)

51
Chapitre 5. Le temps

52
 5. Le temps
• La fonction delay()est dite bloquante.
On ne peut rien faire pendant l’attente.
• On préfèrera utiliser la fonction millis():
– L’Arduino possède un timer, sorte de chronomètre
– millis() donne le temps (en milliseconde) depuis que l’Arduino a
démarré
– Compte jusque 50 jours ! Variable temps à stocker dans un long
if((millis()-temps)> 1000)
{
//Instructions à exécuter
temps = millis(); //on stocke la nouvelle heure
}
53
 5. Le temps
• Millis() – Exercice 5.1
1) Câbler une LED, la faire clignoter avec Millis()

2) Câbler une deuxième LED et la faire clignoter trois fois plus vite avec
Millis()

54
 5. Le temps
• L’Arduino possède en réalité plusieurs timers

– Utilisé pour exécuter un code de manière périodique

– Une bibliothèque permet d’ajouter des fonctionnalités

Exemple:
– Bibliothèque TimerOne pour l’Arduino UNO #include <TimerOne.h>
• À installer depuis le gestionnaire de bibliothèque
void setup()
(ctrl+shift+I)
{
• Croquis/inclure une bibliothèque/TimerOne Timer1.initialize(1000000);
Timer1.attachInterrupt(nom_fonction);
• #include <TimerOne.h> apparait en début de code
void nom_fonction()
{
• Exercice 5.2: Faire clignoter une LED avec TimerONE //Instructions à exécuter
}
55
Chapitre 6. Les entrées numérique/analogique

56
 6. Les entrées numérique/analogique
• Entrées numériques: exemple du bouton
– 3 possibilités de montage

57
 6. Les entrées numérique/analogique
• Bouton en pullup (tirage à Vcc)
– Le niveau logique est « haut » (Vcc) en absence
d’appui sur le bouton
– A l’appui, la masse (gnd) est imposée,
et le niveau logique devient « bas »
int button_pullup = 4;

void setup() {
pinMode(button_pullup,INPUT);
}

void loop() {
bool reading=digitalRead(button_pullup);
delay(100);
}
58
 6. Les entrées numérique/analogique
• Bouton en pulldown (tirage à la masse)
– Le niveau logique est « bas » (gnd) en absence
d’appui sur le bouton
– A l’appui, la tension Vcc est imposée,
et le niveau logique devient « haut »
int button_pulldown = 7;

void setup() {
pinMode(button_pulldown,INPUT);
}

void loop() {
bool reading=digitalRead(button_pulldown);
delay(100);
}
59
 6. Les entrées numérique/analogique
• Bouton en pullup logiciel
– Même fonctionnement que le montage pullup
– Utilisation d’une résistance de pullup interne à l’Arduino

int button = 8;

void setup() {
pinMode(button,INPUT_PULLUP);
}

void loop() {
bool reading=digitalRead(button);
delay(100);
}

60
 6. Les entrées numérique/analogique
• Entrée numérique – Exercice 6.1
1) Câbler une LED, et un bouton (montage de votre choix)
a) L’appuie allume la LED
b) Le relâchement l’éteint

2) Modifier le programme précédent afin que:

a) La LED clignote tant que le bouton est appuyé (delay() autorisé)
b) Le relâchement arrête le clignotement

61
 6. Les entrées numérique/analogique
• Entrée numérique – Exercice 6.2
1) Modifier le programme de l’exercice 6.1 afin que le 1er bouton
active le clignotement et un second bouton l’arrête (nul besoin
de rester appuyé) -> besoin d’une variable supplémentaire

2) Désormais le clignotement doit être géré avec un code de Millis()

(la fonction delay() n’est plus autorisée)

62
 6. Les entrées numérique/analogique
• Les fronts représentent le passage d’un niveau logique à un
autre, on distingue:
– Le front montant (passage du niveau bas au niveau haut)
– Le front descendant (passage du niveau haut au niveau bas)
• Ils se « détectent » lorsque le niveau a changé entre l’instant t et
l’instant précédent

t-1 t
63
 6. Les entrées numérique/analogique
• Les fronts – Exemple:
int button=8;
bool prec_reading = 1;

void setup()
{
pinMode(button,INPUT_PULLUP);
}
t-1 t
void loop()
{
bool reading=digitalRead(button);
if(reading==0 && prec_reading == 1)
{
//instruction à exécuter
}
prec_reading=reading;
}

• Un anti-rebond est souvent requis pour éviter de multiple détections de front

64
 6. Les entrées numérique/analogique
• Entrée numérique – Exercice 6.3
1) Modifier le code d’exemple du front afin qu’il puisse écrire sur le
moniteur série un message lorsqu’un front montant est détecté

2) A chaque relâchement (front montant), une LED doit s’allumer ou

s’éteindre (mémorisation de l’état avec une variable de type bool)

65
 6. Les entrées numérique/analogique
• L’effet de rebond et l’anti-rebond
int button=8;
bool prec_reading = 1;
long lastDebounceTime=0;
int debounce=50;

void setup()
{
pinMode(button,INPUT_PULLUP);
}

void loop()
{
bool reading=digitalRead(button);
if(reading==0 && prec_reading == 1)
{
if(millis()-lastDebounceTime >debounce)
{
Exercice 6.4:
//instruction à exécuter Puis-ce que du rebond apparait, gérer la
lastDebounceTime=millis();
}
gestion du front avec un anti-rebond
}
prec_reading=reading;
} 66
 6. Les entrées numérique/analogique
• Entrée analogique
– L’Arduino possède 6 entrées analogiques (A0 à A5)
– La tension (comprise entre 0 et 5V) est convertie par un
Convertisseur Analogique Numérique (CAN) sur 10 bits

– Exemple:
int Value = analogRead(A0);

– Quelle est la plus petite tension

mesurable ? ≈ 5mV
67
 6. Les entrées numérique/analogique
• Exemple du potentiomètre
– C’est un composant à 3 broches
– En déplaçant le curseur B, la tension BA est modifiée
• Pont diviseur de tension !
void setup() {
Serial.begin(9600);
}

void loop() {
int sensorValue = analogRead(A0);
float voltage = sensorValue * (5.0 / 1023.0); //conversion
Serial.println(voltage);
}

– Remarque: A0 est forcément une entrée, donc pas besoin de la déclarer

68
 6. Les entrées numérique/analogique
• Entrée analogique – Exercice 6.4
1) Câbler un potentiomètre et tester le code d’exemple
(afficher la valeur sur le traceur série)

2) Câbler une LED qui devra clignoter +/- rapidement en fonction de

la valeur analogique lue
- potentiomètre au minimum -> clignotement toutes les 100ms
- potentiomètre au maximum -> clignotement toutes les 1s
Indice: il faudra modifier l’équation responsable de la conversion

69
Chapitre 7. Les interruptions

70
 7. Les interruptions
• Dans l’exemple du bouton, on scrute régulièrement son état
• Par exemple, si loop() exécute un long programme, l’appui ne
sera pas détecté…
• On utilise alors une interruption matérielle:
– Permet de détecter un événement
– Et d’exécuter une fonction dès la détection
– Le programme principal est suspendu pendant l’exécution…
– …puis reprend là où il s’est arrêté

71
 7. Les interruptions
• Configuration d’une interruption:
– Dans le setup()
attachInterrupt(interruption,fonction,mode);
– Où interruption est le numéro de l’interruption:
0 (événement sur la pin 2) ou 1 (pour la pin 3) pour l’Arduino UNO

– Fonction: c’est le sous-programme à exécuter (de préférence court)

– Mode: choisir le type d’événement
• RISING/FALLING: front montant/descendant
• CHANGE: changement (montant ET descendant)
• HIGH/LOW: événement sur niveau haut/bas
72
 7. Les interruptions
• Interruption: exemple du bouton avec anti-rebond
int button= 2;
unsigned long lastDebounceTime = 0;
unsigned long debounce = 50;

void setup() {
pinMode(button, INPUT_PULLUP);
attachInterrupt(0,Reagir,FALLING); //pour un bouton en pin 2
}

void loop() {}

Void Reagir() {
if ((millis() - lastDebounceTime) > debounce) {
//instructions à executer
lastDebounceTime=millis();
}
}

73
 7. Les interruptions
• Interruptions – Exercice 7.1
1) Utiliser une interruption pour changer une variable « cligno » de
type bool. Si cligno==1, alors une led clignotera depuis le loop.
(avec millis() )

2) Modifier le programme précédent afin que le clignotement s’arrête

à l’aide d’un second bouton, également géré par interruption

74
 7. Les interruptions
• Exemple du codeur incrémental:
– Dispose de deux canaux: A et B
– Les signaux évoluent lors de la rotation
– Si A apparait avant B: sens horaire
– Sinon: sens trigonométrique

– Possibilité de doubler le nombre

d’impulsions par tour: quadrature

75
 7. Les interruptions
• Exemple: codeur incrémental sans la quadrature
int codA= 2;
int codB= 3;
int compteur=0;

void setup() {
pinMode(codA, INPUT_PULLUP);
pinMode(codB, INPUT_PULLUP);
attachInterrupt(0,comtA,CHANGE);
}

void loop() {}

void comtA() {
if(digitalRead(codA)!=digitalRead(codB)){
compteur++;
}
else{
compteur--;
}
} 76
 7. Les interruptions
• Interruptions – Exercice 7.2
1) Tester l’exemple en le modifiant pour faire apparaitre la valeur du
compteur dans le moniteur série

2) Utiliser la valeur du compteur pour faire varier la vitesse de

clignotement de la led interne (E/S 13)

77
Chapitre 8. La puissance

78
 8. La puissance
• Un Arduino n’est capable de fournir qu’une tension maximale
de 5V et un courant de 40 mA pour une unique entrée.

• Si l’on a besoin de plus de puissance, il faut par exemple:

– Un transistor
– Un relais
– Un pont en H, etc…

• Ils font office d’interrupteur de puissance commandé par une

sortie numérique de l’Arduino
79
 8. La puissance
• Parmi la multitude de transistors: les bipolaires
– En particulier le « NPN », est un composant à 3 broches:
• Le collecteur: broche d’entrée
Interrupteur
• L’émetteur: broche de sortie
• La base: broche de commande

– Il se comporte comme un interrupteur commandé en courant

lorsqu’il est en commutation.
– Il faut donc limiter le courant qui le traverse !
• Références: BC547 par exemple
80
 8. La puissance
Vcc Vcc
• Exemple de montage en commutation
– R1 permet la « saturation » du transistor
– R2 limite le courant dans la diode

• Prenons Vce≈0V, que vaut le courant dans la diode ?

Ic = (Vcc-Vce-Vdiode)/R2 ≈ 17mA
81
 8. La puissance
• Le transistor – Exercice 8.1
1) Faire le montage de l’exemple, puis faire clignoter la led par le code

2) Désormais, allumer la led progressivement en utilisant une sortie

PWM (~) pour commander le transistor

82
 8. La puissance
• Le relais
– Permet une vraie séparation des circuits.
– Composé d’une bobine (la commande)
– Et d’une lamelle (Interrupteur)

– En alimentant la bobine, un champ magnétique

déplace la lamelle, créant un contact

83
 8. La puissance
• Exemple de montage
– Besoin de puissance pour alimenter la bobine du relais
– Utilisation d’un transistor !
– Cette référence permet d’alimenter jusque:
• 1A à 24 V en continue
• 0,5 A en alternatif (125 V)

– Une diode de roue libre protège le transistor des pics de tension

84
 8. La puissance
• Le relais – Exercice 8.2
1) Faire clignoter la LED avec un montage transistor/relais
(sur commun et normalement ouvert a)

2) Faire clignoter en même temps une deuxième led sur la seconde

partie du relais (sur commun et normalement fermé b)

B1

B2
85
Chapitre 9. Les extensions

86
 9. Les extensions
• Afin d’augmenter les capacités de l’Arduino et de simplifier le
développement de tâches complexes:
– Utilisation de bibliothèques et extensions
• Une bibliothèque est une collection de routine permettant
d’exécuter des tâches courantes
• TimerOne.h est une bibliothèque pour gérer le temps
• Ajout d’une bibliothèque:

87
 9. Les extensions
• Exemple: le servomoteur
– C’est un composant intégrant:
• Un moteur avec des engrenages
• Un potentiomètre pour la mesure d’angle
• Une carte électronique pour le contrôle
#include <Servo.h> //on ajoute la bibliothèque

Servo myservo; //on crée un objet servomoteur…

void setup() {
myservo.attach(2); //…connecté en pin 2
}

void loop() {
myservo.write(50); //on impose un déplacement
delay(1000); //vers la position 50
} 88
 9. Les extensions
• L’Arduino dispose d’un bus I2C lui permettant de
communiquer avec des périphériques
– Chaque périphérique possède une adresse
– Le bus utilise les pins SDA (Data) et SCL (Clock)
– Remarque: Les signaux sont présents en A4 (SDA) et A5 (SCL)
• Exemple de trame:
SDA

SCL

• L’utilisation de l’I2C est facilitée grâce à la bibliothèque Wire.h

89
 9. Les extensions
• Le bus I2C: exemple du PCF8574A
– Le PCF8574A est un composant permettant d’ajouter
8 E/S à l’Arduino en utilisant le bus I2C
– Il est possible de choisir son adresse grâce aux pin A0-A2

– En connectant A0, A1 et A2 à la masse, nous obtenons l’adresse 38h

90
 9. Les extensions
• Le bus I2C: exemple du PCF8574A en écriture
– Remarque: les sorties sont par défaut en pullup
#include <Wire.h> 7654
#define PCF8574_ADDR 0x38

void setup() {
Wire.begin();
}

void loop() {
Wire.beginTransmission(PCF8574_ADDR);
Wire.write(0b01011111);
Wire.endTransmission();
delay(500);
}
– Quelles leds s’allument ? Les leds 7 et 5
– Pour écrire sur une seule led à la fois: nécessité d’utiliser des masques!
91
 9. Les extensions
• Le bus I2C: exemple du PCF8574A avec un masque
– Masques d’écriture

Masque à 0 -> sortie à zéro Masque à 1 -> sortie à un

Masque à 1 -> recopie Masque à 0 -> recopie

entrée masque résultat entrée masque résultat

– Donc:
• écrire un 1 en P2 (masque en « ou »): c = c | 0b00000100
• écrire un 0 en P2 (masque en « et »): c = c & 0b11111011
92
 9. Les extensions
• Le PCF8574A– Exercice 9.1
1) Faire le montage du PCF8574A à l’adresse 0x38, puis écrire sur les
8 bits afin de faire clignoter une led connectée en P4

2) Ajouter une led en P3, faire clignoter les deux leds à des vitesses
différentes (obligation d’utiliser deux masques)

93
 9. Les extensions
• Le bus I2C: exemple du PCF8574A en lecture
– Remarque: les entrées sont par défaut en pullup
#include <Wire.h>
#define PCF8574_ADDR 0x38

byte c=0;

void setup() {
Wire.begin();
Serial.begin(9600);
}

void loop() {
Wire.requestFrom(PCF8574_ADDR, 1); //demande d’un octet…
while (Wire.available()) {
c = Wire.read(); //…stocké dans c
Serial.println(c,BIN);
}
delay(500);
} 94
 9. Les extensions
• Le bus I2C: lecture avec un masque
– Lorsque l’on lit sur le PCF8574A, c’est avec un octet complet
– Si on ne souhaite lire qu’une partie indépendamment du reste:
-> Utilisation d’un masque !
– Exemple d’un masque de lecture pour P2:
c = Wire.read();
c =c & 0b00000100;
if (c == 0)
{
Serial.println("P2=LOW");
}
else
{
Serial.println("P2=HIGH");
}
95
 9. Les extensions
• Le PCF8574A– Exercice 9.2
1) Faire le montage du PCF8574A à l’adresse 0x3D, lire l’état de
2 boutons connectés en P1 et P2 et les afficher sur le moniteur série

2) Ajouter une led en P5, le premier bouton doit allumer la led, le

deuxième l’éteint

Remarque: lors d’une lecture/écriture, il faut « réarmer » le(s) entrée(s)

en écrivant un « 1 » sur la pin concernée

96
Chapitre 10. Le Bluetooth

97
 10. Le Bluetooth
• Le Bluetooth Low Energy est une norme de
communication bidirectionnelle sans-fil
– Présent nativement sur l’Arduino 101
– Nécessite un composant (HM-10 par exemple)
pour les autres Arduino
• Il permet de créer une liaison série sans fils
• Application:
– Serial Bluetooth Terminal (Android)
– BLE Terminal HM-10 (iOS)

98
 10. Le Bluetooth
• Exemple simple:
#include <SoftwareSerial.h>
SoftwareSerial blue(2, 3);

void setup()
{
// Ouvre la voie série avec l'ordinateur
Serial.begin(9600);

// Ouvre la voie série avec le module BT

blue.begin(9600);
}
void loop()
{
if (blue.available()) //Si une donnée bluetooth est disponible
{
String input = blue.readStringUntil(‘\n’); //on effectue la lecture du texte
Serial.println(input); //et on l’affiche sur le moniteur
}
if (Serial.available()) //Si une donnée série est disponible
{
String output = Serial.readStringUntil(‘\n’); //on effectue la lecture du texte
blue.println(output); //et on l’envoie par bluetooth
}
}
99
 10. Le Bluetooth
• Exemple avec E/S:
– Led en pin 13, bouton en pin 4
void loop()
#include <SoftwareSerial.h>
{
SoftwareSerial blue(2, 3);
if (blue.available()) //Si une donnée bluetooth est disponible
{
void setup()
String input = blue.readStringUntil(‘\n’); //on effectue la lecture du texte
{
// Ouvre la voie série avec l'ordinateur
if (input.substring(0,5).equals("D13_1")) //Si le texte commence par l'instruction D13_1
Serial.begin(9600);
{
digitalWrite(13,HIGH); //met un 5V à la sortie 13
//Configure les Entrées/Sorties
}
pinMode(13,OUTPUT); //Digital 13 en sortie
if (input.substring(0,5).equals("D13_0")) //Si le texte commence par l'instruction D13_0
pinMode(4,INPUT_PULLUP); //Digital 4 en entrée
{
digitalWrite(13,LOW); //met un 0V à la sortie 13
// Ouvre la voie série avec le module BT
}
blue.begin(9600);
}
if (input.substring(0,2).equals("D4")) //Si le texte commence par l'instruction D4
{
blue.print("D4_"); //L'arduino envoie à son tour un msg indiquant l'état de D4
blue.println(digitalRead(4));
}
}
}
100
Chapitre 11. Projet

101
 11. Projet
• Centrale domotique
– Nous souhaitons développer une maquette qui simule la
centrale domotique d’une maison
– Celle-ci comportera obligatoirement:
• Un détecteur de présence (PIR)
• Un écran LCD i2c 16x2 caractères muni de 4 boutons
• Un clavier matriciel
• Un PCF8574A (pour la gestion des E/S supplémentaires)
– Les fonctionnalités souhaitées sont:
• Gestion de l’éclairage (2 interrupteurs / 2 lampes)
• Gestion du chauffage (affichage température + consigne)
• Gestion de l’alarme (activation / désactivation par mot de passe)
102
 11. Projet
• Module PIR (détection de présence)
– En cas de détection de présence, envoie d’un signal haut pendant une
durée définie par un trimmer de réglage
int PIR_sensor=2;
– Nécessite une alimentation int sensorValue=0;

void setup() {
pinMode(PIR_sensor,INPUT);
Serial.begin(9600);
}

void loop() {
sensorValue = digitalRead(PIR_sensor);

if(sensorValue==1)
{
Serial.println("mouvement détecté");
}
} 103
 11. Projet
• Ecran LCD 16x2 caractères
– Installation de la bibliothèque dédiée
• Croquis/Inclure une bibliothèque/Ajouter la bibliothèque .ZIP
• La bibliothèque LCD16x2 vous est fourni
• Fonctionne avec le bus I2C, nécessite la bibliothèque Wire
– Exemple fourni: affichage et boutons
• Fichier/Exemples/LCD16x2/buttons_and_lcd
• Utilisation d’un masque pour les boutons

104
 11. Projet
• Clavier matriciel
– Permet avec 4 lignes et 4 colonnes (8 pins), d’obtenir
16 entrées
– Remarque: ne permet pas le multitouche
#include <Keypad.h> void setup() {
Serial.begin(9600);
char Keys[4][4] = { }
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'}, void loop() {
{'7', '8', '9', 'C'}, char touche = clavier.getKey();
{'*', '0', '#', 'D'} if (touche)
}; {
Serial.println(touche);
byte rowPins[4] = {9, 8, 7, 6}; }
byte colPins[4] = {5, 4, 3, 2}; }

Keypad clavier = Keypad(makeKeymap(Keys), rowPins, colPins, 4, 4);

105
 11. Projet
• Mesure de température: le LM335
– Permet d’obtenir une tension proportionnelle
à la température en degrés Celsius (0V-> 0 kelvin)
– Température=tension/0,01-273+α
– α sera à ajuster en fonction d’une mesure étalon

106
 11. Projet
• LED RGB (Red Green Blue) à cathode commune
– Se comporte comme 3 Leds qui partage leurs cathodes
– Une résistance sur la cathode est toujours requise
– Remarque: ici la patte longue se connecte à la masse

107
Fin du diaporama

108