Livret de La formation-ENSA PDF

Embedded Systems Training
Arduino Platform
ENSA Tetouan, Maroc –2019
Formation sur les Systèmes Embarqués
Support de Formation
EL HARRAK HAJRI MOHAMMAD

Sommaire
Notions de base ..................................................................................................................... 4
L’électronique ................................................................................................................... 4
La charge électrique ....................................................................................................... 4
La tension ...................................................................................................................... 4
Le courant...................................................................................................................... 5
La résistance .................................................................................................................. 5
Le courant continu et le courant alternatif ...................................................................... 5
Les systèmes embarqués .................................................................................................... 6
Les microcontrôleurs ......................................................................................................... 6
Présentation de la plateforme Arduino ................................................................................... 9
Installation de l’Arduino IDE .............................................................................................. 12
Installation du logiciel de simulation ISIS Proteus ............................................................... 12
Premier Programme : Blink ................................................................................................. 13
Timers et interruptions ......................................................................................................... 15
Les Timers ....................................................................................................................... 15
La fonction delay() ...................................................................................................... 15
La fonction millis() ...................................................................................................... 17
La fonction micros() .................................................................................................... 19
La fonction delayMicroseconds() ................................................................................. 19
Les interruptions .............................................................................................................. 19
La fonction noInterrupts() ............................................................................................ 19
La fonction interrupts() ................................................................................................ 19
La fonction attachInterropt() ........................................................................................ 20
La function detachInterrupt() ....................................................................................... 20
Communication série ........................................................................................................... 21
La fonction begin() ...................................................................................................... 21
La fonction println() .................................................................................................... 21
La fonction available() ................................................................................................. 23
La fonction read() ........................................................................................................ 23
Conversion Analogique/Numérique ..................................................................................... 24
La fonction analogRead()............................................................................................. 24
Contrôle de moteurs ............................................................................................................ 26
Le moteur DC .................................................................................................................. 26

Commande unidirectionnel par transistor ..................................................................... 27
Commande unidirectionnel par relai ............................................................................ 28
Commande bidirectionnel par relai .............................................................................. 28
Commande bidirectionnel par pont H........................................................................... 30
Le servomoteur ................................................................................................................ 32
Commande d’un servomoteur SG90 par Arduino ......................................................... 32
Le moteur pas-à-pas......................................................................................................... 34
Contrôle d’un moteur unipolaire pas-à-pas par Arduino ............................................... 35
Control de puissance par modulation de largeur d'impulsion (PWM) ................................... 37
Affichage LCD et Clavier matriciel ..................................................................................... 41
L’afficheur LCD alphanumérique 16x2 ........................................................................... 41
La bibliothèque LiquidCrystal...................................................................................... 42
Le clavier matriciel 4x3 ................................................................................................... 46
La bibliothèque Keypad ............................................................................................... 47
Les modules compatibles Arduino ....................................................................................... 50
Mini projet .......................................................................................................................... 50

Notions de base
L’électronique
La charge électrique
Charge - Une propriété que les particules subatomiques peuvent avoir. Sur un niveau
macroscopique, les objets ont une charge en raison d'un excédent ou déficit d'électrons. 1
Coulomb (C) : de charges électriques (électrons).
Toute matière est composée d'atomes qui contiennent des particules chargées positivement et
négativement (protons et électrons). Un champ électrique entoure chaque particule chargée,
est qui peut exercer une force sur d’autres particules chargées. Un champ positif entoure un
proton, et un champ négatif entoure un électron. L'intensité du champ est la même pour
chaque électron et proton, d'une magnitude de de Coulombs. Le Coulomb est une mesure de
la charge dérivée à partir d'une mesure du courant électrique ; une coulomb de charge est
transféré par un ampère de courant en une seconde. Si un coulomb de protons pourrait être
isolé et tenu à un mètre d’un coulomb d'électrons, une force d'attraction (donnée par la loi
Coulombs) de Newtons, équivalent à près d'un million de tonnes à la surface de la terre,
existerait entre eux. De même, deux groupes de protons ou d'électrons présenteraient une
force tout aussi importante de répulsion. C’est cette grande force intra-particules qui est mise
à profit pour donner vie aux circuits électriques.
La tension
Tension – ou généralement la différence de potentiel électrique est définie comme la quantité

de travail nécessaire pour déplacer une charge. Son unité est le Volt (V), qui est définie
comme Joule de travail par Coulomb de charge.
Un champ électrique positif qui entoure un groupe d’un ou plusieurs protons va exercer une
force de répulsion sur d’autres groupes de protons, et une force d'attraction sur des groupes
d'électrons. Etant donné qu’un champ électrique peut causer un déplacement des particules
chargées, il peut fournir une certaine quantité de travail, et il est dit d'avoir de l'énergie
potentielle.
La quantité d'énergie qu’un champ électrique peut conférer à une unité de charge est mesurée
en joules par Coulomb, plus communément connu comme "tension". Pour nos fins, la tension
peut être considérée comme la "force électromotrice" qui peut causer un déplacement des
particules chargées.
Une alimentation électrique est un dipôle en déséquilibre d'électrons, avec du matériel d'un
côté (le côté négatif) contenant une abondance d'électrons, et le matériel de l'autre côté
(positif) contenant une absence relative d'électrons.
L’énergie potentielle électrique disponible dans une alimentation, mesurée en volts, est
déterminée par le nombre d'électrons qu'elle peut stocker, la distance de séparation entre les
matériaux négatifs et positifs, les propriétés de la barrière entre les matériaux, et d'autres
facteurs. Certaines alimentations, comme des petites batteries, fournissent moins d'un volt,
tandis que d'autres, comme les stations de production d'énergie peuvent produire des dizaines
de milliers de volts.
Le courant
Courant électrique - un flux de charge électrique. Dans les circuits électriques ce courant est
le résultat du déplacement d'ensemble de porteurs de charges électriques, généralement des
électrons. L’ampère (A) est l'unité de mesure du flux de courant, équivalent à un coulomb de
charge électrique passant devant un point donné par seconde.
Les électrons portent la plus petite quantité possible de charge négative, des milliards
d'électrons sont présents dans la plus petite portion de la matière. Dans la plupart des
matériaux, les électrons sont maintenus fermement en place par les protons chargés
positivement. Dans ces matériaux, appelés isolants, les électrons ne peuvent pas se déplacer
librement entre les atomes. En revanche, dans d'autres matériaux comme les métaux, les
électrons peuvent se déplacer plus facilement d'un atome à l’autre, et ces matériaux sont
appelés conducteurs. Le mouvement des électrons dans un conducteur est appelé courant
électrique, mesurée en ampères. Si une alimentation est utilisée pour appliquer une tension
aux bornes d'un conducteur, les électrons se déplacent du côté négatif de l'alimentation à
travers le conducteur vers le côté positif.
La résistance
Résistance - l'opposition à l'écoulement de la charge électrique que toutes les substances

