Vous êtes sur la page 1sur 65

Systèmes à base de microprocesseurs

« Arduino »

1
Systèmes à base de microprocesseurs
Architecture d’un système à base de microprocesseur
Un système à base de microprocesseur est formé des trois éléments :

 Une unité CPU (central processing unit )

 Une mémoire (ROM et RAM)

 Des ports d'entrées/sorties.

Les trois modules sont interconnectés comme le montre la figure suivante autour de trois bus : bus de données, bus
d'adresses et bus de contrôles et commandes

2
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
Un microprocesseur est un circuit intégré complexe caractérisé par une très grande intégration et doté des facultés
d'interprétation et d'exécution des instructions d'un programme. Il est chargé d’organiser les tâches précisées par le programme et
d’assurer leur exécution. Il doit aussi prendre en compte les informations extérieures au système et assurer leur traitement. C’est
le cerveau du système.

Un microprocesseur est construit autour de deux éléments principaux :


Une unité de commande : appelé aussi Unité de Commande et de Contrôle (UCC)
Une unité de traitement (unité de calcul)
associés à des registres chargées de stocker les différentes informations à traiter. Ces trois éléments sont reliés entre eux par un
bus interne permettant les échanges d’informations.

3
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
L’unité de commande:
Elle permet de séquencer le déroulement des instructions. Elle effectue la recherche en mémoire de l'instruction. Comme
chaque instruction est codée sous forme binaire, elle en assure le décodage pour enfin réaliser son exécution puis effectue la
préparation de l'instruction suivante. Pour cela, elle est composée par :
 le compteur de programme : (en anglais Program Counter PC) appelé aussi compteur ordinal (CO). Le CO est constitué par un
registre dont le contenu représente l’adresse de la prochaine instruction à exécuter. Il est donc initialisé avec l'adresse de la
première instruction du programme. Puis il sera incrémenté automatiquement pour pointer vers la prochaine instruction à
exécuter;
 le registre d'instruction : Contient l’instruction en cours de traitement;
 le décodeur d'instruction: Permet d’interpréter l’instruction à exécuter;
 Le séquenceur : Permet d'ordonnancer les diverses opérations élémentaires du processeur, nécessaires pour exécuter
l'instruction, grâce à un microprogramme;
 L'horloge : Est un dispositif qui détermine le rythme dans lequel sont exécutées les instructions. Elle fournit un signal régulier
au processeur;
 Le registre d'état : Est un registre particulier. Il représente à tout moment l'état du processeur. En effet, divers évènements
peuvent créer des situations « exceptionnelles ». Par exemple, l'addition de deux valeurs peut dépasser les capacités de
représentation du processeur. Dans ce cas, un bit du registre d'état signale que le processeur est dans l'état « overflow ».
4
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
L’unité de traitement:
C’est le cœur du microprocesseur. Elle regroupe les circuits qui assurent les traitements nécessaires à l'exécution des instructions.

Unité arithmétique et logique : (UAL)


Elle est composée de circuits tels que les additionneurs, soustracteurs, comparateurs logiques…etc., afin d’effectuer les calculs
et les opérations logiques des différents instructions à exécuter, les données à traiter se présentent aux entrées de l’UAL, sont
traités, puis le résultat est fourni en sortie et généralement stocké dans un registre dit accumulateur. Les informations qui
concernent l’opération sont envoyées vers le registre d’état.

5
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
Unité de décodage :
Elle décompose et analyse l’instruction se trouvant dans le registre d’instructions, selon le code opération, elle envoie la nature
des opérations à effectuer à l’unité de commande et précisément le séquenceur qui va ensuite générer les microcommandes
nécessaires aux différents composants participant à l’exécution de l’instruction en cours.

Exemple :

6
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
Les registres du microprocesseur
Un registre est une zone mémoire à l’intérieur du microprocesseur de faible taille, qui permet de mémoriser des mot mémoires
ou des adresses d’une façon temporaire lors de l’exécution des instructions.
Les registres généraux :
Ce sont des mémoires rapides, à l'intérieur du microprocesseur, qui permettent à l'unité d'exécution de manipuler des données à
vitesse élevée. Ils sont connectés au bus données interne au microprocesseur. L'adresse d'un registre est associée à son nom (on
donne généralement comme nom une lettre A,B,C...) Ces registres permettent de sauvegarder des informations utilisées dans les
programmes ou des résultats intermédiaires, cela évite des accès à la mémoire, accélérant ainsi l’exécution des programmes.
Les registres généraux sont à la disposition du programmeur qui a normalement un choix d’instructions permettant de les
manipuler comme:

 Chargement d’un registre à partir de la mémoire ou d’un autre registre;

 Enregistrement dans la mémoire du contenu d’un registre;

 Transfert du contenu d’un registre dans l’accumulateur et vice versa;

 Incrémentation ou décrémentation d’un registre. 7


Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
Les registres du microprocesseur
Le compteur ordinal : (pointeur de programme PC)
Il contient l'adresse de l'instruction à rechercher en mémoire. L'unité de commande incrémente le compteur ordinal (PC) du
nombre d'octets sur lequel l'instruction, en cours d'exécution, est codée. Le compteur ordinal contiendra alors l'adresse de
l'instruction suivante.
Exemple :

