Cours pour débuter dans la programmation d’une carte Arduino

Pour les utilisateurs de Linux, la procédure mérite qu’on s’y attarde un peu, car par défaut l’utilisateur ne peut écrire ou lire sur le port série ce qui risque de poser problème dès les premiers programmes ! Pour cela il faut réaliser quelques opérations : après l’installation de l'IDE Arduino, branchez la carte Arduino sur un port USB. On va ensuite lister les périphériques disponibles :

$ls -l /dev/tty*

Selon le type de carte, on verra dans la liste affichée /dev/ttyACM0 ou /dev/ttyUSB0. Si l'Arduino est sur /dev/ttyUSB0 on lira dans la console quelque chose du genre :

$crw-rw---- 1 root dialout 188, 0 5 apr 23.01 ttyUSB0

Si vous déconnectez la carte Arduino après cette opération, la ligne correspondante ne sera plus affichée dans la liste lors d’une recherche ultérieure des périphériques disponibles. Pour que l'utilisateur $USER puisse accéder au port série, il faut l'inscrire dans le groupe dialout (attention commande en sudo) :

$sudo usermod -a -G dialout $USER

puis modifier les droits de lecture et d'écriture sur le port /dev/ttyUSB0 (commande en sudo)

$sudo chmod a+rw /dev/ttyUSB0

Au premier démarrage, le logiciel peut être un peu long à s’ouvrir : c’est normal, pas d’inquiétude.

Une fois la carte connectée, il faut vérifier qu’elle est bien reconnue : pour cela, un petit tour dans le menu Outil → Type de carte → sélectionner le type et dans Outil → Port→ si le type de carte n’est pas indiqué, il vous faudra installer manuellement le driver (c’est le cas le plus fréquent avec les modèles non officiels Arduino) en passant par le gestionnaire de périphériques.

La fenêtre du logiciel comporte quatre grandes parties :

• interaction avec l’utilisateur  : les icônes permettent dans l’ordre de Compiler, Téléverser, Créer un nouveau programme, Ouvrir un programme, Enregistrer le programme en cours ;
• corps du programme : là où vous rédigerez le code, vous remarquerez que des lignes de code sont déjà inscrites ;
• moniteur série  : pour afficher des données ou des résultats et transmettre des données textuelles grâce au moniteur série ;
• console de débogage où s’affichent notamment les messages d’erreur de votre programme lors de la compilation.
  

Dans la fenêtre qui s’ouvre, on trouve à droite tous les composants, cartes Arduino, capteurs utilisables dans la simulation. Pour ajouter un élément au circuit, il suffit de le sélectionner en cliquant dessus (on peut faire une recherche par nom) puis de déplacer la souris jusqu’à la position souhaitée et de cliquer pour valider l’emplacement : voilà, le composant est ajouté au circuit.

Certains composants possèdent des caractéristiques propres : lorsqu’ils sont positionnés, une boîte de dialogue propose des valeurs par défaut. Par exemple, on peut changer la valeur d’une résistance (les habitués remarqueront que le code couleur de la résistance est directement mis à jour), choisir la couleur d’une LED (c’est l’acronyme anglais d’une DEL) ou d’un câble.

Ensuite, pour relier les composants entre eux, il est nécessaire de rajouter des câbles : pour cela, il suffit de cliquer sur une borne d’un composant (ou un trou de la platine d’essai – bredboard) puis de cliquer jusqu’à l’autre extrémité de branchement du câble.

Si on a besoin de tourner un composant, on utilise le bouton  : on peut alors facilement le placer sur la platine d’essai.

Je ne détaillerai pas ici le principe d’un programme Arduino, mais seulement la méthode pour accéder au logiciel de programmation intégré à Tinkercad (je laisse un peu de suspens…)

On rentre dans le « logiciel » en cliquant sur Code : si aucun composant pouvant être programmé n’est présent dans la fenêtre, on obtient un message d’erreur.

Le logiciel permet de programmer par Blocs (par défaut), par Blocs+Texte ou par Texte.

Pour être utilisable par la suite dans le logiciel Arduino, il faut sélectionner Texte (cliquer sur Continuer lorsque la boîte de dialogue « Êtes-vous sûr ? » apparaît). La programmation par Blocs a l’avantage d’être plus visuelle, mais le code ne pourra pas être copié dans le logiciel Arduino lorsque vous souhaiterez passer à un test en conditions réelles avec du vrai matériel.

Vous remarquerez au passage que par défaut, un programme est déjà présent dans le logiciel : il s’agit du programme permettant de faire clignoter une DEL, mais on anticipe déjà sur la suite, je ne m’y attarderai pas encore.

Une fois le programme écrit, il suffit d’appuyer sur Démarrer la simulation : on voit sur le circuit électrique la prise USB se connecter à la carte et le programme est lancé.

Pour en terminer avec la présentation rapide de Tinkercad, j’ajouterai un point qui servira pour la première partie pratique (La fonction setup) : pour accéder au moniteur série, on clique sur .

Une DEL est l’acronyme de Diode ElectroLuminescente (en anglais LED pour Light Emitting Diode). Comme toute diode, elle ne laisse passer le courant que dans un seul sens (cette phrase est à nuancer pour quelques diodes particulières) comme en témoigne son symbole ci-dessous :

La DEL a un truc en plus que les autres diodes : elle émet de la lumière lorsqu’elle est parcourue par un courant ce qui en fait un des composants à la mode, car elle ne consomme pas grand-chose et peut être très lumineuse. On retrouve cette particularité sur son schéma normalisé avec les flèches qui symbolisent l’émission de lumière.

Pour connaître la couleur d’une DEL, il faut se méfier du boîtier : ce n’est pas parce qu’il est transparent que la DEL s’illuminera en blanc. Certaines DEL, généralement bas de gamme, sont en fait des DEL blanches dont le boîtier est coloré donnant l’impression de la couleur. À l’inverse, la plupart des DEL plus puissantes et de meilleure qualité disposent d’un boîtier transparent, mais illuminent bien avec une couleur une fois branchée (dans le bon sens évidemment !)

Comme on l’a vu au point précédent, le courant doit circuler dans un certain sens pour que la DEL s’allume : comment faire pour savoir dans quel sens je dois la brancher ? Pour cela, deux méthodes sont possibles :

• la patte la plus longue est à l’origine la patte représentant le plus : il faut nuancer ce propos, car un petit malin a pu couper les pattes de la DEL auparavant…
• regarder le méplat de la DEL (quand on regarde du dessus une DEL, on voit qu’elle n’est pas complètement circulaire et dispose d’un côté plat) qui correspond au pôle moins :

En électricité, la plupart du temps, pour faire circuler un courant électrique, il faut imposer une certaine tension (ou différence de potentiel) aux bornes des composants. Pour être plus clair, il faut que la tension du côté du plus de la DEL soit plus grande que la tension du côté du moins : en pratique, on branchera donc la patte la plus longue de la DEL vers le 5 V délivré par Arduino tandis que la petite patte sera du côté du 0 V (ou GND).

Mais ce n’est pas tout : comme tout composant, les caractéristiques électriques d’une DEL ne sont pas infinies et il faut donc respecter une fourchette de valeurs pour la tension et le courant sous peine de la voir griller. Pour les non-initiés à l’électronique, ces caractéristiques se trouvent dans la DATASHEET du composant :

Pour ce qui nous intéresse, les informations les plus intéressantes sont :

• Peak wavelenght : donne la longueur d’onde (donc la couleur) de la DEL ;
• Forward Voltage : la tension minimum à imposer aux bornes de la DEL pour qu’un courant « significatif » la traverse en d’autres termes, pour qu’elle éclaire ;
• Test Conditions : dans les conditions normales d’utilisation, le courant usuel de fonctionnement vaut I_F.

On voit donc que, dans le cas de la DEL citée en exemple, elle fonctionne dans les conditions normales lorsqu’elle est parcourue par un courant d’intensité I_F=20 mA et avec une tension à ses bornes de 1,65 V : elle émet alors un rayonnement lumineux de longueur d’onde 660 nm correspondant à une couleur rouge.

On a donc tout ce qu’il faut pour faire fonctionner notre DEL : on la branche sur Arduino et puis voilà. Sauf que, ce n’est pas aussi simple. Si on reprend les caractéristiques de notre carte Arduino, elle délivre grâce à son régulateur une tension de 5 V : c’est une bonne nouvelle, notre DEL a besoin d’une tension de 1,65 V. Mais en la faisant fonctionner avec une valeur trop élevée, elle risque de ne pas aimer du tout ! Pour vous en convaincre, vous pouvez essayer dans Tinkercad (surtout pas avec votre vraie carte Arduino !) de brancher une DEL entre l’entrée 5 V (côté anode, la plus longue broche de la DEL) et le GND (côté cathode, la plus courte broche) : en démarrant la simulation, on voit tout de suite que la DEL n’apprécie pas vraiment :

Il faut donc ajouter dans le circuit un composant dont le rôle va être d’absorber ce surplus, et éviter tout risque à notre DEL, ce composant c’est la résistance. La DEL va donc prendre ce dont elle a besoin puis laisser le reste à la résistance qui va l’évacuer sous forme de chaleur, c’est ce qu’on appelle le réchauffement par effet Joule.

La question qui vient donc maintenant, c’est comment je dois choisir la résistance pour mon circuit ? Pour cela, il faut revenir à deux relations importantes en électricité : la loi d’Ohm et la loi d’additivité des tensions (appelée également loi des mailles).

Pour la seconde, c’est une simple question de répartition des tensions : dans une boucle du circuit électrique, la tension se répartit (pas forcément équitablement) aux bornes des différents composants de la boucle. On peut schématiser la boucle comme ceci

Dans le cas de notre circuit, la tension délivrée par la carte (5 V) va se répartir entre la DEL et la résistance : comme on a vu que la tension aux bornes de la DEL doit valoir 1,65 V, il faut donc que la résistance ait à ses bornes une tension de 5-1,65=3,35 V.

il faut ensuite utiliser la fameuse loi d’Ohm, bourreau de la plupart des collégiens. Cette loi indique que pour une résistance, la tension U à ses bornes est proportionnelle à l’intensité I du courant électrique qui la traverse ce qui se traduit par la formule kitxmlcodeinlinelatexdvpU=R \cdot Ifinkitxmlcodeinlinelatexdvp, R étant le facteur de proportionnalité qui s’exprime en Ohms W.

On connaît la tension aux bornes de la résistance (3,35 V) et on souhaite que l’intensité soit de 20 mA → on calcule donc à partir de la loi d’Ohm que la résistance doit valoir kitxmlcodeinlinelatexdvpR=167,5 \: \Omegafinkitxmlcodeinlinelatexdvp. Et voilà, la boucle est bouclée, enfin presque parce qu’en pratique, pas facile d’avoir une telle résistance. Les valeurs des résistances sont normalisées et seules certaines sont disponibles : qu’à cela ne tienne, on prendra donc la valeur la plus proche supérieure (si on prend une valeur inférieure, on risque d’avoir un courant trop important qui circule et donc un risque pour la DEL et la carte Arduino de griller) → dans la gamme des résistances, la valeur normalisée juste au-dessus est la kitxmlcodeinlinelatexdvp220 \: \Omegafinkitxmlcodeinlinelatexdvp : ce qui est pile-poil celle que je vous conseillais dans le matériel à prévoir, magique ! Si vous avez un doute, il vaut mieux prendre une valeur plus élevée que trop petite : la luminosité de la DEL sera plus faible qu’attendue (car l’intensité du courant électrique sera moindre), mais cela évitera de détériorer les broches de la carte (40 mA maximum par entrée/sortie digitale) et la DEL.

