La carte ARDUINO

La carte ARDUINO
1. Qu'est-ce que la carte ARDUINO ?
C'est un circuit imprimé comportant tous les composants électroniques nécessaires pour faire fonctionner un
microcontrôleur (Atmega 328) associé à une interface USB lui permettant de communiquer avec un ordinateur.
Un microcontrôleur est l'équivalent d'un petit ordinateur.
Il contient un microprocesseur (unité centrale) associé à
différentes mémoires et des interfaces lui permettant de
communiquer avec l'extérieur, et bien sûr une horloge
pour cadencer l'ensemble.
L'alimentation électrique peut être fournie par le port USB
ou une alimentation externe qui délivre 5V.
Attention! les tensions appliquées sur les entrées ne doivent
pas dépasser la tension d'alimentation sous peine de destruction du circuit.
Le microcontrôleur exécute en permanence un programme qui a été copié dans sa mémoire flash (EEPROM de
32 kO) depuis un ordinateur via le port USB (interface série).
Ce programme est initialisé à la mise sous tension de la carte ARDUINO ou lorsqu'on actionne le bouton
poussoir "reset" sur la carte.
La carte "ARDUNO uno" que nous allons utiliser dispose de 14 broches ("pin" en anglais, numérotées de 0 à
13) qui peuvent être configurées en "entrées digitales" ou en "sorties digitales" susceptibles de délivrer une
intensité maximale de 40mA sous une tension égale à 0V ou 5V.
Certaines de ces broches peuvent être configurées en "sorties PWM" (Pulse Width Modulation ou modulation
de largeur d'impulsion).
Elle possède également 6 entrées analogiques (notées A0 à A5) permettant de mesurer des tensions comprises
entre 0V et 5V grâce à un convertisseur A/N à 10 bits.
Les broches pin0 et pin1 ne sont pas disponibles pour l'utilisateur de la carte car elles sont utilisées pour
communiquer avec l'ordinateur via le port USB, et sont notées RX (réception) et TX (transmission) sur la carte.
Le port USB de la carte ARDUINO est géré par l'ordinateur comme un port série virtuel (COMx) et il est
nécessaire d'installer les drivers correspondants avant d'établir la liaison ordinateur-Arduino.
1

2. Installation de l'environnement de développement (IDE):
 Télécharger le programme de l'environnement de développement correspondant au système d'exploitation
utilisé sur le site du fabricant www.arduino.cc onglet "download".
Par exemple sous windows télécharger le fichier compressé "arduino-1.0.1-windows.zip" (ou une version
plus récente).
 Décompresser le fichier ZIP téléchargé, puis copier le répertoire obtenu "arduino-1.0.1" à l'emplacement de
votre choix, par exemple dans C://Program Files.
 Ouvrir le répertoire puis créer sur le bureau un raccourci pour ouvrir "arduino.exe".
 Brancher la carte ARDUINO sur un port USB de l'ordinateur.
Si la fenêtre "Nouveau matériel détecté" s'ouvre, ne laissez pas Windows update s'en mêler et cochez la
case "Non, pas pour cette fois", puis cliquez sur "Suivant".
Dans la fenêtre qui s'affiche, cochez la case "Installer à partir d'un emplacement spécifié", puis "Suivant".
Dans la nouvelle fenêtre, sélectionner "Parcourir" puis indiquer le chemin du sous-répertoire "drivers" dans le
répertoire "arduino" créé précédemment.
Autoriser Windows à installer le pilote.
Après avoir terminé l'installation de l' USB Sérial Converter, une séquence de "nouveau matériel détecté"
peut s'ouvrir à nouveau pour installer l' USB Sérial Port, et il faut refaire la même procédure mais en
indiquant le chemin de FTDI USB Drivers.
Sinon, il faut aller dans le Panneau de configuration / Système / Gestionnaire de Périphériques / Autres
Périphériques / Arduino Uno Général / Mettre à jour le pilote / Rechercher un pilote sur mon ordinateur /
Parcourir
puis indiquer le chemin du sous-répertoire "drivers" dans le répertoire "Arduino" créé précédemment.
Autoriser Windows à installer le pilote.
Dans le Panneau de configuration / Système / Gestionnaire de Périphériques une nouvelle ligne apparait
correspondant à la création d'un convertisseur USB-Série.
noter le numéro affecté au port COM créé (ici le COM6).
A partir de maintenant, la carte ARDUINO sera reconnue comme n'importe quel périphérique USB
dès sa connexion au PC.
 Cliquer sur le raccourci "arduino.exe" créé précédemment pour lancer l'environnement de développement.
Dans le menu "Fichier" puis "Préférences", choisir la langue "français" si ce n'est déjà fait.
Puis dans "Outils" vérifier le type de carte utilisé (Arduino UNO) puis indiquer le numéro du port affecté par
l'ordinateur (ici le COM6).
Remarque: On peut vérifier rapidement le numéro de port COM affecté par
l'ordinateur à l'Arduino en cliquant sur "Démarrer" puis "Périphériques et
Imprimantes".
Attention! si d'autres ports COM virtuels ont été créés précédemment sur le
PC, la carte Arduino ne pourra pas fonctionner sur un numéro de port partagé,
même si l'autre périphérique n'est pas branché.
On peut éventuellement modifier le numéro du port affecté à la carte Arduino
en allant dans Panneau de configuration / Système / Gestionnaire de Périph. /
Ports (COM et LPT)/ Communications Port/ Paramètres du port/ Avancé/
numéro de port.
Il faut également veiller à brancher la carte Arduino toujours sur le même
port USB de l'ordinateur.
TRANSFERER
VERIFIER
OUVRIR
MONITEUR
SERIE
2

3. Testons notre premier programme:
2.1. Le protocole de transfert:
 Ouvrir l'environnement de développement (I.D.E.) en cliquant sur l'icône qui est sur le bureau.
 Aller sur le site d'ISN (physiquepovo.com) en utilisant Mozilla Firefox et télécharger le fichier "Blink" qui
se trouve page 12.
Ce programme a simplement comme objectif de faire clignoter une DEL déjà connectée entre la borne 5 de
l'Arduino et la masse du montage (via une résistance de protection).
 Copier le script du programme dans la fenêtre principale de l'I.D.E.
 Cliquer sur l'icône "vérifier" de façon à déceler d'éventuels bugs dans la structure du programme (cela sera
surtout nécessaire pour tester nos propres programmes).
La taille du programme apparait dans la fenêtre d'édition en bas.
 Sélectionne dans "Outils" puis "Port Série" le n° du port série attribué à l'Arduino.
 Cliquer sur l'icône "transférer (téléverser)" afin d'enregistrer ce programme dans la mémoire flash de
l'Arduino qui va ensuite l'exécuter en boucle.
2.2. Structure d'un programme Arduino:
Le langage de programmation Arduino dérive du langage C++ et il en respecte les règles de syntaxe:
* Une ligne qui commence par "//" est considérée comme un commentaire
* Un paragraphe qui commence par "/*" et qui se termine par "*/" est considéré comme un commentaire
* Toute ligne d'instruction de code doit se terminer par un point virgule ";"
* Un bloc d'instructions (définition d'une fonction, boucle "while" ou "if"/"else"...) doit être délimité par
des accolades ouvrantes "{" puis fermantes "}".
* Toutes les variables doivent être déclarées, ainsi que leur type (int,float,...) avant d'être utilisées.
Un programme (ou "sketch") Arduino est constitué de 2 fonctions distinctes:
* La fonction de configuration "void setup" exécutée une seule fois au lancement du programme.
* La fonction "void loop" qui est ensuite exécutée indéfiniment en boucle.
Remarque: On peut relancer le programme en actionnant le bouton poussoir "reset" sur la carte.
2.3. Etude d'un exemple: le programme "Blink":
int DEL = 5; ou #define DEL 5;
On donne un nom à la broche 5 de façon à la repérer plus facilement dans le script: c'est celle qui est reliée
à la DEL que l'on souhaite faire clignoter.
On crée ainsi une nouvelle variable nommée "DEL" de type "nombre entier (int)".
void setup()
{
pinMode(DEL, OUTPUT); On initialise la borne 5 de l'Arduino (nommée "DEL") comme une sortie.
}
void loop()
{
digitalWrite(DEL, HIGH); On met la borne 5 au niveau logique haut (+5V): la diode s'allume.
delay(1000); On attend un délai de 1000ms (soit 1s).
digitalWrite(DEL, LOW); On met la borne 5 au niveau logique bas (0V): la diode s'éteint.
delay(1000); On attend un délai de 1000ms (soit 1s).
}
Et ainsi de suite tant que le circuit est alimenté.
Modifier ce script de façon à ce que ce soit la DEL reliée à la sortie numérique 6 de l'Arduino qui clignote,
en restant 1,5s éteinte et 0,5s allumée.
Puis faire clignoter les deux DELs de façon à ce que lorsque l'une est allumée, l'autre soit éteinte.
3