(PC)=10000H ; il pointe la mémoire qui contient l'instruction MOV C,B qui est codée sur deux octets (89D9H) ; l'unité de
commande incrémentera de deux le contenu du PC : (PC) = 10002H (la mémoire sera supposée être organisée en octets).

8
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
Les registres du microprocesseur
Le registre d’instruction :
Il contient l’instruction qui doit être traitée par le microprocesseur, cette instruction est recherchée en mémoire puis placée
dans ce registre pour être décodée par le décodeur et préparée pour l’exécution.
Exemple:
ADD A,B cette instruction correspond à un ordre donné à l’ordinateur en langage assembleur qui permet de faire l’addition
entre les données A et B.
Toute instruction présente en fait deux types d’informations :
 Ce qu’il faut faire comme action (addition, division …)
 Avec quelles données réaliser cette action.

 Zone opération : Cette zone permet de déterminer la nature de l’opération à effectuer par le microprocesseur.
 Zone adresse : Contient les adresses en mémoire des opérandes qui participent dans une opération, dans certains cas elle
contient l’opérande même. Il existe plusieurs modes d’adressages pour accéder aux données. 9
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
Les registres du microprocesseur
Le registre d’adresse :
C’est un registre qui contient l’adresse du mot à accéder en mémoire centrale. A chaque accès mémoire, l’adresse recherchée est
stockée dans ce registre. Il a la taille d’une adresse qui est la même que celle du bus d’adresses ce qui permet de déterminer le
nombre de mots mémoires adressables et l’espace mémoire adressable.
Le registre mot mémoire ou registre de données
Il contient le mot mémoire faisant objet d’une opération de lecture ou d’écriture dans la mémoire centrale. Ce registre a la taille
d’un mot mémoire qui est la même que celle des registres de travail et l’accumulateur qui est égale à la taille du bus de données.

Lecture : l’adresse du mot à lire est transférée au registre d’adresse, le


dispositif d’accès à la mémoire se charge de chercher le mot et de le mettre
dans le registre mot mémoire.
Ecriture : le registre d’adresse est chargé par l’adresse mémoire ou on va écrire,
le mot à écrire est placé dans le registre mot mémoire. Lorsque l’ordre de
l’écriture est donné, le contenu des cases mémoires sera écrasé et remplacé par la
nouvelle valeur. Par contre, en cas de lecture, le contenu des cases mémoire n’est
pas détruit.
10
Systèmes à base de microprocesseurs
Architecture d’un microprocesseur
Les registres du microprocesseur
Le registre d’état: (PSW program status word)
C’est un registre qui contient les différents bits appelés drapeaux (Flags) indiquant l’état d’une condition particulière dans le CPU.
Ces bits peuvent être testés par un programme et donc décider des suites d’actions à prendre.

Le registre pointeur de pile : (Stack Pointer)


Il contient l'adresse de la pile. Celle-ci est une partie de la mémoire, elle permet de stocker des informations (le contenu des
registres) relatives au traitement des interruptions et des sous programmes

Structure Von Neuman:


Un microprocesseur basé sur une structure Von Neuman stocke les
programmes et les données dans la même zone mémoire.
Structure Harvard:
Cette structure se distingue de l’architecture Von Neuman uniquement
par le fait que les mémoires programmes et données sont séparées.
L’accès à chacune des deux mémoires se fait via un chemin distinct.
Cette organisation permet de transférer une instruction et des données
simultanément, ce qui améliore les performances. 11
Systèmes à base de microprocesseurs
Microcontrôleur
Le microcontrôleur est un dérivé du microprocesseur. Sa structure est celle des systèmes à base de microprocesseurs. Il est donc
composé en plus de l’unité centrale de traitement, d’une mémoire (mémoire vive RAM et mémoire morte ROM), une (ou
plusieurs) interface de communication avec l’extérieur matérialisé par les ports d'entrée/sortie.
En plus de cette configuration minimale, les microcontrôleurs sont dotés d'autres circuits d’interface qui vont dépendre du
microcontrôleur choisi à savoir:
 les systèmes de comptage (TIMER);
 les convertisseur analogique/numérique (CAN);
 Gestion d’une liaison série ou parallèle;
 un Watchdog (surveillance du programme);
 une sortie PWM (modulation de largeur d’impulsion).

12
Systèmes à base de microprocesseurs
Microcontrôleurs
Plusieurs Constructeurs se partagent le marché des microcontrôleurs, citons INTEL, MOTOROLA, SEAGATE-THOMSON,
AMTEL, ZILOG, PHILIPS et enfin MICROCHIP