présentent. Il se trouve dans les composants électriques, telles que les ampoules et beaucoup
d’autres éléments chauffants. L’unité de mesure de résistance est l’ohm (Ω).
Tous les matériaux, même les conducteurs, présentent un certain degré de résistance à
l'écoulement du courant électrique. La quantité de la résistance détermine la quantité du
courant qui peut circuler ; plus la résistance est grande, moins est le courant qui peut circuler.
Par définition, un conducteur a une très faible résistance, donc un conducteur en lui-même ne
doit être jamais être placé au bornes d’une alimentation parce beaucoup trop de courant
coulerait, endommageant le générateur ou le conducteur lui-même. Un composant
électronique appelé une "résistance" serait utilisé en série avec le conducteur pour limiter la
circulation du courant.
Le courant continu et le courant alternatif
Le courant électrique peut être en courant continu (DC) ou courant alternatif (AC).
Le courant continu tel que celui généré par les batteries est caractérisé par une direction
uniforme d'écoulement et une quantité (tension) uniforme d'électricité. Le courant alternatif
est caractérisé par la direction de l'écoulement et une quantité d'électricité qui change de
manière cyclique en fonction du temps. Il y a bien longtemps, l'électricité statique était le seul
type d'électricité connu, mais lorsque les piles ont été inventées, il est devenu possible
d'utiliser l'électricité DC. Les générateurs ont été ensuite inventés, et il est devenu possible
d'utiliser l’AC ainsi.
Les systèmes embarqués
- "Les systèmes embarqués sont des systèmes de traitement de l'information embarqués dans
un produit (système) plus vaste." (Peter Marwedel, TU Dortmund).
Le logiciel embarqué - " Le logiciel embarqué est un logiciel intégré à des processus
physiques. Le problème technique est la gestion du temps et de simultanéité dans les
systèmes de calcul." (Edward Lee, Berkeley).
Un système embarqué est un système de calcul avec une fonction bien déterminée au sein
d'un système mécanique ou électrique plus grande, souvent avec des contraintes de calcul en
temps réel. Il est intégré dans le cadre d'un dispositif complet comprenant souvent d’autres
périphériques et des actionneurs mécaniques. Les systèmes embarqués contrôlent de
nombreux appareils d'usage courant aujourd'hui, tels que votre smartphone, un four
microonde, le système ABS de votre voiture, ou le système de pilotage automatique d’un
avion.
Systèmes embarqués (SE) ordinaires se basaient sur des microprocesseurs (CPU) en utilisant
des puces externes pour la mémoire et des circuits d'interface périphériques. Ces systèmes
sont également encore monnaie courante, en particulier dans des applications complexes. Le
processeur(s) utilisé peut être de type usage général ou spécialisé dans certaines classes de
calcul, ou même conçu sur mesure pour l'application visé. Une classe standard commune de
processeurs dédiés est le processeur de signal numérique (DSP). D’autres systèmes
embarqués se basent sur des supports de calculs tels que l’ASIC, ASIP, et les FPGA. Une
autre classe des SE modernes se base sur des microcontrôleurs avec mémoires et interfaces
périphériques intégrés. Cette classe présente des avantages intéressants tels que la réduction à
la fois de la consommation d'énergie, la taille et le coût. Les microcontrôleurs offrent plus de
flexibilité d’adaptation à l’application en main, et surtout ils sont faciles d’utilisation.
Les microcontrôleurs
- Un microcontrôleur (µC) est un petit ordinateur sur un seul circuit intégré contenant un
processeur, mémoires, et des périphériques d’entrée/sortie programmables.
Comme la plupart des ordinateurs, les microcontrôleurs sont tout simplement des exécuteurs
d'instructions d'usage général. L’élément principal d'un système informatique est un
programme d'instructions qui est fourni par un programmeur humain. Ce programme ordonne
à l'ordinateur d'effectuer de longues séquences d'actions très simples pour réaliser des tâches
utiles comme prévu par le programmeur.
Les microcontrôleurs peuvent être classés selon la taille du bus interne, l'architecture, la
mémoire et jeu d'instructions. La figure ci-dessous montre les différents types de
microcontrôleurs :

Les architectures internes de base de microcontrôleurs sont assez similaires. La figure suivante
représente le schéma synoptique d'un microcontrôleur classique. Tous les composants sont reliés
via un bus interne et sont tous intégrés sur une puce. Les modules sont connectés au monde
extérieur par l'interm

édiaire de broches d'E/S.
Microcontrôleur
Cœur de EEPROM/ Module

SRAM
processeur Flash Compteur/
Minuteur
Bus
interne
Module Module
Module
D’E/S d’interface Contrôleur
analogique
numériques série d’interruptions
La liste suivante contient les modules qu'on trouve généralement dans un microcontrôleur.
Vous pouvez trouver une description plus détaillée de ces composants dans les sections
ultérieures.

Cœur de processeur : La CPU du µC. Il contient l'unité arithmétique et logique, l'unité
de commande, et les registres (pointeur de pile, compteur de programme, registre
 accumulateur,...).
 
 Mémoire : La mémoire est parfois scindée en mémoire de programme et mémoire de données.

Contrôleur d’interruptions : Les interruptions sont utiles pour interrompre le
déroulement normal du programme en cas d'événements externes ou internes
  En conjonction avec des modes veille, ils contribuent à économiser
(importants).
l'énergie.
  
Timer/Compteur : La plupart des µC ont au moins un, jusqu’à trois Minuteurs/
Compteurs, qui peuvent être utilisés pour l'horodatage des événements, mesurer des
intervalles de temps, ou compter des événements. De nombreux µC contiennent
également des sorties PWM (Pulse Width Modulation), qui servent à contrôler la
puissance délivrée aux appareils tels que les moteurs, les lampes…

E/S numériques : Les ports numériques parallèles d'E/S sont l'un des atouts principaux
des microcontrôleurs. Le nombre de  broches d'E/S varie de 3 à 4 jusqu’à plus de 90, en
 fonction de la famille et type du µC.

E/S analogiques : Mis à part quelques petits microcontrôleurs, la plupart des µC
intègrent des convertisseurs analogique/numérique, qui diffèrent par le nombre de
canaux (2-16) et leur résolution (8-12 bits). Le module analogique comporte également

généralement un comparateur analogique. Dans certains  cas, le microcontrôleur
comprend des convertisseurs numériques/ analogiques.

Interface série : les microcontrôleurs ont généralement au moins une interface série qui
peut être utilisée pour télécharger le programme et pour la communication un

ordinateur en général. Les interfaces série peuvent également être utilisés pour
communiquer avec un dispositif périphérique externe.

Horloge de surveillance (Watchdog timer) : Pour se prémunir contre les erreurs dans le
programme et/ou le matériel. L’horloge de surveillance estutilisée pour réinitialiser le
microcontrôleur en cas d’échec du logiciel ou du matériel.
Pour résumer, un microcontrôleur est un mini-ordinateur qui est équipé d'une mémoire,
minuteries, broches E/S parallèles et d'autres périphériques sur une même puce. L'élément
primordial derrière tout cela est le coût : Intégration de tous les éléments sur une seule puce
permet d'économiser l'espace et conduit à des coûts de fabrication moins élevés et des délais de
développement optimisés. Cela permet d'économiser temps et argent, qui sont deux facteurs
clés dans les systèmes embarqués. D'autres avantages des µC sont l’évolutivité facile, faible
consommation d'énergie, et une plus grande fiabilité, qui sont également des aspects très
importants dans les systèmes embarqués. A la baisse, en utilisant un microcontrôleur pour
résoudre une tâche avec un logiciel qui pourrait également être résolu avec une solution
matérielle ne vous donnera pas la même vitesse que la solution matérielle pourrait atteindre.
Par conséquent, les applications qui nécessitent de très courts temps de réaction peuvent encore
appeler à une solution matérielle. La plupart des applications, cependant, et en particulier ceux
qui exigent une sorte d'interaction humaine, n’ont pas besoin de tels temps de réaction assez
rapides, donc pour ces applications des microcontrôleurs sont un bon choix.