Pour faire les premiers essais, il est plus pratique d’utiliser une platine d’essai pour disposer les composants et les connecter plus facilement. Cependant, avant de les utiliser, il est nécessaire de connaître le principe de branchement pour éviter soit de griller un composant ou la carte (court-circuit) soit de passer des heures à comprendre le problème du programme alors qu’il s’agit simplement d’un décalage du branchement sur la platine d’essai !

Plusieurs modèles existent : je vais présenter ici une petite carte largement suffisante pour faire ce dont on a besoin. Bien évidemment, pour des montages plus grands, il faudra adapter la taille de la platine d’essai en conséquence.

J’ai encadré quelques groupes de bornes qui sont reliées électriquement : on voit donc qu’une platine d’essai contient deux types de bornes reliées :

• trous en colonne par groupe de 5 : pour la petite platine de l’exemple, on dispose donc de 30x2 groupes de 5 trous ;
• trous reliés en ligne (sur les bords inférieurs et supérieurs de la carte) : sur une même ligne, tous les trous sont reliés entre eux. Les lignes sont utilisées usuellement pour créer une ligne à 5 V (beaucoup de composants nécessitent d’être alimentés en 5 V) et une ligne à 0 V (le GND est également très présent dans les montages).

Désormais, plus de raison de faire une fausse manipulation avec la platine d’essai !

C’est bon, on est prêt : on a vu tout ce qu’il fallait pour faire fonctionner la DEL sans risque de la détériorer.

Comment faire pour faire clignoter une DEL ? Tout simplement, en alternant des moments où le courant va la traverser (DEL allumée) et des moments où aucun courant ne passe (DEL éteinte). Dis autrement, on va alterner des moments pendant lesquels on va imposer une tension différente entre les bornes du circuit (DEL allumée) et des moments pendant lesquels la tension sera la même sur chaque patte (DEL éteinte) : une petite pause entre chaque état permettra de faire clignoter plus ou moins rapidement la DEL.

Le branchement est celui-là :

Vous remarquerez que j’ai bien utilisé une résistance pour protéger la DEL.

Dans le logiciel d’Arduino, on saisit (ou copie) le code suivant :

void setup() 
{
  pinMode(12, OUTPUT); 
}

void loop() 
{
  digitalWrite(12, HIGH);
  delay(1000);
  digitalWrite(12, LOW);
  delay(1000);
}

Si vous le compilez puis l’exécutez (et que vos branchements sont corrects !), vous devriez voir votre DEL qui s’allume pendant une seconde, s’éteint une seconde et ceci à l’infini !

Regardons plus en détail le code pour voir ce qu’il s’y passe.

Ligne 3 : on indique à la carte que la broche 6 est en mode (pinMode) sortie (OUTPUT) ce qui signifie qu’elle se comporte comme une sortie et pourra donc faire circuler un courant (dans la description de la carte, voir le schéma Comment ça fonctionne ?, j’ai indiqué que les broches numériques peuvent être des entrées ou des sorties, il faut donc préciser dans le programme si on utilise la broche comme une entrée ou une sortie).

Ligne 8 : on indique à la carte que la broche numérique (digital) 6 doit être mise au niveau HAUT (HIGH) → en fait cela signifie que la borne 6 est soumise à une tension de 5 V.
On a donc le côté plus de la DEL qui est à 5 V, le côté moins qui est à 0 V (GND) donc un courant peut circuler : la DEL s’allume.

Ligne 9 : on fait une pause de 1000 ms (1 seconde), temps pendant lequel la DEL reste allumée.

Ligne 10 : on indique à la carte que la broche numérique (digital) 6 doit être mise au niveau BAS (LOW) → en fait cela signifie que la borne 6 est soumise à une tension de 0 V.
On a donc le côté plus de la DEL qui est à 0 V, le côté moins qui est également à 0 V (GND) donc aucune différence de tension entre les bornes de la DEL→ aucun courant ne peut circuler : la DEL s’éteint.

Ligne 11 : on fait une pause de 1000 ms (1 seconde) temps pendant lequel la DEL reste éteinte.

Comme cet enchaînement d’états de la diode est dans la partie loop() du programme, le clignotement continue tant qu’on ne coupe pas l’alimentation de la carte Arduino.

En guise d’exercice, je vous propose un classique du genre : simuler un feu tricolore.

Le feu doit suivre la séquence suivante : feu vert allumé pendant 3 secondes, feu orange allumé pendant 1 seconde, feu rouge allumé pendant 3 secondes.

N’hésitez pas à chercher par vous-même, sans aller voir la réponse directement en dessous ou sur la Toile : le plaisir serait gâché. Si vous avez peur de faire une bêtise et de griller votre carte, simulez le tout en ligne via Tinkercad.

Pour vous aider, je vous joins le schéma électrique :

Et la solution se trouve juste en dessous :

void setup()
{

  //initialisation des modes
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);
  
}
void loop()
{
  digitalWrite(10, HIGH);
  digitalWrite(11, LOW);
  digitalWrite(12, LOW);
  delay(3000);

  digitalWrite(10, LOW);
  digitalWrite(11, HIGH);
  digitalWrite(12, LOW);
  delay(1000);
  
  digitalWrite(10, LOW);
  digitalWrite(11, LOW);
  digitalWrite(12, HIGH);
  delay(1000);

}

Un bouton-poussoir est un dipôle c’est-à-dire qu’il n’a besoin que de deux pattes pour être branché dans un circuit. En électronique, pour des raisons de commodité, les boutons-poussoirs disposent de quatre pattes qui sont reliées deux à deux.

Les broches 1 et 2 sont reliées ensemble de même que les broches 3 et 4 (voir le schéma en bas à droite).

Lorsque je branche un bouton-poussoir sur une platine d’essai, il y a deux possibilités de connexion :

1er cas (schéma de gauche) : les pattes « 2 à 2 » sont reliées dans une même colonne de la platine → le courant ne circule donc des bornes 1/2 aux bornes 3/4 que si on appuie sur le bouton → c’est donc le bon sens de branchement

2e cas (schéma de droite) : les pattes « 2 à 2 » sont reliées dans deux colonnes différentes → le courant circule donc toujours des bornes 1/2 aux bornes 3/4 dans le bouton-poussoir, qu’il soit appuyé ou non !

Fondamentalement, il y a une chance sur deux pour que vous soyez dans le cas n° 2 et évidemment, c’est toujours sur ce branchement que vous tombez lors du premier essai ! Une astuce pour connaître le sens des broches d’un bouton-poussoir est de câbler le montage suivant :

Si la DEL s’allume en permanence, sans appuyer sur le bouton-poussoir alors vous êtes dans le cas n° 2 pour le branchement du bouton→ il suffit de tourner le bouton-poussoir d’un quart de tour pour retrouver un fonctionnement normal.

Et si la DEL ne s’allume qu’en appuyant sur le bouton-poussoir, félicitations, vous avez trouvé le bon branchement !

À l’avenir, pour éviter des erreurs (et des angoisses à essayer de trouver d’où vient l’erreur dans votre montage !), je vous conseille de noter avec un code couleur (ou tout autre signe distinctif) les pattes reliées 2 à 2.

Si le sens de branchement vous importe peu, mais que vous souhaitez être sûr du branchement du bouton poussoir, il suffit de le connecter à cheval sur la zone centrale de la platine d’essais et d’utiliser les deux pattes opposées en diagonale comme sur le schéma ci-dessous :

L’objectif ici est de comprendre comment on peut programmer la carte Arduino pour lire si un bouton-poussoir est appuyé ou non.

Dans un premier temps, téléverser le programme suivant et réaliser le montage correspondant :

void setup()
{
    Serial.begin(9600);
    pinMode(2, INPUT);
}
void loop()
{
  int etatBouton = digitalRead(2);  
  Serial.println(etatBouton);
}

En ouvrant le moniteur série, vous devriez obtenir le chiffre 0 quand le bouton-poussoir est appuyé. Lorsqu’il n’est pas appuyé, l’affichage est aléatoire entre des 0 et des 1 : ce qui peut apparaître comme une anomalie dans le montage réel (pas si vous utilisez Tinkercad) sera abordé dans le point suivant. On voit ici une limite de la simulation : rien ne vaut la « vraie »pratique !

Explicitons le code :

Ligne 3 : on démarre la liaison avec le moniteur série pour l’affichage de l’état du bouton ;

Ligne 4 : on indique à la carte que la broche 2 est une entrée (INPUT), elle va donc recevoir une information ;

Ligne 8 : on créée une variable etatBouton de type entière (integer) qui va contenir l’état de la broche numérique (digitalRead) 2. La commande digitalRead() ne renvoie que des 0 et des 1 : 0 quand le courant ne peut pas circuler (bouton-poussoir non appuyé) et 1 quand le courant circule (bouton-poussoir appuyé) ;

Ligne 9 : on affiche avec un saut de ligne à chaque fois (Serial.println()) le résultat stocké dans la variable etatBouton.

Je reviens ici sur les « anomalies » constatées avec le programme précédent, lorsque le bouton-poussoir n’est pas appuyé. Pour les comprendre, le mieux est de schématiser le montage comme ci-dessous par exemple :

Lorsque le bouton-poussoir est appuyé, l’état électrique de la broche est bien défini et vaut 0 V ; par contre lorsque le bouton-poussoir n’est pas (complètement) appuyé, l’état électrique de la broche est mal défini, car la broche est « en l’air » et pourra donc aléatoirement être interprétée comme une valeur HIGH ou une valeur LOW.

La solution consiste à rajouter une résistance entre le 5 V de la carte et la broche de mesure (2 dans notre cas) : on parle de « tirage vers le haut» (montage pull-up) :

Lorsque le bouton n’est pas appuyé : la broche est reliée au 5 V de la carte via la résistance ; lorsque le bouton est appuyé, la broche est reliée au GND. L’état électrique de la broche est donc toujours bien défini et pourra être correctement interprété.

Il est également possible de résoudre ce problème avec un tirage vers le bas (pull-down) en intercalant une résistance entre le GND et la broche. La seule différence est que la logique est inversée : quand le bouton est appuyé, la broche est reliée au 5 V, quand il ne l’est pas, elle est reliée au GND via la résistance.

Jusque-là, on a vu uniquement la partie « récupération de données » or comme je l’ai évoqué au point À quoi cela peut-il me servir ?, l’intérêt est de pouvoir agir ensuite sur l’environnement. Le cas pratique précédent n’était pas très visuel : on appuyait ou non sur le bouton-poussoir et on regardait simplement une suite de 0 et de 1 s’afficher sur le moniteur série.

Pour rendre plus visuel l’état du bouton-poussoir et commencer à faire des programmes plus poussés, j’ajoute une contrainte supplémentaire : si le bouton-poussoir est appuyé alors je vais allumer une DEL sinon elle restera éteinte. Le rendu sera le même que pour le montage avec en série la DEL et le bouton-poussoir (voir au début du point Branchement d’un bouton-poussoir), mais le principe du montage est complètement différent. Dans le premier cas, la carte Arduino ne sert que de source d’alimentation (aucune programmation) et pourrait très bien être remplacée par un générateur continu 5 V ; dans le second cas, l’allumage de la LED est programmé pour s’allumer lorsque le microcontrôleur détecte un appui sur le bouton.

Le schéma du montage à réaliser est le suivant :

Vous remarquerez que j’ai ajouté une résistance de pull-down pour éviter les anomalies électriques.

Le code à téléverser sur la carte Arduino est le suivant :

void setup() 
{
  pinMode(6, OUTPUT); 
  pinMode(2, INPUT);
}

void loop() 
{
  int etatBouton = digitalRead(2);
  if (etatBouton == HIGH)
  {
    digitalWrite(6, HIGH);
  }
  else
  {
    digitalWrite(6, LOW);
  }
}

Si tout se passe bien, la DEL devrait s’allumer lorsque vous pressez le bouton-poussoir.