Les µC sont basés sur 2 architectures possibles, Von Neuman (INTEL80XX, motorolaHC05, HC08 et HC11, ou ZILOG Z80) ou
Harvard (PIC).

13
Arduino
Arduino
Arduino est la marque d'une plateforme de prototypage open-source qui permet aux utilisateurs de créer des objets électroniques
interactifs à partir de cartes électroniques matériellement libres sur lesquelles se trouve un microcontrôleur (d'architecture Atmel
AVR comme l'Atmega328p, et d'architecture ARM comme le Cortex-M3 pour l'Arduino Due).

Le microcontrôleur peut être programmé pour analyser et produire des signaux électriques, de manière à effectuer des tâches très
diverses comme la domotique (le contrôle des appareils domestiques : éclairage, chauffage…), le pilotage d'un robot,
de l'informatique embarquée, etc.

14
Arduino
Types de cartes Arduino
Les cartes Arduino sont conçues pour réaliser des prototypes et des maquettes de cartes électroniques pour l’informatique
embarquée. Ces cartes permettent un accès simple et peu couteux à l’informatique embarquée. De plus, elles sont entièrement
libres de droit, autant sur l’aspect du code source (Open Source) que sur l’aspect matériel (Open Hardware). Ainsi, il est possible à
tout utilisateur de refaire sa propre carte Arduino dans le but de l’améliorer ou d’enlever des fonctionnalités inutiles à son projet.
Le langage Arduino se distingue des langages utilisés dans l’industrie de l’informatique embarquée par sa simplicité. En effet,
beaucoup de librairies et de fonctionnalités de base sont disponibles ce qui permet de faciliter la réalisation des prototypes ou des
petites applications.

Les cartes Arduino font partie de la famille des microcontrôleurs. Un microcontrôleur est une petite unité de calcul accompagné
de mémoire, de ports d’entrée/sortie et de périphériques permettant d’interagir avec son environnement. Parmi les périphériques,
on trouve généralement des Timers, des convertisseurs analogique-numérique, des liaisons Séries, etc. Les microcontrôleurs sont
inévitables dans les domaines de l’informatique embarquée, de l’automatique et de l’informatique industrielle. Ils permettent de
réduire le nombre de composants et de simplifier la création de cartes électroniques dédiées à la commande de processus
industriels.

Il existe plusieurs types de cartes arduino qui se distingue l’une de l’autre principalement par le type du microcontrôleur utilisé,
le nombre d’entrées/sorties, la capacité de la mémoire et la vitesse de fonctionnement. On peut citer à titre indicatif l’arduino
UNO, Mega, Leonardo, Due, Pro mini, micro, Nano, …

15
Arduino
Types de cartes Arduino
Les cartes arduino les plus répandues pour les applications courantes sont la carte UNO et la carte Mega dont les principales
caractéristiques sont données au tableau suivant :

Caractéristiques techniques de l’Arduino UNO


L’Arduino UNO est la première version stable de carte Arduino. Elle possède toutes les fonctionnalités d’un microcontrôleur
classique en plus de sa simplicité d’utilisation.
Elle utilise une puce ATmega328P cadencée à 16Mhz. Elle possède 32ko de mémoire flash destinée à recevoir le programme,
2ko de SRAM (mémoire vive) et 1ko d’EEPROM (mémoire morte destinée aux données). Elle offre 14 pins (broches)
d’entrée/sortie numériques (données acceptées 0 ou 1) dont 6 pouvant générer des PWM (Pulse Width Modulation,). Elle permet
aussi de mesurer des grandeurs analogiques grâce à ces 6 entrées analogiques. Chaque broche est capable de délivré un courant de
40mA pour une tension de 5V. Cette carte Arduino peut aussi s’alimenter et communiquer avec un ordinateur grâce à son port USB.
On peut aussi l’alimenter avec unes alimentions comprise en 7V et 12V via son connecteur Jack.
16
Arduino
Présentation de la carte Arduino UNO

17
Arduino
Brochage externe de la carte Arduino UNO

18
Arduino
Brochage interne de la carte Arduino UNO

19
Arduino
Schéma simplifié de la carte Arduino UNO

20
Arduino
Vue du dessus, la carte fournit les informations suivantes:

Equivalences par apport au schéma précédant :

 (connecteur) Numéros 0 à 7 ↔ Broches PD0 à PD7 (microcontrôleur)


 (connecteur) Numéros 8 à 13 ↔ Broches PB0 à PB5 (microcontrôleur)
 (connecteur) ANALOG IN 0 à 5 ↔ Broches PC0 à PC5 (microcontrôleur)
21
Arduino
Microcontrôleur ATMEL ATMega328

Le microcontrôleur de la carte Arduino UNO est un ATMega328. C'est


un microcontrôleur ATMEL de la famille AVR 8bits.

Les principales caractéristiques sont :

FLASH : mémoire programme de 32Ko


SRAM :données (volatiles) 2Ko
EEPROM : données (non volatiles) 1Ko

Digital I/O (entrées-sorties Tout Ou Rien) : 3 ports PortB, PortC,


PortD (soit 23 broches en tout I/O)

Timers/Counters : Timer0 et Timer2 (comptage 8 bits), Timer1


(comptage 16bits). Chaque timer peut être utilisé pour générer des
signaux PWM. (6 broches OCxA/OCxB)

Plusieurs broches multi-fonctions : Certaines broches peuvent avoir plusieurs fonctions différentes, choisies par programmation.
Elles ont alors plusieurs noms sur le brochage.

22
Arduino
Microcontrôleur ATMEL ATMega328
Exemples de fonctions des broches:
PWM(Pulse Width Modulation): 6 broches OC0A(PD6), OC0B(PD5), 0C1A(PB1),
OC1B(PB2), OC2A(PB3), OC2B(PD3)

Analog to Digital Converter (résolution 10bits) : 6 entrées multiplexées ADC0(PC0) à


ADC5(PC5)

Gestion bus I2C (TWI Two Wire Interface) : le bus est exploité via les broches
SCL(PC5)/SDA(PC4).

Port série (USART) : Emission/réception série via les broches TXD(PD1)/RXD(PD0)

Comparateur Analogique : broches AIN0(PD6) et AIN1 (PD7)

Gestion d'interruptions:
– Interruptions liées aux entrées INT0 (PD2) et INT1 (PD3) – Interruptions sur changement d'état des broches PCINT0 à PCINT23
– Interruptions liées aux Timers 0, 1 et 2 – Interruption liée au comparateur analogique – Interruption de fin de conversion ADC
– Interruptions du port série USART – Interruption du bus TWI (I2C)

23
Arduino
Présentation du logiciel
IDE Arduino
Un IDE (environnement de développement) libre et gratuit est
distribué sur le site d’Arduino (compatible Windows, Linux et Mac).

1 : Editeur de code.
2 : Barre d’outils rapide.
3 : Barre de menus.
4 : Console d’affichage.

Langage Arduino
Le langage Arduino est inspiré de plusieurs langages. On retrouve
notamment des similarités avec le C, le C++, le Java et le Processing. Le
langage impose une structure particulière typique de l’informatique
embarquée. La fonction setup contiendra toutes les opérations nécessaires à
la configuration de la carte (directions des entrées sorties, débits de
communications série, etc.). La fonction loop elle, est exécutée en boucle
après l’exécution de la fonction setup. Elle continuera de boucler tant que la
carte n’est pas mise hors tension ou redémarrée (par le bouton reset).
24
Arduino
Applications (Arduino Uno)
Gestion des entrées/sorties
pinMode(broche, mode)
Configure la broche spécifiée pour qu'elle se comporte soit en entrée, soit en sortie.
Paramètres:
broche: le numéro de la broche de la carte Arduino dont le mode de fonctionnement (entrée ou sortie) doit être défini.
mode: soit INPUT (entrée en anglais) (=0) ou OUTPUT (sortie en anglais) (=1)

digitalWrite(broche, valeur)
Met un niveau logique HIGH (HAUT en anglais) ou LOW (BAS en anglais) sur une broche numérique. Si la broche a été
configurée en SORTIE avec l'instruction pinMode().
Paramètres:
broche: le numéro de la broche de la carte Arduino
valeur : HIGH ou LOW (ou bien 1 ou 0)
digitalRead(broche)
Lit l"état (= le niveau logique) d'une broche précise en entrée numérique, et renvoie la valeur HIGH ou LOW.
Paramètres:
broche : le numéro de la broche numérique que vous voulez lire. 25
Arduino
Applications (Arduino Uno)
Gestion des entrées/sorties
Autre méthode de configuration:
Les broches de la carte arduino UNO sont divisées en 3 groupes (ports) de la façon suivante :

 Port D : comprend les 8 pins de 0 à 7;


 Port B : comprend les 6 pins de 8 à 13;
 Port C : comprend les 6 pins de A0 à A5.

Pour définir la direction d’un port (entrée ou sortie) on utilise un registre de direction pour chaque port (DDRB, DDRC ou
DDRD) :

Exemple:
DDRD = 0B00001111 : Permet de configurer les 4 pins (0 à 3) du port D en sortie et les 4 pins (4 à 7) du même port en entrée.
C’est-à-dire les broches de 0 à 3 de la carte Arduino sont configurées en sortie et les broches de 4 à 7 en entrée

Autres syntaxes:
DDRD = 0X0F ; (en hexadécimal)
DDRD = 15 . (en décimal)
26
Arduino
Applications (Arduino Uno)
Gestion des entrées/sorties
Exemple: Clignotement d’une Led par appui sur un bouton

27
Arduino
Applications (Arduino Uno)
Gestion du temps
Le langage Arduino fournis quelques fonctions permettant de gérer le temps. Il est possible donc d’insérer une pause dans le
programme pendant une certaine durée. Pour cela, on utilise les fonctions delay et delayMicroseconds qui insère une pause
suivant le paramètre passé (en milliseconde pour l’un, en microseconde pour l’autre). Cependant ces fonctions bloquent le
microcontrôleur, on ne peut alors plus effectuer aucune action.
En plus d’insérer une pause, il est possible de mesurer le temps. De la même manière que les fonctions de délai, on utilise les
fonctions millis et micros qui donnent le nombre de millisecondes (respectivement microsecondes) depuis le lancement de la
carte. Attention, ces fonctions incrémente une variable (interne sur 32 bits). Ces variables se remettent à zéro une fois le maximum
atteint (overflow). La variable utilisée pour les millisecondes atteint sont maximum au bout de 49 jours et 17 heures et la variable
utilisée pour les microsecondes au bout de 71 minutes et 34 secondes environ. Il faut donc faire attention lors de l’utilisation de
ces fonctions pour des utilisations longues durées.

delay(ms)
Réalise une pause dans l'exécution du programme pour la durée (en millisecondes) indiquée en paramètre.

delayMicroseconds(us)
Stoppe le programme pendant la durée (en microsecondes) spécifiées en paramètres.
Exemple: voir programme précédent (clignotement d’une Led) 28
Arduino
Applications (Arduino Uno)
Gestion du temps
variable_unsigned_long=millis();
Renvoie le nombre de millisecondes depuis que la carte Arduino a commencé à exécuter le programme courant. Ce nombre
débordera (càd sera remis à zéro) après 50 jours approximativement.
variable_unsigned_long=micros();
Renvoie le nombre de microsecondes depuis que la carte Arduino a démarré le programme en cours. Ce nombre déborde (repasse
à 0) après approximativement 70 minutes.

Exemple:

29
Arduino
Applications (Arduino Uno)
Gestion du temps
Exemple:

30
Arduino
Applications (Arduino Uno)
Affichage
Afficheur 7 segments
Exemple: Compteur décimal

31
Arduino
Applications (Arduino Uno)
Affichage
Afficheur 7 segments
Exemple: Affichage multiplexé

32
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
Les afficheurs de caractères à cristaux liquides LCD sont des modules préfabriqués qui contiennent des pilotes inclus. Ces
écrans disposent d'un bus de données et un bus de commande pour la manipulation de ces composants. Le logiciel Arduino
dispose d'une bibliothèque prédéfinie pour contrôler les LCD.

33
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
Les LCD sont fabriqués dans différentes formes et couleurs, ils sont disponibles avec des écrans verts, bleu et jaune, avec des
distributions de caractères sous forme de matrice comme les LCD 2 lignes, 16 colonnes. Ceux-ci sont connus comme 2x16, de la
même manière on peut trouver des 1x16, 2x16, 2x8, 2x20, 4x20,… .

34
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
Brochage:

VDD : Alimentation +5V


VSS : Masse (0v)
VEE : Cette tension permet, en la faisant varier entre 0 et +5V, le réglage du contraste de l'afficheur.
RS : Selection du registre (Register Select)
Grâce à cette broche, l'afficheur est capable de faire la différence entre une commande et une donnée. Un niveau bas indique
une commande et un niveau haut indique une donnée.
R/W : Lecture ou écriture (Read/Write)
0 : Écriture
1 : Lecture
E : Entrée de validation (Enable) active sur front descendant.
D0…D7 : Bus de données

35
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
L'implémentation de l'afficheur LCD, requiert l'utilisation des instructions et des commandes séquentielles pour la
configuration et l’utilisation de l’afficheur, cependant, la bibliothèque de LiquidCrystal minimise ce travail, car elle se charge de
faire tous ces réglages.
La librairie fonctionne aussi bien en mode 4 bits qu'en mode 8 bits (càd utilisant 4 ou 8 broches numériques en plus des
broches de contrôle RS, Enable et RW (optionnel)). Ainsi, en mode 4 bits, 6 broches numériques de la carte Arduino suffisent
pour contrôler un afficheur LCD alphanumérique.
LiquidCrystal
Crée une variable de type LiquidCrystal en définissant les broches utilisées avec le LCD et son mode de fonctionnement.
L'afficheur LCD peut être contrôlé avec 4 ou 8 lignes de données. La broche RW peut-être connectée à la masse (0V) au lieu
d'être connectée à une broche de la carte Arduino.