4. Améliorons notre premier programme:
3.1. Affichage d'un texte dans le moniteur série:(Blink1)
Pour afficher "la DEL clignote avec une période de 2s" dans le moniteur série que l'on peut ouvrir en
cliquant sur l'icône située en haut à droite de l'environnement de développement, il faut:
* ouvrir la liaison série entre l'Arduino et l'ordinateur via le câble USB en intégrant le script
Serial.begin(9600); dans la fonction "setup" (9600 définit en baud le nombre de bits échangés par seconde).
* introduire dans la fonction "loop" le script associé au texte à écrire à l'écran (en évitant les caractères
accentués: é, è, ê, à, ...) suivi d'un saut à la ligne:
Serial.println("la DEL clignote avec une periode de 2s");
 Teste ce nouveau programme et ouvre le moniteur série. Que constates-tu ?
 Modifie le script de façon à éviter ces répétitions. Détaille ton algorithme.
3.2. Clignotement conditionnel:(Blink2)
On souhaite maintenant provoquer le clignotement ou l'allumage continu de la DEL selon que la borne 10 de
la carte Arduino est portée au niveau logique haut (+5V) ou au niveau bas (0V).
Pour cela, on va utiliser le bouton poussoir situé en bas à gauche de la carte: lorsqu'il est enfoncé, la borne 10
est au niveau bas, sinon elle est au niveau haut.
 La borne 10 de l'Arduino doit-elle être configurée en entrée ou en sortie ?
 Ecris et teste le script correspondant, après avoir conçu l'algorithme adapté à ces consignes, sachant que:
* Le script pinMode(10, INPUT); initialise la borne 10 de l'Arduino comme une entrée numérique.
* Le script etat=digitalRead(10); permet de lire l'état "haut" ou "bas" de la borne 10 de l'Arduino et de le
mémoriser dans une variable nommée "etat" (qui doit être définie au préalable!).
 Complète ce script de façon à afficher dans l'environnement de développement "la DEL est allumée" ou
"la DEL clignote" une seule fois à chaque changement d'état.
3.3. Commande via le moniteur série:(Blink3)
Le moniteur série permet d'afficher des informations (textes, valeurs des variables,...) en provenance de
l'Arduino, mais il permet aussi d'envoyer des informations tapées au clavier de l'ordinateur vers l'Arduino.
L'objectif à atteindre est de provoquer l'allumage de la DEL en envoyant le caractère "A", son extinction en
envoyant le caractère "E" et son clignotement en envoyant le caractère "C".
 Ecris et teste le script correspondant, après avoir conçu l'algorithme adapté à ces consignes, sachant que:
if (Serial.available() > 0) // lit l'octet entrant s'il y a des données disponibles sur le port série
{
lettreLue = Serial.read(); // la lettre correspondant à l'octet reçu est mémorisée dans la variable "lettreLue"
if ((lettreLue = = 'A') || (lettreLue = = 'E') || (lettreLue = = 'C')) // le "ou" logique correspond à || (ALT GR + touche 6)
{
lettre = lettreLue; // la variable "lettre" ne peut contenir que les caractères "A","E" ou "C" en excluant
} tout autre caractère reçu.
}
4