Essayons de voir ce qui se passe en termes de programmation.

Ligne 3 : on indique à la carte que la broche 6 est une sortie (OUTPUT), elle va donc pouvoir faire circuler un courant électrique → cela correspond à la broche de branchement de la DEL.

Ligne 4 : on indique à la carte que la broche 2 est une entrée (INPUT), elle va donc recevoir une information, celle liée au bouton-poussoir.

Ligne 9 : on créée une variable etatBouton de type int (integer) qui va contenir l’état de la broche numérique (digitalRead) 2. La commande digitalRead() ne renvoie que des 0 et des 1 : 0 quand le courant ne peut pas circuler (bouton-poussoir non appuyé) et 1 quand le courant circule (bouton-poussoir appuyé).

Ligne 10 : une nouvelle instruction if qui en bon français signifie si : on teste si la variable etatBouton vaut HIGH (correspondant au bouton appuyé)→ si c’est le cas, alors on exécute toutes les commandes indiquées entre les accolades {} qui suivent : dans notre programme (ligne 12), on indique à la carte que la broche numérique (digital) 6 doit être mise au niveau HAUT (HIGH) → la DEL est parcourue par un courant et va donc s’allumer.

Si le test est faux (donc si la variable etatBouton vaut LOW), on exécute les commandes indiquées entre les accolades qui suivent l’instruction else : dans notre programme (ligne 16), on indique à la carte que la broche numérique (digital) 6 doit être mise au niveau BAS (LOW) → la DEL n’est parcourue par aucun courant et va donc être éteinte.

Jusqu’ici, nous n’avons utilisé que des grandeurs numériques : leur valeur était soit 0 soit 1. Or dans la vraie vie, beaucoup de grandeurs ne prennent pas de valeurs fixes, mais présentent une infinité de valeurs : la température peut valoir 23,5 °C ; -0,5 °C ; 11,0000003 °C… On dit que ce sont des valeurs analogiques.

Les valeurs analogiques sont compréhensibles pour les humains, mais pas par les machines : le mécanisme de mesure n’utilise que le code binaire avec des 0 et des 1. La machine a besoin d’un convertisseur analogique – numérique (CAN) pour transformer notre signal infini de valeurs en une suite de 0 et de 1. Selon la puissance du CAN, la précision de cette conversion est plus ou moins fine : elle se définit à l’aide d’un nombre de bits. Schématiquement, un bit correspond à une case contenant 0 ou 1 → un CAN avec 1 bit ne pourra donc prendre en sortie que 2 valeurs ; si le CAN dispose de 2 bits, il pourra prendre 4 valeurs (chaque bit prenant la valeur 0 ou 1, il y a donc 4 possibilités : 00, 01, 10 et 11) ; si le CAN dispose de n bits, il y aura 2ⁿ bits en sortie.

Le CAN de la carte Arduino dispose de 10 bits soit 1024 valeurs : la grandeur analogique d’entrée sera donc convertie en une valeur entre 0 et 1023. Dans la description rapide de la carte, j’ai indiqué que la tension de fonctionnement de la carte était de 5 V : la résolution de la mesure analogique est donc de 5/1024=0,00488 V → ainsi, une tension d’entrée entre 0 V et 0,00488 V vaudra 0 en sortie, une tension entre 0,00488 V et 0,00976 V vaudra 1 en sortie, etc.

Le LM35 est un composant électronique : dans sa DATASHEET, on apprend qu’il permet de mesurer des températures sur une étendue assez vaste pour nos besoins (de -55 °C à 150 °C pour la version la plus évoluée du capteur, le LM35A), avec une tension d’alimentation entre 4 et 30 V (donc adaptée pour Arduino) et dont la sortie vaut 10 mV par °C.

Dans un premier temps, câblez le circuit suivant :

Téléversez ensuite le programme suivant :

/*
 * Programme : LM35
 * Date : 13/12/2019
 * Auteur : nlbmoi
 * 
 * Ce programme permet de convertir la tension mesurée aux 
 * bornes d'un capteur LM35 en une température, le 
 * capteur étant alimenté en 5V
 */

// variable constante de type entier pour la broche de mesure A0 
const byte mesureTemp = 0;

//variables pour les constantes utilisées dans le programme
const unsigned long flux = 9600; //débit de la liaison série
const unsigned int delai = 1000; //délai entre deux mesures en millisecondes


void setup() 
{
  //on initialise le port série pour communiquer avec le PC
  Serial.begin(flux);
}

void loop() 
{
  // Mesure la valeur sur la broche définie mesureTemp
  int valeurTemp = analogRead(mesureTemp);

  //conversion en tension : convertisseur 10 bit
  float tension = valeurTemp * 5.0 / 1023.0;

  //conversion en température : d'après datasheet
  float temperature = tension * 100;
  
  // Envoi la mesure au PC pour affichage
  Serial.print(valeurTemp);
  Serial.print(" ; ");
  Serial.print(tension);
  Serial.print(" ; ");
  Serial.println(temperature);

  //délai entre deux mesures
  delay(delai);
}

Ouvrez le moniteur série pour vérifier que la température indiquée (dernière valeur sur chaque ligne) est proche de la valeur attendue. En posant votre doigt sur le capteur, vous verrez la valeur qui augmente.

Une autre méthode, plus visuelle, est d’utiliser une fonctionnalité récente dans l’IDE d’Arduino : le traceur série. Il permet d’afficher sous forme graphique les valeurs numériques reçues par le port série du PC (celles que l’on affiche avec l’instruction Serial.begin()) ; Pour y accéder, il faut passer par Outils → Traceur série : une fenêtre s’ouvre et les données s’affichent sous forme de points reliés.

Explorons un peu ce code

Lignes 1 à 9 : il s’agit de lignes de commentaires pour expliquer ce que fait le programme. Pour éviter d’avoir à noter // à chaque ligne, il est possible d’utiliser la syntaxe /* pour commencer un commentaire le et terminer par */ : tout ce qui est entre ces symboles est ignoré à la compilation.

Lignes 11 à 16 : définition des variables utilisées dans le programme à savoir la broche pour la mesure de température (mesureTemp), le flux pour la liaison avec le moniteur série (flux), le délai entre deux mesures (delai). Vous pouvez remarquer que le type de ces variables est différent pour prendre en compte l’étendue des valeurs possibles (vous pouvez revenir au tableau IV.C pour vérifier que le type est adapté).
Par rapport à ce que l’on a déjà vu, il y a une petite modification : pour le flux et le délai, l’instruction unsigned a été rajoutée. Cela permet de spécifier que la variable ne prend que des valeurs positives, son intérêt est de décaler l’étendue du type de variable dans les valeurs positives. Ainsi, une variable de type int « normale » peut prendre des valeurs entre -32765 et 32767 alors qu’une variable de type unsigned int peut prendre des valeurs entre 0 et 65535.

Ligne 28 : on récupère la valeur mesurée sur la broche analogique mesureTemp à l’aide de la commande analogRead (en français, lecture analogique) → cette valeur est stockée dans une variable nommée valeurTemp qui est de type int (entier).

Ligne 31 : on convertit la valeur numérique (codée sur 10 bits, de 0 à 1023) en une tension à l’aide d’un simple produit en croix (à une tension de 5 V correspond une valeur de 1023, donc une valeur de x correspond une tension de ) kitxmlcodeinlinelatexdvp\frac{x \cdot 5}{1023} Vfinkitxmlcodeinlinelatexdvp→ cette valeur est stockée dans une variable nommée tension de type float (flottant, un nombre à virgule).

Ligne 34 : comme 10 mV correspondent à 1 °C, cela signifie qu’à une tension de 1 V correspondent 100 °C → on multiplie donc par 100 la valeur de la tension (en volts) pour obtenir la valeur de la température, que l’on stocke dans une variable nommée temperature de type float.

Lignes 37 à 41 : on affiche dans le moniteur série sur la même ligne (Serial.print) la valeur de la variable mesureTemp, le texte « ; », la valeur de la variable tension, le texte « ; » et on termine par afficher la valeur de la variable temperature avec un retour à la ligne ensuite (Serial.println).

Ligne 44 : on ajoute une pause de delai microsecondes soit 1 seconde dans le cas du programme→ les valeurs seront donc affichées toutes les secondes (tant que la carte est alimentée !)

float tension = map(valeurTemp, 0, 1023, 0, 5);

Le programme proposé donne une précision modeste de la température même si visuellement on a une impression de faire une mesure de la température à 0,01 °C près. Il ne faut pas oublier que la résolution avec un CAN 10 bits est de 0,0488 V soit en convertissant en température une résolution de 0,48 °C : on ne peut donc pas mesurer à priori une température à plus de 0,5 °C près. Certes, pour avoir une idée de la température ambiante, c’est suffisant, mais pour d’autres applications, cela risque d’être un peu juste.

Pour améliorer la précision de la mesure, deux solutions s’offrent à nous que je détaillerai ensuite : une première, logicielle, permettra d’apprendre d’autres commandes Arduino et est adaptable à tout type de capteur ; une seconde, matérielle, n’est adapté qu’à quelques capteurs, dont le LM35.

Une manière rapide d’améliorer les résultats d’une mesure est en fait de faire plusieurs mesures puis d’en faire la moyenne : pour ce faire, on va utiliser les boucles. Le principe est simple : pour un nombre de fois décidé au préalable, on va répéter la mesure du capteur et en faire la somme puis à la fin on divisera par le nombre de mesures faites.

Avant d’utiliser cette boucle (instruction for) dans notre programme, voyons le principe de programmation de cette boucle. Pour le montage, il est très simple : il suffit de brancher la carte Arduino à l’aide du câble USB :

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
for (int compteur = 0 ; compteur < 3 ; compteur = compteur + 1)
  {
    Serial.println(compteur);
  }
}

void loop() {
  // put your main code here, to run repeatedly:
  
}

Après téléversement, dans le moniteur, vous devez voir les chiffres de 0 à 2 sur des lignes différentes qui s’affichent. Comment comprendre ce résultat ?

Ligne 8 : la variable compteur est déclarée (int compteur) et vaut initialement 0, elle est incrémentée de 1 à chaque boucle (compteur = compteur +1) jusqu’à ce que la condition compteur < 3 soit fausse. Pour chaque valeur de compteur qui respecte la condition, on effectue les opérations contenues entre les accolades { } soit ici écrire avec un retour à la ligne la valeur contenue dans la variable compteur.

Souvent (pour ne pas dire quasiment tout le temps), pour incrémenter de 1 le compteur, on simplifie la ligne compteur = compteur +1 en compteur ++ (de la même manière, compteur -- remplace compteur = compteur -1).

On peut désormais passer à la vraie pratique et adapter le code LM35 pour faire la moyenne de nos mesures de température.

Le programme à téléverser sur la carte est le suivant :

/*
 * Programme : LM35_moyenne
 * Date : 13/12/2019
 * Auteur : nlbmoi
 * 
 * Ce programme permet de mesurer une température grâce à un 
 * capteur LM35 en moyennant les valeurs
 */

// variable constante de type entier pour le pin de mesure A0 
byte mesure = 0;  

//variables pour les constantes utilisées dans le programme
long flux = 9600; //débit de la liaison série
int delai = 2000; //délai entre deux mesures en millisecondes
int nbBoucle = 10;

void setup() 
{
  //on initialise le port série pour communiquer avec le PC
  Serial.begin(flux);
}