Syntaxe:
Plusieurs formes sont possibles : les broches omises déterminent le mode de fonctionnement utilisé:
LiquidCrystal lcd(rs, enable, d4, d5, d6, d7); // mode 4 bits - RW non connectée
LiquidCrystal lcd(rs, rw, enable, d4, d5, d6, d7); // mode 4 bits - RW utilisée
LiquidCrystal lcd(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7); // mode 8 bits - RW non connectée
LiquidCrystal lcd(rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7); //mode 8 bits - RW utilisée 36
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
LiquidCrystal

Paramètres:
 lcd: le nom de la variable LiquidCrystal déclarée;
 rs: le numéro de la broche de l'Arduino qui est connecté à la broche RS de l'afficheur LCD;
 rw: le numéro de la broche de l'Arduino qui est connecté à la broche RW de l'afficheur LCD (optionnel);
 enable: le numéro de la broche de l'Arduino qui est connecté à la broche E(Enable) de l'afficheur LCD;
 d0, d1, d2, d3, d4, d5, d6, d7: le numéro de la broche de l'Arduino qui est connecté aux broches correspondantes des broches
de données de l'afficheur LCD. Les broches de données d0, d1, d2 et d3 sont optionnelles; si
elles sont omises, le LCD pourra être contrôlé en utilisant seulement les quatre broches de
données d4, d5, d6 et d7 (mode 4 bits).

