Vous êtes sur la page 1sur 26

Prise En main ARDUINO A.

Oumnad 1
Prise En main ARDUINO A. Oumnad 2

De quoi s'agit-il ?
Arduino est une petite carte de prototypage dotée d'un microcontrôleur ATMEGA et une interface
USB-Série qui permet de connecter l'Arduino à un port USB du PC pour téléverser les programmes
dans l'ATMEGA. La carte possède des connecteurs permettant d'accéder facilement aux E/S du
Microcontrôleur

Les Entrées Sorties


• L'Arduino UNO possède 13 E/S numériques et 6 entrée analogiques,
• Parmi les E/S numériques, 6 peuvent fonctionner comme sorties PWM et 2 peuvent être
programmées comme interface de communication série pour échanger des données entre l'Arduino
et un autre équipement
• Les E/S numériques peuvent fonctionner soit en entrée soit en sortie

Limitation de courant
• Le courant max sur une sortie Arduino ne doit pas dépasser 40 mA
• Le courant max que toutes les sorties réunies peuvent fournir ne doit pas dépasser 200mA
• Le courant max que toutes les sorties réunies peuvent recevoir ne doit pas dépasser 400mA

Logiciel
Pour programme l'Arduino, on dispose d'un environnement de développement intégré (IDE) constitué
essentiellement de:
• Un éditeur de texte qui permet au programmeur de saisir son programme,
• Un compilateur C adapté au microcontrôleur ATMEGA. Le compilateur permet de traduire le code
source écrit en C en programme exécutable constitué d'une suite de codes machine
compréhensibles par le microcontrôleur ATMEGA. Le C utilisé est compatible avec le C standard,
mais on dispose en plus de librairies permettant d'interagir avec les E/S de l'ATMEGA,
• Une fois le programme compilé, l'IDE permet de d'envoyer (téléverser) le programme exécutable
dans la mémoire programme de l'ATMEGA afin d'y être exécuté.

Télécharger et installer l'IDE Arduino


L'IDE de programmation est gratuit, https://www.arduino.cc/en/Main/Software
Il est disponible en deux versions, un installateur (.exe) ou une version zippée (.zip) qu'il suffit
d'extraire dans un dossier. Je crois que la version (1.6.7) Zippée est plus longue à télécharger car elle
fait plus de 150Mo contre seulement 80 Mo pour l'installateur .exe
L'installation ne pose pas de problème particulier
Prise En main ARDUINO A. Oumnad 3

Installation du driver de la carte Arduino


Une fois l'IDE installé, brancher l'Arduino à un connecteur USB, le PC essaye d'installer le driver mais
ne le trouve pas, Procéder comme suit:
• Ouvrir le gestionnaire de périphérique: clic droit sur ordinateur→ proprié té s → Gestionnaire de
périphérique
• Localiser l'équipement qui n'a pas de driver. Si vous avez des doutes, débrancher le câble USB, c'est
celui qui disparait. Rebranchez le câble USB, il réapparait
• Clic droit dessus → mettre à jour le pilote → rechercher un pilote sur mon ordinateur →
Sélectionner le répertoire « drivers » dans le dossier d'installation de IDE

Personnaliser L'IDE
• La première fois qu'on Lance l'IDE, il faut faire une
petite configuration qui consiste à:
• Choisir la carte Arduino sur laquelle on travaille: outils
→ type de carte → sélectionner votre carte dans la liste
• Choisir un dossier pour les programmes que vous allez
écrire: (chez Arduino, un programme = un croquis)
o Utilisez l'explorateur windows pour créer un dossier
de votre choix
o Dans l'IDE Arduino: fichier → pré fé rences →
Sélectionnez votre dossier dans le cadre
Emplacement du carnet de croquis → OK

Premier Programme
On va faire un petit programme qui fait clignoter une LED branchée sur une sortie numérique. Sur la
plupart des carte Arduino, il ya une LED jaune
déjà branchée sur l'E/S 13

13 330Ω
Arduino

• Taper le programme ci-dessous ou faire un


copie/collé
/*
Faire clignoter la LED branchée sur la sortie 13
Sur Arduino UNO, cette LED est disponible sur la carte
*/
// fonction de configuration
void setup() {
pinMode(13, OUTPUT); // configurer la broche 13 en sortie
}

// corp du programme qui se répète en boucle


void loop() {
digitalWrite(13, HIGH); // allumer la LED
delay(500); // attendre un peu
digitalWrite(13, LOW); // éteindre LED
delay(500); // attendre un peu
}
Prise En main ARDUINO A. Oumnad 4

• Sauvegarder le programme dans votre dossier en prenant soin de lui donner un nom
significatif. Remarquer que l'IDE crée un dossier et place le programme dedans. C'est une bonne
chose car cela évite que les programmes se mélangent.

• Cliquer sur le bouton pour compiler et téléverser le programme dans le microcontrôleur de la


carte Arduino
• Admirer le travail

Analyse du programme:
• Le programme est constituée de deux fonctions: setup() et loop(). Ces deux fonctions sont
obligatoires même si on ne met rien dedans,
Dans la fonction setup() on met les instructions qui doivent être exécutées une seule fois. En
général, on y trouve la configuration des E/S, l'initialisation des variables …Dans notre exemple on
trouve la ligne de code pinMode(13, OUTPUT); c'est un appel de la fonction pinMode() qui se trouve
dans la librairie Arduino pour configurer l'E/S 13 en sortie
Dans la fonction loop(), on place les tâches qui doivent se répéter indéfinitivement. Dans notre
exemple, on doit allumer et éteindre la LED en permanence:
• On appelle la fonction digitalWrite() qui force la sortie 13 au niveau HIGH pour allumer la LED
• On appelle la fonction delay() pour attendre ½ seconde afin que notre œil aie le temps de voir la LED
allumée
• On appelle de nouveau la fonction digitalWrite() mais cette fois pour forcer la sortie 13 au niveau LOW
pour éteindre la LED
• On appelle la fonction delay() pour attendre ½ seconde afin que notre œil aie le temps de voir la LED
éteinte
• On recommence

Variante:
//déclaration des variables globales
int LED_PIN = 13;

// fonction de configuration
void setup() {
pinMode(LED_PIN, OUTPUT); // configurer la broche 13 en sortie
}

// corp du programme qui se répète en boucle


void loop() {
digitalWrite(LED_PIN, HIGH); // allumer la LED
delay(500); // attendre un peu
digitalWrite(LED_PIN, LOW); // éteindre LED
delay(500); // attendre un peu
}