void loop() 
{
  //on met à zéro les variables
  float resultatTemp = 0.0 ;
  float moyenneValeur = 0.0 ;
  int sommeValeur = 0;
  
  for (int compteur = 0 ; compteur < nbBoucle ; compteur ++)
  {
    int valeur = analogRead(mesure);

    //on ajoute la valeur à la somme
    sommeValeur = sommeValeur + valeur;
  }

  //on calcule la moyenne en divisant par le nombre de boucles
  moyenneValeur = sommeValeur / nbBoucle;

  //calcul de la température
  resultatTemp = moyenneValeur * 5.0 / 1023.0 * 100;
  
  // Envoi de la mesure au PC pour affichage
  Serial.print("Temperature moyenne : ");
  Serial.print(resultatTemp, 2);
  Serial.println(" °C");

  //délai entre deux mesures
  delay(delai);
}

Dans le moniteur série, vous devez voir la température moyenne qui s’affiche. Étudions un peu plus en détail le code (je passe sous silence les premières lignes, car elles ont été déjà détaillées précédemment).

Lignes 28 à 30 : on remet à zéro les variables qui contiennent les valeurs mesurées ou calculées. En effet, une fois que le programme a tourné une fois, les variables resultatTemp, moyenneValeur et sommeValeur contiennent bien une valeur (celle du tour précédent) : il faut donc remettre à zéro après chaque affichage.

Lignes 32 : le compteur de tours va de 0 (int compteur = 0) jusqu’à nbBoucle-1 (puisque le critère de fin est compteur < nbTour) avec un incrément de 1 au nombre de tour à chaque boucle (compteur ++), on effectue la suite de commandes suivantes : on enregistre dans la variable valeur de type int la mesure de la valeur lue sur la broche analogique (analogRead), on ajoute cette valeur à la variable sommeValeur qui contient donc la somme des valeurs analogiques lues sur la broche du capteur de température pendant le parcours de la boucle.

Ligne 41 : à la fin de la boucle, quand on a mesuré notre nombre de valeurs, on calcule la moyenne des valeurs en divisant la somme (cumulée dans la variable sommeValeur) par le nombre de tours nbBoucle.

Ligne 44 : on convertit la valeur numérique moyennée moyenneValeur en une tension à l’aide du coefficient 5,0/1023,0 que l’on multiplie ensuite par 100 pour la conversion en température (j’ai condensé ici en un seul calcul les lignes 28 et 31 du programme lm35).

Ligne 48 : lorsqu’un second argument est rajouté à l’instruction Serial.print() ou Serial.println(), cela permet de spécifier soit le nombre de décimales après la virgule à utiliser (pour une valeur de type float) soit la base à utiliser pour l’affichage (byte, bin oct, dec ou hex pour une valeur de type int).

Et voilà, on a réussi à calculer une moyenne de plusieurs valeurs : bien sûr, plus on fera de tours de boucle, plus la valeur sera précise. Mais il y a une limite, tout dépend du délai entre deux séries de mesures, car faire des calculs et des commandes prend du temps au microcontrôleur de la carte : si le nombre de boucles est trop important par rapport au délai, vous risquez d’avoir de mauvaises surprises.

Les mesures sont plus précises certes (il faudrait plutôt dire fidèles), mais cette méthode n’améliore pas la justesse du résultat. Effectivement, faire une moyenne de plusieurs mesures permet de les « rassembler » autour d’une même valeur, mais si toutes ces valeurs sont décalées (par exemple à cause d’un problème du composant ou d’un mauvais étalonnage), on n’obtiendra pas la valeur attendue.

Par exemple, un tireur au pistolet très bon est capable de tirer ses balles dans un même endroit de la cible, mais si le viseur est mal réglé, toutes les balles se ne rassembleront pas autour du 10 :

L’utilisation du traceur série permet de visualiser les notions de fidélité et de justesse. Par exemple, à l’aide d’un même montage mesurant la température, on a suivi son évolution au cours du temps pour plusieurs cartes UNO. On obtient selon les cartes des valeurs moins justes et peu fidèles (image en haut à gauche), valeurs fidèles et justes (images de droite) et des valeurs moins justes et fidèles (image en bas à gauche).

Il faut également préciser qu’en cas de valeurs aberrantes, la moyenne est faussée ; néanmoins avec un grand nombre de mesures, des mesures peu vraisemblables impactent moins la moyenne.

Au début de ce point, j’ai abordé une autre manière d’améliorer la précision de la mesure de la température. Pour la comprendre, il faut se rappeler que par défaut, la tension de référence de la carte Arduino est de 5 V : les 1024 valeurs possibles se répartissent entre 0 et 5 V. Or dans le cas de notre capteur, la valeur maximale de température est de 110 °C (j’ai utilisé la version LM35C du composant) soit une tension maximale de 1,1 V en sortie : on a donc toutes les valeurs de 1,1 V à 5 V qui ne seront pas utilisées ce qui nuit fortement à la précision de la mesure. Pour contourner ce problème, il est possible de programmer un changement de tension de référence : la carte Arduino dispose d’une autre tension de référence à 1,1 V , valeur qui tombe bien (mais c’est un pur hasard !), car elle correspond à la valeur maximale de cette version du composant (par exemple, la version LM35A va jusqu’à 150 °C donc 1,5 V en sortie, avec la tension de référence à 1,1 V, les températures au-dessus de 110 °C seront donc évaluées à 110 °C). Pour indiquer à la carte la modification de référence, on doit saisir dans la partie setup() du programme la commande :

analogReference(INTERNAL) ;

Le reste du programme est identique : hormis la ligne 44 qu’il faut modifier puisque la tension de référence est 1,1 V et non plus 5 V :

resultatTemp = moyenneValeur * 1.1 / 1023.0 * 100;

L’objectif ici est de mettre en place un montage électrique de mesure de la température (ça, on sait faire désormais) : si la valeur mesurée dépasse une certaine valeur alors on fait déclencher une alarme sonore, une alarme visuelle (une DEL qui s’allume) et l’affichage d’un texte. Si vous avez bien suivi jusque-là, vous pouvez écrire le programme tout seul sauf pour l’alarme, car il vous manque les commandes pour faire fonctionner un buzzer.

Pour faire jouer un son à un buzzer, plusieurs solutions, la plus simple à mettre en œuvre utilise la fonction spécifique tone(). Un petit montage d’essai pour comprendre :

Et le programme à téléverser :

void setup() {
  pinMode(13, OUTPUT);
  tone(13, 261, 200);
  delay(400);
  tone(13, 294, 200);
  delay(400);
  tone(13, 330, 200);
  delay(400);
  tone(13, 349, 200);
  delay(400);
  tone(13, 392, 200);
  delay(400);
  tone(13, 440, 200);
  delay(400);
  tone(13, 494, 2000);
}

void loop() {
  // put your main code here, to run repeatedly:

}

Si tout se passe bien, vous devriez entendre la gamme tempérée. Pour votre confort auditif, je vous conseille de déconnecter l’une des broches du buzzer pour éviter un bourdonnement désagréable.

La fonction tone() a besoin de deux ou trois arguments : le numéro de la broche à laquelle le buzzer est connecté, la fréquence du son émis, et éventuellement la durée de la note en millisecondes.

Maintenant que vous savez tout sur le buzzer, enfin assez pour construire notre petite alarme, je vous laisse chercher le programme à téléverser sur la carte, le schéma électrique étant celui-là :

//LM35 détecteur incendie

//déclaration des variables
const unsigned long flux = 9600; //flux de la liaison série
const unsigned int delai = 1000; //délai entre deux mesures en millisecondes
const int tempSeuil = 25; //température seuil de 25°C

//définition des broches utilisées dans le programme
const byte mesureTemp = 0;   // sélection de la borne A0 à laquelle est reliée le capteur
const byte delRouge = 7;   //broche de branchement de la DEL Rouge
const byte buzzer = 5; //broche de branchement du buzzer


// le setup est lancé une fois lors du branchement de la carte
// ou lorsqu'on appuie sur le bouton reset de la carte
void setup() 
{
  //on initialise le port série pour communiquer avec le PC
  Serial.begin(flux); 

  //Initialisation de la del rouge en sortie
  pinMode(delRouge, OUTPUT); //on indique que la broche de la del rouge est une sortie
  pinMode(buzzer, OUTPUT); //le buzzer est une sortie
  pinMode(mesureTemp, INPUT); //la broche de la température est une entrée
}

// Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est alimentée
void loop() 
{
  // Mesure la tension sur la broche définie mesureTemp et conversion en température
  int temperature = analogRead(mesureTemp) * 5.0 / 1023.0 * 100;

  Serial.print("temperature mesurée : ");
  Serial.print(temperature);
  Serial.print("  °C ");

  //test si la température dépasse la valeur seuil
  if (temperature > tempSeuil) 
  {

    //si la température est dépassée
    //on alimente en 5V la Del
    digitalWrite(delRouge, HIGH);

    tone(buzzer, 440);

    //on affiche un message d'erreur sur le moniteur série

    Serial.println("Attention : la température de consigne est dépassée");
    Serial.println(""); // permet d’ajouter un saut de ligne
  }

  //sinon on éteint la DEL et le buzzer
  else 
  {
    digitalWrite(delRouge, LOW);
    noTone(buzzer);
  }

  //délai entre deux mesures
  delay(delai);
}

Avant d’explorer plus en détail la mesure de la température à l’aide d’un capteur numérique, il faut que je vous parler des bibliothèques (libraries en anglais). Pour comprendre à quoi cela correspond, je vais utiliser une comparaison avec une voiture.

Lorsque vous utilisez votre voiture, vous tournez la clé (ou appuyez sur un bouton) ce qui met en route le moteur. Ensuite, vous passez une vitesse et commencez à accélérer pour faire rouler la voiture. C’est simple et pourtant, ce qui se passe « derrière », dans le moteur, ne l’est pas du tout : si vous deviez manuellement enclencher le démarreur à l’aide de la batterie, faire tourner le moteur, engager le carburant et de l’air dans l’admission, enclencher la compression du mélange, produire l’arc électrique à l’aide de la bougie, faire s’échapper les gaz : il serait beaucoup moins agréable d’utiliser une voiture. Pour nous faciliter la vie, les constructeurs ont créé une boîte noire (le moteur) que l’on actionne par quelques dispositifs d’entrée/sortie (clé, pédales, levier de vitesse) sans qu’on ait besoin de savoir ce qu’il y a à l’intérieur pour que cela fonctionne : les plus bricoleurs peuvent par contre farfouiller dans la « boîte noire » pour modifier les éléments constitutifs du moteur.