Présentation de la plateforme Arduino
Arduino est le nom d’une entreprise, une communauté et un projet libre (open-source). Ce
projet avait été initié en Italie, dans le but de concevoir et fabriquer des solutions matérielles et
logiciel à faible cout qui faciliteront le développement d’objets interactifs qui peuvent interagir
avec le monde physique. Les cartes Arduino peuvent être achetées préassemblée, ou réalisés
par soi-même (RSM). Les schémas de conception du matériel sont disponibles pour ceux qui
voudraient assembler un Arduino à partir de zéro.
Le microcontrôleur Arduino est un outil facile à utiliser. Ce puissant ordinateur à carte unique
a réussi à se faire une bonne place dans le marché des amateurs ainsi que dans le marché des
professionnels et académiques. Les cartes Arduino sont disponibles en plusieurs saveurs :
Arduino Arduino Arduino

Uno Leonardo Due
Arduino Arduino Arduino

Nano Mega YUN
Ces cartes diffèrent toutes principalement selon les diverses microcontrôleurs 8 bits Atmel
AVR, ou les processeurs ARM 32 bits Atmel, sur lesquels elles sont basées. Elles fournissent
des ensembles de broches numériques et analogiques d'E/S qui peuvent être interfacés à
diverses cartes d'extension et d'autres circuits. Les cartes disposent d'interfaces de
communication série, y compris USB sur certains modèles, pour les le chargement des
programmes à partir d'ordinateurs personnels. Pour la programmation des microcontrôleurs, la
plateforme Arduino fournit un environnement de développement intégré (IDE) qui inclut le
support des langages de programmation C et C++.
La carte Arduino qui nous intéresse est l’Arduino UNO, un kit qui est basé sur le
microcontrôleur ATmega328 (datasheet1) fonctionnant à 5V avec 2K de RAM, 32 Ko de
mémoire flash pour stocker des programmes et une 1Ko de mémoire EEPROM pour le
stockage des paramètres. La vitesse d'horloge est de 16 MHz, ce qui se traduit sur l'exécution
environ 300.000 lignes de code source C par seconde. Un connecteur USB permet de connecter
la carte à l'ordinateur hôte, et une prise d'alimentation DC pour connecter une source
d'alimentation externe de 7 à 12V, par exemple une batterie de 7.4V, lors de l'exécution d'un
programme sans être connecté à l'ordinateur hôte.
L’Arduino UNO en chiffres
Microcontrôleur : ATmega328
Tension de fonctionnement : 5V
Tension d'entrée (recommandé) : 7-12 V
Tension d'entrée (limites) : 6-20V
Broches d’E/S numérique : 14 (dont 6 fournissent la sortie PWM)
Broches d'entrée analogiques : 6
Courant DC par broche d’E/S : 40 mA
Courant DC de la sortie 3,3V : 50 mA
Mémoire Flash : 32 Ko dont 0,5 KB utilisé par bootloader
SRAM : 2 KB
EEPROM : 1 KB
Vitesse d'horloge : 16 MHz
Longueur : 68,6 mm
Largeur : 53,4 mm
Poids : 25 g
La figure suivante représente le schéma synoptique de la carte Arduino UNO :
Référence Broches d’E/S

Bouton de Masse
remise à zéro analogique LED de test numériques
PIN13 (2-13)
Entrée série
Port USB
Échange de
données et
alimentation
Sortie série
ATmega328 ♥
Quartz LED témoin
(Horloge) d’alimentation
Régulateur de Broches
tension ICSP
LEDs témoin
de communication
série
Entrée
d’alimentation
Entrées
Masse Entrée analogiques
Broche de remise Sortie 3.3V
à zéro Sortie 5V régulée d’alimentation

Installation de l’Arduino IDE
L’Arduino IDE est un logiciel libre disponible en téléchargement gratuit 2 pour les systèmes
d’exploitation Linux, Windows et Mac OS X. L’environnement de développement permet
d’éditer les programmes, les compiler et les charger sur la carte Arduino.
Les étapes à suivre pour installer l’Arduino IDE sous Windows s’enchainent comme suit :
1. Repérer le fichier d’installation "arduino-1.6.0-windows.exe" sur votre poste de

travail. Ce fichier est disponible dans le dossier "Arduino Software" sur le CD de la
formation.
2. Avec un clic droit lancez l’installation du logiciel entant qu’administrateur.
3. Suivez les étapes de l’installation naïvement jusqu’à ce que Windows vous demande
l’autorisation pour installer le pilote USB Arduino, une fois que vous acceptez,
l’installation se termine.
Installation du logiciel de simulation ISIS Proteus

Proteus est un outil logiciel permettant la conception électronique assistée par ordinateur
éditée par la société Labcenter Electronics3. Proteus est composé de deux logiciels principaux
: ISIS, permettant entre autres la création de schémas et la simulation électrique, et ARES,
dédié à la création de circuits imprimés. Grâce à des librairies additionnels, ISIS est
également capable de simuler le comportement d'un microcontrôleur (PIC, Atmel, 8051,
ARM, HC11...) et son interaction avec les composants qui l'entourent.
L’installation de la version 7.6 de Proteus se fait comme suit :
1. Repérer le fichier "setup76 Sp4.exe". Et lancer son installation avec un clic droit,
entant qu’administrateur.
2. Acceptez d’installer WinHelp
3. Choisissez d’installer votre clé de licence installée localement.
4. Cliquez sur "Next" pour pouvoir indiquer au gestionnaire de licences le chemin de

votre clé. Cliquer en suite sur "Browse For Key File», indiquez le chemin de la clé,
puis cliquer sur "Install", confirmer avec "Yes" et enfin fermer le gestionnaire de
licence avec "Close".
5. Poursuivez l’installation, mais n’oublier pas de cocher "Converter Files" comme
composante à installer.
6. Amusez-vous à cliquer sur "Next" jusqu’à fin de l’installation.
Pour pouvoir simuler les cartes Arduino plus efficacement, il est nécessaire d’ajouter la
librairie Arduino à ISIS. La démarche suivante permet de le faire :
1. Copier les fichiers "ARDUINO.IDX", "ARDUINO.LIB", "AVR2.IDX", et

"AVR2.LIB" du dossier "Librairie Arduino pour Proteus" et collez-les dans le
dossier : "C:\Program Files (x86)\Labcenter Electronics\Proteus 7
Professional\LIBRARY".
2. Copier le fichier "AVR2.DLL" du dossier "Librairie Arduino pour Proteus" et collez-
le dans le dossier : "C:\Program Files (x86)\Labcenter Electronics\Proteus 7
Professional\MODELS".
Maintenant votre logiciel ISIS est capable de simuler Arduino.
Premier Programme : Blink

Si "Hello world"est le premier programme que vous à apprenez en programmation,
"Blink" est votre premier programme en développement Arduino.
  
 Tout d’abord ouvrez l’Arduino IDE, et allez vers File Examples 01.Basics Blink. 

 Le code source du programme est le suivant :
 void setup() { 
 pinMode(13, OUTPUT); 
} 

void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
 delay(1000); 
} 
Le bouton "Verify" permet de compiler le programme et de générer le fichier
d’extension .hex. Le bouton "Upload" permet de charger le programme sur la mémoire

Flash de la carte Arduino. Mais pour pouvoir simuler l’Arduino sur ISIS, il faut lui indiquer le
chemin du fichier ".hex" ; pour cela nous devons activer une fonctionnalité d’Arduino IDE qui
permet d’afficher le chemin du fichier ".hex".

 Allez vers File Preferences 
 Cochez les deux cases suivantes : 


 Dès maintenant, à chaque fois que vous compilez un programme, la console en bas