Quelques instructions
Initialisation
lcd.begin(colonnes, lignes);

Spécifie les dimensions de l'afficheur LCD (nombre de colonnes et nombre de lignes).


37
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
LiquidCrystal
Quelques instructions
lcd.begin(colonnes, lignes);

Paramètres:
 lcd: une variable de type LiquidCrystal
 colonnes: le nombre de colonnes de l'afficheur LCD utilisé.
 lignes: le nombre de lignes de l'afficheur LCD utilisé.
lcd.print("texte");
lcd.print(data); Affiche texte et nombre sur l'afficheur LCD.
lcd.print(data, BASE);
 lcd : une variable de type LiquidCrystal;
 "texte" : une chaîne de caractères;
Paramètres:  data : la donnée à afficher (char, byte, int, long, float);
 BASE (optionel): la base dans laquelle vous voulez afficher les nombres : BIN pour binaire (base 2),
DEC pour décimal (base 10 - base par défaut), OCT pour octal (base 8) et HEX pour
hexadécimal (base 16). 38
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
LiquidCrystal
Quelques instructions

lcd.setCursor(colonne, ligne);

Positionne le curseur de l'afficheur LCD à la localisation voulue (colonne,ligne), et donc définit la position à laquelle le texte
sera dorénavant affiché à l'écran.