Dans le cas de nombreux composants, le principe est identique pour fonctionner, ils ont besoin d’une suite d’étapes dont l’utilisateur n’a pas besoin de connaître tous les détails pour l’utiliser. Pour revenir à notre carte Arduino, la boîte noire est constituée de bibliothèques c’est-à-dire de bouts de code, enregistrés dans des fichiers, qui vont faire le lien entre l’utilisateur (qui n'aura besoin que de quelques commandes simplifiées) et le composant. La programmation de ces bibliothèques est souvent complexe, mais un utilisateur averti peut y accéder pour optimiser le fonctionnement du composant.

Pour une majorité de composants « classiques », les fichiers de bibliothèque sont préinstallés sur la carte et sont accessibles via Outils → Gérer les bibliothèques → sélectionner la bibliothèque souhaitée, puis cliquer sur Installer. Pour les autres composants, il faudra les installer manuellement : après avoir récupérer les fichiers (via le constructeur du composant généralement ou sur le site Github), il faut passer par Croquis → Inclure une bibliothèque → Ajouter la bibliothèque .ZIP.

Pour utiliser une bibliothèque, il faut indiquer au programme Arduino qu’on va en avoir besoin. : on indique alors en début de programme #include <la_bibliothèque.h>.

Par exemple, je dispose d’un petit écran pour afficher du texte : pour qu’il fonctionne, le constructeur m’indique d’utiliser deux bibliothèques, je dois donc définir en début de programme

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

Ensuite, il faut créer un objet, que l’on nommera correctement (dans mon cas ce sera tout simplement lcd) qui permettra de faire le lien entre mon programme et les bibliothèques. Avec l’exemple de mon écran, le code à écrire sera :

Adafruit_SSD1306 lcd(4);

Cette ligne permet également d’initialiser l’objet.

Dans cette syntaxe, on définit l’objet lcd comme étant l’écran Adafruit_SSD1306 qui reçoit les données sur la broche 4. Ainsi, pour indiquer au programme d’afficher du texte, j’utiliserai la commande lcd.print("Mon texte").

Si cela vous semble un peu compliqué, il ne faut pas vous en faire. Quand vous allez sur le site du revendeur (ou sur Github), tout est expliqué, en anglais, avec les branchements, les bibliothèques à utiliser, les commandes possibles : chaque constructeur a ses propres codes ! Mais c’est rarement compliqué à comprendre et au pire, les forums spécialisés sur Arduino (par exemple, le forum officiel Arduino ou le forum sur le site developpez.com) regorgent de personnes disponibles pour aider les utilisateurs.

#include<LiquidCrystal_I2C.h> 
LiquidCrystal_I2C lcd(0x27, 20, 4);

Si je vous ai parlé des bibliothèques au point précédent, ce n’est pas juste pour le plaisir : c’est parce qu’on en a besoin pour notre capteur de température. Le capteur DS18B20 est un capteur de température numérique qui intègre toute l’électronique de la mesure analogique, la conversion analogique-numérique jusqu’à la communication série de type « 1-wire » (prononcer « one wire »), c’est-à-dire qu’il nécessite un seul fil pour récupérer des données (il faut également alimenter le capteur) : on utilise donc la bibliothèque associée (Onewire, à installer au préalable comme indiqué dans le point précédent). En parallèle, il faut intégrer une bibliothèque supplémentaire qui va servir en gros à interpréter les mesures de température, c’est la bibliothèque DallasTemperature (à installer également).

Le montage est le suivant :

Il est impératif d’associer une résistance (kitxmlcodeinlinelatexdvp4,7\:k\Omegafinkitxmlcodeinlinelatexdvp) dite de tirage à l’alimentation sur la broche de données.

Pour tester la mesure de température par un capteur numérique, on va utiliser un exemple de programme fourni par la bibliothèque : Fichier → Exemples → DallasTemperature → Simple

Le code doit ressembler à ça (j’ai traduit en français les commentaires du code pour améliorer sa compréhension) :

// chargement des bibliothèques nécessaires
#include <OneWire.h>
#include <DallasTemperature.h>

// Définition de la broche de connexion du capteur de température
#define ONE_WIRE_BUS 2

// déclaration de l'objet one wire qui permet de gérer le bus one wire
OneWire oneWire(ONE_WIRE_BUS);

// déclaration de l'objet DallasTemperature qui permet de gérer le bus one wire
DallasTemperature sensors(&oneWire);

// La fonction setup. On initialise le capteur
void setup(void)
{
  // start serial port
  Serial.begin(9600);
  Serial.println("Dallas Temperature IC Control Library Demo");

  // Démarrage de la bibliothèque
  sensors.begin();
}

/*
   Fonction principale, obtention et affichage de la température
*/
void loop(void)
{
  // demande la température aux capteurs
  // demande à tous appareils connectés sur le bus
  Serial.print("Requesting temperatures...");
  sensors.requestTemperatures(); // Envoi de la commande de récupération de la température
  Serial.println("DONE");
  // Après réception des températures, on peut les afficher
  // La fonction ByIndex est utilisée, mais à titre d’exemple, seule la température du premier capteur est affichée
  Serial.print("Temperature for the device 1 (index 0) is: ");
  Serial.println(sensors.getTempCByIndex(0));
}

Lignes 2 et 3 : on définit les bibliothèques nécessaires pour le programme.

Ligne 6 : on définit une variable ONE_WIRE_BUS correspondant à la broche à laquelle est branchée le capteur one wire. Il s’agit ici d’une syntaxe prise au langage C (remarquez la fin de ligne sans le point-virgule) ; elle a le même effet que la syntaxe déjà vue.

const byte ONE_WIRE_BUS = 12;

Ligne 8 : on crée un objet oneWire (et on l’initialise) qui est branché sur la broche définie à la ligne 6.

Ligne 12 : on crée un objet sensors et on l’initialise ; il prend en paramètre un objet oneWire.

Ligne 24 : avant de faire une mesure, on doit d’abord démarrer la connexion avec la sonde de température.

Ligne 35 : on demande au capteur de faire une mesure de la température.

Ligne 40 : on récupère la valeur mesurée pour l’afficher dans le moniteur série.

Cette procédure peut paraître complexe, elle n’a pas forcément vocation à être comprise (du moins dans une première approche de la programmation Arduino), mais simplement à être codée !

Comme je l’ai indiqué en préambule de cette partie, l’énorme avantage de ce modèle one-wire est de pouvoir faire des mesures à partir de plusieurs capteurs différents montés sur le bus.

Pour tester la mesure de température, vous pouvez téléverser ce code :

//chargement des bibliothèques nécessaires
#include <OneWire.h>
#include <DallasTemperature.h>

//définition des constantes du programme
const unsigned long baud = 9600; //débit de la liaison série
const unsigned byte oneWireBus= 7; //broche de connexion des capteurs température

//déclaration de l'objet one wire qui permet de gérer le bus one wire
OneWire oneWire(oneWireBus ); 
DallasTemperature sensors(&oneWire);

byte nbTemperature ;  //variable qui contiendra le nombre de capteurs détectés


//variable pour le délai
unsigned int delai = 5000;


void setup(void)
{
  Serial.begin(baud);
  sensors.begin();

  //on récupère le nombre de capteurs détectés par le système et on l'affiche
  nbTemperature = sensors.getDeviceCount() ;
  Serial.println("Nombre de capteurs de température : " + String(nbTemperature)) ;
}

void loop(void)
{
  sensors.requestTemperatures();
  
  //Mesure des températures sur le nombre de sondes détectées
  for(int i = 0 ; i < nbTemperature ; i++)
  {
    Serial.print(sensors.getTempCByIndex(i));
    Serial.print(" ; ");  //pour séparer les mesures de chaque sonde
  }

  Serial.println(""); //passage à la ligne à la fin des mesures
  
  //délai entre deux mesures
  delay(delai);
}

Comme d’habitude, explorons ce code.

Lignes 2 et 3 : les bibliothèques dont on a besoin.

Lignes 6 et 7 : les constantes utilisées dans le programme.

Lignes 10 et 11 : on définit les objets nécessaires pour utiliser les commandes spécifiques du capteur de température DS18B20 et on les initialise.

Ligne 26 : on stocke dans la variable nbTemperature le nombre de capteurs détectés à l’aide de la commande sensors.getDeviceCount().

Ligne 27 : on affiche dans le moniteur série le texte « Nombre de capteurs de température : » et le nombre de capteurs nbTemperature qui est converti en chaîne de caractères à l’aide de la fonction String() → on fait ce qu’on appelle une concaténation de chaînes.

Ligne 32 : on demande au capteur de faire une mesure des températures.

Lignes 35 à 39 : on fait une boucle for qui va afficher les températures mesurées sur la même ligne, séparées par un point-virgule : la boucle se fait sur le nombre de capteurs détectés à la ligne 26.

Ligne 41 : la commande Serial.println("") affiche une chaîne de caractères vide et fait un retour à la ligne → on aurait pu écrire de manière équivalente l’instruction Serial.print("\n").

Il est à remarquer que la mesure de la température ne se fait qu’une seule fois (ligne 32), mais qu’on doit appeler à chaque fois que nécessaire la fonction sensors.getTempCByIndex().

Ce capteur, que l’on trouve dans beaucoup de kits pour débutant (d’où son utilisation ici), permet à moindres coûts d’obtenir des valeurs relativement fiables et précises de la température et de l’humidité. Je joins quelques caractéristiques de ce composant ainsi que de deux autres versions que l’on trouve couramment

Pour le câblage de ce composant, il est similaire à celui utilisé pour le capteur de température numérique DS18B20 avec une résistance de tirage entre les broches de données et d’alimentation :

Pour le branchement, si vous avez des doutes, il faut se référer à la DATASHEET du composant qui nous indique (de gauche à droite si la « grille » du composant est face à nous) :

• broche 1 : alimentation( VDD ou power supply) ;
• broche 2 : données (DATA ou signal) ;
• broche 3 : non connectée (NULL) ;
• broche 4 : zéro (GND).

Pour faire fonctionner ce capteur, il faut une fois encore installer sa bibliothèque que l’on trouve dans Croquis → Inclure une bibliothèque → Gérer les bibliothèques puis chercher la bibliothèque DHT sensor library by Adafruit. En regardant le programme (juste en dessous), on voit qu’il faut également installer la bibliothèque Adafruit Unified Sensor Lib.

On va tester ce capteur en utilisant un fichier exemple tiré de la bibliothèque (comme on l’avait fait pour le capteur DS18B20). On sélectionne donc Fichier → Exemples → DHT sensor library → DHTester qui donne le code ci-dessous (version du programme en décembre 2019) :

// Exemple de programme pour différentes versions de capteur d’humidité et de température
// Écrit par  ladyada, public domain

// Nécessite les bibliothèques Arduino suivantes :
// - DHT Sensor Library: https://github.com/adafruit/DHT-sensor-library
// - Adafruit Unified Sensor Lib: https://github.com/adafruit/Adafruit_Sensor

#include "DHT.h"

#define DHTPIN 2     // broche digitale de connexion du capteur DHT
// Si vous utilisez la carte Feather HUZZAH avec module Wi-Fi ESP8266 , il faut utiliser les broches : 3, 4, 5, 12, 13 ou 14 --
// La broche 15 peut fonctionner, mais il faut déconnecter le capteur DHT pendant le téléversement du programme.

// Décommenter selon le type de capteur DHT utilisé
#define DHTTYPE DHT11   // DHT 11
//#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

// Connecter la broche 1 située à gauche du capteur  à la broche 5 V de la carte 
// Si vous utilisez une carte fonctionnant en 3,3 V comme la carte Arduino Due, connectez la broche 1 sur la broche 3,3 V

// Connecter la broche 2 du capteur à la broche DHTPIN définie
//  Connecter la broche 2 située à droite du capteur  à la broche GROUND de la carte
// Connecter une résistance de  10 K  entre les broches 1 et 2 du capteur

// Initialisation du capteur DHT.
// Les anciennes versions de la bibliothèque demandent un 3e paramètre optionnel
//pour gérer le temps pour des processeurs plus rapides. 
//Ce paramètre n’est plus nécessaire avec les nouvelles versions
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  Serial.println(F("DHTxx test!"));

  dht.begin();
}

void loop() {
  // Attendre quelques secondes entre les mesures
  delay(2000);

  // La lecture de la température ou du taux d’humidité prend 250 millisecondes!
  // Les mesures peuvent prendre jusqu’à 2 secondes (c’est un capteur très lent)
  // Lecture du taux d’humidité
  float h = dht.readHumidity();
  // lecture de la température en degrés Celsius (par défaut)
  float t = dht.readTemperature();
  // lecture de la température en degrés Fahrenheit (le paramètre isFahrneheit est égal à true)
  float f = dht.readTemperature(true);

  //  Vérification si les lectures ont échoué : si c’est le cas, on réessaie une mesure.
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println(F("Failed to read from DHT sensor!"));
    return;
  }

  // Calcul de la chaleur ressentie en Fahrenheit (par défaut)
  float hif = dht.computeHeatIndex(f, h);
  // Calcul de la chaleur ressentie en Celsius (par défaut) (paramètre isFahrenheit est égal à false)
  float hic = dht.computeHeatIndex(t, h, false);

  Serial.print(F("Humidity: "));
  Serial.print(h);
  Serial.print(F("%  Temperature: "));
  Serial.print(t);
  Serial.print(F("°C "));
  Serial.print(f);
  Serial.print(F("°F  Heat index: "));
  Serial.print(hic);
  Serial.print(F("°C "));
  Serial.print(hif);
  Serial.println(F("°F"));
}