d’Arduino IDE vous permettra de récupérer le chemin absolu de votre fichier ".hex". 

Maintenant vous êtes prêt à simuler votre premier programme sous ISIS.
 Réalisez le montage suivant sous ISIS : 
  Indiquer à la carte Arduino le chemin du programme. 

 Lancez la simulation du montage. 
Pour visualiser l’exécution du programme sur la carte Arduino UNO réelle :
 brancher la carte à votre ordinateur. 

 Allez vers l’Arduino IDE, assurer vous le port com correspondant à votre carte est bien

 choisi. Pour cela cliquer sur Tools Port, et choisissez le port convenable. 
 Charger le programme sur la carte en cliquant sur le bouton Upload. 

 Si vous rencontrez des problèmes ou des messages d’erreurs lors de la programmation
de votre carte, fermer Arduino IDE est relancer le entant qu’administrateur. 
La LED de test branchée sur le PIN 13 va commencer à clignoter, désormais vous êtes
développeur Arduino.
Remarque : Vous pouvez débrancher un Arduino sans avoir besoin de l’éjecter.

Timers et interruptions
Les Timers
Le module Timer (minuteur) qui est à proprement parler un module de comptage, est une
partie importante de chaque microcontrôleur. La plupart des µC comportent un ou plusieurs
compteurs avec une résolution de 8 et/ou 16 bits. Les Timers sont utilisés pour une variété de
tâches allant de simples délais à la mesure des périodes des signaux alternatifs. L'utilisation la
plus basique d’un Timer est sa fonction entant que compteur, mais ils permettent également à
l'utilisateur de horodater des événements externes, de déclencher des interruptions après un
certain nombre de cycles d'horloge, et même de générer des signaux modulés en largeur
d'impulsion (PWM) pour le contrôle moteur à titre d’exemple. L’Arduino UNO possède trois
Timers, appelés timer0, timer1 et timer2. Timer0 et timer2 sont de 8 bit, et timer1 est un
minuteur de 16 bits. La différence la plus importante entre les minuteurs 8 bits et 16 bits est la
résolution de l'horloge. 8 bits signifie 256 valeurs et 16bit signifie 65 536 valeurs pour une
résolution plus élevée ou plus compter.
Les fonctions delay(), et millis() utilise timer0 pour permettre d’introduire et de gérer le
temps dans vos programme d’une façon simple et efficace.
La fonction delay()
La fonction Delay() Suspend le programme durant un laps de temps (en millisecondes)

spécifié comme paramètre. (Il y a 1000 millisecondes dans une seconde) .
Exemple :
Un exemple typique qui illustre l’utilité de la fonction delay() est le programme Blink que
nous avons vu précédemment. Dans ce programme le delay permet de maintenir la LED
allumée durant une seconde et de la maintenir éteinte durant la seconde qui suit.
Exercice 1 :
Le but de l’exercice est d’écrire un programme qui fait clignoter une LED avec un delay
graduel au fil du temps ; au début la LED commencera à clignoter à 100ms de pause, et à
chaque itération du programme la pause va se doubler.
Exercice 2 :
Nous voulons réaliser un montage qui permet d’allumer une LED branchée sur le PIN 13
durant 5 secondes une fois un bouton poussoir actionné. Le bouton poussoir est lié au PIN
A0. Réaliser le montage et écrivez le programme approprié.

Exercice 3 :
Réalisez un montage qui permet d’allumer une LED branchée sur le PIN 13 une fois un
bouton poussoir actionné (A0). La LED s’éteint une fois un autre bouton poussoir (A5) est
poussé.
Casse-tête 1 :
Maintenant nous voulons reprendre l’exercice 3 de la façon suivante : une fois que le bouton
ON est actionné la LED doit rester allumée durant 5 secondes, mais à tout instant si le bouton
OFF est poussé la LED doit s’éteindre instantanément.
La fonction millis()
Il est facile de créer un clignotement de la LED avec la fonction delay(), Néanmoins

l'utilisation du delay dans un programme présente des inconvénients importants. Aucune
autre lecture de capteurs, des calculs mathématiques, ou une manipulation de broches ne peut
être effectuée lors de l’exécution de la fonction delay(). Une alternative au delay et la
fonction millis(). Cette fonction retourne le nombre de millisecondes depuis la carte Arduino
a commencé à exécuter le programme jusqu’au moment de l’exécution de la fonction millis().
La valeur de retour de millis() est remise à zéro après 50 jours de fonctionnement.
Exercice 4 :
Réutiliser le même montage qui précède, cette fois pour restreindre le droit de l’utilisateur à
allumer la LED qu’une fois toutes les 20 secondes.
Remarque :
Certaines choses peuvent se passer pendant que la fonction delay() est en contrôle de la puce
Atmega. La fonction de retard ne désactive pas les interruptions, la communication série qui
reçue par la broche RX est enregistrée, les valeurs PWM (analogWrite), les états des broches
sont maintenues et les interruptions fonctionnent comme prévu.

La fonction micros()
Retourne le nombre de microsecondes depuis la carte Arduino a commencé l'exécution du