Paramètres:

 lcd: une variable de type LiquidCrystal;

 colonne: la colonne à laquelle positionner le curseur (0 est la 1ère colonne, 1 la 2ème, etc..);

 ligne: la ligne à laquelle positionner le curseur ( 0 est la 1ère ligne, 1 la 2ème, etc..).

39
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
LiquidCrystal
Quelques instructions

Exemple:

40
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
LiquidCrystal
Quelques instructions
lcd.write(data);
Ecrit un caractère sur l'afficheur LCD.

Paramètres:
 lcd: une variable de type LiquidCrystal;
 data: le caractère à écrire sur l'écran.

lcd.clear();
Efface l'écran et positionne le curseur dans le coin supérieur gauche de l'écran.
Paramètres:
 lcd: une variable de type LiquidCrystal

41
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
LiquidCrystal
Quelques instructions
lcd.write(data);
Exemple:

42
Arduino
Applications (Arduino Uno)
Affichage
Afficheur LCD
LiquidCrystal
Quelques instructions
lcd.clear();
Exemple:

43
Arduino
Applications (Arduino Uno)
Interruptions
Une interruption est un événement qui provoque l’arrêt d’un programme en cours d’exécution pour aller exécuter un
autre programme appelé programme d’interruption ou routine d’interruption encore une ISR pour Interrupt Service
Routine en anglais. A la fin du programme d’interruption, le microcontrôleur reprend le programme principal à
l’endroit où il s’est arrêté.
On distingue deux types d’interruptions :
 Les interruptions externes, qui sont déclenchées lorsqu’un événement extérieur se produit tels que le changement
d’état d’une entrée destinée à l’interruption.
 Les interruptions internes, qui sont déclenchées par le déroulement du programme tel que le débordement d’un
Timer.
Atmega328 qui équipe l’Arduino Uno possède 26 interruptions différentes. Chaque interruption possède un niveau de priorité au
sein du microcontrôleur.

L'interruption possédant le numéro de vecteur le


plus faible dispose de la priorité la plus haute et
est exécutée la première.

44
Arduino
Applications (Arduino Uno)
Interruptions
Interruptions externes INT0 et INT1

attachInterrupt (interruption, fonction, mode);


