Ministère de l’Enseignement Supérieur et

de la Recherche Scientifique

*****************
Direction Générale des Etudes Technologiques

*****************
Institut Supérieur des Etudes Technologiques de Djerba

*****************
Département Technologies de l’Informatique

Fascicule de Travaux Pratiques

Atelier Interfaces et
Communication
(ARDUINO)

Élaboré par :
Slah MHAYA

Public cible :
Classe de 2ème année
Licence Technologies de l’Informatique
(Système Embarqué et Mobile)

Version 2016
 AVANT-PROPOS

Ce support est consacré à la mise en œuvre d’applications d’interfaçage et d’exploitation des différents
protocoles de communication par un microcontrôleur.

Cet atelier permet à l’étudiant d’acquérir des compétences pratiques lui permettant de concevoir et de
déployer une solution sous l’environnement Arduino. A la fin de cet atelier, l’étudiant sera capable mettre en
œuvre une application d’interfaçage et de communication via les protocoles les plus standards (série,
OneWire, parallèle,..)

Comme pré requis, cet atelier nécessite des connaissances de base en architecture et systèmes
(Systèmes Industriels), Réseaux et Protocoles, les microcontrôleurs et leur programmation.

Le support présente neuf ateliers, dont chacun est précédé par une partie intitulée «Présentation ». Cette
partie vise d’une part, à faire le lien avec les parties théoriques en question, et d’autre part, à se rappeler des
concepts de bases nécessaires.

Le premier TP (TP1 : commande d’une diode LED) est précédé par une présentation sous forme de
diapositives, au cours de laquelle il y’aura une description de l’environnement Arduino (matériel et logiciel).
Cette présentation est disponible en consultation dans l’espace de cours réservé à notre institut sur la
plateforme MOODLE à l’adresse ent.uvt.rnu.tn.

Le contenu, ainsi que l’enseignement pédagogique de cet atelier peut toujours évoluer en fonction des
critiques et remarques constructives des lecteurs.

2
 SUIVI DES VERSIONS DU SUPPORT

Version Date Auteurs Raisons Collaboration et révision

0 2016 MHAYA Slah

Pré requis
Architecture et systèmes
Programmation des microcontrôleurs

Objectifs généraux

Cet atelier vise à Mettre en œuvre des applications d’interfaçage, de gestion

Atelier Interfaces et communication

d’Entrées/Sorties et de communication sur l’environnement Arduino

Niveau cible

Classe : 2ème année

Licence : Technologies de l’Informatique
Parcours : Système Embarqué et Mobile

Volume horaire
- 3h de Travaux Pratiques pour chaque groupe
Soit en total : 45h

Moyens pédagogiques
- PC
- Carte Arduino
- Périphériques d’E/S
- Vidéoprojecteur

Evaluation
- Coefficient : 2
- Note non présentielle : 20%
- Moyenne des TP : 80%

3
Atelier Interfaces et Communication TRAVAUX PRATIQUES

Plan

-Travaux pratique N°1 :

Commande d’une diode LED

-Travaux pratique N°2 :

Utilisation d’un bouton poussoir

-Travaux pratique N°3 :

Gestion du clavier
-Travaux pratique N°4 :

Commande d’un afficheur LCD

-Travaux pratique N°5 :

Gestion de la conversion A/N

-Travaux pratique N°6 :

L’acquisition de la température et de l’humidité : le capteur

DHT11
-Travaux pratique N°7 :

Mesure de la distance : le capteur HC-SR04

-Travaux pratique N°8 :

Commande d’un servomoteur

-Travaux pratique N°9 :

Interfaçage Labview - Arduino (initiation)

4
 TP 1 : COMMANDE D’UNE DIODE LED

 Objectifs spécifiques :

Le but de ce TP est de commander une diode LED à l’aide d’une carte Arduino UNO.
A la fin du TP, l’étudiant sera capable de réaliser un clignotement et un jeu de lumière à l’aide de plusieurs
diodes LED.

 Volume horaire :

3 heures

5
1 Présentation :

La diode électroluminescente (LED) émet de la lumière. Elle est polarisée: la patte “+” est la plus longue, l’autre patte
est la patte “-”. Les broches numériques de l’Arduino, lorsqu’elles sont configurées en sorties et qu’elles sont à l’état
1 ou haut (HIGH), fournissent une tension de 5 volts, supérieure à ce que peut accepter une LED. Les LED doivent
donc être couplées en série avec une résistance (sauf pour la broche numérique 13 qui est déjà câblée en série avec
une résistance de valeur moyenne pour une LED ( 1K ohm ), on peut donc, dans la plupart des cas, directement lui
brancher une LED).

Figure 1 : image et symbole d'une LED

Comment calculer la valeur de la résistance à ajouter en série avec la diode LED :

Figure 2 : Tension et courant de seuil d'une LED

Résistance (en Ohms) = (5 – Vf)/If

Figure 3 : Code couleurs des résistances

2 Manipulation 01 :
Le but de cette manipulation est de faire clignoter une diode LED toutes les secondes.

2.1 Schéma de câblage :

Réalisez le montage de la figure suivante :

6
 Figure 4 : branchement d'une diode LED

Vous notez l’utilisation d’une résistance en série avec la diode LED pour minimiser l’appel en courant.

2.2 Programmation de la carte :

Lancez l’application ARDUINO et ouvrez l’exemple « Blink » (Fichier>Exemples>01.Basics>Blink).

2.2.1 Explication du code ARDUINO :

Figure 5 : Structure d'un programme ARDUINO

Une fois la dernière ligne exécutée, la carte revient au début de la troisième phase et recommence sa lecture et son
exécution des instructions successives. Et ainsi de suite. Cette boucle se déroule des milliers de fois par seconde et
anime la carte.

2.2.2 Vérification et chargement du programme :

A présent, il faut vérifier la syntaxe du programme et s’il n’y a aucune erreur l’envoyer vers la carte ARDUINO.

7
 Figure 6 : Vérification et chargement du programme

Une fois le chargement du programme terminé, la LED commencera à clignoter.

3 Manipulation 02 :
Modifiez le programme précédent pour commander deux diodes LED (choisissez les broches de votre choix)

4 Manipulation 03 :
En utilisant six diodes LED, réalisez un jeu de lumière (exemple : un chenillard)

8
TP 2 : UTILISATION D’UN BOUTON POUSSOIR

 Objectifs spécifiques :