programme en cours. La fonction a une résolution de 4 microsecondes (Arduino UNO) et sa
valeur de retour est remise à zéro après 70 minutes de fonctionnement.
La fonction delayMicroseconds()
Suspend le programme pour un laps de temps (en microsecondes) spécifié comme paramètre.
Les interruptions
Un programme s’exécute sur un µcontrôleur qui tourne normalement d’une façon séquentielle
: instruction par instruction. Une interruption est un événement extérieur qui interrompt le
programme en cours et exécute un programme spécial (routine d'interruption).
Après la routine d’interruption a été terminé, le programme en cours se poursuit avec
l'instruction suivante. Une Instruction signifie une seule instruction de la machine, et non pas
une ligne de code. Autrement dit une interruption est un réflexe à une excitation, que le µC
doit exécuter sans y réfléchir.
Le processeur au cœur de tout Arduino a deux types d'interruptions: externe et par

changement d’état d’une broche (pin). Il y a seulement deux broches d'interruption externes
sur l’Arduino, INT0 et INT1, et ils sont mappés sur les broches 2 et 3 de la carte. Ces
interruptions peuvent être configurées pour déclencher sur front montant (RISING),
descendant (FALLING), ou zéro logique (LOW). Les déclencheurs sont interprétés par le
matériel, et l'interruption est très rapide.
D'autre part, les interruptions par changement d’état (CHANGE) de broches peuvent être
activées sur beaucoup plus de broches. Pour l’UNO, elles peuvent être activées sur toutes ou
une partie des 20 broches de l'Arduino. Elles sont déclenchées également sur les fronts
montants ou descendants, c’est au code d'interruption de définir les broches qui ont causé
l’interruption, et de déterminer ce qui est arrivé (quelle broche? ... front montant ou
descendant ?), Et de gérer l’interruption correctement.
La fonction noInterrupts()
La fonction noInterrupts() permet de désactiver les interruptions. Les interruptions

sont activées par défauts.
La fonction interrupts()
La fonction interrupts() permet de réactiver les interruptions.
La fonction attachInterropt()

Détermine une routine d'interruption nommé (ISR) pour l’exécuter quand une interruption se
produit. Elle remplace toute fonction précédente qui a été attaché à l'interruption. La plupart
des cartes Arduino ont deux interruptions externes: numéros 0 (sur la broche numérique 2) et
1 (sur la broche numérique 3).
Syntaxe de la fonction : attachInterrupt(interruption, routine, mode)
Interruption : Numéro de l’interruption (0 (pin 2) ou 1 (pin3))
Routine : fonction à appeler une fois que l’interruption se produit. Cette fonction ne doit pas
prendre de paramètres et ne retourne rien.
Mode : LOW, CHANGE, RISING, ou FALLING.
La function detachInterrupt()
Désactive une interruption.

Syntaxe de la fonction: detachInterrupt(interrption)
Interruption : Numéro de l’interruption
Remarque : Typiquement les variables globales sont utilisées pour transmettre des données
entre une routine et le programme principal. Pour s'assurer que les variables utilisées dans une
routine sont correctement mises à jour, déclarez-les comme volatile.
Exercice 5 : Reprenons le casse-tête 1, nous allons nous forcer à le résoudre mais cette fois
sans avoir recourt à la fonction millis() ni aux autres fonction du temps.
Communication série
Utilisé pour la communication entre la carte Arduino et un ordinateur ou d'autres appareils.
Toutes les cartes Arduino ont au moins un port série (également connu comme un UART ou
USART). Il communique sur les broches numériques 0 (Rx) et 1 (TX) et avec l'ordinateur via
USB. Ainsi, si vous utilisez ces fonctions, vous ne pouvez pas utiliser également broches 0 et
1 comme entrée ou sortie numérique.
La fonction begin()

Cette fonction une fois insérée dans la partie setup du programme, permet d’initialiser le port
série de la carte Arduino. La vitesse de transmission des données est donnée en paramètre à la
fonction serial.begin().
Exemple :
void setup() {
Serial.begin(9600);
}
void loop() {}
La fonction println()
Transmet les données au port série sous forme de texte lisible ASCII suivie d'un caractère de
retour chariot (ASCII 13, ou '\ r') et un caractère de nouvelle ligne (ASCII 10, ou '\ n').
Exemple :
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.println(“Hello
world”); delay(500);
}
Exercice 6 :
Réaliser un montage sous ISIS, reliant la carte Arduino à un moniteur série (Virual Terminal).
Le moniteur servira à afficher l’état du bouton poussoir connecté au pin A0 en temps réel.
Exercice 7 :
Même chose que l’exercice 6, sauf que la manipulation doit être faite en utilisant une réelle
carte UNO. Un fil remplacera le bouton poussoir.
La fonction available()
Lorsque la carte Arduino est configurée pour recevoir des données sur le port série, il est
nécessaire de pouvoir vérifier à tout instant si une nouvelle trame de données a été reçue est
prête à être traiter. La fonction Serial.available() permet d’obtenir le nombre d'octets
(caractères) disponibles pour lecture sur port série. Ce sont des données qui ont déjà arrivé et
ont été stockés dans la mémoire tampon de réception série (qui détient 64 octets).
La fonction read()
Lit les données série reçues.

Exercice 8 : (facultatif)
Réalisons un montage de simulation

qui consiste à transmettre des
caractères à la carte Arduino via le
terminal virtuel. Arduino
retransmettra chaque caractère au
terminal virtuel pour qu’il soit
affiché.


Conversion Analogique/Numérique
Les µcontrôleurs ATMega utilisés pour l'Arduino contiennent six canaux de conversion
analogiques-numérique (A/D). Le convertisseur a une résolution de 10 bits, c’est-à-dire que
chaque valeur analogique réelle entre 0 et 5V sera représentée par un nombre entier entre 0 et
1023. La fonction principale des broches analogiques pour la plupart des utilisateurs Arduino
est de lire les capteurs analogiques. Les broches analogiques ont aussi toutes les
fonctionnalités d’entrée/sortie à usage général (GPIO) ; les mêmes que les broches
numériques 0-13.
Entrées analogiques
La fonction analogRead()
Lit la valeur de la broche analogique spécifiée.

Syntaxe :
analogRead(pin)
pin : A0-A5
Exercice 9 :
Pour créer une variation de la tension, nous allons utiliser un potentiomètre raccordé au pin
A0. L’objectif de l’exercice est d’écrire un programme qui permettra de récupérer la valeur
analogique de A0 et de l’afficher sur le terminal virtuel.

Exercice 10 :
Réalisons un montage avec lequel nous pourrons commander l’allumage et l’extinction d’une
LED par degré de luminosité. Pour cela une photorésistance doit être branchée sur l’une des
entrées analogiques. Si la valeur de l’entrée analogique dépasse un seuil donnée la LED doit
s’éteindre et s’allumer dans le cas contraire.
Contrôle de moteurs
L’Arduino comme tout cerveau d’un système embarqué est utilisé dans un éventail
d’applications pour commander et interagir avec des actionneurs mécaniques, parmi lesquels
les moteurs. Ce sont des dispositifs permettant d’effectuer des mouvements physiques à partir
d’énergie (dans notre cas électrique).
Le moteur DC
Les moteurs à courant continu forment une classe des moteurs électriques qui convertit
l'énergie électrique sous forme d’un courant continu en puissance mécanique. Généralement
ces moteurs ont deux bornes, l’application d’une tension continue à ces bornes conduit à la
rotation du moteur dans un sens, l’inversion de la polarité de la tension le conduit à tourner
dans le sens contraire. Actionner un moteur DC dans les deux sens manuellement est si facile,
mais pour automatiser sa commande, c’est là ou intervient l’électronique.
Commande unidirectionnel par transistor
Exercice 12 :
Réalisons un circuit de commande d’un moteur DC 12V unidirectionnel à l’aide d’un

transistor NPN (Darlington) TIP122. Deux boutons poussoirs relié à l’Arduino, seront
responsables de la mise en marche/arrêt du moteur.

Commande unidirectionnel par relai
Reprenons l’exercice 12, mais nous allons

choisir de commander un moteur DC 120V par
un relai au lieu d’un transistor.
Commande bidirectionnel par relai
Réalisons un circuit de commande d’un moteur DC 120V bidirectionnel à l’aide de deux

relais. Deux boutons poussoirs relié à l’Arduino, seront responsables de la mise en marche du
moteur, l’un dans un sens et l’autre dans le sens contraire. Un troisième bouton poussoir
servira à arrêter le moteur.

Commande bidirectionnel par pont H
Un pont en H est un circuit électronique qui permet à une tension appliquée à travers une
charge dans les deux sens. Ces circuits sont souvent utilisés en robotique et autres
applications pour permettre aux moteurs à courant continu de tourner dans les deux sens.
Exemple d’un pond H