Pour qu'une variable soie connue de toutes les fonctions, elle doit être déclarée en dehors des
fonctions ( globale)
Prise En main ARDUINO A. Oumnad 5

Comment travailler si on ne dispose pas d'un Arduino


C'est possible. On peut utiliser le logiciel de simulation Proteus ISIS. Il suffit de lui ajouter une librairie
Arduino. On peut en télécharger une ici:
http://www.instructables.com/id/How-to-add-Arduino-Library-in-to-Proteus-7-8/
ou
http://www.theengineeringprojects.com/ArduinoProjects/Arduino%20Library%20for%20Proteus.rar
Il suffit ensuite de copier les deux fichiers .idx et .lib dans le dossier LIBRARY de proteus:
C:\Program Files\Labcenter Electronics\Proteus 7 Professional\LIBRARY
Il faut redémarrer Proteus ISIS
La figure ci-dessous montre l'utilisation d'un Arduino UNO avec un afficheur LCD

?
13
12
11
10
9
8

7
6
5
4
3
2
1
0

Avec l'IDE Arduino, le bouton compile et téléverse


PB5/SCK

PD4/T0/XCK
AREF

PB0/ICP1/CLKO

PD7/AIN1
~ PD6/AIN0
PD5/T1

~ PD3/INT1
PD2/INT0
TX PD1/TXD
RX PD0/RXD
PB4/MISO
~PB3/MOSI/OC2A
~ PB2/SS/OC1B
~ PB1/OC1A

le programme dans le Arduino à travers le bus USB.


~

Pour utiliser les programmes avec ISIS, il faut les DIGITAL (~PWM)
compiler juste pour créer un programme .hex qui sera
implanté dans le Arduino sous ISIS. Pour ça: ATMEGA328P-PU
1121

croquis → Exporter les binaires compilés


ceci crée un exécutable avec le nom xxx.ino.standard.hex microcontrolandos.blogspot.com
PC4/ADC4/SDA
PC5/ADC5/SCL

ANALOG IN
Exercice:
PC0/ADC0
PC1/ADC1
PC2/ADC2
PC3/ADC3
RESET

Essayer le programme qui fait clignoter la LED sur ISIS


A0
A1
A2
A3
A4
A5
Prise En main ARDUINO A. Oumnad 6

Manipulation directe des ports du microcontrôleur ATMEGA


Pour apprendre à programmer, la meilleure façon est de faire des programmes pour s'amuser.
Essayons de faire un chenillard sur les sorties numérique de 0 à 7.
Le programme le plus simple mais le plus débile est le suivant
#define TMP 500

// fonction de configuration
void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
}

// corp du programme qui se répète en boucle