Le but de ce TP est la gestion du bouton poussoir. A la fin du TP l’étudiant sera capable de lire l’état d’un
bouton et de réaliser un traitement selon cet état (commander une diode LED ou afficher un message)

 Volume horaire :

6 heures

9
1 Présentation :
Les boutons sont les capteurs les plus simples. En appuyant sur un bouton, on connecte ses fils, de telle sorte que le
bouton agit comme un interrupteur. En relâchant le bouton, on interrompt le circuit. Il existe des boutons de
différentes tailles et formes. Quand on utilise une plaque à essais, il est pratique d’employer un bouton avec quatre
fils. Les fils fonctionnent par paires, si bien que deux fils adjacents sont toujours connectés l’un à l’autre.

Figure 7 : Différentes vues d'un bouton poussoir

Pour lire une broche de donnée, elle doit être connectée à quelque chose. On ne doit pas lire une broche qui n’est
pas connectée car son état est instable. Une résistance pull-up met la broche à l’état haut (HIGH) quand elle n’est
pas connectée ce qui évite son instabilité.

2 Manipulation 01 :
Au cours de cette manipulation, nous allons commander une diode LED à l’aide d’un bouton poussoir. Lorsqu’on
appuie sur le bouton, la LED va allumer et lorsqu’on relâche le bouton la LED s’éteindra.

2.1 Schéma de câblage :

Réalisez le montage de la figure qui suit et n’oubliez pas d’ajouter la LED à la broche de votre choix.

Figure 8 : Branchement d'un bouton poussoir

2.2 Programmation de la carte :

Pour lire l’état du bouton poussoir vous devez utiliser la fonction : digitalRead (broche).

3 Manipulation 02 :
Modifiez le programme précédent de telle sorte que le premier appui sur le bouton poussoir allume la diode LED et
que le second appuie l’éteint.

10
4 Manipulation 03 :
Nous allons réaliser un dé numérique à l’aide de trois diodes LED. L’appuie sur le bouton poussoir va générer un
numéro aléatoire entre 1 et 6 ; le numéro obtenue sera codé de la façon suivante :

Figure 9 : Combinaisons du dé numérique

Bonus :

Pour générer un numéro aléatoire, vous devez utiliser les fonctions randomSeed() et random().

11
 TP 3 : GESTION DU CLAVIER

 Objectifs spécifiques :

Le but de ce TP est la gestion du clavier. L’étudiant sera capable à la fin de ce TP de lire un code à partir du
clavier pour réaliser un traitement spécifique en sortie.

 Volume horaire :

6 heures

12
1 Présentation :
Le clavier dispose de 12 touches arrangées selon la matrice des téléphones sur une grille de 3X4. Les touches sont
reliées sur une matrice, il suffit donc de 7 pins d'un microcontrôleur pour pouvoir l'utiliser (3 colonnes et 4 lignes).

Figure 10 : Clavier numérique 3x4 à ruban

2 Manipulation 01 :
Au cours de cette manipulation, vous devez réaliser un montage qui permet de lire le numéro du bouton appuyé par
l’utilisateur et d’envoyer son code sur le moniteur série de l’Arduino.

2.1 Schéma de câblage :

Réalisez le montage de la figure qui suit :

Figure 11 : Branchement du clavier à la carte ARDUINO

2.2 Programmation de la carte :

Pour réaliser votre programme, vous devez utiliser la bibliothèque Arduino spécifique du clavier matriciel (keypad
en anglais). A noter que cette librairie n'est pas installée par défaut et qu'il faut la télécharger. Lancez le logiciel
ARDUINO, ensuite allez à Croquis>Inclure une bibliothèque>Gérer les bibliothèques. Tapez le mot « keypad »,
« more info » puis « installer ».

13
 Figure 12 : Ajout d'une bibliothèque

Bonus :

Pour communiquer avec le moniteur série de l’Arduino, il faut utiliser la bibliothèque Serial (Serial.begin,
Serial.print, Serial.println,…)

Vous pouvez vous inspirer de l’exemple « HelloKeypad » de la bibliothèque Keypad.

3 Manipulation 02 :
Au cours de cette manipulation vous allez réaliser une serrure codée.

Principe de fonctionnement :

Un code à plusieurs chiffres (4 chiffres par exemple) doit être saisi par l’utilisateur pour ouvrir une porte. Le
programme commence par envoyer le message « Saisir code » sur le moniteur série. Si le code saisi est correct, une
diode LED s’allume et le message « code correct » est envoyé sur le moniteur série, sinon le programme envoie le
message « code erroné » suivi de « Saisir code ».

14
 TP 4 : COMMANDE D’UN AFFICHEUR LCD

 Objectifs spécifiques :

Le but de ce TP est de commander un afficheur LCD. L’étudiant sera capable d’afficher des messages et
gérer la position du curseur de l’afficheur

 Volume horaire :

6 heures

15
1 Présentation :
Les afficheurs LCD (Liquid Crystal Display) sont devenues incontournables dans toute application qui demande la
visualisation de paramètres, il s’agit donc d’une interface Homme/Machine. Ils sont très utilisés dans les montages à
microcontrôleur, et permettent une grande convivialité. Au cours de ce TP nous allons utiliser un afficheur LCD
alphanumérique de 2x16 caractères représenté par la figure ci-dessous :

Figure 13 : Afficheur LCD 2x16

2 Brochage de l’afficheur LCD 2x16 :

Le tableau suivant donne une description de la fonction de chaque broche :

Tableau 1 : Brochage de l'afficheur LCD

N.B : Les broches 15 et 16 ne sont présentes que sur les afficheurs LCD avec rétroéclairage avec :

15 : A : Anode rétroéclairage (+5V)

16 : K : Cathode rétroéclairage (masse)

En observant le brochage de l’afficheur, on constate qu’il faut un minimum de 6 sorties pour le commander. En effet,
si on utilise l’adressage sur 4 bits et que l’on se prive de la lecture dans l’afficheur, il nous faut commander les six
broches EN, RS, D4, D5, D6, et D7.

Ce mode 4 bits est bien pratique quand on utilise un petit microcontrôleur où le nombre d’entrées/sorties est très
limité. En contrepartie, le mode 4 bit complique un petit peu le protocole de communication (logiciel) puisque qu’il
faut passer la donnée 8 bits en deux fois (4 + 4 = 8 ). Ce passage s’effectue comme suit :