Comme le montre la figure ci-dessus le schéma d’un pond H est un peu compliqué à utiliser
surtout si vous voulez contrôler plusieurs moteurs à la fois. Une solution plus simple à utiliser
est le contrôleur de moteur L2984 qui est un double pond H permettant de contrôler deux
moteurs DC à la fois par un seul et unique circuit intégré.
Exercice 15 :
L’exercice vise la réalisation d’un circuit de commande d’un moteur DC 12V bidirectionnel
par le contrôleur L298, avec deux boutons pour les sens, et un bouton pour l’arrêt.
Le servomoteur
Les servomoteurs sont des petits dispositifs électromécaniques en forme de caisson qui
contiennent un moteur à courant continu, un circuit électronique pour commander le moteur
avec un signal, un système d'engrenage pour amplifier le couple de rotation et un
potentiomètre qui fournit l’information sur la position (angle de rotation).
Les servomoteurs sont commandés par l'intermédiaire d'un câble électrique à trois fils (masse,
tension d’alimentation, et le signal) qui permet d’alimenter le moteur et de lui transmettre des
consignes de position sous forme d’un signal codé en largeur d'impulsion plus communément
appelé PWM. Cela signifie que c'est la durée des impulsions qui détermine l'angle absolu de
l'axe de sortie et donc la position du bras de commande du servomoteur. Le signal est répété
périodiquement, en général toutes les 20 millisecondes, ce qui permet à l'électronique de
contrôler et de corriger continuellement la position angulaire de l'axe de sortie, cette dernière
étant mesurée par le potentiomètre. Lorsque le moteur tourne, l'axe du servomoteur change de
position, ce qui modifie la résistance du potentiomètre. Le rôle de l'électronique est de
commander le moteur pour que la position de l'axe de sortie soit conforme à la consigne
reçue.
Commande en largeur d'impulsion
Commande d’un servomoteur SG90 par Arduino
La bibliothèque Servo.h permet à une carte Arduino de contrôler des servomoteurs. Les
servomoteurs intègrent des engrenages et un arbre qui peut être contrôlée avec précision. Les
modèles standards permettent l'arbre d’être positionné à divers angles, généralement entre 0 et
180 degrés (cas du SG90). L'utilisation de la bibliothèque désactive la fonctionnalité
analogWrite() (PWM) sur les broches 9 et 10 même si aucun servomoteur n’est branché.
La fonction attach()
Cette fonction sert à associer un objet "servomoteur" à une broche de l’Arduino.
Syntaxe :
servo.attach(broche) ;
La focntion write()
Commande l’arbre du servomoteur à tourner vers l’angle donné en paramètre (0°-180°).
Syntaxe :
servo.write(angle)
La fonction read()
La fonction servo.read() retourne la valeur de l’angle de l’arbre du moteur (0°-180°).
La fonction detach()
servo.detach() désassocie un servo d’une broche.
Exemple :
#include <Servo.h>
Servo monservo;
void setup()
{
monservo.attach(9);
}
void loop()
{
monservo.write(0);
delay(1000);
monservo.write(90);
delay(1000);
monservo.write(180);
delay(1000);
}
Exercice 16 :
Un mythe marocain dit que si vous demandez à une mante religieuse (insecte) où vous allez
vous marier, elle vous indiquera la direction avec son bras. Nous allons mécaniser le mythe
avec un servomoteur qui nous indiquera une direction aléatoire chaque fois que la broche A0
est mise à la masse.
Le moteur pas-à-pas
Un moteur pas à pas est un moteur commandé par une série de bobines électromagnétiques.
L'arbre central comporte une série d'aimants montés sur elle, les bobines entourant l'arbre sont
excitées à tour de rôle par un courant continu. La création de champs magnétiques qui
repoussent ou attirent les aimants sur l'arbre, provoque la rotation du moteur.
Cette conception permet un contrôle très précis du moteur: par pulsation correcte, il peut être
tourné dans des mesures très précises (généralement 1.8° par pas). Ils sont utilisés dans les
imprimantes, disques durs et autres périphériques où un positionnement précis du moteur est

nécessaire.
Il y a deux types de base de moteurs pas à pas, les moteurs unipolaires et bipolaires :
Moteurs pas à pas unipolaires
Le moteur pas à pas unipolaire a cinq ou six fils et quatre bobines. Les connexions centrales
des bobines sont attachées ensemble et sont utilisés en tant que connexion d'alimentation. Ils
sont appelés steppers unipolaires parce que l’alimentation est toujours connecté au pôle
commun. Une de chaque paire de bobines est activée à un moment donné.
Moteur pas-à-pas unipolaire

Moteurs pas à pas bipolaires
Le moteur pas à pas bipolaire comporte généralement quatre fils. Contrairement aux steppers
unipolaires, les bipolaires n’ont aucune broche commun. Ils ont deux ensembles indépendants
de bobines.

Moteur pas-à-pas bipolaire
Contrôle d’un moteur unipolaire pas-à-pas par Arduino
Les steppers comme les servomoteurs ne peuvent être contrôlé par simple circuiterie
électronique. Avec une carte Arduino vous avez le choix de concevoir un circuit de
commande d’un stepper à base d’un vecteur de transistor Darlington (ULN2004a5) ou d’un
contrôleur de moteur spécialement conçu pour un type de moteur donné, comme le L298n qui
peut aussi servir à contrôler un stepper bipolaire.
La bibliothèque stepper.h d’Arduino offre un jeu de fonctions qui facilite le contrôle d’un
stepper :
La fonction stepper()
Cette fonction crée une nouvelle instance de la classe Stepper qui représente un moteur pas-à-
pas particulier attaché à votre carte Arduino. (A utiliser avant le setup() et loop() ).
Syntaxe :
Stepper(steps, pin1, pin2, pin3, pin4)
Steps : le nombre de pas dans d'une révolution de votre moteur.
pinX : les broches sur lesquels votre stepper est connecté.

La fonction setSpeed()
Règle la vitesse du moteur en tours par minute (RPM).
Syntaxe :
setSpeed(rpms)
rpms : vitesse désirée en tours par minute.
La fonction step()
Syntaxe :
step(steps)
steps : nombre de pas à effectuer.
Exemple de programme :
#include <Stepper.h>
Stepper stepper(4, 8, 9, 10,11);
void setup()
{
stepper.setSpeed(180);
}
void loop()
{
stepper.step(4);
}
Exercice 17 :
Réaliser un circuit de commande d’un stepper unipolaire à l’aide d’un Darlington ULN2004a
et un Arduino UNO. Un bouton poussoir maintenu permettra de tourner le moteur à un pas
chaque seconde dans un sens, un autre bouton poussoir permet de faire la même chose dans
l’autre sens.

Control de puissance par modulation de largeur
d'impulsion (PWM)
PWM est une technique pour contrôler la puissance électrique fournie aux charges (appareils).
Le signal d’alimentation PWM est constitué d’une série d’impulsions sous forme d’un signal
rectangulaire. Si est la durée de l’impulsion, est la période du signal la tension efficace
délivré à la charge est donnée par :
Le rapport est dit : duty cycle et en français : rapport cyclique.
Exemple :
Si nous voulons simuler une tension continue d’une valeur efficace de 2.5V, alors que nous ne
disposons que d’un générateur de tension 5V, la solution PWM consiste à générer un signal
rectangulaire (haute fréquence) avec une durée d’impulsion égale à la moitié de la période du
signal.
1.25V
2.5V
3.75V

La fonction analogWrite()
L’Arduino offre la possibilité de simuler des valeurs de tensions analogique efficaces grâce à
la fonction analogWrite() qui fonctionne sur les broches 3, 5, 6, 9, 10, et 11.
Syntaxe :
analogWrite(pin, value)
pin : identifiant de la broche de sortie.

value : valeur du rapport cyclique entre 0 (0%) et 255 (100%).
Exercice 18 :
Sur votre plaque d’essai réalisez le montage suivant : une LED est attachée au pin numéro 3,
sa luminosité varie en fonction de la valeur analogique lise sur le port A5 connecté à une
photorésistance. En complète obscurité la LED s’éclaircie au maximum, en plein lumière la
LED s’éteint.
Réalisons la simulation d’un montage qui permettra la visualisation du signal PWM sur
oscilloscope virtuel, en agissant sur un potentiomètre.
Casse-tête 2 : (facultatif)
Un moteur DC appel un courant de démarrage important, ce qui peut endommager un circuit