Vous devriez obtenir sur l’écran quelque chose de similaire à l’image ci-dessous :

Ce programme paraît long, mais si on y regarde de plus près, il est constitué quasi exclusivement de commentaires : le constructeur a donné toutes les informations utiles à une bonne utilisation du capteur.

Étudions les quelques lignes intéressantes qui font fonctionner notre capteur.

Ligne 8 : on inclut la bibliothèque dont on a besoin.

Ligne 10 : on indique la broche de la carte sur laquelle est connectée la broche de données du capteur.

Lignes 15 à 17 : le programme test est le même pour trois versions du capteur (DHT11, DHT 22 et DHT21), il suffit de « décommenter » la ligne qui correspond à la version du capteur utilisé c’est-à-dire enlever les deux barres (par défaut le capteur DHT22 est sélectionné).

Ligne 30 : on crée un objet nommé dht lié à la bibliothèque DHT et on l’initialise.

Ligne 33 : initialisation de la liaison avec le moniteur série à la vitesse de 9600 bauds.

Ligne 34 : on écrit dans le moniteur série le texte « DHTxx test ! ». La syntaxe utilisée est légèrement différente de ce qu’on a vu jusqu’à présent. En termes de programmation pure, cette écriture ne fait aucune différence, le texte sera écrit de la même manière. Par contre, l’intérêt de cette syntaxe est de diminuer l’utilisation de la mémoire vive par le programme ce qui est un atout non négligeable pour des gros programmes.

Objet.print(F("Mon texte"));

Objet.print("Mon texte");

Ligne 36 : on démarre le processus de mesure du capteur.

Ligne 45 : on mesure le taux d’humidité à l’aide de l’instruction dht.readHumidity() que l’on stocke dans une variable de type float (nombre à virgule) nommée h.

Ligne 47 : on mesure la température en degrés Celsius à l’aide de l’instruction dht.readTemperature() que l’on stocke dans une variable de type float (nombre à virgule) nommée t.

Ligne 49 : on mesure la température en degrés Fahrenheit à l’aide de l’instruction dht.readTemperature(true) que l’on stocke dans une variable de type float (nombre à virgule) nommée f.

Ligne 52 : on teste avec l’instruction if si une des variables h, t ou f (les deux barres verticales || signifient « ou ») n’est pas un chiffre à l’aide de la commande isnan (isnan = is not a number) : si c’est le cas, il y a donc une erreur de lecture dans les lignes précédentes et on renvoie un texte (ligne 53) pour notifier une erreur à l’utilisateur.

Ligne 58 : on convertit la valeur de la température en Fahrenheit réelle en température ressentie à l’aide de l’instruction dht.computeHeatIndex() à partir de la mesure de la température f et de l’humidité h → c’est pour cette raison qu’on a testé précédemment (ligne 52) si les mesures ont bien été faites pour éviter une erreur dans l’exécution du programme.

Ligne 60 : on convertit la valeur de la température en degrés Celsius en température ressentie (le 3e paramètre de l’instruction dht.computeHeatIndex() est false pour dire qu’on n’utilise pas la température en Fahrenheit).

Lignes 62 à 72 : on affiche les résultats des mesures.

Une photorésistance est une résistance particulière dont la valeur dépend de la lumière qu’elle reçoit : elle fait partie de la famille des capteurs dits résistifs. Son symbole normalisé est

Dans l’obscurité, la résistance est grande, typiquement de l’ordre de kitxmlcodeinlinelatexdvp1\: k\Omegafinkitxmlcodeinlinelatexdvp, tandis qu’elle est « faible » en pleine lumière (de l’ordre de kitxmlcodeinlinelatexdvp1\: M\Omegafinkitxmlcodeinlinelatexdvp).

Pour visualiser le niveau de luminosité, il faut donc pouvoir remonter à la résistance de ce composant ce qui n’est pas aisé dans un circuit électrique. Pour ce faire, on utilise un montage particulier, peu compliqué, mais qui fait appel à quelques notions de base en électricité et en mathématiques : mais ne commencez pas à avoir des sueurs froides si ces mots vous rendent malades, tout va très bien se passer !!

Avant d’aborder le montage réel, je vais détailler le principe avec un montage plus simple comprenant une alimentation et deux résistances en série dont on connaît les valeurs R₁ et R₂.

On peut utiliser la loi d’additivité des tensions dans ce circuit kitxmlcodeinlinelatexdvpU=U_1 + U_2finkitxmlcodeinlinelatexdvp.

Comme les tensions U₁ et U₂ sont celles aux bornes des résistances, on peut utiliser la loi d’Ohm qui s’écrit respectivement kitxmlcodeinlinelatexdvpU_1 = R_1 \cdot Ifinkitxmlcodeinlinelatexdvpet kitxmlcodeinlinelatexdvpU_2 = R_2 \cdot Ifinkitxmlcodeinlinelatexdvp→ la loi d’additivité des tensions se réécrit donc , kitxmlcodeinlinelatexdvpU=U_1 + U_2 = \left( R_1 + R_2 \right) \cdot Ifinkitxmlcodeinlinelatexdvprelation qu’on peut écrire également kitxmlcodeinlinelatexdvpI=\frac{U}{R_1 + R_2}finkitxmlcodeinlinelatexdvp.

En prenant cette expression de l’intensité I dans le circuit, on peut écrire la loi d’Ohm pour chaque résistance de manière un peu différente, mais complément équivalente kitxmlcodeinlinelatexdvpU_1 = R_1 \cdot I=\frac{R_1}{R_1 + R_2} Ufinkitxmlcodeinlinelatexdvpet kitxmlcodeinlinelatexdvpU_2 = R_2 \cdot I=\frac{R_2}{R_1 + R_2} Ufinkitxmlcodeinlinelatexdvp : la tension aux bornes de chaque résistance ne dépend donc que de la tension d’alimentation U et de la valeur des résistances dans le circuit : la tension aux bornes de chaque résistance est donc « divisée » par un facteur qui ne dépend que de la valeur des résistances, c’est pour cette raison que ce circuit est appelé pont diviseur de tension.

Quelques exemples numériques :

pour U=5 V (tension de référence de la carte Arduino) et kitxmlcodeinlinelatexdvpR_1=R_2=1\: k\Omegafinkitxmlcodeinlinelatexdvp → kitxmlcodeinlinelatexdvpU_1 = U_2 = \frac{1}{1+1} 5 = 2,5Vfinkitxmlcodeinlinelatexdvp→ on a divisé la tension par 2.

En prenant kitxmlcodeinlinelatexdvpR_1=1\: k\Omegafinkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvpR_2=2\: k\Omegafinkitxmlcodeinlinelatexdvp, on arrive à U₁=1,67 V et U₂=3,33 V.

Si maintenant mon circuit comporte une résistance de valeur connue et une résistance inconnue, il suffit de mesurer une des deux tensions (U₁ ou U₂) aux bornes d’une des résistances pour remonter à la valeur de la résistance inconnue: c’est exactement ce qu’on l’on fait avec un capteur de type résistif comme la photorésistance.

On alimente à l’aide de la tension de référence 5 V de la carte Arduino un montage constitué d’une résistance de valeur R₂ connue et de notre capteur de résistance R₁ inconnue : on connecte à l’aide d’un câble une entrée analogique de la carte au point commun aux deux résistances pour mesurer la tension aux bornes de la résistance connue tel qu’indiqué sur le schéma ci-dessous que vous pouvez reproduire :

Pour tester ce montage, téléversez le programme ci-dessous :

/* Programme pour mesurer la résistance aux bornes d'une
 *  photorésistance permettant d'avoir une évolution de la
 *  luminosité ambiante
 */
 
const byte mesureCapteur = 0;
const unsigned long flux = 9600;
const unsigned delai = 1000;
//const unsigned resistConnue = 10000; //valeur en ohm     

void setup() {
  Serial.begin(flux) ; 
  
}
void loop() {
  int valeurCapteur = analogRead(mesureCapteur);
  float valeurTension = valeurCapteur * 5.0 / 1023.0;
  //float valeurResistance = (5.0 / valeurTension – 1) * resistConnue;
  Serial.println(valeurCapteur);
  //Serial.println(valeurResistance, 0);
  delay(delai);
}

En passant votre main devant le capteur, vous devriez voir la valeur affichée dans le moniteur série qui diminue.

Le programme (je ne parle pas pour l’instant des lignes en commentaires) est très ressemblant à ce que l’on a déjà vu : on lit la valeur analogique (ligne 16) que l’on convertit en tension (ligne 17) avant de l’afficher (ligne 19).

Avant de revenir sur les lignes commentées du programme précédent, je précise qu’ici j’ai fait le choix de suivre l’évolution de la luminosité au travers de la tension aux bornes de la résistance connue R_2, car elles varient toutes deux de la même manière.

Si vous souhaitez voir l’évolution de la luminosité au travers de la résistance de la photorésistance, vous pouvez utiliser les lignes de code que j’ai rajoutées en commentaires :

Ligne 9 : valeur de la résistance connue en Ohms.

Ligne 18 : à partir de la relation donnant U₂ en fonction des grandeurs U, R₁ et R₂ on peut remonter à la valeur de la résistance R₁ qui correspond à la valeur de la résistance de la photorésistance dans la luminosité ambiante.

Ligne 19 : il faut mettre en commentaire (ou supprimer) cette ligne pour éviter d’afficher la valeur de la tension.

On peut améliorer le code précédent en mémorisant les valeurs minimales et maximales de la luminosité.

/*
 * Code d'exemple pour une photorésistance.
 */

 //déclaration des variables
const unsigned long flux = 9600; //flux de la liaison série
const unsigned int delai = 5000; //délai entre deux mesures en millisecondes
int minval = 1023; //valeur minimale de départ
int maxval = 0; //valeur maximale de départ

//définition des broches utilisées dans le programme
const byte mesureCapteur = 0;   // sélection de la borne A0


// Fonction setup(), appelée au démarrage de la carte Arduino
void setup() 
{
  // Initialise la communication avec le PC
  Serial.begin(flux);
}

// Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est alimentée
void loop() 
{
  // Mesure la tension sur la broche A0
  int valeur = analogRead(mesureCapteur);
  if (valeur > maxval)
  {
    maxval = valeur;
  }
  if (valeur < minval)
  {
    minval = valeur ;
  }    

  // Envoi la mesure au PC pour affichage et attends 250 ms
  Serial.print(F("valeur actuelle : "));
  Serial.print(valeur);
  Serial.print(F(" ; valeur maximale : "));
  Serial.print(maxval);
  Serial.print(F(" ; valeur minimale : "));
  Serial.println(minval);
  delay(delai);
}

Le code proposé n’est pas beaucoup plus compliqué que ce que nous avons vu.

Ligne 8 : pour stocker la valeur minimum, il faut partir de la valeur maximale mesurable sur la broche.

Ligne 9 : logique similaire à la précédente sauf qu’ici on doit partir de la valeur minimale mesurable.

Ligne 27 ou 31 : on teste si la valeur mesurée est supérieure (ou inférieure) à la valeur stockée maximale (ou minimale) → si c’est le cas, on met à jour la valeur maximale (ou minimale) par la valeur mesurée.

Dans la partie précédente, le dernier programme donnait une structure de code pour stocker et conserver (du moins tant que la carte est allumée) les valeurs minimale et maximale relevées. Dans le cas de la mesure de la luminosité, on pouvait très bien faire apparaître ces lignes directement dans le code principal sans que cela nuise réellement à sa compréhension. Mais dans notre projet global, on souhaite également stocker les valeurs minimale et maximale relevées pour la température et le taux d’humidité, voire, si le cœur vous en dit, de toute autre grandeur que vous estimerez importante (la pression…) : on ne va pas pour chacun de ces paramètres rajouter les 8 lignes qui seront identiques pour chacun hormis les noms de variables utilisées.