D7 = Bit Donnée 7, D6 = Bit Donnée 6, D5 = Bit Donnée 5, D4 = Bit Donnée 4

puis :

D7 = Bit Donnée 3, D6 = Bit Donnée 2, D5 = Bit Donnée 1, D4 = Bit Donnée 0

En mode 4 bits, les broches D0, D1, D2, D3 doivent rester « en l’air » (non connectées).

16
A l’inverse, si on utilise toutes les broches de l’afficheur il faut 11 sorties pour le commander. Mais cela n’apporte
rien de plus; en mode 4 bits toutes les fonctionnalités sont disponibles.

3 Manipulation 01 :
Le but de cette première manipulation et d’afficher un texte fixe sur l’écran LCD (votre nom et prénom par exemple)

3.1 Schéma de câblage :

Branchez l’écran LCD à votre carte Arduino comme indiqué dans le schéma suivant :

Figure 14 : branchement de l'écran LCD

3.2 Programmation de la carte :

Lancez l’application ARDUINO et ouvrez l’exemple « HelloWorld » qui se trouve sous :

Fichier > Exemples > LiquidCrystal > HelloWorld. Adaptez le code pour afficher votre nom et prénom (sur deux
lignes). Si vous ne trouverez pas la bibliothèque « LiquidCrytal », il faut l’ajouter

Bonus :

Ajouter une animation au texte affiché : clignotement, défilement à droite, défilement à gauche.

Pour se faire, utilisez les fonctions lcd.scrollDisplayLeft() et lcd.scrollDisplayRight()

4 Manipulation 02 :
Reprenez la manipulation du TP précédent (serrure codée) et utilisez l’afficheur LCD à la place du moniteur série.

5 Manipulation 03 :
Vous allez réaliser un jeu où il faut deviner un nombre choisi au hasard par le programme (fonction
random(Min,MAX+1)) . Le jeu commence par afficher le message « Devine un nombre entre Min et Max » (avec Min
et Max : les limites inférieure et supérieure des nombres à deviner). Après chaque tentative, le programme vous

17
dira si le nombre que vous avez proposé est trop grand, trop petit, ou si vous avez trouvé la bonne réponse et après
combien d’essais.

Exemple d’exécution :

Devine un nombre de 1-30 :

15

Trop petit

22

Trop grand

17

Trop grand

16

Exact

4 essais

18
 TP 5 : GESTION DE LA CONVERSION A/N

 Objectifs spécifiques :

Le but de ce TP est d’exploiter le convertisseur Analogique/Numérique de la carte Arduino UNO. L’étudiant

sera capable de lire une grandeur analogique et de l’exploiter dans un programme pour traitement
spécifique.

 Volume horaire :

6 heures

19
1 Présentation :
En plus des pattes numériques, l’Arduino possède 6 pattes (A0..A5) qui peuvent être utilisées comme entrées
analogiques. Ces entrées prennent un voltage (entre 0 et 5V) et le convertissent en un nombre compris entre 0 (0V)
et 1023 (5V) (résolution de 10 bits). Un composant très utile qui utilise ces entrées est le potentiomètre (aussi
appelé résistance variable). Quand il est connecté avec 5V entres ces pattes extérieures, la patte centrale ressort des
valeurs comprises entre 0 et 5V en fonction de l’angle selon lequel son axe est tourné (ex : 2,5V au milieu). Cette
valeur peut être ensuite utilisée comme variable dans le programme.

Figure 15 : Entrées analogiques de la carte Arduino UNO

2 Manipulation 01 :
Lors de cette manipulation, vous allez réaliser un programme qui permet de lire la valeur analogique délivrée par le
potentiomètre sur l’une des entrées analogiques et d’afficher le résultat sur le moniteur série de l’Arduino.

2.1 Schéma de câblage :

Réalisez le schéma de câblage suivant :

Figure 16 : Branchement d'un potentiomètre

2.2 Programmation de la carte :

Pour lire une entrée analogique, utilisez la fonction AnalogRead().

3 Manipulation 02 :
Lors de la précédente manipulation, vous avez remarqué que les valeurs affichées sur le moniteur série sont
comprises entre 0 et 1023. Modifiez votre programme pour qu’il calcule les valeurs réelles de la tension lue
(comprises entre 0 et 5V) et les affiche sur un afficheur LCD.

20
Bonus :

Vous pouvez utiliser la fonction map() pour passer de la valeur numérique (0-1023) à la valeur analogique (0-5).

4 Manipulation 03 :
Commandez le clignotement d’une diode LED à l’aide du potentiomètre : plus la valeur de la tension lue est grande,
plus le clignotement de la diode est rapide et inversement.

5 Manipulation 04 :
Commandez la luminosité d’une diode LED à l’aide du potentiomètre : plus la valeur de la tension lue est grande,
plus la luminosité de la diode augmente et inversement.

Bonus :

Il faut brancher la diode LED sur l’une des pins de l’ARDUINO (3, 5, 6, 9, 10 et 11) qui utilisent le PWM. Pour
commander la diode LED, utilisez la commande AnalogWrite(). Il est à noter que le rapport cyclique de la sortie
PWM varie de 0 à 255. Pensez à utiliser encore une fois la fonction map().

6 Manipulation 05 :
Réalisez une jauge électronique à l’aide de 5 diodes LED : plus la tension augmente plus le nombre de diodes
allumées augmente

Tableau 2 : Etat de la jauge

Valeur de la tension en Volt Etat de la jauge

0

3
4

21
TP 6 : L’ACQUISITION DE LA TEMPERATURE
ET DE L’HUMIDITE : LE CAPTEUR DHT11

 Objectifs spécifiques :

Le but de ce TP est de faire l’acquisition de l’information envoyée par le capteur numérique DHT11.
L’étudiant sera capable de gérer une communication OneWire et d’exploiter les informations acquises à
savoir la température et l’humidité

 Volume horaire :

3 heures

22
1 Présentation :
Le capteur DHT11 est constitué d’un senseur de température à base d'une thermistance à coefficient négatif de
température et d’un capteur d’humidité résistif. Un microcontrôleur intégré s’occupe de faire les mesures, de les
convertir et de les transmettre. Le DHT11 fait partie des circuits numériques qui dialoguent au moyen d'une seule
ligne série bidirectionnelle de type OneWire (Un fil).

Figure 17 : Brochage du capteur DHT11

1.1 Caractéristique du capteur DHT11 :

• Mesure de l'humidité relative (RH)