void loop() {
digitalWrite(7, LOW); // éteindre la LED allumée
digitalWrite(0, HIGH); // allumer la LED suivante
delay(TMP); // attendre un peu
digitalWrite(0, LOW); // éteindre la LED allumée
digitalWrite(1, HIGH); // allumer la LED suivante
delay(TMP); // attendre un peu
digitalWrite(1, LOW); // éteindre la LED allumée
digitalWrite(2, HIGH); // allumer la LED suivante
delay(TMP); // attendre un peu
digitalWrite(2, LOW); // éteindre la LED allumée
digitalWrite(3, HIGH); // allumer la LED suivante
delay(TMP); // attendre un peu
digitalWrite(3, LOW); // éteindre la LED allumée
digitalWrite(4, HIGH); // allumer la LED suivante
delay(TMP); // attendre un peu
digitalWrite(4, LOW); // éteindre la LED allumée
digitalWrite(5, HIGH); // allumer la LED suivante
delay(TMP); // attendre un peu
digitalWrite(5, LOW); // éteindre la LED allumée
digitalWrite(6, HIGH); // allumer la LED suivante
delay(TMP); // attendre un peu
digitalWrite(6, LOW); // éteindre la LED allumée
digitalWrite(7, HIGH); // allumer la LED suivante
delay(TMP); // attendre un peu

On va améliorer tout ça en introduisant une boucle for:

int p;
void setup(){
for(p = 0; p < 8; p++){
pinMode(p, OUTPUT);
}
}
void loop(){
for(p = 0; p < 8; p++){
digitalWrite(p, HIGH);
delay(300);
digitalWrite(p , LOW);
}
}

Il est encore possible de simplifier ce programme en manipulant directement les ports du


microcontrôleur Atmega sans passer par les fonction pinMode() et digitalWrite().
Comme on peut le constater sur la figure ci-dessous, les E/S de l'Arduino sont connectés aux ports
d'E/S de l'ATMEGA.
Prise En main ARDUINO A. Oumnad 7

Les E/S numériques sont connectés sur les ports ARDUINO


B et D et les E/S analogiques viennent du port C.
ATMEGA328
Chaque port est géré par 3 registres. Prenons le
cas du port D pour illustrer tous ça:
PB5 13
Le port D est géré par les registres: P
O PB4 12
DDRD: registre de direction qui permet de R PWM
PB3 11
configurer la direction de chaque bit du port, 1=> T
B PB2 PWM
sortie, 0=> entrée. 10
DDRD=B00001111; signifie que les 4 bits de plus faible poids PB1 PWM
9
de PORTD seront des sorties, les 4 autres seront des entrées
PB0 8
PORTD: registre de sortie. On écrit dedans pour
contrôler les broches du port. On peut le lire, A0 PC0 PD7 7
mais on va y trouver ce que nous y avons écrit A1 PC1 PD6 PWM
6
auparavant. PC2 PD5 PWM
A2 5
P P
PIND: Registre d'entrée. On le lit pour savoir A3 PC3 O O PD4 4
l'état des broches configurées en entrée. PC4
R R
PD3 PWM
A4 T T 3
PC5 C D PD2
A5 2
En résumé:
TX
• Pour définir d'un coup les 8 bits d'un registre, PD1 1
une simple affectation suffit. Ex: PD0 RX
0
DDRB = B11001100;
PORTB =B11110000;
• Pour lire le contenu d'un port configuré en entrée, on peut affecter son contenu à une variable ou
l'utiliser dans une expression
x = PINB;
if (PINB == B'1100111) …

• Pour forcer un bit à 1, on fait un OU avec 1,


PORTD |= B00001000; // forcer le bit PD3 à 1

• Pour forcer un bit à 0, on fait un ET avec 0,


PORTD &= B11011111; // forcer le bit PD5 à 0

• Pour inverser un bit, on fait un XOR avec 1,


PORTD ^= B00000001; // forcer le bit PD0 à 1

Exemple de la LED qui clignote


void setup() {
DDRB |= B00010000; // PB4=P12 -> sortie
}
void loop() {
PORTB ^= B00010000; // inverser PB4 = P12
delay(300);
}

Exemple du chenillard
void setup() {
DDRD = 0xFF; //PORTD sortie
PORTD = B00000001; allumer la LED de droite
}

void loop() {
PORTD = PORTD << 1 ; // décaler à gauche d'une position
if (PORTD == 0)PORTD = B00000001; //quand le 1 sort du coté gauche, on le réinjecte du coté droit
delay(200);
}

Les avantages de cette façon de programmer sont multiples. On économise la RAM car on utilise
moins variables. On optimise le temps d'exécution en évitant les boucles et les appels de fonctions…
Prise En main ARDUINO A. Oumnad 8

Surveiller des entrées Numériques (TOR)


La fonction qui permet de lire l'état d'une entrée est digitalRead()
Le meilleur moyen pour faire les tests est l'utilisation de réalisations avec des boutons poussoir. On
dispose de deux façons pour brancher un bouton poussoir. Etat actif=0 ou état actif = 1

B1

uC Rebonds
B2 mécaniques

1 à 30
Ces composants ne sont pas toujours faciles à utiliser à cause des rebonds.

Surveiller un seul bouton Poussoir


On va réaliser un chenillard manuel. On utilise un bouton poussoir
B1 actif au niveau bas branché sur l'entrée 8 et un ensemble de 8
LEDs branchées sur les entrées 0 à 7 qui sont connectées au port D
de l'ATMEGA. Chaque fois qu'on "clique" sur le bouton, la LED B1
?
?
?
?
?
?
?
?
allumée se déplace vers la gauche.
13
12
11
10
9
8

7
6
5
4
3
2
1
0

/*
PB5/SCK

PD4/T0/XCK
AREF

PB0/ICP1/CLKO

TX PD1/TXD
RX PD0/RXD
PD7/AIN1
~ PD6/AIN0
~ PD5/T1

~ PD3/INT1
PD2/INT0
~PB3/MOSI/OC2A
~PB2/SS/OC1B
~ PB1/OC1A
PB4/MISO

* Un bouton poussoir sur la broche 8 (PB0) 1


* 8 LEDs sur PORTD (broches 0 à 7) test
* au départ: PD0 allumée
* chaque foi qu'on clique sur le bouton, la LED allumée se décale 0
vers la gauche www.TheEngineeringProjects.com
*/ on fait le ATMEGA328P-PU
1121

void setup() { travail ON


PC4/ADC4/SDA
PC5/ADC5/SCL

pinMode(8, INPUT); // la broche 8 est une entrée ANALOG IN


PC0/ADC0
PC1/ADC1
PC2/ADC2
PC3/ADC3

DDRD = 0xFF; //PORTD sortie


RESET

PORTD = B00000001; // LED de droite allumée


GND
VCC

} attendre ↑ Reset BTN


A0
A1
A2
A3
A4
A5

void loop() {
if( digitalRead(8) == LOW){
PORTD <<= 1; // décaler à gauche
if(PORTD == 0)PORTD = 1; // assure la rotation
delay(20); // anti rebond
while( digitalRead(8) == LOW);
delay(20); // anti rebond
}
}
Prise En main ARDUINO A. Oumnad 9

Surveiller deux boutons Poussoir


On va réaliser un chenillard manuel. On utilise deux boutons
poussoir B1 et B2 actifs au niveau bas, branchés sur les entrées R2 R1
8 et 9. Un ensemble de 8 LEDs branchées sur les entrées 0 à 7
qui sont connectées au port D de l'ATMEGA. Si on "clique" sur le
bouton B1, la LED allumée se déplace vers la droite, si on clique B2 B1
sur le bouton B2, la LED allumée se déplace vers la gauche

?
?
?
?
?
?
?
?
13
12
11
10
9
8

7
6
5
4
3
2
1
0
0

PB5/SCK

PD4/T0/XCK
PB0/ICP1/CLKO
AREF

TX PD1/TXD
RX PD0/RXD
PD7/AIN1
~ PD6/AIN0
~ PD5/T1

~ PD3/INT1
PD2/INT0
~PB3/MOSI/OC2A
~PB2/SS/OC1B
~ PB1/OC1A
PB4/MISO
B1

1 décalage à
droite www.TheEngineeringProjects.com
B2 attendre ↑
0 ATMEGA328P-PU
1121

1 ON
décalage à

PC4/ADC4/SDA
PC5/ADC5/SCL
ANALOG IN
gauche

PC0/ADC0
PC1/ADC1
PC2/ADC2
PC3/ADC3
RESET
attendre ↑

GND
VCC
Reset BTN

A0
A1
A2
A3
A4
A5
void setup() {
pinMode(8, INPUT);
pinMode(9, INPUT);
DDRD = 0xFF; //PORTD sortie
PORTD = B00001000; //on allume une seule LED
}

void loop() {
if(digitalRead(8) == LOW){
PORTD = PORTD >> 1 | PORTD << 7; // décaler à droite
delay(20); // anti rebond
while( digitalRead(8) == LOW); // attendre que B1 repasse à 1
}

if(digitalRead(9) == LOW){
PORTD = PORTD << 1 | PORTD >> 7; // décaler à gauche
delay(20); // anti rebond
while( digitalRead(9) == LOW); // attendre que B2 repasse à 1
}
}

Exercice:
Ecrire le programme qui surveille 3 boutons B1, B2, B3 branchés sur les broches 8, 9, 10.
B1 → PORTD = 00001111
B2 → PORTD = 11110000
B3 → PORTD clignote 5 fois (0.5s/0.5s)
Essayer le programme sur ISIS
Prise En main ARDUINO A. Oumnad 10

Commander un afficheur LCD


Les afficheurs les plus courants sont les 2× 16
• Deux lignes de 40 caractères dont 16 sont visibles

VDD
VEE

VSS
RW
RS
D7
D6
D5
D4
D3
D2
D1
D0

E
14
13
12
11
10
9
8
7

6
5
4

3
2
1
• Les informations sont envoyées sous forme d'octets. L'interprétation dépend de l'entrée RS:
RS = 0 → L'octet envoyé sera interpré té comme une commande
RS = 1 → L'octet envoyé est le code ASCII d'un caractère qui sera affiché
L'octet peut être envoyé en un seul coup (mode 8 bits) ou moitié-moitié (mode 4 bits). Quelque soit le
mode, l'envoi d'un octet ou d'un demi octet est toujours validé par une impulsion ⎍ sur l'entrée E
L'IDE Arduino intègre la bibliothèque liquid crystal qui permet d'utiliser ces afficheurs sans en
connaitre le fonctionnement interne.

Les fonctions les plus importantes sont:


• LiquidCrystal lcd(RS, E, d4, d5, d6, d7): Pour préciser comment l'afficheur est branché à l'Arduino
• lcd.begin(Nc, Nl) : Pour initialiser l'afficheur et définir le nombre de lignes et de colonnes
• lcd.clear(): Pour effacer l'afficheur
• lcd.setCursor(col, lgn) : Pour positionner le curseur
• lcd.print(donnée) : Pour afficher une chaine ou des nombres
• lcd.write(caractère) : Pour afficher un caractère
• lcd.scrollDisplayLeft(): décaler l'affichage d'un caractère vers la gauche
• lcd.scrollDisplayRight(): décaler l'affichage d'un caractère vers la droite

Voir le paragraphe Références pour le détail d'utilisation de ces fonctions


Voir https://www.arduino.cc/en/Reference/LiquidCrystal pour d'autres fonctions
Voir https://www.arduino.cc/en/Reference/Libraries pour d'autres librairies

Exemple:
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
VDD
VSS

VEE

RW
RS

D0
D1
D2
D3
D4
D5
D6
D7
E

lcd.begin(20, 2); LM032L


lcd.print("2GE 2015-");
1
2
3

4
5
6

7
8
9
10
11
12
13
14

lcd.print(2016);
lcd.setCursor(0, 1);
lcd.print("La creme de l'EMI");
13
12
11
10
9
8

7
6
5
4
3
2
1
0

}
B0/ICP1/CLKO
PB5/SCK

PD4/T0/XCK

TX PD1/TXD
RX PD0/RXD
AREF

B3/MOSI/OC2A
PB2/SS/OC1B
~ PB1/OC1A

PD7/AIN1
~ PD6/AIN0
PD5/T1

~ PD3/INT1
PD2/INT0
PB4/MISO

void loop() {}
~

Remarque importante: DIGITAL (~PWM)


• la variable (classe) lcd crée par la fonction LiquidCrystal() doit être globale pour être connue de
toutes les fonctions
• Ne pas oublier d'inclure le fichier des entêtes <LiquidCristal.h>

Exercice:
Ecrire un programme qui affiche un nombre en décimal et en binaire sur la même ligne
Prise En main ARDUINO A. Oumnad 11

Lecture d'une entrée analogique


Arduino UNO dispose de 6 entrées analogiques:
• Les entrées analogiques sont appliquées à un convertisseur Analogique Numérique de 10 bits,
• Le résultat de conversion est N=0 pour la valeur analogique minimale et N=1023 pour la valeur
analogique max
• Par défaut, la dynamique du convertisseur est fixée à [OV, 5V], 0V N=0, 5V 1023
• Pour lire une entrée analogique, on utilise la fonction analogRead(pin) qui retourne un entier
compris entre 0 et 1023 correspondant à la tension analogique sur l'entrée pin

5V 102
3
v ADC N

0 0
V

Exemple:
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
int N;
float v;
void setup() {
VDD
VSS

VEE

RW
RS

D0
D1
D2
D3
D4
D5
D6
D7
lcd.begin(20, 2);

E
LM032L
}
1
2
3

4
5
6

7
8
9
10
11
12
13
14
void loop() {
N = analogRead(5); RV1
v = N * 5.0 / 1023.0 ;
13
12
11
10
9
8

7
6
5
4
3
2
1
0
lcd.clear();

54%
lcd.print("N=");
PB5/SCK

PD4/T0/XCK
PB0/ICP1/CLKO
AREF

TX PD1/TXD
RX PD0/RXD
~PB3/MOSI/OC2A
~ PB2/SS/OC1B
~ PB1/OC1A

PD7/AIN1
~ PD6/AIN0
PD5/T1

~ PD3/INT1
PD2/INT0
PB4/MISO

lcd.print(N);
lcd.print(" --> ");
lcd.print(v); 1k
lcd.print(" Volts");
~

delay(200);
} DIGITAL (~PWM)

Remarques: ATMEGA328P-PU

• l'appel de la fonction clear() est


1121

important. Sinon, à chaque passage, le


nouveau texte est affiché à la suite du microcontrolandos.blogspot.com
PC4/ADC4/SDA
PC5/ADC5/SCL

précédent, ANALOG IN
• l'appel de la fonction delay() est
PC0/ADC0
PC1/ADC1
PC2/ADC2
PC3/ADC3
RESET

important. C'est elle qui fixe la période


d'échantillonnage,
• On n'est pas obligé de déclarer les
A0
A1
A2
A3
A4
A5

entrées analogiques avec la fonction


pinMode(),

Exercice:
Programme qui mesure les quatre entrées analogiques (0 à 3) et affiche les résultats en volts sur
l'afficheur LCD
Prise En main ARDUINO A. Oumnad 12

Communication Série
L'Arduino UNO possède un module de communication série (UART) qui permet de se connecter à tout
autre équipement équipé d'un module de communication série

Autre équipement

Tx
Rx
GND

• La communication est bidirectionnelle (full duplex) La réception (RX) se fait sur le broche 0 et la
transmission (TX) se fait sur la broche 1
• Les niveaux de tension sont compatibles TTL (0V / 5V). Pour se connecter à un port série standard
RS232, il faut utiliser un adaptateur de niveaux. Le standard RS232 utilise les niveaux de tension
+12V / -12V avec des niveaux logiques inversés (0→ +12V, 1→ -12V) . Le circuit Max232 permet de
réaliser cette adaptation
5V
16
1
+
+
2
3 Max232
4 6
+
+
5 1
10 7 2 6
Rx
TTL 9 8 RS232 3
Tx
11 14
5 9
12 13 GND

15
Prise En main ARDUINO A. Oumnad 13

• La vitesse de communication doit être la même des deux cotés. Les vitesses de communication
standard sont 300, 600, 1200, 2400, 4800, 9600, 19200, 28800, 38400, 57600, or 115200 baud
• L'UART de l'Arduino dispose d'un buffer de réception de 64 octets

La librairie serial propose des fonctions pour utiliser le port série. Les fonctions les plus importantes
sont:
• Serial.begin(speed); Initialise le port série et définit la vitesse de communication
• Serial.write(data); Transmet un octet, une chaine ou les octets d'un tableau de type char[] ou byte[]
• serial.write('A'); transmet le caractère A (octet 65)
• serial.write(66); transmet l'octet 66 = caractère B
• serial.write("Bonjour"); transmet la chaine Bonjour (octet par octet)
• serial.write(856); le nombre 856 est tronqué à un octet puis transmis
byte b[] = {0x11, 0x22, 0x33, 0x44, 0x55}; Serial.write(b,3); transmit 3 octets du tableau b
• Serial.print(data,[base]); Sert surtout à transmettre des nombres en tant que chaine. On peut aussi s'en servir pour transmettre des
caractères et des chaines
Serial.print(2048); Transmet le nombre 2048 comme la chaine "2048"
Serial.Print(235.4567); Transmet le nombre réel 235.4567 en tant que chaine en arrondissant à 2 chiffres décimaux "235.46"
Serial.print(240,BIN); Convertit le nombre 240 en binaire et le transmet en tant que chaine "11110000"
• Serial.println(data); Identique à Serial.print() mais transmet en plus un retour ligne (CR LF)=(13 10)
• n= Serial.available(); retourne le nombre d'octets disponible dans le buffer de réception
• b=Serial.read(); Lit un octet du buffer de réception. Retourne -1 (255) si le buffer de réception est vide. Le receveur b peut être de type
byte, char ou int
• n=Serial.readBytes(buffer, length); Lit un ensemble d'octets sur le port série et les place dans la variable buffer
o buffer: nom de la variable qui reçoit les données. Type char[] ou byte[]
o length: nombre d'octets à lire (int)
o cette fonction retourne le nombre n d'octets effectivement lus qui peut être inférieur à length en cas de timeout
• n=Serial.readBytesUntil(terminator, buffer, length); lit un ensemble d'octets et les place dans la variable buffer.
La réception s'arrête quand on reçoit l'octet terminator ou après la réception de length octets ou après un timeout. La fonction retourne le
nombre n d'octets effectivement lus
• S = Serial.readStringUntil(car); lit les caractères qui arrivent et les place dans la chaine S (type string). S'arrête à la réception du
caractère car ou après un Timeout
• Serial.end(); Désactive l'USART. Les broches 0 et 1 peuvent de nouveau être utilisées comme des E/S normales
• Serial.setTimeout(tms); Définit la durée de timeout en lecture. Par défaut le time out est fixé à 1000 ms = 1s

En résumé
• Transmettre un caractère
Serial.write('A');

• Transmettre une chaine


Serial.write("Bonjour");

• Transmettre un entier (int) (unsigned int)


unsigned int N = 0x4142;
Serial.write((byte*) &N , 2); //ordre little Indian, LSB d'abord

• Transmettre un entier long (long)


unsigned long int Z = 0x44434241;
Serial.write((byte*) &Z, 4);

• Transmettre un réel (float)


float R = 123.456;
Serial.write((byte*) &R, 4);
Prise En main ARDUINO A. Oumnad 14

• Recevoir un entier (int) (unsigned int)


int N ;
Serial.readBytes((byte*) &N , 2); //ordre little Indian, LSB d'abord

• Recevoir un entier long (long) (unsigned long)


long N ;
Serial.readBytes((byte*) &N , 4); //ordre little Indian, LSB d'abord

• Recevoir un réel (float)


float R ;
Serial.readBytes((byte*) &R , 4); //ordre little Indian, LSB d'abord

Arduino UNO, MEGA… ne supporte pas les réels de type double, ils sont représentés comme des float. Seul le Arduino DUE est capable de coder
les réel double correctement sur 8 octets

Exercice:
Programme pour tester la fonction serial.write:
transmettre le caractère 'A'
transmettre le caractère 'B' en utilisant son code ASCII
transmettre la chaine "CDE"
transmettre le nombre 6543 (> 255) pour vérifier la troncature
transmettre (correctement) le nombre entier (int) 6543
transmettre (correctement) le nombre entier (long) 1234567890
transmettre l'octet bas du nombre entier (int) 6543
transmettre l'octet haut du nombre entier (int) 6543
transmettre 3 octets d'un tableau de bytes
transmettre 4 octets d'un tableau de char
transmettre le nombre réel (float) 123.456
transmettre un réel (double) 123.456
Ce programme peut être testé sur ISIS à l'aide de VIRTUAL TERMINAL . Pour vérifier la transmission
des nombres, il faut passer en mode affichage HEX

Nombre réel Simple précision, 32 bits =4 octets Double précision, 64 bits = 8 octets
125.456 42F6E979 (hex) 405EDD2F1A9FBE77 (Hex)
Prise En main ARDUINO A. Oumnad 15

Commande d'une charge de petite puissance


Quand on commande une charge, il ne suffit pas de s'intéresser aux aspects logiques. Il faut s'assurer
qu'on est capable de fournir à la charge commandée, tout le courant dont elle a besoin pour
fonctionner.
Dans le cas d'une charge qui ne consomme pas un courant important comme une LED par exemple. On
peut la commander directement par une sortie de l'Arduino. Il faut s'assurer que la dite sortie est
capable de fournir le courant nécessaire.
La fiche technique du microcontrôleur ATMEGA précise que la tension sur une sortie au niveau haut
est 5V et que le courant max quelle peut fournir est 40 mA
Calculons le courant dans la LED sachant que le seuil des LEDs est 1.5V. Nous avons utilisé R=330Ω
I = (5 – 1.5)/330 = 10.6 mA
Tout va bien, ce courant est suffisant pour allumer la LED correctement et il est inférieur à la limite
Max que la sortie de l'Arduino peut fournir
Se pose maintenant le problème de l'alimentation de l'Arduino. Si celui-ci est alimenté par le câble USB
du PC, sachez qu'un port USB-2 ne peut pas fournir beaucoup plus que 100 mA. Si vous utilisez votre
Arduino pour commander plusieurs charges, le datasheet précise que l'ensemble des sorties de
l'Arduino peut fournir jusqu'à 200 mA. Dans ce cas, l'Arduino ne doit pas être alimenté par le port USB

Commande d'une charge CC de puissance moyenne


Si on veut commander une charge qui demande plus 200mA ou une charge nécessitant une
alimentation supérieure à 5V. Il est évident qu'on ne peut pas la commander directement par une
sortie de l'Arduino. Il faut utiliser une interface de puissance capable de fournir à la charge la tension
et le courant dont elle a besoin.
La solution la plus simple consiste à utiliser un transistor de commutation. Celui-ci joue le rôle
d'interrupteur pour alimenter ou non la charge.
• Il faut juste choisir un transistor capable de conduire le courant de la charge quand il est saturé,
• Il faut calculer Rb pour que le transistor se sature quand la sortie de l'Arduino est au niveau haut
• Si le courant de la charge est élevé, il peut s'avérer nécessaire d'utiliser un transistor de puissance.
Les transistors de puissance ont un β assez faible, on risque de se retrouver avec un courant Ib
important. Pour y remédier, on peut utiliser un transistor Darlington qui a un fort β.

Vch

Vcc
char

Rb
Arduino
Vcc
Rb < βRch
Vch
Prise En main ARDUINO A. Oumnad 16

Transistor petite puissance 2n2222

Transistor de puissance BDX53


Prise En main ARDUINO A. Oumnad 17

Commande d'une charge inductive


Dans le cas d'une charge inductive comme un relai ou un moteur, il est IMPERATIF de rajouter une
DIODE de récupération (roue libre) sinon le transistor sera détruit à la première coupure du courant

Vre

Vcc

Rb
Arduino
Vcc
Rb < βRrel
Vrel

Commande d'une charge alimentée par secteur


Plusieurs solutions sont possibles. Nous exposons ici la solution avec un relai. Elle présente l'avantage
d'une isolation galvanique et la possibilité de contrôler des charges de forte puissance

Vre

Vcc
220
Rel
Rb
Arduino
Vcc Lam
Rb < βRrel
Vrel

Le transistor joue le rôle d'interrupteur pour alimenter ou non la bobine du relai. Ainsi le courant qui
alimente la bobine n'est pas fourni directement par la sortie de l'Arduino mais il vient de
l'alimentation du relai Vrel. Cette dernière peut être différente de celle de l'Arduino dans le cas où le
relai nécessite une alimentation > 5V
La résistance Rb doit être calculée pour que le transistor soit saturé quand la sortie de l'Arduino est au
niveau haut.

Exemple:
Rrel = 43Ω, β=250, Vrel = 5V, Vcc = 5V
Rb doit être inférieure à 250 × 43 Ω = 10.7 k, On prend Rb=8.2k
Quand la sortie de l'Arduino est au niveau haut, elle fournit un courant Is =(5 – 0.7)/8.2k = 0.5 mA
Ce courant sature le transistor qui devient un circuit fermé. La bobine est alors traversée par un
courant Ic = 5V / 43Ω = 116mA qui vient directement de l'alimentation Vrel. Le courant dans la bobine
crée un champ magnétique suffisant pour faire coller le relai, la charge est alors alimenter par le
secteur 220V
Prise En main ARDUINO A. Oumnad 18

Commande d'une sortie PWM


Un signal PWM (Pulse Width Modulation) ou MLI (Modulation de largeur d'impulsion) est un signal de
rapport cyclique TH/T réglable.
TH

6 sorties (3, 5, 6, 9, 10 et 11) de l'Arduino peuvent fonctionner comme sorties PWM.

Pour générer un signal PWM, on utilise la fonction:

analogWrite(pin, rs);
pin : numéro de la broche PWM
rs : entier compris entre 0 et 255 qui définit le rapport cyclique

Après un appel de la fonction analogWrite(), le signal PWM reste actif sur la sortie PWM jusqu'à ce
qu'on le modifie avec un autre appel de analogWrite(). Pour l'arrêter on peut appeler la fonction
digitalWrite() ou digitalRead() sur la broche considérée.

remarque: On n'est pas obligé de configurer la broche en sortie à l'aide de pinMode()

Modifier la période du signal PWM


// For Arduino Uno, Nano, Micro Magician, Mini Driver, Lilly Pad and any other board using ATmega 8, 168 or 328**

//---------------------------------------------- Set PWM frequency for D5 & D6 -------------------------------

//TCCR0B = TCCR0B & B11111000 | B00000001; // set timer 0 divisor to 1 for PWM frequency of 62500.00 Hz
//TCCR0B = TCCR0B & B11111000 | B00000010; // set timer 0 divisor to 8 for PWM frequency of 7812.50 Hz
TCCR0B = TCCR0B & B11111000 | B00000011; // set timer 0 divisor to 64 for PWM frequency of 976.56 Hz (The DEFAULT)
//TCCR0B = TCCR0B & B11111000 | B00000100; // set timer 0 divisor to 256 for PWM frequency of 244.14 Hz
//TCCR0B = TCCR0B & B11111000 | B00000101; // set timer 0 divisor to 1024 for PWM frequency of 61.04 Hz

//---------------------------------------------- Set PWM frequency for D9 & D10 ------------------------------

//TCCR1B = TCCR1B & B11111000 | B00000001; // set timer 1 divisor to 1 for PWM frequency of 31372.55 Hz
//TCCR1B = TCCR1B & B11111000 | B00000010; // set timer 1 divisor to 8 for PWM frequency of 3921.16 Hz
TCCR1B = TCCR1B & B11111000 | B00000011; // set timer 1 divisor to 64 for PWM frequency of 490.20 Hz (The DEFAULT)
//TCCR1B = TCCR1B & B11111000 | B00000100; // set timer 1 divisor to 256 for PWM frequency of 122.55 Hz
//TCCR1B = TCCR1B & B11111000 | B00000101; // set timer 1 divisor to 1024 for PWM frequency of 30.64 Hz

//---------------------------------------------- Set PWM frequency for D3 & D11 ------------------------------

//TCCR2B = TCCR2B & B11111000 | B00000001; // set timer 2 divisor to 1 for PWM frequency of 31372.55 Hz
//TCCR2B = TCCR2B & B11111000 | B00000010; // set timer 2 divisor to 8 for PWM frequency of 3921.16 Hz
//TCCR2B = TCCR2B & B11111000 | B00000011; // set timer 2 divisor to 32 for PWM frequency of 980.39 Hz
TCCR2B = TCCR2B & B11111000 | B00000100; // set timer 2 divisor to 64 for PWM frequency of 490.20 Hz (The DEFAULT)
//TCCR2B = TCCR2B & B11111000 | B00000101; // set timer 2 divisor to 128 for PWM frequency of 245.10 Hz
//TCCR2B = TCCR2B & B11111000 | B00000110; // set timer 2 divisor to 256 for PWM frequency of 122.55 Hz
//TCCR2B = TCCR2B & B11111000 | B00000111; // set timer 2 divisor to 1024 for PWM frequency of 30.64 Hz

//For Arduino Mega1280, Mega2560, MegaADK, Spider or any other board using ATmega1280 or ATmega2560**

//---------------------------------------------- Set PWM frequency for D4 & D13 ------------------------------

//TCCR0B = TCCR0B & B11111000 | B00000001; // set timer 0 divisor to 1 for PWM frequency of 62500.00 Hz
//TCCR0B = TCCR0B & B11111000 | B00000010; // set timer 0 divisor to 8 for PWM frequency of 7812.50 Hz
TCCR0B = TCCR0B & B11111000 | B00000011; <// set timer 0 divisor to 64 for PWM frequency of 976.56 Hz (Default)
//TCCR0B = TCCR0B & B11111000 | B00000100; // set timer 0 divisor to 256 for PWM frequency of 244.14 Hz
//TCCR0B = TCCR0B & B11111000 | B00000101; // set timer 0 divisor to 1024 for PWM frequency of 61.04 Hz

//---------------------------------------------- Set PWM frequency for D11 & D12 -----------------------------

//TCCR1B = TCCR1B & B11111000 | B00000001; // set timer 1 divisor to 1 for PWM frequency of 31372.55 Hz
//TCCR1B = TCCR1B & B11111000 | B00000010; // set timer 1 divisor to 8 for PWM frequency of 3921.16 Hz
TCCR1B = TCCR1B & B11111000 | B00000011; // set timer 1 divisor to 64 for PWM frequency of 490.20 Hz
//TCCR1B = TCCR1B & B11111000 | B00000100; // set timer 1 divisor to 256 for PWM frequency of 122.55 Hz
//TCCR1B = TCCR1B & B11111000 | B00000101; // set timer 1 divisor to 1024 for PWM frequency of 30.64 Hz
Prise En main ARDUINO A. Oumnad 19

//---------------------------------------------- Set PWM frequency for D9 & D10 ------------------------------

//TCCR2B = TCCR2B & B11111000 | B00000001; // set timer 2 divisor to 1 for PWM frequency of 31372.55 Hz
//TCCR2B = TCCR2B & B11111000 | B00000010; // set timer 2 divisor to 8 for PWM frequency of 3921.16 Hz
//TCCR2B = TCCR2B & B11111000 | B00000011; // set timer 2 divisor to 32 for PWM frequency of 980.39 Hz
TCCR2B = TCCR2B & B11111000 | B00000100; // set timer 2 divisor to 64 for PWM frequency of 490.20 Hz
//TCCR2B = TCCR2B & B11111000 | B00000101; // set timer 2 divisor to 128 for PWM frequency of 245.10 Hz
//TCCR2B = TCCR2B & B11111000 | B00000110; // set timer 2 divisor to 256 for PWM frequency of 122.55 Hz
//TCCR2B = TCCR2B & B11111000 | B00000111; // set timer 2 divisor to 1024 for PWM frequency of 30.64 Hz

//---------------------------------------------- Set PWM frequency for D2, D3 & D5 ---------------------------

//TCCR3B = TCCR3B & B11111000 | B00000001; // set timer 3 divisor to 1 for PWM frequency of 31372.55 Hz
//TCCR3B = TCCR3B & B11111000 | B00000010; // set timer 3 divisor to 8 for PWM frequency of 3921.16 Hz
TCCR3B = TCCR3B & B11111000 | B00000011; // set timer 3 divisor to 64 for PWM frequency of 490.20 Hz
//TCCR3B = TCCR3B & B11111000 | B00000100; // set timer 3 divisor to 256 for PWM frequency of 122.55 Hz
//TCCR3B = TCCR3B & B11111000 | B00000101; // set timer 3 divisor to 1024 for PWM frequency of 30.64 Hz

//---------------------------------------------- Set PWM frequency for D6, D7 & D8 ---------------------------

//TCCR4B = TCCR4B & B11111000 | B00000001; // set timer 4 divisor to 1 for PWM frequency of 31372.55 Hz
//TCCR4B = TCCR4B & B11111000 | B00000010; // set timer 4 divisor to 8 for PWM frequency of 3921.16 Hz
TCCR4B = TCCR4B & B11111000 | B00000011; // set timer 4 divisor to 64 for PWM frequency of 490.20 Hz
//TCCR4B = TCCR4B & B11111000 | B00000100; // set timer 4 divisor to 256 for PWM frequency of 122.55 Hz
//TCCR4B = TCCR4B & B11111000 | B00000101; // set timer 4 divisor to 1024 for PWM frequency of 30.64 Hz

//---------------------------------------------- Set PWM frequency for D44, D45 & D46 ------------------------

//TCCR5B = TCCR5B & B11111000 | B00000001; // set timer 5 divisor to 1 for PWM frequency of 31372.55 Hz
//TCCR5B = TCCR5B & B11111000 | B00000010; // set timer 5 divisor to 8 for PWM frequency of 3921.16 Hz
TCCR5B = TCCR5B & B11111000 | B00000011; // set timer 5 divisor to 64 for PWM frequency of 490.20 Hz
//TCCR5B = TCCR5B & B11111000 | B00000100; // set timer 5 divisor to 256 for PWM frequency of 122.55 Hz
//TCCR5B = TCCR5B & B11111000 | B00000101; // set timer 5 divisor to 1024 for PWM frequency of 30.64 Hz
Prise En main ARDUINO A. Oumnad 20

Commande d'un moteur CC à l'aide d'un pont en H


Vcm=12V

A KA KC C

B KB KD D

A B C D Moteur
0 0 0 0 Roue libre
1 0 0 1 gauche
0 1 1 0 droite
1 1 x x interdit
x x 1 1 interdit
1 0 1 0 frein
0 1 0 1 frein
1 0 0 PWM Gauche variable
0 PWM 1 0 Droite variable

On peut concevoir des ponts en H avec des transistors bipolaires ou des transistors MOS. Plusieurs
configurations des transistors son disponibles. J'ai une préférence pour le schéma ci-dessous:
V

RA RC
A 1 2 QC 6 5 C
1k QA 1k
7406 Vm 7406
Vm
RB RD
1k 1k

B 3 4 QB QD 8 9 D
7407 7407

• Le 7406 et le 7407 sont des circuits à sortie collecteur ouvert


• Les transistors QA et QC sont des PNP, ils sont commandés par niveau BAS
• Les transistors QB et QD sont des NPN, ils sont commandés par niveau HAUT

Prise En main ARDUINO A. Oumnad 21

Le pont en H intégré L298

Le L298 contient deux ponts en H avec trois entrées de commande pour chaque pont. Chaque pont
utilise quatre transistors NPN

Les caractéristiques du L298 sont les suivantes :


Intensité maximale : 2A par pont ;
Alimentation de puissance de 5.5V à 50V ;
Dissipation puissance total : 25w ;
Trois entrées par pont : In1, In2 et ENABLE, la fonctionnement comme suite :

Entrées Sorties Fonction


ENA = 1 In1=1 ; In2=0 Out1=1 ; Out2=0 La marche avant (droite)
In1=0 ; In2=1 Out1=0 ; Out2=1 La marche arrière (gauche)
In1=In2 Out1=1 ; Out2=1 Le frein
Ou
Out1=0 ; Out2=0
ENA = 0 In1=X ; In2=X rien roue libre

Pour faire varier la vitesse du moteur, on fixe In1 et In2 pour définir le sens de rotation et on applique
un signal PWM sur l'entrée ENA
Prise En main ARDUINO A. Oumnad 22

Simulation sur ISIS:

Vcc Vm
VALUE=5 VALUE=12

C2 C1

100nF 100nF
1 9 4

5
IN1 VCC VS
7 2
0 10
IN2
IN3
OUT1

+88.8
12 3
IN4 OUT2
6 L298
1 11
ENA
ENB OUT3
13

1 14
SENSA OUT4
15
SENSB GND

Exercice
Hardware: On contrôle un moteur CC à l'aide du circuit L298.
Sortie Arduino Entrée L298
2 In1
3 In2
9(PWM) ENA

Programme qui écoute le port série. S'il reçoit


• G moteur gauche
• D Moteur droite
• S Arrêt
• L Roue libre
• + Accélérer
• - Ralentir
Prise En main ARDUINO A. Oumnad 23

Commande d'un moteur PAS à PAS (Stepper)


Il existe différents types de moteurs pas à pas, les moteurs à aimant permanent,
les moteurs à réluctance variable et les moteurs hybrides qui utilisent les deux
technologies. L'objectif de cette page n'est pas de détailler le principe de
fonctionnement de ces différentes technologies. Nous allons nous intéresser
seulement à la façon de commander ces moteurs. En gros on va essayer de voir
comment il faut les brancher et comment il faut faire pour les tourner d'un pas
vers la droite ou vers la gauche.
Les moteurs les plus faciles à commander sont les moteurs unipolaires. Ils ont
quatre bobines comme indiqué sur la figure ci-dessous

Pour les commander, on alimente les bobines séquentiellement.

Chaque fois qu'on passe d'une bobine à la suivante, le moteur tourne d'un seul pas. Pour un moteur 4
pas, l'angle d'un pas est 90°. Pour un moteur 100 pas, l'angle d'un pas fait 3.6°. Pour un moteur 400
pas, l'angle minimum est 0.9°

Voyons maintenant le séquencement de la commande des 4 phases A B C D

Position D C B A
1 0 0 0 1
3 0 0 1 0
5 0 1 0 0
7 1 0 0 0
Prise En main ARDUINO A. Oumnad 24

exercice
Hardware:
On contrôle un moteur 100 pas à l'aide de circuit ULN2003
Software:
Programme qui fait tourner le moteur doucement (1 tours / 10secontes)

exercice
Hardware:
On contrôle un moteur 100 pas à l'aide de circuit ULN2003
Software:
Programme qui écoute le port série. S'il reçoit
• G moteur gauche,, 1 pas/seconde
• D Moteur droite,, 1 pas/seconde
• S Arrêt
• L Roue libre
• + Accélérer
• - Ralentir
Prise En main ARDUINO A. Oumnad 25

Références

Fonctions agissant sur les E/S:


• pinMode(pin, State);
• Permet de configurer une E/S numérique en Entrée ou en Sortie
• pin: numéro de l'E/S
• State: INPUT ou 0 pour Entrée, OUTPUT ou 1 pour Sortie
• digitalWrite(pin, State);
• Permet de forcer une sortie au niveau logique haut ou au niveau logique bas
• pin: numéro de l'E/S
• State: HIGH ou 1 pour le niveau haut, 0 ou LOW pour le niveau bas
• digitalRead(pin);
• retourne l'état d'une entrée numérique
• pin: numéro de l'entrée

• n = analogRead(pin);
• Permet de lire une entrée analogique
• pin: numéro de l'Entrée analogique
• n: entier (int) compris entre 0 et 1023

Les temporisations
• delay(Nms);
• Temporisation: le processeur attend Nms millisecondes avant de continuer le programme
• ddd

afficheur LCD
• LiquidCrystal objet_lcd(RS, E, d4, d5, d6, d7)
• Crée un objet pour commander l'afficheur LCD en mode 4 bits. La pate WR de l'afficheur doit être reliée à la masse
• RS: Numéro de la sortie qui commande la pate RS du LCD
• E: Numéro de la sortie qui commande la pate E du LCD
• D4: Numéro de la sortie qui commande la pate D4 du LCD
• D5: Numéro de la sortie qui commande la pate D5 du LCD
• D6: Numéro de la sortie qui commande la pate D6 du LCD
• D7: Numéro de la sortie qui commande la pate D7 du LCD

• Exemple: LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

• lcd.begin(Nc, Nl)
Initialise l'afficheur LCD
Nc: Nombre de caractères par ligne
Nl: Nombre de ligne de l'afficheur

• lcd.clear()
Efface l'afficheur et ramène le curseur au début de la première ligne

• lcd.setCursor(col, lgn)
Place le curseur à la position (col, lgn), les deux paramètres commencent par 0
Prise En main ARDUINO A. Oumnad 26

• lcd.print(donnée,[base])
Affiche une chaine ou un nombre
Exemples:
lcd.print("Hello world"); // affiche la chaine Hello World
lcd.print(1024); // Affiche le nombre 1024
lcd.print(85, BIN); // affiche le nombre 85 en binaire --> 1010101
lcd.print(255, HEX); // affiche le nombre 255 en hexadécimal --> FF

• lcd.write(caractère)
Affiche un caractère
Exemples:
lcd.write('X'); // affiche le caractère X
lcd.print(65); // Affiche le caractère A