Spécifie la fonction à appeler lorsqu'une interruption externe survient. La plupart des cartes Arduino ont deux interruptions externes
: interruption externe n°0 sur la broche numérique 2 et interruption externe n°1 sur la broche numérique 3. La carte Arduino
Mega en possède quatre de plus : interruption externe n°2 sur la broche 21, n°3 sur la broche 20, n°4 sur la broche 19 et n°5 sur la
broche 18.
Paramètres:
 interruption : le numéro de l'interruption (type int)
 fonction: la fonction à appeler quand l'interruption survient; la fonction doit recevoir aucun paramètres et ne renvoie rien.
Cette fonction est également appelée une routine de service d'interruption (ou ISR).
 Mode: définit la façon dont l'interruption externe doit être prise en compte. Quatre constantes ont des valeurs prédéfinies
valables:
 LOW : pour déclenchement de l'interruption lorsque la broche est au niveau BAS
 CHANGE : pour déclenchement de l'interruption lorsque la broche change d'état BAS/HAUT
 RISING : pour déclenchement de l'interruption lorsque la broche passe de l'état BAS vers HAUT (front montant)
 FALLING : pour déclenchement de l'interruption lorsque la broche passe de l'état HAUT vers l'état BAS (front descendant)
45
Arduino
Applications (Arduino Uno)
Interruptions
Interruptions externes INT0 et INT1
detachInterrupt(interruption);
Désactive l'interruption externe spécifiée

Paramètres:
 interruption: le numéro de l'interruption externe à désactiver.

noInterrupts();

Désactive les interruptions.

interrupts();