5. Le typage des variables:
En javascript, il suffisait de déclarer une variable « var bidule ; » avant de l’utiliser sans préciser son type qui
peut être : nombre entier, nombre décimal, chaine de caractère,…
Cela peut paraître plus simple mais gaspille de l’espace mémoire (pour pouvoir caser n’importe quoi dans un
tiroir il faut forcément prévoir au départ un grand tiroir !) et n’est pas sans poser de problème.
Par exemple : var bidule = 3 ; var machin = 5 ; Quel est le contenu de : var somme = bidule+machin ;
En langage Arduino, il faut indiquer le type de variable que l’on souhaite créer lorsqu’on la crée.
int variable1 est codée sur 16 bits et peut donc contenir un nombre entier compris entre –32768 et +32768.
float variable2 est codée sur 32 bits et peut contenir un nombre décimal (presque) quelconque.
boolean variable3 est une donnée logique qui ne peut prendre que 2 valeurs : « true » ou « false » ou encore
« high » et « low » ou même 1 ou 0.
Codée sur seulement 8 bits, elle convient pour les entrées ou sorties numériques (ou digitales).
char variable4 = 'A' ; peut contenir n’importe quel caractère alphanumérique (lettre, chiffre)
les tableaux (array) peuvent contenir n’importe quel type de variable défini précédemment.
Le nom de la variable est terminé par des crochets[] mais le type « array » n’est pas indiqué… il est
remplacé par le type de variable qu’il contient.
Exemples: int variable5[ ] = {2,0,1,3} ; ou char variable6[ ] = « bonjour » ;
On peut accéder à n’importe quel élément d’un tableau, sachant que les indices commencent par 0 à gauche.
Ainsi : variable5[2] = = 1 et variable6[3] = = 'j'
Les chaines de caractère (string) sont en fait considérées comme des tableaux contenant des caractères.
Les notations suivantes sont donc équivalentes :
char variable6[ ] = « bonjour » ; ou char variable6[ ] = { 'b' , 'o' , 'n' , 'j' , 'o' , 'u' , 'r' , '\0' } ;
Remarque: une chaine de caractère doit toujours être terminée par un caractère nul '\0' qui est pris en compte
dans le calcul de la longueur de la chaine. Si on oublie de le mettre, il est rajouté automatiquement !
char* variable7[ ] = { « message1 », « message2 », « message3 »} ; définit un tableau de chaines.
On obtient ainsi par exemple : variable7[0] = = message1
6. Entrées analogiques et sorties PWM:
5.1. Les entrées analogiques:
La carte Arduino Uno dispose de 6 entrées analogiques notées A0, A1,…A5 mais d’un seul convertisseur
analogique/numérique sur 10 bits. La durée d’une conversion est de l’ordre de 100µs.
La donnée numérique qu’il fournit après conversion est donc comprise entre 0 et …….
Il n’est pas nécessaire d’initialiser ces entrées analogiques qui n’ont que cette seule fonction.
int valeur4 = map(analogRead(4),0,1023,0,255) ; permet de lire la valeur numérique de la tension
analogique présente sur l’entrée A4 et de la transformer en une valeur comprise entre 0 et 255.
5.2. Les sorties analogiques (ou plutôt PWM):
La carte Arduino Uno dispose de 6 sorties (3,5,6,9,10 et 11) qui peuvent être utilisées en mode PWM, c'est-
à-dire en modulation de largeur d’impulsion.
Ce sont des signaux logiques binaires de fréquence constante (500Hz)
mais de rapport cyclique variable.
Lorsqu’un moteur ou une lampe est alimenté par ce type de tension,
tout se passe comme si il était alimenté par une tension continue
ajustable entre 0V (rapport cyclique= 0) et 5V (rapport cyclique=255).
Ces sorties doivent être initialisées comme des sorties digitales.
analogWrite ( 5 , 200 ) ; permet d’envoyer un rapport cyclique 200 sur la sortie digitale 5.
0,4ms
0,8ms
1,2ms
2ms
5