• Alimentation comprise entre 3 Vcc et 5.5 Vcc.

• Courant d'alimentation : 100 μA maximum en veille, 2.5 mA maximum en dialogue.

• Mesures des températures comprises entre 0 °C et 50 °C.

• Mesures d'humidité entre 30 % et 90% RH à 0°C.

entre 20 % et 90% RH à 25°C.

entre 20 % et 80% RH à 50°C.

• Résolution 1 % RH.

• Précision à 25 °C : ± 5% RH.

2 Manipulation 01 :
Téléchargez la bibliothèque « DHT11 » et ajoutez-la au dossier des bibliothèques de l’Arduino.

Réalisez le branchement conformément à la figure 18 et exécutez l’exemple de la bibliothèque.

Testez le bon fonctionnement du programme en affichant les résultats sur le moniteur série.

23
 Figure 18 : branchement du capteur DHT11

3 Manipulation 02 :
Modifiez le programme précédent pour afficher les valeurs de la température et de l’humidité sur un afficheur LCD.

Ajoutez deux diodes LED l’une pour contrôler la température et l’autre pour l’humidité (les LED s’allumeront
lorsqu’on atteint un seuil bien déterminé de température ou d’humidité ; essayez de faire varier les valeurs de
température et d’humidité pour atteindre ces seuils et allumer les LED)

Bonus :

La ligne de connexion (DATA) peut faire jusqu'à 20 m de longueur entre le capteur et la carte Arduino, dans ce cas il
faut diminuer la valeur de R à 4,7 kW.

24
 TP 7 : MESURE DE LA DISTANCE :
LE CAPTEUR HC-SR04

 Objectifs spécifiques :

Le but de ce TP est de détecter un obstacle et de renvoyer une distance en utilisant le capteur ultrason HC-
SR04. L’étudiant sera capable de faire des traitements spécifiques selon la distance acquise.

 Volume horaire :

6 heures

25
1 Présentation :
Le capteur HC-SR04 utilise les ultrasons pour déterminer la distance d'un objet. Il offre une excellente plage de
détection sans contact, avec des mesures de haute précision et stables. Son fonctionnement n'est pas influencé par
la lumière du soleil ou des matériaux sombres, bien que des matériaux comme les vêtements puissent être difficiles
à détecter.

1.1 Caractéristiques :
 Dimensions : 45 mm x 20 mm x 15 mm
 Plage de mesure : 2 cm à 400 cm
 Résolution de la mesure : 0.3 cm
 Angle de mesure efficace : 15 °
 Largeur d'impulsion sur l'entrée de déclenchement (Trigger Input Pulse width) : 10 µs

Le capteur dispose de 4 bornes :

 Vcc : alimentation en 5V
 Trig : entrée. Une impulsion (5V) supérieure à 10µs permet de lancer la mesure.
 Echo : sortie. La durée de l’impulsion correspondra à la distance.
 Gnd : commun

Figure 19 : brochage du HC-SR04

1.2 Principe de fonctionnement :

Pour déclencher une mesure, il faut présenter une impulsion "high" (5 V) d'au moins 10 µs sur l'entrée "Trig". Le
capteur émet alors une série de 8 impulsions ultrasoniques à 40 kHz, puis il attend le signal réfléchi. Lorsque celui-ci
est détecté, il envoie un signal "high" sur la sortie "Echo", dont la durée est proportionnelle à la distance mesurée.

Figure 20 : Principe de fonctionnement du HC-SR04

26
1.3 Calcul de la distance :
La distance parcourue par un son se calcule en multipliant la vitesse du son, environ 340 m/s par le temps de
propagation, soit : d = v · t (distance = vitesse · temps).

Le HC-SR04 donne une durée d'impulsion en dizaines de µs. Il faut donc multiplier la valeur obtenue par 10 µs pour
obtenir le temps t.

On sait aussi que le son fait un aller-retour. La distance vaut donc la moitié.

d = 34000 cm/1000000 µs · 10us · durée / 2

En simplifiant d =170000 /1000000 cm · durée

Finalement, d = 17/100 cm · durée

La formule d = durée/58 cm figure aussi dans le manuel d'utilisation du HC-SR04 car la fraction 17/1000 est égale à
1/58.8235.

Note : A grande distance, la surface de l'objet à détecter doit mesurer au moins 0.5 m²

2 Manipulation 01 :
Téléchargez une des bibliothèques du capteur HC-SR04 disponibles.

Ecrire un programme qui permet de lire la distance à partir du capteur et d’envoyer l’information sur le moniteur
série de l’Arduino (la distance doit être exprimée en cm).

2.1 Schéma de câblage :

La figure suivante donne le branchement du capteur sur la carte

Figure 21 : Branchement du capteur HC-SR04

27
3 Manipulation 02 :
Ajoutez un deuxième capteur à votre montage. Le but est de réaliser un détecteur d’obstacle. Le premier capteur
détecte un obstacle à droite (distance inférieur à 5 cm par exemple) et votre programme affiche le message
« obstacle à droite » sur le moniteur série et le deuxième capteur détecte un obstacle à gauche et le programme
affiche « obstacle à gauche ».

Bonus :

Vous pouvez ajouter deux diodes LED pour signaler l’approche d’un obstacle (une de chaque côté)

4 Manipulation 03 :
Modifier le montage précédent en ajoutant un afficheur LCD. Le but de cette manipulation est d’afficher tous les
messages sur l’écran de l’afficheur au lieu de les envoyer au moniteur série

28
 TP 8 : COMMANDE D’UN SERVOMOTEUR

 Objectifs spécifiques :

Le but de ce TP est de comprendre le fonctionnement d’un servomoteur et de pouvoir le commander.

L’étudiant sera capable de spécifier la position exacte du servomoteur et d’envoyer la commande
correspondante.

 Volume horaire :

6 heures

29
1 Présentation :
Les servomoteurs sont des actionneurs très utilisés en modélisme et dans l’industrie. Ils ont comme caractéristique
principale leur « couple », c'est-à-dire la force de rotation qu’ils peuvent exercer. Plus un servomoteur aura de
couple et plus il pourra actionner des « membres » lourds comme déplacer un bras qui porte une charge.

Pour la robotique de loisirs, les servomoteurs ont en général peu de couple et sont de taille réduite, bien adaptée à
un encombrement minimal et à une énergie disponible limitée.

Figure 22 Le servomoteur

Les servomoteurs sont pilotés par un fil de commande et alimentés par deux autres fils.