Réactive les interruptions (après qu'elles aient été désactivée par l'instruction noInterrupts().

46
Arduino
Applications (Arduino Uno)
Interruptions
Interruptions externes INT0 et INT1
Exemple: L’allumage d’une Led à l’arrivé d’une interruption sur la broche 3

47
Arduino
Applications (Arduino Uno)
Convertisseur analogique numérique(CAN ou ADC)
Principes et caractéristiques
Un convertisseur CAN permet de convertir une tension analogique, comprise entre deux tension de référence Vref- et Vref+, en
une valeur numérique N sur n bits

Les étapes de conversion:


L’échantillonnage:
 Action de prélever la valeur du signal à intervalle fixe et répétitif
 Fréquence des échantillons: Te
48
Arduino
Applications (Arduino Uno)
Convertisseur analogique numérique(CAN ou ADC)
Principes et caractéristiques
Les étapes de conversion:
L’échantillonnage:

Le blocage:
 Temps de conversion non nul
 Maintien de la valeur pendant ce temps

49
Arduino
Applications (Arduino Uno)
Convertisseur analogique numérique(CAN ou ADC)
Principes et caractéristiques
Les étapes de conversion:
Les différents signaux d’un CAN

 Le signal à convertir (si périodique T)


 Signal échantillonné (période d’échantillonnage Te)
 L’horloge du convertisseur Tconv
50
Arduino
Applications (Arduino Uno)
Convertisseur analogique numérique(CAN ou ADC)
Principes et caractéristiques
La résolution et quantum
 Quantum ou LSB: Incrément de tension d'entrée produisant une variation d'une unité du résultat de la conversion .

q=(Vref+ - Vref-)/ 2n pour un convertisseur n bits


 Résolution: nombre de « points » =2n

51
Arduino
Applications (Arduino Uno)
Convertisseur analogique numérique(CAN ou ADC)
Instructions
analogRead(broche_analogique);
Lit la valeur de la tension présente sur la broche spécifiée. La carte Arduino Uno comporte 6 voies (8 voies sur la Mini et la Nano)
connectées à un convertisseur analogique-numérique 10 bits. Cela signifie qu'il est possible de transformer la tension d'entrée entre
0 et 5V en une valeur numérique entière comprise entre 0 et 1023. Il en résulte une résolution (écart entre 2 mesures) de : 5 volts /
1024 intervalles, autrement dit une précision de 0.0049 volts (4.9 mV) par intervalle.
Paramètres
 broche_analogique : le nom de la broche sur laquelle il faut convertir la tension analogique appliquée
Exemple:

52
Arduino
Applications (Arduino Uno)
Convertisseur analogique numérique(CAN ou ADC)
Instructions
analogRead(broche_analogique);
Exemple: Voltmètre

53
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
La librairie Serial est utilisée pour les communications par le port série entre la carte Arduino et un ordinateur ou d'autres
composants. Toutes les cartes Arduino ont au moins un port Série ( également désigné sous le nom de UART ou USART). Ce port
série communique sur les broches 0 (RX) et 1 (TX) avec l'ordinateur via le port USB.
La carte Arduino Mega dispose de trois port série supplémentaires : Serial1 sur les broches 19 (RX) et 18 (TX), Serial2 sur les
broches 17 (RX) et 16 (TX), Serial3 sur les broches 15 (RX) et 14 (TX).
Les fonctions de la librairie
Serial.begin(debit);

 Fixe le débit de communication en nombre de caractères par seconde (l'unité est le baud) pour la communication série.
 Pour communiquer avec l'ordinateur, utiliser l'un de ces débits : 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400,
57600, or 115200. On peut, également, spécifier d'autres débits - par exemple, pour communiquer sur les broches 0 et 1 avec
un composant qui nécessite un débit particulier.

Paramètres
 int debit: debit de communication en caractères par seconde (ou baud).

54
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Les fonctions de la librairie
Serial.available();
Donne le nombre d'octets (caractères) disponible pour lecture dans la file d'attente (buffer) du port série.

Valeur renvoyée
Le nombre d'octet disponible pour lecture dans la file d'attente (buffer) du port série, ou 0 si aucun caractère n'est disponible. Si
une donnée est arrivée, Serial.available() sera supérieur à 0. La file d'attente du buffer peut recevoir jusqu'à 128 octets.

Serial.read();

Lit les données entrantes sur le port Série.


Valeur renvoyée
 Renvoi le premier octet de donnée entrant disponible dans le buffer du port série, ou -1 si aucune donnée n'est disponible.

 L'octet lu est « enlevé » de la file d'attente. Le prochain appel de la fonction read() lira l'octet suivant, etc...

55
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Les fonctions de la librairie
Serial.print(val);
Serial.print(val, format);

Affiche les données sous le port série sous forme lisible (texte ASCII). Cette instruction peut prendre plusieurs formes.

 Les nombres entiers sont affichés en utilisant les caractères ASCII pour chaque chiffre.
 Les nombres à virgules (float) sont affichés de la même façon sous forme de caractères ASCII pour chaque chiffre, par défaut
avec 2 décimales derrière la virgule.
 Les valeurs de type byte sont affichés sous la forme d'un caractère ASCII.
 Les caractères et les chaînes sont affichés tels que.
Exemples:

Serial.print(78); // affiche "78"


Serial.print(1.23456); // affiche "1.23"
Serial.print(byte(78)); // affiche "N" (dont la valeur ASCII est 78)
Serial.print('N'); // affiche "N"
Serial.print("Hello world."); // affiche "Hello world."
56
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Les fonctions de la librairie
Serial.print(val);
Serial.print(val, format);

Paramètres:
 val: la valeur à afficher. N'importe quel type de données;
 format : spécifie la base utilisée(pour les nombres entiers) ou le nombre de décimales (pour les nombres de type float).
serial.write(val);
serial.write(str);
serial.write(buf, len);

Ecrit des données binaires sur le port série. Ces données sont envoyées comme une série d'octet;
Paramètres:
 val: une valeur à envoyer sous forme d'octet simple
 str: une chaîne à envoyer sous forme d'une série d'octets
 buf: un tableau pour envoyer une série d'octets
 len: la largeur du tableau
57
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Les fonctions de la librairie
Serial.flush();
Vide le buffer de réception de données du port série. Par conséquent, tout appel de la fonction Serial.read() ou Serial.avalaible()
renverra seulement les données reçues après le plus récent appel de la fonction Serial.flush().
Exemple: Communication avec le terminal virtuel

58
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Exemple: Communication entre deux cartes

59
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Exemple: Communication entre deux cartes

Carte (2)
Carte (1)

60
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Exemple: Communication entre carte et PC

61
Arduino
Applications (Arduino Uno)
Librairie Serial pour la communication série
Exemple: Communication entre carte et PC

62
Arduino
Applications (Arduino Uno)
Sorties analogiques (PWM)
PWM signifie « Pulse Width Modulation », ce qu’on pourrait traduire par modulation de largeur d’impulsion. Son objectif est de changer une
valeur moyenne en jouant sur le rapport cyclique.

PWM est configurable sur les broches 3, 5, 6, 9, 10 et 11 de la carte Arduino Uno

analogWrite(broche, valeur);

Génère une impulsion de largeur / période voulue sur une broche de la carte Arduino

Après avoir appelé l'instruction analogWrite(), la broche générera une onde carrée stable avec un "duty cycle"

Paramètres:

 broche: la broche utilisée pour "écrire" l'impulsion. Cette broche devra être une broche ayant la fonction PWM, Par exemple,
sur la UNO, ce pourra être une des broches 3, 5 ,6 ,9 ,10 ou 11.
 valeur: la largeur du "duty cycle" (proportion de l'onde carrée qui est au niveau HAUT) : entre 0 (0% HAUT donc toujours
au niveau BAS) et 255 (100% HAUT donc toujours au niveau HAUT).

63
Arduino
Applications (Arduino Uno)
Sorties analogiques (PWM)
analogWrite(broche, valeur);

64
Arduino
Applications (Arduino Uno)
Sorties analogiques (PWM)
analogWrite(broche, valeur);
Exemple: Variation de la vitesse d’un moteur à courant continu

65

Vous aimerez peut-être aussi