de commande sous dimensionné. Pour pallier à ce problème on se propose de démarrer le
moteur graduellement. Reprenons l’exercice 15. Le montage et le programme doivent être
modifié pour que le bouton de mise en marche du moteur ne l’actionnera pas pour tourner à
pleine puissance instantanément, mais graduellement (PWM), pour atteindre la pleine
puissance au bout de 3 secondes.
Affichage LCD et Clavier matriciel

L’afficheur LCD alphanumérique 16x2
Lorsque l’affichage est nécessaire dans une application, il y a plusieurs options de l’afficheur
LCD couleur, LCD monochrome, aux LEDs individuelles. Toutes ces options ont des avantages
uniques par rapport aux autres. Les LEDs sont les plus simples à mettre en œuvre, mais peuvent
transmettre de l'information limitée. Les afficheur LCD couleur peuvent transmettre une grande
quantité d'informations, mais sont les plus difficiles à mettre en œuvre en plus d'être les plus
chers. Un bon compromis entre un écran LCD couleur et des LEDs est un écran LCD
monochrome. La puce du contrôleur le plus couramment utilisé sur les modules
LCD monochrome est l’Hitachi HD44780.
Le HD44780 est une puce qui reçoit des informations à partir d'un microcontrôleur, puis
utilise ces informations pour afficher des caractères sur l'écran LCD en activant/désactivant
les pixels individuellement.
Les modules LCD monochromes basé sur le HD44780 (ou compatibles) sont disposent
généralement d’une, deux ou 4 lignes, et 16, 20, ou 40 caractères par ligne. Pour plus de
simplicité, nous avons choisi un écran LM016L 16x2: 16 caractères, 2 lignes.

Afficheur LCD LM016L
Les écrans LCD ont une interface parallèle, ce qui signifie que le microcontrôleur doit
manipuler plusieurs broches de l'interface à la fois pour contrôler l'affichage. L'interface se
compose des broches suivantes :
Une broche de sélection (RS) du registre qui contrôle l’emplacement de la mémoire de l'écran
LCD où vous écrivez les données. Vous pouvez sélectionner soit le registre de données, qui
détient ce qui se passe sur l'écran, ou le registre d'instruction, lequel le contrôleur de l'écran
LCD inspecte, pour que les prochaines instructions soient exécutées.
Une broche lecture/écriture (R/W) qui sélectionne le mode lecture ou le mode écriture.
Une broche de validation qui permet l'écriture dans les registres
8 broches de données (D0-D7). Les états de ces broches (haute ou basse) sont les bits qui
définissent ce que sera affiché sur l’écran.
Il y a aussi une broche du contraste de l’affichage (VEE), broches d'alimentation (+5V et

GND) et des broches de rétro-éclairage LED (BKLT+ et BKLT-) que vous pouvez utiliser
pour contrôler le contraste de l'écran, alimenter l'écran LCD, et allumer ou éteindre la LED
rétroéclairage, respectivement.
Le processus de contrôle de l'affichage consiste à mettre les données qui forment l'image de
ce que vous souhaitez afficher dans les registres de données, en mettant ensuite les
instructions dans le registre d'instruction. La Bibliothèque LiquidCrystal d’Arduino
simplifie la tâche, donc vous n’avez pas besoin de connaître les instructions de bas niveau.
Les écrans LCD compatibles Hitachi peuvent être contrôlés en deux modes: 4 bits ou 8-bits.
Le mode 4 bits nécessite sept broches E/S de l'Arduino, tandis que le mode 8 bits nécessite 11
broches. Pour afficher du texte sur l'écran, vous pouvez faire presque tout en mode 4 bits.
La bibliothèque LiquidCrystal
La bibliothèque LiquidCrystal.h permet à une carte Arduino de contrôler les écrans LCD
basés sur la puce Hitachi HD44780 (ou compatible), qui se trouve dans la plupart des écrans
LCD alphanumériques. La bibliothèque fonctionne en mode avec 4 ou 8 bits. Ci-dessous la
listes des fonctions les plus utiles de cette bibliotheque :
LiquidCrystal()
Crée une variable de type LiquidCrystal. L'affichage peut être contrôlé en utilisant quatre ou
huit lignes de données. Si vous choisissez le mode 4 bits, il faut omettre les broches D0 à D3
et laisser ces lignes non connectées. La broche de RW peut être liée à la terre au lieu d’être
connectée à l’Arduino; dans ce cas il faut omettre ce paramètre.
Syntaxe :
LiquidCrystal(RS, ENABLE, D4, D5, D6, D7)
LiquidCrystal(RS, RW, ENABLE, D4, D5, D6, D7)
LiquidCrystal(RS, ENABLE, D0, D1, D2, D3, D4, D5, D6, D7)
LiquidCrystal(RS, RW, ENABLE, D0, D1, D2, D3, D4, D5, D6, D7)
Paramètres :
RS : le numéro de la broche Arduino qui est connecté à la broche RS de l'afficheur.
RW : le numéro de la broche Arduino qui est connecté à la broche RW sur l'écran LCD
(optionnelle).
ENABLE : le numéro de la broche Arduino qui est connecté à la broche ENABLE de l'écran
LCD.
D0, D1, D2, D3, D4, D5, D6, D7: les numéros des broches Arduino qui sont connectés aux
broches de données correspondantes sur l'écran LCD. D0, D1, D2, D3 sont facultatifs; si
omis, l'écran LCD sera contrôlé en utilisant seulement les quatre lignes de données (D4, D5,
D6, D7).
Example :
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 10, 5, 4, 3,2);
void setup()
{
lcd.begin(16,1);
lcd.print("hello, world!");
}
void loop() {}
begin()
Initialise l'interface à l'écran LCD, et précise les dimensions (largeur et hauteur) de

l'affichage. begin() doit être appelée avant toutes les autres commandes de la bibliothèque
LCD.
syntaxe :
lcd.begin(cols,rrows)
paramètres :
lcd : une variable de type LiquidCrystal.
cols : le nombre de colonnes de l’afficheur.
rows : le nombre de lignes.
setCursor()
Sert à placez le curseur de l'écran; c’est-à-dire définir l'emplacement où le texte sera affiché.
Syntaxe :
lcd.setCursor (col, row)
Paramètres :
col : la colonne à laquelle le curseur sera positionné (0 étant la première colonne).
row : la ligne à laquelle le curseur sera positionné (0 étant la première ligne).
print()
Imprime le texte à l'écran LCD.
Syntaxe :
lcd.print (données)
lcd.print (données, BASE)
Paramètres :
Données : les données à imprimer (char, byte, int, long, ou string)
BASE (en option) : la base utilisée pour imprimer les données: BIN pour binaire (base 2),
DEC pour décimal (base 10), octobre pour octal (base 8), HEX pour hexadécimal (base 16).
clear()
Efface l'écran LCD et positionne le curseur dans le coin supérieur gauche.
Syntaxe :
lcd.clear()
Paramètres :
Le tableau suivant indique le brochage d’un écran LM016L avec la carte Arduino Uno :
Broche LCD A connecter à
VSS GND

VDD +5V
VEE +2.5V (potentiomètre)
RS Arduino pin 12
R/W Arduino pin 11
E (ENABLE) Arduino pin 10
D0-D3 Non connectées
D4-D7 Arduino pin 5-2

Exercice 20 :
Sous Proteus, affichez un message clignotant "Hello Tetouan" sur un écran LM016L en
utilisant un Arduino UNO.
Solution :
Simulons un montage qui récupère la valeur analogique VEE (utilisée

pour ajuster le contraste de l’écran) et l’affiche sur l’écran.