Habituellement, ces 3 fils sont rassemblés dans une prise au format standard.

Un fil rouge est relié à l’alimentation positive (+5 ou +6 V selon le servomoteur), le fil noir est relié à la masse (GND)
et le fil jaune est utilisé pour la commande.

2 Commande du servomoteur
Pour commander un servomoteur il faut envoyer sur son fil de commande (fil jaune) une impulsion dont la durée
correspond à l’angle désiré. Historiquement, cette impulsion était délivrée par un circuit oscillateur ( exemple :
NE555).

Avec la programmation de l’Arduino, le circuit oscillateur n’est plus nécessaire ; la bibliothèque « servo » permet de
piloter un servomoteur en lui transmettant simplement l’angle sur lequel il souhaite se positionner (cet angle est
compris entre 0° et 180°).

Figure 23 : Principe de la commande d'un servomoteur

30
3 Manipulation
Téléchargez la bibliothèque « Servo » qui permet de commander le servomoteur.

Lancez l’exemple de la bibliothèque « Sweep » qui permet de piloter le servomoteur de 0° à 180° et inversement
d’une façon continue.

3.1 Schéma de câblage :

Le servomoteur accepte généralement une plage d’alimentation comprise entre 4.5V et 6V. Si on n’a besoin
d’utiliser qu’un ou deux servomoteurs, on peut les brancher sur la sortie 5V de la carte Arduino. Si le montage
demande plus, il serait bon d’envisager une alimentation externe (shields moteur) car le régulateur de l’Arduino
n’est pas fait pour délivrer trop de courant, on risque de le griller.

Branchez le servomoteur conformément à la figure suivante :

Figure 24 : Branchement du servomoteur

Transférez votre programme et testez son bon fonctionnement.

4 Manipulation 02 :
Le but de cette manipulation est de commander le servomoteur à l’aide d’un potentiomètre ; lorsque l’axe du
potentiomètre tourne, le bras du servomoteur doit tourner à son tour et dans le même sens.

Bonus :

N’oubliez pas que la valeur numérique délivrée par le CAN est comprise entre 0 et 1023 et que le servomoteur
accepte un angle compris entre 0 et 180° ; pensez à utiliser la fonction map().

5 Manipulation 03 :
Reprenez le programme de la manipulation 02 du TP8 (utilisation de deux capteurs pour détecter les obstacles à
droite et à gauche). Modifiez ce programme pour qu’il commande le servomoteur de telle sorte que lorsque
l’obstacle détecté est à gauche, il fait tourner le bras du servomoteur à droite et inversement.

31
TP 9 : INTERFAÇAGE LABVIEW - ARDUINO
(INITIATION)

 Objectifs spécifiques :

Le but de ce TP est de s’initier à l’interfaçage entre le logiciel Labview et la carte Arduino UNO.
L’étudiant sera capable d’établir cet interfaçage en manipulant les différents outils et logiciels nécessaires à
l’établissement de cette communication. Il pourra aussi commander les Entrées/Sorties de l’Arduino à l’aide
de Labview en exploitant des exemples simples fournis par labVIEW.

Ce TP sera une initiation aux étudiants pour l’année suivante (3ème année, spécialité SEM) qu’ils pourraient la
développer et l’exploiter pour la réalisation des mini projets au niveau du module Projet Professionnel
Personnalisé (PPP).

 Volume horaire :

3 heures

32
1 Présentation :
Le but de cet atelier est de découvrir comment se fait l’interfaçage entre le logiciel LabVIEW avec un Arduino. C’est
aussi de comprendre comment récupérer les données de différents capteurs, comment par l’appuie sur un bouton il
sera possible d’allumer une LED ou faire tourner un servomoteur

LabVIEW est un logiciel développé par National Instruments permettant de coder à l’aide de diagramme. Grâce à ce
logiciel il est possible de créer des outils de mesure et de contrôle.

Pour établir cette communication, un certain nombre d’outils et logiciels sont nécessaires :

Télécharger et installer Labview (en s’inscrivant sur le site officiel de National

Instruments, on peut télécharger une version d’évaluation de Labview)