Pour automatiser certaines tâches redondantes, en programmation, on peut créer nos propres fonctions : il s’agit de bouts de code, écrits une seule fois dans le programme, que l’on pourra appeler à partir du nom de la fonction que l’on aura choisie.

Comme d’habitude, je vais expliquer le principe de construction d’une fonction à l’aide d’un exemple simple avant de l’adapter à notre projet.

Mettons que vous souhaitiez dans votre programme faire afficher cinq fois les mêmes lignes de texte (par exemple les premières lignes de code que nous avions vues dans ce cours avec « Enfin mon » « premier programme Arduino ! » sur deux lignes séparées). Pour cela, il faudra donc écrire dix lignes de code (cinq blocs de deux lignes identiques) dans notre programme : évidemment, plus la séquence répétée est longue et plus le code principal sera long ! Au lieu de cela, on va créer une fonction, que l’on va nommer affiche_texte, qui contiendra nos lignes de code d’affichage et que l’on appellera quand on le souhaite dans le programme principal.

Téléversez le programme suivant (pas besoin de circuit électrique pour cet essai) :

/*Programme pour voir le principe d'écriture d'une fonction
 * 
 */

 // déclaration des variables utilisées dans le programme
 const unsigned long flux = 9600;
 
void setup() {
  // put your setup code here, to run once:
  Serial.begin(flux);
}

void loop() {
  // put your main code here, to run repeatedly:
  affiche_texte();
  delay(1000);
  affiche_texte();
  delay(2000);
  affiche_texte();
  delay(3000);
  affiche_texte();
  delay(4000);
  affiche_texte();
  delay(5000);
}

void affiche_texte() 
{
  Serial.print("Enfin mon premier ");
  Serial.println("programme Arduino !");
}

Pour l’explication de ce programme, je vais commencer par la fin :

Ligne 27 : on définit une fonction à l’aide de l’instruction void() suivie par le nom de la fonction et des parenthèses (on verra par la suite qu’il peut y avoir des éléments dans les parenthèses).

Lignes 24 et 25 : les lignes de code de la fonction sont écrites entre les accolades { et }, de la même manière qu’on le fait pour le setup() et le loop().

Lignes 15, 17, 19, 21 et 23 : on appelle la fonction par son nom (ici affiche_texte) avec les parenthèses () → le programme va donc exécuter les actions de la fonction avant de revenir aux lignes du programme principal.

Schématiquement, le programme effectue les opérations dans l’ordre suivant :

Dans le programme, l’instruction delay() figure après chaque affichage : il est donc dommage de ne pas l’inclure dans la fonction affiche_texte. Par contre, il faut pouvoir avertir le programme de la valeur du délai souhaitée. C’est ici que les paramètres que j’évoquais précédemment vont nous servir : si vous avez suivi l’explication du programme principal, vous aurez compris qu’on va utiliser les parenthèses qui suivent le nom de la fonction !
On modifie donc un peu le programme précédent :

/*Programme pour voir le principe d'écriture d'une fonction
 * 
 */

 // déclaration des variables utilisées dans le programme
 const unsigned long flux = 9600;
 
void setup() {
  // put your setup code here, to run once:
  Serial.begin(flux);
}

void loop() {
  // put your main code here, to run repeatedly:
  affiche_texte(1000);
  affiche_texte(2000);
  affiche_texte(3000);
  affiche_texte(4000);
  affiche_texte(5000);
}

void affiche_texte(int delai) 
{
  Serial.print("Enfin mon premier ");
  Serial.println("programme Arduino !");
  delay(delai);
}

Ligne 22 : la définition de la fonction indique qu’il s’agit d’une fonction qui ne renvoie aucune valeur au programme (instruction void), mais qui demande au programme une valeur de type int comme entrée.

Lignes 15 : on appelle la fonction avec un paramètre chiffré entier 1000 ce qui signifie que la fonction va être exécutée en prenant comme valeur pour la variable delai de 1000 dans la fonction → concrètement, la ligne affiche_texte(1000) va donc afficher le texte puis faire un délai de 1000 millisecondes avant que le programme ne poursuive son exécution à la ligne 16.

Ici, la représentation schématique de fonctionnement du programme est celui-ci :

On peut encore aller un peu plus loin dans les paramètres sans toucher la structure de la fonction affiche_texte, pour voir toutes les possibilités offertes par l’utilisation d’une fonction :

/*Programme pour voir le principe d'écriture d'une fonction
 * 
 */

// déclaration des variables utilisées dans le programme
const unsigned long flux = 9600;

void setup() 
{
  // put your setup code here, to run once:
  Serial.begin(flux);
}

void loop() 
{
  // put your main code here, to run repeatedly:
  for (int i = 1000; i < 6000; i = i + 1000)
  {
   affiche_texte(i);
  }
}

void affiche_texte(int delai) {
  Serial.print("Enfin mon premier ");
  Serial.println("programme Arduino !");
  delay(delai);
}

Ce programme permet de montrer que le paramètre qui intervient dans une fonction lorsqu’elle est appelée dans le programme principal (ligne 19) peut être également une variable et pas forcément une valeur comme dans le programme précédent. Bon, c’est vrai je l’avoue, l’utilisation dans le cas précis du programme d’affichage d’une variable pour ajouter un délai incrémenté n’est pas très utile, mais il permet de comprendre facilement le principe et de voir l’étendue des possibilités et la facilité d’utilisation des fonctions dans un programme.

Dernier point à relever : il n’y a aucune obligation d’utiliser le même nom de variable entre le paramètre lors de l’appel de la fonction (affiche_texte(i) dans l’exemple du programme) et le paramètre lors de sa définition (affiche_texte(int delai) dans le programme).

Maintenant que l’on dispose des bases pour écrire des fonctions, je vais présenter le cas de fonctions qui doivent renvoyer une valeur au programme en s’appuyant sur le projet de mini station météo. On aimerait pouvoir automatiser le stockage des valeurs minimale et maximale de chaque grandeur mesurée (humidité, température, luminosité). La fonction que l’on va définir devra donc recevoir en entrée la valeur courante mesurée et la valeur minimale (ou maximale) ; elle renverra en sortie la valeur minimale (ou maximale) qui pourra être différente ou non de la valeur d’entrée.

On va partir sur du concret : définissons la fonction qui renvoie la valeur minimale pour le taux d’humidité. Les paramètres d’entrée sont de type float tout comme la valeur de sortie. On définira donc la fonction de la manière suivante :

float mini_humidite(float valeur, float mini_mesure)
{
  float mini = mini_mesure;
  if (valeur < mini)
  {
    mini = valeur;
  }
  return mini;
}

Expliquons un peu le code de cette fonction.

Ligne 1 : on définit la fonction en indiquant d’abord le type de valeur retournée (float), son nom (mini_humidite) et entre parenthèses les paramètres avec leur type (float valeur, float mini_mesure).

Ligne 3 : on définit une nouvelle variable, spécifique à la fonction (et donc non utilisable ailleurs dans le programme principal), qui contient initialement la valeur minimale indiquée comme paramètre de la fonction.

Ligne 4 à 7 : on cherche à savoir si la valeur courante est inférieure à la valeur minimale ou non → si c’est le cas, on met à jour la variable mini avec la valeur courante.

Ligne 8 : la commande return termine la fonction et renvoie la valeur qui suit au programme principal.

Et voilà, si dans le programme principal on appelle la fonction de la manière suivante :

float valeur = 20.60;
float mini = 23.1;
float test = mini_humidite(valeur, mini);
Serial.print(test);

On obtiendra le résultat suivant (pour changer un peu, j’ai pris l’écran du moniteur série présent dans Tinkercad) :

qui est bien conforme à ce que l’on attendait puisque 20,60 est bien inférieur à 23,1.

Désormais, c’est bien, on peut savoir si une mesure du taux d’humidité est le minimum mesuré ou non, mais qu’en est-il pour la température ? Si on regarde, le code de la fonction, dans le détail, on se rend compte qu’il n’est pas spécifique au taux d’humidité et reste très général. La seule différence réside dans les paramètres d’entrée de la fonction :

• pour le taux d’humidité, l’appel de la fonction sera :

  mini humidite

  Sélectionnez

  float test = mini_humidite(valeur_humid, mini_humid);

• Pour la température, l’appel se fera avec :

float test = mini_humidite(valeur_temp, mini_temp);

Alors, bien évidemment, dans ce contexte, le nom de la fonction n’est pas adapté : il est en effet bizarre de calculer le minimum de mesures de température à l’aide de la fonction mini_humidite → on utilisera donc plutôt un nom plus généraliste, par exemple min_valeur.

Si on prend tout en compte, on peut réécrire le programme de mesure du taux d’humidité et de la température avec affichage de la valeur mesurée, du minimum et du maximum.

/*Programme qui affiche la température et le taux d'humidité
 * mesurés à l’aide d'un capteur DHT11 et qui affiche également
 *les valeurs minimales et maximales de ces deux grandeurs
 */

//Chargement des bibliothèques nécessaires
#include "DHT.h" //bibliothèque du capteur

//Définition des broches utilisées
#define DHTPIN 2     // broche de mesure du DHT11

//Définition du type de capteur
#define DHTTYPE DHT11   // DHT 11

//Déclaration des constantes du programme
const unsigned long flux = 9600; //débit de la liaison série
const unsigned long delai = 2000; //délai entre deux mesures

//Déclaration des variables du programme
float valeur_humid, valeur_temp; //valeurs courantes
float min_humid = 100; //valeur prise dans la DATASHHET
float max_humid = 0; //valeur prise dans la DATASHHET
float min_temp = 80;  //valeur prise dans la DATASHHET
float max_temp = -40;  //valeur prise dans la DATASHHET

// Initialisation du capteur
DHT dht(DHTPIN, DHTTYPE);

void setup() 
{
  Serial.begin(9600);
  dht.begin();
}

void loop() 
{
  // Délai entre deux séries de mesures
  delay(delai);

  valeur_humid = dht.readHumidity();
  valeur_temp =  dht.readTemperature();

  // Test d'une éventuelle erreur de mesure
  if (isnan(valeur_humid) || isnan(valeur_temp)) 
  {
    Serial.println(F("Erreur de mesure!"));
    return;
  }

  min_humid = min_valeur(valeur_humid, min_humid);
  max_humid = max_valeur(valeur_humid, max_humid);

  min_temp = min_valeur(valeur_temp, min_temp);
  max_temp = max_valeur(valeur_temp, max_temp);

  //Affichage des résultats
  Serial.print(F("Humidité: "));
  Serial.print(valeur_humid);
  Serial.print(F("%  Minimum : "));
  Serial.print(min_humid);
  Serial.print(F("%  Maximum : "));
  Serial.print(max_humid);
  Serial.println(F("%"));
  
  Serial.print(F("Température: "));
  Serial.print(valeur_temp);
  Serial.print(F("°C  Minimum : "));
  Serial.print(min_temp);
  Serial.print(F("°C  Maximum : "));
  Serial.print(max_temp);
  Serial.println(F("°C"));
  Serial.println("\n");
}

float min_valeur(float valeur, float mini_mesure)
{
  float mini = mini_mesure;
  if (valeur < mini)
  {
    mini = valeur;
  }
  return mini;
}

float max_valeur(float valeur, float maxi_mesure)
{
  float maxi = maxi_mesure;
  if (valeur > maxi)
  {
    maxi = valeur;
  }
  return maxi;
}

Au passage, vous voyez que l’utilisation de fonctions dans notre code facilite grandement la lecture du programme en diminuant les lignes de code dans le programme principal.