Le clavier matriciel 4x3
Quand les boutons est les interrupteurs ne sont pas suffisants pour les exigences d’une
application, un clavier matriciel est une bonne alternative. Il consiste en une matrice de LxC
bouton poussoirs (figure). Quand un bouton de position (li,ci) est actionné, la colonne ci et la
ligne li deviennent reliées. Pour utiliser ce type de clavier avec une carte Arduino vous n’avez
pas besoin d’écrire l’ensemble du protocole qui va se charger de l’interfaçage du clavier, une
bibliothèque pseudo-officielle nommé Keypad.h est disponible pour les développeurs
Arduino. Keypad.h avait été réalisée et entretenue par Mark Stanley, Alexander Brevig depuis
2009, elle est téléchargeable depuis le site officiel arduino.cc.
Clavier matriciel 4x3
Pour installer la bibliothèque Keypad, copier le dossier Keypad (CD de la formation) et coller
le dans l’emplacement suivant :
C:\Users\user\Documents\Arduino
Remarque : remplacez user par vote nom d’utilisateur Windows.
La bibliothèque Keypad
Le constructeur :
Keypad(makeKeymap(userKeymap), row[], col[], rows, cols)
Exemple :
const byte rows = 4; // 4 lignes

const byte cols = 3; // 3
colonnes char keys[rows][cols] =
{
{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'}
};
byte rowPins[rows] = {5, 4, 3, 2}; // indique les numéros
des broches connectées aux lignes du clavier
byte colPins[cols] = {8, 7, 6}; // indique les numéros
des broches connectées aux colonnes du clavier
Keypad keypad = Keypad( makeKeymap(keys), rowPins,
colPins, rows, cols );
Dans cet exemple le constructeur instancie un objet de type clavier qui utilise les broches 5, 4,
3, 2 comme repères des lignes, et 8, 7, 6 que repères des colonnes. Ce clavier dispose de 4
lignes et 3 colonnes, résultant en 12 touches.
Les fonctions utiles :
char getKey()
Renvoie la touche qui est enfoncée, s'il en a une. Cette fonction est non bloquante.
char waitForKey()
Cette fonction attend indéfiniment jusqu'à ce qu’une touche soit actionnée. La fonction
bloque toute autre instruction du code jusqu'à ce qu'une touche soit enfoncée.
Exemple :
#include <Keypad.h>
const byte ROWS = 4;

const byte COLS = 3; char
keys[ROWS][COLS] = {
{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'} };
byte rowPins[ROWS] = {5, 4, 3,
2}; byte colPins[COLS] = {8, 7,
6};
Keypad keypad = Keypad( makeKeymap(keys), rowPins,
colPins, ROWS, COLS );
void setup(){
Serial.begin(9600);
}
void loop(){
char key = keypad.getKey();
if (key != NO_KEY){
Serial.println(key);
}
}
Exercice 22 :
Dans cet exercice nous allons doter L’Arduino d’un clavier matriciel 4x3 de référence
LM016L et d’un écran LCD. Le caractère correspondant à chaque touche enfoncée doit être
affiché sur écran.
En se basant sur le montage précédant, nous allons essayer de mettre en œuvre un système de
vérification d’un mot de passe. La procédure de vérification se déroule comme suit :
L’utilisateur sera invité à entre un code PIN composé de 4 chiffres, au moment où le
quatrième chiffre du mot de passe sera entré, le microcontrôleur le comparera à celui stocké
déjà dans la mémoire programme. Si le code est correct un message "PIN valide" s’affichera,
sinon l’écran affichera "PIN invalide".

Casse-tête 3 : (facultatif)
Reprenons l’exercice 22. Nous allons essayez de modifier le montage (ajouter d’autres
composants passifs) de façon que le clavier matriciel 4x3 n’occupera qu’une seule broche de
l’Arduino au lieu de sept, dans ce cas la bibliothèque Keypad deviendra inutile.

Livret de La formation-ENSA PDF

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Livret de La formation-ENSA PDF

Hochgeladen von

Copyright:

Verfügbare Formate

Embedded Systems Training

Formation sur les Systèmes Embarqués

EL HARRAK HAJRI MOHAMMAD

EL HARRAK HAJRI MOHAMMAD

EL HARRAK HAJRI MOHAMMAD

Tension – ou généralement la différence de potentiel électrique est définie comme la quantité

Résistance - l'opposition à l'écoulement de la charge électrique que toutes les substances

Les systèmes embarqués

EL HARRAK HAJRI MOHAMMAD

EL HARRAK HAJRI MOHAMMAD

Cœur de EEPROM/ Module

EL HARRAK HAJRI MOHAMMAD

Arduino Arduino Arduino

Arduino Arduino Arduino

La figure suivante représente le schéma synoptique de la carte Arduino UNO :

Référence Broches d’E/S

EL HARRAK HAJRI MOHAMMAD

1. Repérer le fichier d’installation "arduino-1.6.0-windows.exe" sur votre poste de

Installation du logiciel de simulation ISIS Proteus

4. Cliquez sur "Next" pour pouvoir indiquer au gestionnaire de licences le chemin de

1. Copier les fichiers "ARDUINO.IDX", "ARDUINO.LIB", "AVR2.IDX", et

Premier Programme : Blink

Le bouton "Verify" permet de compiler le programme et de générer le fichier

d’extension .hex. Le bouton "Upload" permet de charger le programme sur la mémoire

 Cochez les deux cases suivantes : 

EL HARRAK HAJRI MOHAMMAD

  Indiquer à la carte Arduino le chemin du programme. 

EL HARRAK HAJRI MOHAMMAD

La fonction Delay() Suspend le programme durant un laps de temps (en millisecondes)

EL HARRAK HAJRI MOHAMMAD

Il est facile de créer un clignotement de la LED avec la fonction delay(), Néanmoins

EL HARRAK HAJRI MOHAMMAD

Retourne le nombre de microsecondes depuis la carte Arduino a commencé l'exécution du

Le processeur au cœur de tout Arduino a deux types d'interruptions: externe et par

La fonction noInterrupts() permet de désactiver les interruptions. Les interruptions

La fonction interrupts() permet de réactiver les interruptions.

EL HARRAK HAJRI MOHAMMAD

Désactive une interruption.

EL HARRAK HAJRI MOHAMMAD

Lit les données série reçues.

Réalisons un montage de simulation

EL HARRAK HAJRI MOHAMMAD

Lit la valeur de la broche analogique spécifiée.

EL HARRAK HAJRI MOHAMMAD

Réalisons un circuit de commande d’un moteur DC 12V unidirectionnel à l’aide d’un

EL HARRAK HAJRI MOHAMMAD

Reprenons l’exercice 12, mais nous allons

Commande bidirectionnel par relai

Réalisons un circuit de commande d’un moteur DC 120V bidirectionnel à l’aide de deux

EL HARRAK HAJRI MOHAMMAD

Exemple d’un pond H

EL HARRAK HAJRI MOHAMMAD

Commande en largeur d'impulsion

Commande d’un servomoteur SG90 par Arduino

EL HARRAK HAJRI MOHAMMAD

Moteur pas-à-pas unipolaire

EL HARRAK HAJRI MOHAMMAD

Contrôle d’un moteur unipolaire pas-à-pas par Arduino

EL HARRAK HAJRI MOHAMMAD

EL HARRAK HAJRI MOHAMMAD

Le rapport est dit : duty cycle et en français : rapport cyclique.

EL HARRAK HAJRI MOHAMMAD

pin : identifiant de la broche de sortie.