Télécharger et installer la dernière version des drivers NI-VISA : c’est un pilote qui permet
à Labview de communiquer avec les instruments comme l’Arduino(dans notre cas en
utilisant une connexion USB

Télécharger et installer le module VIPM (VI Package Manager) permettant d’ajouter de

nombreux compléments, dont ceux de l’arduino

2 Installation des packages :

Une fois tous les logiciels installés, lancez VIPM. Le but est d’installer dans labVIEW les instruments virtuels (VI)
d’Arduino.

Pour cela, il existe deux types de VI :

- LIFA : Labview Interface For Arduino

- MakerHub(LINX).

Nous allons télécharger les deux types de VI ensuite nous verrons la différence entre les deux outils.

Dans la zone de recherche de VIPM, tapez Arduino et chercher labVIEW Interface For Arduino :

Figure 25 : Recherche du VI LIFA

33
Sélectionner LIFA et cliquez sur l’icône install :

Figure 26 : Ajout du VI LIFA

Refaire la même chose, mais cette fois ci le VI s’appelle MakerHub:

Figure 27 : Ajout VI MakerHub

Une fois tous les VI installés, on peut passer à l’interfaçage.

3 Interfaçage labVIEW-Arduino
L’interfaçage diffère selon le type de VI installé.

3.1 Installation du firmwar LIFA

Le firmware LIFA est disponible après installation de labVIEW 2015 dans le répertoire «C:\Program Files
(x86)\National Instruments\LabVIEW 2015\vi.lib\LabVIEW Interface for Arduino\Firmware\LIFA_Base». Au niveau de
ce répertoire, on trouve plusieurs fichiers dont les trois principaux sont :

- le sketch « LIFA_Base.ino » : c’est ce sketch que vous compilerez et transfèrerez à la carte Arduino
- le sketch « LabVIEWInterface.ino » : il contient l’implémentation de toutes les fonctions utilisées par
LabVIEW pour dialoguer avec la carte Arduino
- le fichier d’inclusion « LabVIEWInterface.h » : ce fichier d’en-tête est particulièrement intéressant puisque
c’est lui qui contient les « define » que vous pouvez modifier pour adapter LIFA.

Finalement, il faut charger le sketch « LIFA_Base.ino » dans l’environnement Arduino, le compilez puis programmez
la carte Arduino ; ainsi la carte est prête à fonctionner avec labVIEW

34
3.2 Installation du firmwar MakerHub(LINX)
L’installation de MakerHub(LINX) est beaucoup plus facile. Pour ce faire connecter la carte Arduino sur le port USB
du pc et lancer labVIEW. Choisir dans le menu principal outils > MakerHub > LINX > LINX Firmwar Wizard.

Au niveau de la fenêtre qui s’ouvre, choisir les options suivantes :

- Devise Family : Arduino

- Devise Type : Arduino Uno
- Firmware Upload Method : Serial/USB

Figure 28 : Choix du type de la carte dans LINX

En cliquant sur suivant, on se retrouve avec la fenetre du choix du numéro du port serie :

Figure 29 : Choix du port série pour LINX

35
L’étape suivante est le choix de la version du firmware et de la méthode du chargement :

Figure 30 : Choix de la méthode de chargement

Finalement le chargement du firmware commence :

Figure 31 : Chargement du firmware

A la fin du chargement la carte est prête pour communiquer avec labVIEW.

36
4 Fonctionnement de labVIEW :
Un programme LabVIEW se compose de deux parties. Une partie appelée « Front_Panel » est l’interface sur laquelle
l’utilisateur va interagir pour commander son arduino. Puis une partie « Block-Diagram » où le programme sera écrit.

Figure 32 : exemple d'interfaces labVIEW

5 Manipulation 01 :
Pour réaliser l’interfaçage avec la carte Arduino, nous allons utiliser le firmware LINX de MakerHub.

1- Brancher la carte et transférer le firmware

2- Une fois le transfert terminé, cliquez sur le bouton « launch exemple ».
L’exemple en question permet de commander une diode LED branchée sur la sortie 13 de la carte Arduino à
l’aide d’un bouton poussoir (bouton vert sur l’interface labVIEW)
3- Connectez une diode LED sur la sortie 13 de la carte Arduino (vous pouvez utiliser la diode LED branchée sur
la carte à la sortie 13 de la carte Arduino), exécutez le programme et vérifier son bon fonctionnement.

6 Manipulation 02 :
1- Lancer l’exemple « LINX Servo 1 Chanel »

Ce programme permet de commander un servomoteur connecté à la sortie 2 de la carte. Brancher votre

servomoteur et vérifier son bon fonctionnement.

37
CORRECTION DES ATELIERS

38
TP 1 : COMMANDE D’UNE DIODE LED
Manipulation 02 :
Modifiez le programme précédent pour commander deux diodes LED (choisissez les broches de votre choix)

Manipulation 03 :
En utilisant six diodes LED, réalisez un jeu de lumière (exemple : un chenillard)

39
TP 2 : UTILISATION D’UN BOUTON POUSSOIR
Manipulation 01 :
Au cours de cette manipulation, nous allons commander une diode LED à l’aide d’un bouton poussoir. Lorsqu’on
appuie sur le bouton, la LED va allumer et lorsqu’on relâche le bouton la LED s’éteindra.

Manipulation 02 :
Modifiez le programme précédent de telle sorte que le premier appui sur le bouton poussoir allume la diode LED et
que le second appuie l’éteint :

40
Lors de l’exécution de ce programme, on remarque que la diode LED ne suit pas toujours l’appui sur le bouton
poussoir ; il y’a l’effet rebond (un seul appui sur le bouton, correspond réellement à plusieurs fronts successifs) : du
coup, parfois la diode reste éteinte ou bien au contraire reste allumée. Pour remédier à ce disfonctionnement, il faut
sauvegarder l’état précédent du bouton poussoir et n’inverser l’état de la diode LED que si l’état du bouton est
différent de son ancien état et qu’il est haut. Ce qui nous donne le programme suivant :

Manipulation 03 :
Nous allons réaliser un dé numérique à l’aide de trois diodes LED. L’appuie sur le bouton poussoir va générer un
numéro aléatoire entre 1 et 6 :

41
Pour générer un numéro aléatoire, il faut utiliser les fonctions randomSeed() et random() :

La fonction randomSeed() permet d’ initialiser le générateur de nombres pseudo-aléatoire, imposant à la séquence

aléatoire de démarrer à un point arbitraire. S'il est important que les valeurs d'une séquence générée par
l'instruction random() diffèrent, lors d'exécutions successives d'un programme, il faut utiliser la fonction
randomSeed() pour initialiser le générateur de nombres aléatoires avec une entrée suffisamment aléatoire. Cette
entrée aléatoire peut être récupérée de la valeur renvoyée par l'instruction analogRead() sur une broche analogique
non connectée.

Pour récupérer la valeur renvoyée par random() bit par bit, il suffit d’appliquer des masques avec les valeurs binaires
B001, B010 et B100.

42
TP 3 : GESTION DU CLAVIER
Manipulation 01 :
Au cours de cette manipulation, vous devez réaliser un montage qui permet de lire le numéro du bouton appuyé par
l’utilisateur et d’envoyer son code sur le moniteur série de l’Arduino.

Manipulation 02 :
Au cours de cette manipulation vous allez réaliser une serrure codée.

Un code à plusieurs chiffres (4 chiffres par exemple) doit être saisi pour ouvrir une porte. Le programme commence
par envoyer le message « Saisir code » sur le moniteur série. Si le code saisi est correct, une diode LED s’allume et le
message « code correct » est envoyé sur le moniteur série, sinon on envoie le message « code erroné » suivi de
« Saisir code » (dans notre exemple le code correcte est : 1234).

43
44
Résultat d’exécution :

45
TP 4 : Commande d’un afficheur LCD
Manipulation 01 :
Le but de cette première manipulation et d’afficher un texte fixe sur l’écran LCD (votre nom et prénom par exemple)

Résultat exécution :

Ajouter une animation au texte affiché : défilement à droite, défilement à gauche

46
lcd.scrollDisplayLeft() : Décale le contenu de l'écran (texte et curseur) d'un espace vers la gauche ; puisque la chaine
« Mohamed Ben Ali » contient 15 caractères, il faut décaler le curseur 15 fois à gauche pour la faire disparaitre de
l’écran.

lcd.scrollDisplayRight() : Décale le contenu de l'écran (texte et curseur) d'un espace vers la droite ; notre but est de
faire réapparaitre le texte ensuite le décaler vers la droite pour le faire disparaitre. Du coup, il nous faut un décalage
de 31 fois (15 : longueur de la chaine + 16 : longueur d’une ligne de l’écran).

Une fois le texte disparait vers la droite, il faut le faire réapparaitre avec un deuxième décalage à gauche de 16
caractères et revenir à la situation initiale.

Résultat d’exécution :

Manipulation 02 :
Reprenez la manipulation du TP précédent (serrure codée) et utilisez l’afficheur LCD à la place du moniteur série.

47
Résultat d’exécution :

48
Manipulation 03 :
Vous allez réaliser un jeu où il faut deviner un nombre choisi au hasard par le programme :

49
Résultat d’exécution :

50
TP 5 : Gestion de la conversion A/N
Manipulation 01 :

Lors de cette manipulation, vous allez réaliser un programme qui permet de lire la valeur analogique délivrée par le
potentiomètre sur l’une des entrées analogiques et d’afficher le résultat sur le moniteur série.

Résultat d’exécution :

Manipulation 02 :
Lors de la précédente manipulation, vous avez remarqué que les valeurs affichées sur le moniteur série sont
comprises entre 0 et 1023. Modifiez votre programme pour qu’il calcule les valeurs réelles de la tension lue
(comprises entre 0 et 5V) et les affiche sur un afficheur LCD.

51
 Résultat d’exécution :

L’utilisation de la fonction map(), permet de calculer la tension d’entrée à partir de la valeur numérique (l’équivalent
de la règle de trois). La conversion se fait par rapport à 5000 pour avoir plus de précision et ne pas se retrouver avec
uniquement six valeurs (0, 1, 2, 3, 4, 5). Ensuite le résultat obtenu est divisé par 1000 pour retrouver la valeur de la
tension en volts.

Manipulation 03 :
Commandez le clignotement d’une diode LED à l’aide du potentiomètre : plus la valeur de la tension lue est grande,
plus le clignotement de la diode est rapide et inversement.

Il suffit de gérer l’intervalle d’attente entre le changement d’état de la diode LED par la valeur de la tension lue à
partir du potentiomètre.

52
Manipulation 04 :
Commandez la luminosité d’une diode LED à l’aide du potentiomètre : plus la valeur de la tension lue est grande,
plus la luminosité de la diode augmente et inversement.

Résultat d’exécution :

La diode est branchée sur la sortie 9 qui utilise le module PWM. La valeur lue à partir du potentiomètre ne pourra
pas être renvoyée directement vers la diode LED. Elle doit être formatée à l’aide de la fonction map() qui nous
permettra de passer d’une valeur comprise entre 0 et 1023 (sortie du CAN sur 10 bits) à une valeur comprise entre 0
et 255 (rapport cyclique du PWM).

Manipulation 05 :
Réalisez une jauge électronique à l’aide de 5 diodes LED : plus la tension augmente plus le nombre de diodes
allumées augmente

53
Explication de l’instruction digitalWrite(pin[i],(niveau >= i)?HIGH : LOW) : si « niveau » est supérieur ou égal à « i »,
alors « pin[i] » reçoit « HIGH » sinon elle reçoit « LOW ».

On peut réaliser le même traitement en utilisant la structure switch case :

54
TP 6 : L’acquisition de la temperature et de
l’humidite : le capteur DHT11
Manipulation 01 :
Téléchargez la bibliothèque DHT11.h et ajoutez-la au dossier des bibliothèques de l’Arduino.

Testez le bon fonctionnement du programme en affichant les résultats sur le moniteur série.

Résultat d’exécution :

La fonction dht11.read() peut retourner trois valeurs différentes :

- DHTLIB_OK (0): le contrôle du capteur et ses mesures sont correctes

- DHTLIB_ERROR_CHECKSUM (-1): le contrôle du capteur a échoué ; c'est-à-dire que la donnée a été reçu mais
pourrait être eronnée.
- DHTLIB_ERROR_TIMEOUT (-2): le délais d’attente a été dépassé et la communication a échouée.
 C’est pourquoi on teste dans le programme si la fonction dht11.read() retourne un zéro ou non.

DHT11-RETRY_DELAY : c’est le delais minimum entre deux lectures successives du capteur. Ce délais est fixé par la
datasheet du capteur et au niveau de sa bibliothèque à 1000 ms.

55
Manipulation 02 :
Modifiez le programme précédent pour afficher les valeurs de la température et de l’humidité sur un afficheur LCD.

Ajoutez deux diodes LED l’une pour contrôler la température et l’autre pour l’humidité (les LED s’allumeront
lorsqu’on atteint un seuil bien déterminé de température ou d’humidité ; essayez de faire varier les valeurs de
température et d’humidité pour atteindre ces seuils et allumer les LED)

Résultat d’exécution :

56
TP 7 : mesure de la distance : le capteur
HC-SR04
Manipulation 01 :
Téléchargez une des bibliothèques du capteur HC-SR04 disponibles.

Ecrire un programme qui permet de lire la distance à partir du capteur et d’envoyer l’information sur le moniteur
série de l’Arduino (la distance doit être exprimée en cm).

Résultat d’exécution :

- digitalWrite(trigpin, LOW) et delayMicroseconds(2) : envoyer un niveau bas pendant 2 us pour stabiliser la

sortie.
- digitalWrite(trigpin, HIGH) et delayMicroseconds(10) : envoyer un niveau supérieur ou égal à 10 us (10 us
dans notre cas)
- pulseIn(echopin, HIGH) : cette instruction attend que la broche « echopin » passe à HAUT, commence alors
le chronométrage, attend que la broche repasse au niveau BAS et stoppe alors le chronométrage. Elle
renvoie la durée de l'impulsion en microsecondes.

Manipulation 02 :
Ajoutez un deuxième capteur à votre montage. Le but est de réaliser un détecteur d’obstacle. Le premier capteur
détecte un obstacle à droite (distance inférieur à 5 cm) et votre programme affiche le message « obstacle à droite »
sur le moniteur série et le deuxième capteur détecte un obstacle à gauche et le programme affiche « obstacle à
gauche ».

57
 Résultat d’exécution :

Manipulation 03 :
Modifier le montage précédent en ajoutant un afficheur LCD. Le but de cette manipulation est d’afficher tous les
messages sur l’écran de l’afficheur au lieu de les envoyer au moniteur série.

58
Résultat d’exécution :

59
 TP 8 : commande d’un servomoteur
Manipulation
Téléchargez la bibliothèque « Servo » qui permet de commander le servomoteur.

Lancez l’exemple de la bibliothèque « Sweep » qui permet de piloter le servomoteur, avec un pas de 1°, de 0° à 180°
et inversement d’une façon continue.

Manipulation 02 :
Le but de cette manipulation est de commander le servomoteur à l’aide d’un potentiomètre ; lorsque l’axe du
potentiomètre tourne, le bras du servomoteur doit tourner à son tour et dans le même sens.

60
Manipulation 03 :
Reprenez le programme de la manipulation 02 du TP8 (utilisation de deux capteurs pour détecter les obstacles à
droite et à gauche). Modifiez ce programme pour qu’il commande le servomoteur de telle sorte que lorsque
l’obstacle détecté est à gauche, il fait tourner le ras du servomoteur à droite et inversement.

61
62
 TP 9 : interfaçage Labview - Arduino
(initiation)
Manipulation 01 :
Une fois l’exemple lancé, on obtient les interfaces suivantes :

- Face avant :

1 : choix du numéro du port série

2 : choix du numéro de la sortie sur laquelle sera branchée la diode LED

3 : le bouton poussoir qui permet de commander la diode LED

63
 - Fenêtre du diagramme :

1 : c’est la partie de configuration ; elle est équivalente à la fonction setup() dans le sketch Arduino. C’est à ce
niveau qu’on fait la configuration du port série

2 : c’est la fonction digitalWrite() équivalente à la fonction Arduino qui prend en argument le numéro de la sortie et
la valeur à envoyer ( un appui sur le bouton poussoir envoie un niveau haut)

3 : c’est le rectangle gris qui encadre tous les autres éléments ; il s’agit de la boucle infinie void loop()

Manipulation 02 :
- Face avant de l’exemple de la commande du servomoteur :

64
1 : choix de la sortie de commande du servomoteur

2 : sélection de l’angle à envoyer au servomoteur : en variant la commande de 500 à 2500, l’axe du servo suivra le
mouvement (la valeur 1500us correspond à un angle de 90 degrés).

- Face Diagramme :

1 : initialisation de la sortie vers le servomoteur (cette sortie restera occupée tant que la connexion avec le
servomoteur est active

2 : envoi de la valeur du rapport cyclique à la sortie PWM vers le servomoteur

3 : fermeture de la connexion avec le servomoteur

65
 LISTE DES FIGURES
Figure 1 : image et symbole d'une LED ............................................................................................................................. 6
Figure 2 : Tension et courant de seuil d'une LED .............................................................................................................. 6
Figure 3 : Code couleurs des résistances .......................................................................................................................... 6
Figure 4 : branchement d'une diode LED .......................................................................................................................... 7
Figure 5 : Structure d'un programme ARDUINO ............................................................................................................... 7
Figure 6 : Vérification et chargement du programme ...................................................................................................... 8
Figure 7 : Différentes vues d'un bouton poussoir........................................................................................................... 10
Figure 8 : Branchement d'un bouton poussoir ............................................................................................................... 10
Figure 9 : Combinaisons du dé numérique ..................................................................................................................... 11
Figure 10 : Clavier numérique 3x4 à ruban ..................................................................................................................... 13
Figure 11 : Branchement du clavier à la carte ARDUINO ................................................................................................ 13
Figure 12 : Ajout d'une bibliothèque .............................................................................................................................. 14
Figure 13 : Afficheur LCD 2x16 ........................................................................................................................................ 16
Figure 14 : branchement de l'écran LCD ......................................................................................................................... 17
Figure 15 : Entrées analogiques de la carte Arduino UNO ............................................................................................. 20
Figure 16 : Branchement d'un potentiomètre ................................................................................................................ 20
Figure 17 : Brochage du capteur DHT11 ......................................................................................................................... 23
Figure 18 : branchement du capteur DHT11 .................................................................................................................. 24
Figure 19 : brochage du HC-SR04.................................................................................................................................... 26
Figure 20 : Principe de fonctionnement du HC-SR04...................................................................................................... 26
Figure 21 : Branchement du capteur HC-SR04 ............................................................................................................... 27
Figure 22 Le servomoteur ............................................................................................................................................... 30
Figure 23 : Principe de la commande d'un servomoteur ................................................................................................ 30
Figure 24 : Branchement du servomoteur ...................................................................................................................... 31
Figure 25 : Recherche du VI LIFA..................................................................................................................................... 33
Figure 26 : Ajout du VI LIFA ............................................................................................................................................. 34
Figure 27 : Ajout VI MakerHub........................................................................................................................................ 34
Figure 28 : Choix du type de la carte dans LINX .............................................................................................................. 35
Figure 29 : Choix du port série pour LINX ....................................................................................................................... 35
Figure 30 : Choix de la méthode de chargement ............................................................................................................ 36
Figure 31 : Chargement du firmware .............................................................................................................................. 36
Figure 32 : exemple d'interfaces labVIEW ...................................................................................................................... 37

66
 BIBLIOGRAPHIE

[1] E.Bartmann, Le grand livre d’arduino, eyrolles, décembre 2013.

[2] T.Karvinen, K.Karvinen, V.Valtokari, les capteurs pour arduino et raspberry pi tutoriels et projets, dunod, 2014.

WEBOGRAPHIE

[3] http://www.mon-club-elec.fr, la commande RandomSeed, X. HINAULT

[4] http://www.mon-club-elec.fr, la bibliothèque LCD, X. HINAULT

[5] http://electroremy.free.fr, les afficheurs LCD, Remy LUCAS

[6] http://nalhossri.free.fr, les afficheurs LCD 2*16 Alphanumériques, Nabil Al-HOSSRI

[7] http://gd.tuwien.ac.at, C programming, B Brown

[8] http://playground.arduino.cc, A DHT11 Class for Arduino, Arduino community

[9] http://www.gotronic.fr, utilisation du HC-SR04, e-commerce Arobases

[10] https://itechnofrance.wordpress.com, utilisation du module ultrason hc-sr04 avec larduino

[11] http://www.micronet91.com, Utilisation du module Ultrason, Miconet 91

[12] http://www.worldofgz.com, telemetre ultrason hc-sr04, world of GZ

[13] http://www.planete-sciences.org, Commander des servomoteurs classiques, Planète Sciences

[14] http://eskimon.fr, un moteur qui a de la tete le servo-moteur

[15] http://eduscol.education.fr, labview et arduino

[16] http://simple-duino.com, labview pour arduino

[17] http://innovelectronique.fr, arduino et lifa

67