On a déjà bien avancé : avec le capteur DHT11 (ou équivalent), on arrive à obtenir une bonne partie des informations souhaitées pour notre mini station météo. Désormais, il faut intégrer la partie liée à la mesure de la luminosité. Et là, on se retrouve face à un cas de conscience, car, rappelons-le, nous ne mesurons pas la vraie luminosité, mais la valeur de la tension aux bornes d’une photorésistance dans un montage pont diviseur de tension : et cette tension n’est pas du même type de variables que celui pour le taux d’humidité et la température. Quand le capteur DHT11 permettait d’obtenir des valeurs de type float, la tension est de type int. Pour remédier à ce petit problème, je vous propose deux solutions simples à mettre en œuvre :

• convertir au préalable la valeur int en float à l’aide de l’instruction float(valeur_tension) → pour le reste, il suffit de conserver le même type de formalisme que pour le taux d’humidité et la température → cette solution est la plus facile à mettre en œuvre ;
• faire la moyenne de plusieurs valeurs de tension (comme vu au point Amélioration des mesures), la variable moyenne étant de type float pour prendre en compte tous les cas possibles → cette solution a l’avantage d’améliorer la précision du résultat et donc de rendre plus fiable les données de la station météo. Pour cette solution, le plus simple est de créer une fonction calcul_moyenne qui ne prend aucun paramètre d’entrée (la boucle de mesures se fera dans la fonction) et qui renvoie la valeur de la moyenne.

Je vous laisse le choix de la méthode à utiliser, je ne pense pas qu’il n’y ait de grande difficulté puisque vous avez réussi à en arriver jusque-là de ce cours !

En dernier point de programmation, j’aimerais vous parler d’un composant assez utilisé dans le monde de la programmation embarquée : l’ajout d’un écran LCD pour lire les données. J’ai déjà commencé à en parler lors du point sur les bibliothèques. Comme nous avons un certain nombre d’informations à afficher, j’ai opté pour un écran comportant 4 lignes de 20 caractères.

Pour afficher du texte, un écran LCD a besoin de plusieurs éléments :

• un branchement électrique : selon les modèles, ils ont besoin de 12 ou 16 bornes (transmission directe des informations) ou de 4 bornes (programmation via le protocole I²C) → c’est ce dernier que j’aborderai ;
• charger une bibliothèque (ce point a déjà été vu au Utilisation de bibliothèques) ;
• définir un objet lcd et l’initialiser ;
• initialiser la communication ;
• régler certains paramètres et en particulier placer le curseur à l’endroit souhaité.

Pour le branchement, il est utile de choisir un écran LCD qui accepte le protocole I²C (Inter Integrated Circuit) dont je n’aborderai pas le principe de la communication.

L’intérêt est qu’avec 4 connexions, on peut faire fonctionner un écran LCD (ou d’autres capteurs d’ailleurs) : une alimentation (5 V de la carte Arduino), le zéro (GND de la carte), une connexion pour les données (SDA, Serial Data) et une connexion pour synchroniser et cadencer les échanges de données avec un signal d’horloge (SCL, Serial Clock). Sur une carte Arduino Uno, ces deux dernières connexions sont respectivement la broche A4 et A5.

Le chargement de la bibliothèque, la définition de l’objet lcd et son initialisation ont été vus au point Utilisation de bibliothèques).

Pour en apprendre davantage sur les instructions spécifiques de l’écran LCD, le plus simple est de faire comme on l’a déjà fait, prendre le programme exemple fourni avec le matériel. Dans mon cas, le programme est le suivant :

#include <Wire.h>
#include<LiquidCrystal_I2C.h>

//-----Adressage matériel -----
// En cas de non-fonctionnement, mettez la ligne 8 en 
// commentaire et retirez le commentaire à la ligne 9.

LiquidCrystal_I2C lcd(0x27, 20, 4);
//LiquidCrystal_I2C lcd(0x3F,20,4);

void setup()
{
  lcd.init(); // initialisation de l'afficheur
}
  
void loop()
{
  lcd.backlight();
  
  // Envoi du message
  lcd.setCursor(0, 0);
  lcd.print(" Test ecran");
  lcd.setCursor(0, 1);
  lcd.print(" ");
  lcd.setCursor(0, 2);
  lcd.print(" I2C Serial");
  lcd.setCursor(0, 3);
  lcd.print(" LCD");
}

Lignes 1 et 2 : les bibliothèques à inclure (et à avoir installé au préalable bien sûr !) ;

Ligne 4 à 9 : on suit les instructions qui sont indiquées pour créer l’objet lcd et l’initialiser ;

Ligne 13 : on initialise la communication avec l’écran LCD.

Ligne 18 : on active le rétroéclairage → cette ligne n’est pas obligatoire, elle dépend de votre envie et de votre écran !

Ligne 21 : on place le curseur de l’écran (lcd.setCursor) au caractère n° 0 et la ligne 0 (en informatique, les numéros de lignes et de colonnes commencent généralement à zéro.

Ligne 22 : on affiche sur le LCD (lcd.print()) un texte → vous remarquerez la similitude avec la syntaxe d’affichage dans le moniteur série (Serial.print()).

Ligne 23 : on place le curseur de l’écran (lcd.setCursor) au caractère n° 0 et la ligne n°1 (donc située sur la 2e ligne).

Je dois également mentionner une instruction très utile lcd.clear() qui permet d’effacer l’écran.

Bien sûr, il est tout à fait possible, voire conseillé de définir une fonction affichage_ecran qui prendra en paramètre d’entrée le numéro de colonne et de ligne ainsi que le texte à afficher : le code de cette fonction permettra de placer le curseur à la position définie et d’afficher le texte correspondant.

La syntaxe pour l’écran que j’ai choisi n’est pas spécifique à ce modèle : beaucoup d’écrans utilisent les mêmes instructions. Parfois, il y a de petits changements, mais globalement vous ne devriez pas trop avoir de problèmes. En cas de doutes, il faut se référer à la documentation du constructeur qui contient toutes les informations utiles.

Avec tous les derniers points que l’on a vus, on peut désormais écrire le programme complet associé au montage électrique suivant :

Il permet de mesurer le taux d’humidité, la température et la luminosité ambiants, de stocker les valeurs minimale et maximale de chacune de ces grandeurs et d’afficher les résultats sur un écran LCD (le composant noir en bas à droite est généralement directement fixé à l’écran LCD avec branchement en I²C).

Je vous invite à essayer par vous-même à écrire ce programme et le tester. Si cela ne marche pas, vous pouvez jeter un œil sur ma proposition qui respecte le cahier des charges :

/*Programme qui affiche la température, le taux d'humidité
 * et la luminosité mesurés à 'laide d'un capteur DHT22 et
 * d'une photorésistance. Il affiche également les valeurs 
 * minimales et maximales de ces deux grandeurs
 */

//Chargement des bibliothèques nécessaires
#include "DHT.h" //bibliothèque du capteur DHT11
#include <Wire.h>
#include<LiquidCrystal_I2C.h> //pour l'écran LCD branché en I2C

//Définition des broches utilisées
#define DHTPIN 2     // broche de mesure du DHT11
const byte lumin = 0; // broche pour l’évolution de la luminosité

//Définition du type de capteur
#define DHTTYPE DHT11   // DHT 11


//Déclaration des constantes du programme
const unsigned long flux = 9600; //débit de la liaison série
const unsigned long delai = 200; //délai entre deux mesures

//Déclaration des variables du programme
float valeur_humid, valeur_temp, valeur_lumin; //valeurs courantes
float min_humid = 100; //valeur prise dans la DATASHEET
float max_humid = 0; //valeur prise dans la DATASHEET
float min_temp = 80;  //valeur prise dans la DATASHEET
float max_temp = -40;  //valeur prise dans la DATASHEET
float min_lumin = 1023.0; //valeur max mesurable par Arduino
float max_lumin = 0.0; //valeur min mesurable par Arduino

// Initialisation des composants
DHT dht(DHTPIN, DHTTYPE);
LiquidCrystal_I2C lcd(0x27, 20, 4); //à remplacer par la ligne suivante si problème d'écran
//LiquidCrystal_I2C lcd(0x3F, 20, 4);

void setup() 
{
  Serial.begin(flux);
  dht.begin();
  lcd.init();
}

void loop() 
{
  // Délai entre deux séries de mesures
  delay(delai);

  //activation du rétroéclairage
  lcd.backlight();

  valeur_humid = dht.readHumidity();
  valeur_temp =  dht.readTemperature();
  valeur_lumin = analogRead(lumin);
  
  // Test d'une éventuelle erreur de mesure sur capteur DHT22
  if (isnan(valeur_humid) || isnan(valeur_temp)) 
  {
    //affichage dans le moniteur série
    Serial.println(F("Erreur de mesure"));
    affiche_texte(0, 0, "Erreur de mesure");
    return;
  }

  min_humid = min_valeur(valeur_humid, min_humid);
  max_humid = max_valeur(valeur_humid, max_humid);

  min_temp = min_valeur(valeur_temp, min_temp);
  max_temp = max_valeur(valeur_temp, max_temp);

  min_lumin=min_valeur(valeur_lumin, min_lumin);
  max_lumin=max_valeur(valeur_lumin, max_lumin);

  //Affichage des résultats sur l'écran lcd
  affiche_texte(0, 0, "Valeur ; Mini ; Maxi");
  lcd.setCursor(1, 0); lcd.print(valeur_humid);
  affiche_texte(1, 6, " ; ");
  lcd.setCursor(1, 9); lcd.print(min_humid);
  affiche_texte(1, 13, " ; ");
  lcd.setCursor(1, 16); lcd.print(max_humid);
  
  lcd.setCursor(2, 0); lcd.print(valeur_temp);
  affiche_texte(2, 6, " ; ");
  lcd.setCursor(2, 9); lcd.print(min_temp);
  affiche_texte(2, 13," ; ");
  lcd.setCursor(2, 16); lcd.print(max_temp);
  
  lcd.setCursor(3, 0); lcd.print(valeur_lumin);
  affiche_texte(1, 6, " ; ");
  lcd.setCursor(1, 9); lcd.print(min_lumin);
  affiche_texte(1, 13, " ; ");
  lcd.setCursor(1, 16); lcd.print(max_lumin);
  
  
  //Affichage des résultats dans le moniteur série
  Serial.print(F("Humidité: "));
  Serial.print(valeur_humid);
  Serial.print(F("%  Minimum : "));
  Serial.print(min_humid);
  Serial.print(F("%  Maximum : "));
  Serial.print(max_humid);
  Serial.println(F("%"));
  
  Serial.print(F("Température: "));
  Serial.print(valeur_temp);
  Serial.print(F("°C  Minimum : "));
  Serial.print(min_temp);
  Serial.print(F("°C  Maximum : "));
  Serial.print(max_temp);
  Serial.println(F("°C"));
  Serial.println("\n");

  Serial.print(F("Luminosité relative : "));
  Serial.print(valeur_lumin);
  Serial.print(F(" ;  Minimum : "));
  Serial.print(min_lumin);
  Serial.print(F(" ;  Maximum : "));
  Serial.println(max_lumin);
  Serial.println("\n");
  
  //Affichage des résultats sur l'écran LCD
  
}

float min_valeur(float valeur, float mini_mesure)
{
  float mini = mini_mesure;
  if (valeur < mini)
  {
    mini = valeur;
  }
  return mini;
}

float max_valeur(float valeur, float maxi_mesure)
{
  float maxi = maxi_mesure;
  if (valeur > maxi)
  {
    maxi = valeur;
  }
  return maxi;
}

void affiche_texte(byte colonne, byte ligne, String texte)
{
  lcd.setCursor(colonne, ligne);
  lcd.print(texte);
}