Blog ENI : Toute la veille numérique !
-25€ dès 75€ sur les livres en ligne, vidéos... avec le code FUSEE25. J'en profite !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Arduino
  3. Montages avancés
Extrait - Arduino Apprivoisez l'électronique et le codage (3e édition)
Extraits du livre
Arduino Apprivoisez l'électronique et le codage (3e édition)
7 avis
Revenir à la page d'achat du livre

Montages avancés

Les capteurs

Ils sont capables de recueillir des informations sur l’environnement (température, lumière, bruit, distance d’un obstacle...), ce qui permet à l’Arduino de modifier son comportement lorsque surgit une situation nouvelle.

1. Capteur de luminosité (photorésistance)

Il s’agit d’un composant électronique dont la résistance change en fonction de la lumière ambiante. Du point du vue de l’Arduino, ce type de capteur peut être considéré comme un potentiomètre dont on tournerait automatiquement le bouton en fonction de la lumière ambiante.

images/Maj0713.png

Capteurs lumineux pour breadboard et module Grove (www.lextronic.fr)

Il existe sous forme de module (pour breadboard ou au format Grove) ou d’un simple composant ; dans ce cas, reproduisez alors le branchement suivant en utilisant une résistance de 10 kΩ. Vous pouvez aussi choisir une valeur différente (ou même utiliser un potentiomètre), car la valeur de la résistance influe directement sur la sensibilité de la photorésistance. Plus elle est élevée et plus la photorésistance sera sensible, ce qui est très intéressant lorsque la luminosité est faible. Au contraire, si la valeur de la résistance est plus faible, la photorésistance sera moins sensible et donc plus adaptée à un environnement très lumineux. Par exemple, pour une utilisation en extérieur, choisissez plutôt une résistance de 1 kΩ.

images/07-01.png

Branchement de la photorésistance avec une résistance de 10 kΩ

Comme toute valeur analogique, la luminosité peut être récupérée avec l’instruction analogRead. Cette valeur (comprise entre 0 et 1023) peut être affectée à une variable ou utilisée directement. Le sketch suivant se contente d’afficher la valeur récupérée dans le moniteur série.

 Téléversez-le et modifiez la luminosité en éclairant ou masquant la photorésistance.

// Photorésistance 
const int PHOTORESISTANCE = A0; 
void setup() { 
  pinMode(PHOTORESISTANCE, INPUT); 
  Serial.begin(9600); 
} 
 
