Utiliser un potentiomètre avec un
Arduino***
Un potentiomètre est un bouton qui fournit une résistance variable. Les valeurs des
potentiomètres sont envoyés dans l’Arduino sous un signal analogique.
Le potentiomètre possède 3 broches :
– Une alimentation (généralement, nous utilisons le +5V délivré par l’Arduino)
– Une sortie analogique
– Une masse
En tournant l’axe du potentiomètre, nous modifions la résistance vers l’interface de sortie.
L’entrée analogique de l’Arduino Uno est codé sur 10 bits (210 = 1024 valeurs). Quand nous
envoyons la tension en sortie du potentiomètre vers l’entrée de l’Arduino, celle-ci va être
convertie en un nombre numérique.
Pour une alimentation de 5V :
0V –> 0
5V –> 1023
Attention, la valeur du potentiomètre, alimenté sous 5V ici, devrait varier entre 0 et
1023. Mais certains potentiomètres ne renvoient pas un ‘0’ lorsqu’ils sont tournés au
minimum, et ‘1023’ lorsqu’ils sont tournés au maximum.
Il faudra donc effectuer un essai afin de visualiser la valeur minimum et maximum.
La commande permettant de lire une entrée analogique est :
analogRead(Nom_de_la_broche);
Ce code permet de récupérer la valeur du potentiomètre, et de l’afficher dans le moniteur
série.
Câblage :
Code :
// Initialise la variable qui va recueillir la valeur du potentiomètre
int Pot ;
void setup() {
Serial .begin(9600); //Initialise la communication entre le PC et Arduino
}
void loop() {
// Lire la valeur du potentiomètre
Pot = analogRead( A0 );
//Affiche la valeur du potentiomètre sur le moniteur série
Serial .println( Pot );
//Pause de 200 millisecondes
delay(200);
}
Ce second code permet de modifier la luminosité d’une led, en fonction de la valeur du
potentiomètre.
Câblage :
Code :
// Initialise la variable qui va recueillir la valeur du potentiomètre
int Pot ;
// Initialise la variable de la led
int led = 13;
// Initialise la variable qui permettra d'envoyer le bon rapport cyclique à la led
int Val_led ;
void setup() {
Serial .begin(9600); //Initialise la communication entre le PC et Arduino
}
void loop() {
// Lire la valeur du potentiomètre
Pot = analogRead( A0 );
//Affiche la valeur du potentiomètre sur le moniteur série
Serial .println( Pot );
}
Le montage de démonstration
Afin de comprendre comment mesurer une tension avec une carte Arduino, nous
allons faire un petit montage de démonstration très simple.
Dans notre montage, la carte Arduino va lire la tension en sortie d'un potentiomètre
et envoyer la valeur numérique mesurée à l'ordinateur via le câble USB.
Matériel nécessaire
Pour réaliser ce montage, il va nous falloir :
Une carte Arduino UNO (et son câble USB),
Un potentiomètre (la valeur de celui-ci n'a pas d'importance), j'utilise un
potentiomètre de 10K ohms,
Une plaque d'essai et des fils pour câbler notre montage.
Parenthèse technique : le potentiomètre
Un potentiomètre est un composant très pratique. Il s'agit en réalité d'une résistance
variable.
Photographie et symbole d'un potentiomètre
Un potentiomètre est composé d'une résistance de valeur fixe et d'un curseur. Le
curseur peut se déplacer le long de la résistance de valeur fixe pour donner une
résistance de valeur variable.
Schéma de montage d'un potentiomètre en résistance variable
En connectant une extrémité de la résistance fixe et le curseur à un circuit, on obtient
une résistance de valeur variable.
Schéma de montage d'un potentiomètre en générateur de tension variable
En connectant les deux extrémités de la résistance fixe à une alimentation et le
curseur à un circuit, on obtient une sorte de mini générateur de tension variable.
Vue schématique du montage
Vue prototypage du montage
Pour commencer notre montage, nous allons câbler les deux broches de la résistance
fixe du potentiomètre respectivement aux broches 5V et GND de la carte Arduino.
Le montage fini
On achève ensuite le circuit en reliant le curseur du potentiomètre à la broche A0 de
la carte Arduino avec un fil.
N.B. Pour les potentiomètres à trois broches "en ligne", le curseur est soit sur la
broche au centre, soit sur la broche n°1. En général, une petite flèche permet de
savoir où se trouve la broche du curseur.
Le code de démonstration
Maintenant que nous avons notre montage, passons au code !
Le but de notre code va être de :
1. Lire la tension sur la broche A0
2. Convertir la valeur en une tension (pour l'affichage)
3. Envoyer la valeur au PC (pour l'affichage)
4. Recommencer au point 1.
Pour réaliser ce morceau code, nous allons utiliser la fonction analogRead().
Détails de la fonction analogRead()
La fonction analogRead() permet de mesurer une tension sur une broche analogique
(dont le nom commence par le préfixe "A…").
int
1analogRead(broche);
La fonction analogRead() accepte un paramètre obligatoire : le numéro de broche
analogique à lire.
Dans le cas d'une carte Arduino UNO, ce paramètre peut prend une des valeurs
suivantes : A0, A1, A2, A3, A4, A5.
N.B. Ne confondez pas les broches analogiques (préfixe "An") avec les broches
numériques (préfixe "Dn").
La fonction analogRead() retourne un nombre entier (int) compris entre 0 et 1023.
Ce nombre correspondant à la tension mesurée, 0 = 0 volt, 1023 = tension
alimentation = 5 volts (ou 3v3 suivant les cartes Arduino).
La mesure prend environ 100µs, il n'est donc pas possible de faire plus de 10 000
mesures par secondes.
N.B. Si la broche n'est pas connectée, la valeur retournée par analogRead() va
fluctuer entre 300 et 500. Ce n'est pas un bug, c'est tout simplement dû au fait
qu'une entrée analogique flottante est une antenne qui capte tous les parasites
environnants.
1void setup() {
[Link](9600);
2
}
3
Nous allons commencer notre programme de démonstration avec la
fonction setup() qui va simplement initialiser la communication avec le PC.
PS Ne cherchez pas à comprendre comment utiliser de [Link]() pour le
moment, cela fera l'objet d'un futur tutoriel
void loop() {
1 int valeur = analogRead(A0);
2
3 float tension = valeur * (5.0 /
41023.0);
5
6 [Link](tension);
7 delay(250);
8}
Dans la fonction loop(), nous allons faire trois choses : 1) Mesurer la tension sur la
broche A0 avec analogRead(). 2) Transformer le résultat de la mesure en un nombre à
virgule (type float) en faisant un simple produit en croix. 3) Envoyer la valeur au PC
et attendre quelques millisecondes pour avoir le temps de lire ce qui se passe côté PC.
N.B. On utilise valeur * (5.0 / 1023.0) dans le calcul du produit en croix, car lors
de la compilation du programme, c'est le type des valeurs d'une opération qui
définit le type du résultat. Si on faisait valeur * (5 /
1023) comme valeur, 5 et 1023 sont des nombres entiers, le résultat serait un
nombre entier, ce qui n'est pas notre but, nous voulons un calcul avec des nombres à
virgule. On utilise donc 5.0 et 1023.0 pour forcer un calcul avec des nombres à
virgule.
Le code complet avec commentaires :
/*
1
* Code d'exemple pour la fonction analogRead().
*/
2
3 // Fonction setup(), appelée au démarrage de la carte Arduino
void setup() {
4
// Initialise la communication avec le PC
5
[Link](9600);
6 }
7
// Fonction loop(), appelée continuellement en boucle tant que la
carte Arduino est alimentée
8
void loop() {
9
1 // Mesure la tension sur la broche A0
0 int valeur = analogRead(A0);
1
1
// Transforme la mesure (nombre entier) en tension via un produit
1 en croix
2
float tension = valeur * (5.0 / 1023.0);
1
3
1 // Envoi la mesure au PC pour affichage et attends 250ms
4
[Link](tension);
1
delay(250);
5
}
1
6
1
7
1
8
1
9
2
0
2
1
2
2
2
3
2
4
Si jamais vous dépassez la tension de référence que vous utilisez, sans pour autant
dépasser la tension d'alimentation interne de la carte (5v ou 3v3 suivant la carte), il
n'y aura pas de dégât.
Evitez cependant de dépasser la tension de référence, vos mesures seront fausses et
en plus cela n'est pas très bon pour le microcontrôleur à long terme.
Voici un exemple de code qui part du principe que vous avez une tension de référence
sur AREF :
void setup() {
1 analogReference(EXTERNAL);
2}
3
4void loop() {
5 int val = analogRead(A0);
6 // 0 = 0v, 1023 = tension
7AREF
8}
Bonus : Adapter la plage de tension pour la mesure
Mesurer des tensions comprises entre 0 et 5 volts, c'est bien. Cependant, il arrive
régulièrement qu'on ait besoin de mesurer des tensions plus élevées.
Prenons l'exemple d'un montage relié à une batterie de 12v, si votre montage veut
connaitre la tension de la batterie, il va falloir ramener la plage de tension 0 - 12v vers
la plage mesurable 0 - 5v.
Schéma d'un pont diviseur de tension
Pour faire cela, on utilise un pont diviseur de tension. Comme son nom l'indique, un
pont diviseur de tension permet de diviser une tension par un coefficient fixe.
Un pont diviseur de tension se construit toujours de la même façon. Tout d'abord,
deux résistances sont mises en série pour former un pont de résistances. Les deux
extrémités des résistances sont respectivement reliées à la masse d'un côté et à la
"haute" tension de l'autre. Le point milieu au centre des deux résistances en série est
la sortie "basse tension".
La formule mathématique d’un pont diviseur de tension est la suivante : Vs = Vin *
(R2 / (R1 + R2))
Avec Vs = tension de sortie, Vin = tension d'entrée, R1 & R2 = valeurs en ohms des
résistances du pont diviseur.
La méthodologie de calcul d'un pont diviseur de tension est la suivante :
1. Vin = tension max de la plage d'entrée (prévoir 10% de marge pour éviter les
mauvaises surprises)
2. Vs = tension max de la plage de sortie (5v dans la plupart des cas, 3v3 parfois
suivant la carte Arduino utilisée)
3. Choisir une valeur de R2 arbitrairement (je commence toujours avec 10K ohms
ou 1K ohms)
4. Calculer R1 avec la formule : R1 = ((Vin / Vs) * R2) - R2
5. Ajuster la valeur de R2 si besoin pour obtenir les meilleures valeurs
normalisées possibles de R1 et R2.
6. Enjoy
N.B. Je passe la partie théorique, loi des mailles, etc. Ce n'est pas le but de ce
tutoriel.
Exemple pratique : passer d'une plage 0 - 18v à une plage 0 - 5v.
Avec R1 = 3300 ohms (3.3K ohms) et R2 = 1100 ohms (1.1K ohms), on obtient
pour Vin = 20v (soit 18v maximum admissible + 10% marge) : Vs = 20 * (1100 /
(3300 + 1100)) = 20 * (1100 / 4400) = 20 * 0.25 = 5 volts
Ces valeurs de R1 et R2 sont communément utilisées pour mesurer des tensions
d'alimentation en provenance d'une batterie, d'un panneau solaire, etc.
N.B. Pour les curieux, un potentiomètre est un pont diviseur de tension un peu
particulier avec la somme de R1 et R2 toujours égale à la valeur de la résistance fixe
du potentiomètre.
Si votre code envoi régulièrement sur le port série un nombre (entier ou à virgule) sur
une ligne (avec [Link]()), vous pouvez demander au logiciel Arduino de
vous tracer un graphique en temps réel de ces valeurs.
Le principe des ultrasons
Les capteurs à ultrasons ont établi de nouvelles références en automatisation
Le principe des ultrasons:
Un capteur à ultrasons émet à intervalles réguliers de courtes impulsions sonores à haute
fréquence. Ces impulsions se propagent dans l’air à la vitesse du son. Lorsqu’elles rencontrent
un objet, elles se réfléchissent et reviennent sous forme d’écho au capteur. Celui-ci calcule alors
la distance le séparant de la cible sur la base du temps écoulé entre l’émission du signal et la
réception de l’écho.
Le principe des ultrasons
La distance étant déterminée par le temps de propagation des ultrasons et non par leur intensité,
les capteurs à ultrasons conviennent parfaitement à une suppression d’arrière-plan.
Pratiquement tous les matériaux qui reflètent le son peuvent être détectés et ce, quelle que soit
leur couleur. Même les matériaux transparents ou les feuilles minces ne représentent aucun
problème pour un capteur à ultrasons.
LCD :
La technologie LCD procède par filtrage de la lumière pour afficher les images à l'écran, en
exploitant deux propriétés spécifiques des cristaux liquides : leur faculté à être orientés
lorsqu'ils sont soumis à un courant électrique et leur capacité à modifier ainsi la polarisation
de la lumière qu'ils laissent passer.
Tant qu'aucune tension n'est appliquée aux électrodes pour orienter les cristaux
liquides des pixels, la lumière ne peut pas traverser les cellules. Polarisée
horizontalement à l'entrée de la dalle LCD, elle se heurte en effet au filtre polarisant vertical
en sortie.