void loop() { 
  Serial.println(analogRead(PHOTORESISTANCE)); ...

Le cadran analogique (galvanomètre)

images/07-15.png

Voltmètre gradué de 0 à 5 V (utilisant un galvanomètre)

Ce dispositif d’affichage était surtout utilisé avant les années 1980. Il équipait la plupart des appareils de mesure électriques (voltmètre, ampèremètre), mais aussi beaucoup d’objets courants comme des thermomètres ou des compteurs de vitesse de voiture.

L’aiguille (retenue par un ressort) est reliée à une bobine entourée d’un champ magnétique (créé par un aimant permanent). Si la bobine n’est pas alimentée, l’aiguille est ramenée à zéro par le ressort, mais plus elle reçoit d’électricité et plus elle est attirée par une des bornes de l’aimant (ce qui déplace aussi l’aiguille).

Au-delà de son petit côté rétro, le galvanomètre est très pratique pour afficher une valeur, car il ne nécessite que deux fils et son utilisation est extrêmement simple. Il en existe sous forme de voltmètre et gradué de 0 à 5 V, ce qui est parfait pour l’Arduino. De plus, ils sont très faciles à démonter pour changer la petite plaque graduée (de 0 à 5) et la remplacer par une échelle personnalisée (de 0 à...

Le relais

Il permet de contrôler des appareils fonctionnant à une tension beaucoup plus élevée, car le circuit de commande (l’Arduino) et le circuit de puissance (l’appareil à contrôler) sont complètement isolés. Le relais fonctionne comme un bouton poussoir actionné par un électroaimant. Il peut donc piloter un appareil utilisant un courant alternatif ou continu.

Mais l’Arduino ne peut pas actionner directement le relais. Il faut ajouter un transistor pour le protéger. Ce système n’est pas très compliqué à faire soi-même, mais il existe aussi des modules regroupant un à huit relais, qui sont souvent moins chers et plus faciles à utiliser.

 Choisissez de préférence un module utilisant un circuit de commande de 5 V et un circuit de puissance de 250 V.

Attention, des tensions supérieures à 24 V peuvent être dangereuses. Ne travaillez sur de tels circuits que si vous possédez les compétences nécessaires en électricité. N’hésitez pas à vous faire assister d’un ami ou demander des conseils sur Internet. N’oubliez pas les règles de sécurité élémentaires. Par exemple, utilisez toujours un boîtier fermé pour isoler le circuit sous 220 V. Et ne l’ouvrez jamais lorsqu’il est sous tension.

images/07-17.png

Utilisation du relais en toute sécurité

1. Contrôle de deux ampoules

Le relais peut être alimenté par l’Arduino ou par une autre source (5 V).

 Dans ce cas, retirez le cavalier reliant les bornes VCC, puis branchez le (+) de l’autre alimentation à la borne JD-VCC et le (-) à la borne GND. Le branchement des autres bornes est assez logique. Branchez les bornes GND, VCC, IN1, IN2 du module relais aux bornes GND, 5 V et à deux sorties numériques...

Les moteurs

1. Le moteur à courant continu

C’est un moteur très courant, vous pouvez facilement en trouver dans de nombreux appareils hors d’usage. Son utilisation est très simple. Il n’a que deux fils, en branchant le (+) à une borne et le (-) à l’autre, il tourne dans un sens. Si vous inversez les deux bornes, il tournera dans l’autre sens. Et si vous baissez la tension de l’alimentation, il tournera moins vite.

Vous pouvez le connecter à une sortie numérique, mais dans ce cas vous ne pourrez pas contrôler sa vitesse, car vous n’aurez que deux possibilités (LOW et HIGH), soit le moteur est à l’arrêt, soit il fonctionne à vitesse maximum. Pour augmenter les possibilités de contrôle, utilisez plutôt une des six sorties analogiques (PWM) de l’Arduino Uno (3, 5, 6, 9, 10 ou 11).

Cependant, vous ne pouvez pas connecter directement un moteur à une sortie de l’Arduino. Car la puissance de sortie est limitée et les moteurs génèrent des courants parasites qui risqueraient d’endommager le microcontrôleur.

a. Utilisation d’un transistor

Une des solutions est d’utiliser un transistor de type NPN (comme le 2N222A, que nous avons déjà utilisé), pour protéger l’Arduino et une diode Schottky (de roue libre) pour protéger le transistor d’un retour de courant. La sortie PWM de l’Arduino doit aussi être protégée (par la résistance de 1 kΩ). Mais l’inconvénient de ce branchement est que le moteur ne peut tourner que dans un seul sens.

 Si vous n’avez qu’un petit moteur de 5 V à alimenter, vous pouvez utiliser ce branchement. La sortie 5 V de l’Arduino pourra sans problème alimenter votre moteur, surtout si vous utilisez une alimentation externe.

images/07-19.png

Branchement d’un moteur avec un transistor

 Mais pour alimenter un moteur plus gros, utilisez plutôt le branchement ci-dessous avec une alimentation externe.

images/07-20.png

Utilisation d’une autre source d’alimentation pour le moteur

 Téléversez ce code dans l’Arduino. La vitesse du moteur varie si vous tournez le potentiomètre.

// Moteur_avec_transitor 
const int POTENTIOMETRE = A0; 
const int MOTEUR = 9; 
void setup() { ...

L’afficheur sept segments

Il est généralement constitué de huit LED (sept segments et le point en bas à droite). Vous pouvez le trouver dans de nombreux appareils et notamment les radios-réveils. Les LED sont reliées ensemble par une borne commune. Il existe donc deux types d’afficheurs : à cathode commune, borne (-) ou à anode commune, borne (+). L’autre borne peut être connectée aux sorties de l’Arduino et la LED s’allumera s’il y a une différence de potentiel entre les deux bornes (HIGH pour les afficheurs à cathode commune et LOW pour les afficheurs à anode commune).

 Si vous ne savez pas de quel type est votre afficheur sept segments, vous pouvez facilement le déduire en branchant la borne commune (3 ou 8) de l’afficheur à une petite résistance (de 220 à 330 Ω), reliée à la borne GND de l’Arduino, et en connectant brièvement une autre borne (1, 2, 4, 5, 6, 7, 9 ou 10) à la borne 5 V de l’Arduino. Si une des LED s’allume, cela signifie que vous avez un afficheur à cathode commune. Sinon, inversez le branchement (5 V et résistance sur la borne commune et GND sur une des autres) pour vérifier que vous avez un afficheur à anode commune. Si, là encore, aucune LED ne s’allume, soit votre afficheur n’est pas standard et il vous faudra procéder à de nombreux essais pour trouver comment il est câblé, soit il est défectueux et il faudra en utiliser un autre.

images/07-27.png

Schéma de l’afficheur sept segments

1. Branchement direct sur l’Arduino

En fonction de votre type d’afficheur, vous pouvez choisir l’un des branchements suivants. Comme pour n’importe quelle LED, il ne faut pas oublier d’ajouter une petite résistance (de 220 à 330 Ω).

images/07-28.png

Branchement d’un afficheur sept segments à anode commune

images/07-29.png

Branchement d’un afficheur sept segments à cathode commune

Le code suivant (basé sur le compteur binaire) permet de faire défiler avec le bouton les principaux caractères affichables. Il est conçu pour un afficheur à cathode commune, si le vôtre est à anode commune, il faudra modifier les fonctions d’affichage en inversant...

La matrice de LED

Il s’agit d’un carré constitué de LED disposées en lignes et en colonnes. Vous pouvez la fabriquer vous-même, mais comme souvent, cela vous coûtera certainement moins cher de l’acheter toute faite. Il en existe de différentes tailles, certaines sont capables d’afficher plusieurs couleurs ou peuvent même être en trois dimensions. L’une des plus courantes est la matrice à 64 LED (8x8). Elle est souvent vendue accompagnée d’un module équipé d’une puce MAX7219 (un registre à décalage,16 bits) permettant de faciliter la gestion de l’affichage. Cependant, il est tout à fait possible de la relier directement à l’Arduino.

1. Utilisation de la matrice seule (sans le module MAX7219)

images/07-35.png

La matrice de 64 LED (8x8), seule

Il existe plusieurs types de matrices et leurs branchements ne sont pas forcément identiques.

 Pour en connaître le schéma, il faut tout d’abord l’identifier (sur cette photo, il s’agit de la matrice 1088AS).

 Ensuite, vous pouvez retrouver son schéma de branchement sur Internet, dans la documentation fournie par le constructeur.

images/07-36.png

Schéma de branchement de la matrice 1088AS

Nous découvrons donc que chacune des 64 LED n’est pas reliée à une borne spécifique et à une anode ou une cathode commune, comme c’était le cas avec l’afficheur à sept segments. Pour économiser des bornes, et ainsi contrôler les 64 LED avec seulement seize bornes, le fabricant a choisi d’utiliser le principe de la matrice. Les LED de chaque colonne possèdent une anode commune - borne (+) - et celles de chaque ligne, une cathode commune - borne (-). Pour allumer une LED, il faut que l’anode soit à un potentiel plus élevé que la cathode. Dans tous les autres cas, si le potentiel est égal (LOW ou HIGH) ou si le potentiel de la cathode est plus élevé que celui de l’anode, la LED reste éteinte.

Il existe aussi des matrices où les colonnes sont reliées à une cathode commune et les lignes à une anode commune. Dans ce cas, intervertissez les valeurs HIGH et LOW dans le code pour parvenir au même résultat.

Malheureusement, les bornes de la matrice ne sont...

Les matrices de LED Neopixel

En remplaçant les LED classiques par des LED adressables, vous pourrez fabriquer des panneaux d’affichage en couleur.

1. Adafruit Neopixel Shield

Il s’agit simplement d’une chaîne de 40 LED (5 lignes de 8 LED) disposées sur une carte d’extension au format de l’Arduino Uno (et contrôlée par le port n°6).

images/Maj2-07-01.png

Adafruit Neopixel Shield

La carte Adafruit Neopixel Shield peut tout à fait être programmée comme un module classique (anneau, bande ou guirlande), mais elle offre de nouvelles possibilités lorsqu’on la considère comme une mini-matrice.

a. Installation des bibliothèques Adafruit

Pour cela, il est nécessaire d’ajouter les bibliothèques Adafruit_GFX et Adafruit_NeoMatrix à la bibliothèque Adafruit_NeoPixel que nous avions déjà utilisée pour piloter les rubans et les anneaux de LED Neopixel (cf. chapitre Premiers sketchs - Les LED adressables (Neopixel)).

 Lancez l’IDE Arduino et sélectionnez Croquis - Inclure une bibliothèque - Gérer les bibliothèques, puis recherchez successivement "Adafruit_GFX" et "Adafruit_NeoMatrix" et cliquez à chaque fois sur Installer.

images/Maj2-07-02.png

Installation de la bibliothèque Adafruit_GFX

Si vous rencontrez un message de ce type vous proposant d’installer les dépendances, acceptez en cliquant sur Install all. Cela signifie que la bibliothèque a besoin d’autres bibliothèques pour fonctionner correctement.

images/Maj2-07-03.png

Installation des dépendances de la bibliothèque Adafruit_GFX

b. Affichage d’un texte défilant

Pour afficher correctement du texte, il est nécessaire d’effectuer une rotation de 90° parce que les bibliothèques utilisent une police de caractères d’une hauteur de 8 pixels.

images/Maj2-07-04.png

Affichage d’une lettre sur la matrice

Voilà un exemple de code (inspiré de l’exemple fourni par la bibliothèque Adafruit_NeoMatrix) :

//Adafruit_Neopixel_Shield_Texte_Defilant  
// Appel des bibliothèques  
#include <Adafruit_GFX.h>  
#include <Adafruit_NeoMatrix.h>  
#include <Adafruit_NeoPixel.h>  
// Définition de la matrice (avec rotation de 90°)  
Adafruit_NeoMatrix...

L’afficheur alphanumérique LCD

Les écrans à cristaux liquides ou LCD (Liquid Crystal Display) sont souvent utilisés pour remplacer les afficheurs à LED sur des appareils portables, car ils consomment beaucoup moins d’énergie.

L’afficheur alphanumérique est un tableau. Ses cases contiennent huit lignes de cinq pixels et chaque case est séparée par un espace d’un pixel. Il en existe de plusieurs tailles, mais le plus courant possède deux lignes de seize cases.

1. Connexion parallèle

L’afficheur utilise une connexion parallèle, c’est-à-dire que plusieurs bits de données sont envoyés en même temps, mais en passant par des fils différents. Ce type de connexion (surtout utilisé au XXe siècle) permettait d’augmenter la vitesse de transfert des données en multipliant le nombre de fils.

La connexion parallèle est beaucoup moins utilisée de nos jours, car de nouveaux protocoles de communication beaucoup plus rapides sont apparus (comme l’USB 1, 2 et 3). Ils nécessitent moins de fils, ce qui permet d’utiliser des câbles et des connecteurs moins chers et plus fins.

Il existe deux types de connexions parallèles pour l’afficheur alphanumérique : celle envoyant 4 bits à la fois, et celle envoyant 8 bits (nécessitant respectivement quatre ou huit fils de données). La connexion à 4 bits est forcément deux fois moins rapide que celle à 8 bits, mais en ce qui concerne l’afficheur alphanumérique, la différence n’est absolument pas perceptible pour l’être humain.

Les ports de l’afficheur alphanumérique sont repérés par leur nom.

Port

Rôle et connexion

1

VSS

Masse (GND)

2

Vdd

Alimentation (5 V)

3

V0

Réglage du contraste (Potentiomètre)

4

RS

Sélection du registre, mode commande ou donnée (sortie Arduino)

5

R/W

Mode lecture ou écriture (GND pour écriture)

6

E

Enable, validation (sortie Arduino)

7 à 10

D0 à D3

Données en 8 bits (sorties Arduino) et masse en 4 bits (GND)

11 à 14

D4 à D7

Données en 4 ou 8 bits (sorties Arduino)

15

A

Rétroéclairage, anode (5 V)

16

K

Rétroéclairage, cathode (GND)...

Le module RFID RC522

La technologie RFID (radio frequency identification) est utilisée dans différents domaines, comme la traçabilité, les antivols ou l’identification d’une carte d’accès.

Le lecteur RFID est capable de lire des informations contenues dans une puce spéciale (un tag). Il génère un champ magnétique qui permet l’activation et l’alimentation du tag, lorsqu’il se trouve suffisamment proche (quelques centimètres). Le tag peut ensuite échanger des informations avec le lecteur (comme son numéro d’identifiant, mais il possède aussi une mémoire de quelques kilo-octets).

Les tags RFID sont souvent intégrés à un porte-clés ou une carte au format carte bancaire, mais vous pouvez aussi les rencontrer dans les objets du quotidien comme les jouets. Par exemple, les Skylanders ou les Amiibo de vos enfants sont parfaitement compatibles avec le module RFID RC522.

images/07-52.png

Le lecteur RFID RC522 et quelques tags compatibles

1. Test du module

L’utilisation du module nécessite l’installation des bibliothèques SPI.h et MFRC522.h.

 Pour cela, lancez l’IDE Arduino et allez dans Croquis - Inclure une bibliothèque - Gérer les bibliothèques. Puis, tapez le nom des bibliothèques dans la barre de recherche et installez-les.

images/07-53.png

Installation des bibliothèques

Pour tester le module RFID, nous allons simuler un système de contrôle d’accès utilisant des badges d’identification. Par défaut, l’accès est interdit (la LED rouge est allumée et la LED verte éteinte). Si vous présentez un tag dont le numéro est reconnu par le système de contrôle, l’accès est autorisé pendant trois secondes (la LED verte s’allume et la LED rouge s’éteint). Mais si le tag n’est pas autorisé, la LED rouge se met à clignoter rapidement pendant deux secondes.

Dans la pratique, vous pouvez tout à fait remplacer la LED verte par un relais pour commander l’ouverture d’une gâche électrique ou d’une porte de garage.

Le module RFID utilise le bus SPI, il faut donc obligatoirement connecter les bornes 11, 12 et 13 de l’Arduino aux bornes MOSI, MISO et SCK du module. Mais vous pouvez éventuellement...

L’horloge en temps réel

L’Arduino est capable de mesurer le temps écoulé avec les fonctions millis ou micros. Mais en cas de coupure électrique (ou après quelques semaines), les données sont remises à zéro. Il est cependant possible de relier à l’Arduino un module RTC (Real Time Clock ou horloge en temps réel), afin d’inclure la gestion de la date et de l’heure dans vos projets.

Il existe de nombreux modèles de RTC, mais les modèles construits autour des puces DS1307 et DS3231 sont plus faciles à utiliser, car ils communiquent avec l’Arduino par bus I2C.

Nous avons déjà utilisé le bus I2C pour relier un écran LCD à l’Arduino avec seulement deux fils (en plus des deux fils d’alimentation). Mais l’avantage de ce protocole est qu’il accepte jusqu’à 128 périphériques. Vous pouvez donc utiliser les mêmes fils pour connecter à la fois l’écran LCD et le module RTC.

L’écran LCD n’est pas obligatoire pour tester l’horloge en temps réel. Si vous n’en avez pas, utilisez simplement le moniteur série.

images/07-55.png

Branchement de l’afficheur LCD et du module RTC

Le module est muni d’une pile permettant à l’horloge de continuer à fonctionner lorsque l’Arduino est éteint. Il peut s’agir d’une batterie rechargeable (environ un mois d’autonomie) ou d’une simple pile (quelques années d’autonomie)....

Le lecteur de cartes SD (ou microSD)

Le lecteur de cartes SD permet d’accéder à un espace de stockage (non volatile) pour lire ou enregistrer des données volumineuses. Il permet donc de conserver les données en cas de coupure de courant ou d’extinction de l’Arduino.

images/07-56.png

Le lecteur de cartes microSD

La carte SD doit être formatée en FAT32.

 Si ce n’est pas le cas, utilisez un utilitaire spécialisé comme Rufus ou SDFormatter.

Le lecteur utilise les bibliothèques SPI et SD, pré-installées dans l’IDE Arduino. Les noms de fichiers ou de dossiers ne doivent pas dépasser huit caractères (plus trois caractères pour l’extension).

1. Les fonctions de la bibliothèque SD

SD.begin(borneCS) : initialise la carte SD et vérifie le fonctionnement correct du module (renvoie la valeur true ou false).

SD.exists("dossier/fichier.txt") : vérifie la présence d’un fichier ou d’un dossier (renvoie la valeur true ou false).

SD.mkdir("dossier") : crée un dossier nommé "dossier".

SD.rmdir("dossier") : supprime le dossier nommé "dossier".

SD.remove("dossier/fichier.txt") : supprime le fichier "fichier.txt" du répertoire "dossier" (renvoie la valeur true ou false, si l’opération a réussi ou échoué).

File fichier1 = SD.open("dossier/fichier.txt", FILE_READ) : ouvre un fichier en lecture seule. Crée un objet de type File nommé "fichier1" utilisable ensuite. La lecture commence au début du fichier.

File fichier1 = SD.open("dossier/fichier.txt", FILE_WRITE) : ouvre un fichier en écriture et le crée s’il n’existe pas. Crée un objet de type File nommé "fichier1" utilisable ensuite. L’écriture...