Editions ENI Livres | Vidéos | e-Formations
Premiers sketchs
Introduction
Les exemples présentés dans ce chapitre ont été réalisés avec un Arduino Uno R4 Wi-Fi, mais si vous possédez un autre modèle, vous pourrez facilement vous adapter (sauf pour les fonctions, comme par exemple la matrice de LED interne).
L’Arduino Uno R4 Wi-Fi
Blink, le programme de base
Même s’il sort tout juste de sa boîte, l’Arduino, contient déjà un programme. Il s’agit de Blink (clignotement), un petit programme de test, implanté en usine et qui demande simplement à la petite LED interne orange (L) de clignoter.
Dans l’environnement Arduino, un programme s’appelle un sketch (ou croquis en français). Le langage de programmation utilisé est proche du C/C++.
Lorsqu’il est alimenté en électricité, l’Arduino s’allume et exécute automatiquement le dernier sketch enregistré dans sa mémoire. L’Arduino ne peut en mémoriser qu’un seul à la fois. Si vous téléversez (transmettez) un nouveau sketch, cela effacera l’ancien, il faudra donc penser à les sauvegarder sur votre ordinateur.
Il existe plusieurs façons d’alimenter l’Arduino, mais pour commencer, le plus simple est de brancher simplement sa prise USB à un ordinateur ; cela fournit les 5 V nécessaires à son fonctionnement (et permettra par la suite de téléverser de nouveaux sketchs).
1. Que se passe-t-il ?
-
La LED verte (ON) s’allume, pour indiquer que l’Arduino est sous tension. Elle reste allumée jusqu’à l’extinction.
-
La LED orange (RX) clignote très brièvement, l’Arduino démarre et charge son programme.
-
L’Arduino exécute le sketch programmé (Blink) qui fait clignoter lentement la LED orange (L) (elle s’allume une seconde sur deux).
La LED « L » clignote
2. Examinons le programme Blink
Si ce n’est pas déjà fait, installez l’IDE Arduino sur votre ordinateur (cf. chapitre Programmation de l’Arduino - L’IDE Arduino).
Allez dans Fichier - Exemples - 01.Basics - Blink pour charger le programme.
Comment charger l’exemple Blink ?
a. Les commentaires
Les premières lignes du sketch sont constituées de commentaires. Il faut savoir que les commentaires sont ignorés lors de la compilation, aussi ils ne sont pas transmis à l’Arduino. Cela signifie que vous pouvez les modifier ou les supprimer sans que cela change le déroulement du programme.
Cependant, ils sont très importants pour nous. En effet...
Faire du Morse avec une LED externe
1. LED externe, le branchement
Pour ce premier branchement, vous pouvez utiliser le module LED Grove ou une simple LED (avec une breadboard et des fils électriques). Mais dans ce cas, il est nécessaire d’ajouter une résistance afin limiter le courant délivré par les broches de l’Arduino.
, ne descendez jamais en dessous de 470 avec l’Arduino Uno R4. Mais pour être
tranquille (surtout si vous branchez plusieurs LED), utilisez plutôt
des résistances de 1000 .Reproduisez le branchement ci-dessous :
-
La pin GND (ground) est reliée à la masse. Dans cet exemple, elle représente la borne (-).
-
La LED ne fonctionnera que si elle est branchée à l’endroit, la plus grande patte sur le (+) et la plus petite sur le (-).
-
La sortie numérique de l’Arduino représente la borne (+). Dans cet exemple, il s’agit de la pin n°6. Vous pouvez utiliser une autre broche (de 0 à 13) à condition bien sûr d’adapter le programme.
-
En cas de besoin, vous pouvez même utiliser les broches A0, A1, A2, A3, A4 ou A5 en les nommant respectivement 14, 15, 16, 17, 18 ou 19.
-
La résistance et la LED doivent être branchées en série, c’est-à-dire à la suite l’une de l’autre, comme le montre le schéma. Mais rien ne vous empêche de les inverser et de brancher la petite patte de la LED à la borne GND et la résistance à la sortie numérique de l’Arduino.
Branchement d’une LED externe sur la broche 6
Ensuite, modifiez le programme Blink en remplaçant la constante LED_BUILTIN par le numéro de la broche (6).
Téléversez ensuite le sketch afin de tester le branchement :
// Une_LED
// la fonction setup s'exécute une seule fois quand vous appuyez
// sur la touche reset ou quand vous alimentez la carte
void setup() {
pinMode(6, OUTPUT); // La broche 6 est une sortie numérique
}
// la fonction loop s'exécute indéfiniment jusqu'à l'extinction
void loop() {
digitalWrite(6, HIGH);...Inverser la LED
Pour que la LED s’allume, il faut une différence de potentiel, (cf. Connaissances de base - Comprendre l’électronique et l’électricité). Le courant électrique s’écoule du (+) vers le (-). Il ne s’écoule donc pas du (+) vers le (+) ou du (-) vers le (-).
Nous avons, jusqu’à présent, branché la LED entre la borne GND (-) et une sortie de l’Arduino (n°6, par exemple). Dans ce cas, la LED s’allume quand la broche 6 est sur le (+), avec l’instruction :
digitalWrite(6, HIGH); et s’éteint quand elle est sur le (-), avec l’instruction :
digitalWrite(6, LOW); Mais il est tout à fait possible de brancher la LED entre la borne 5 V et l’entrée/sortie. En faisant cela, le comportement de la LED est inversé : elle s’allume quand la fonction digitalWrite est sur LOW et s’éteint quand elle est sur HIGH. Toutefois, n’oubliez pas que la LED est une diode, elle ne laisse passer le courant électrique que dans un sens. Alors, il faut aussi l’inverser (la plus grande patte vers le 5 V et la petite vers l’entrée/sortie).
Pour tester cela, nous allons ajouter une LED d’une autre couleur, branchée entre l’entrée/sortie n°8 et la borne 5 V. Vous pouvez reproduire ce branchement et téléverser le sketch qui l’accompagne....
Les feux tricolores
Les feux tricolores
Vous vous êtes certainement déjà retrouvé bloqué par un feu routier interminablement rouge. Et vous vous êtes alors peut-être dit qu’il n’était pas bien réglé. Cela tombe bien puisque dans ce petit exercice vous allez devoir gérer les feux tricolores d’un carrefour.
), d’une breadboard et de quelques fils équipés
de connecteurs Dupont.Nous avons donc un carrefour contrôlé par deux feux de signalisation. Vous pouvez reproduire le branchement ci-dessous ou laisser libre cours à vos talents de modélisme pour faire quelque chose de plus réaliste. Vous pouvez aussi utiliser d’autres pins que dans cet exemple (mais il faudra évidemment en tenir compte dans le code).
Branchement des feux tricolores
Au départ, l’un des feux est rouge tandis que l’autre est vert. Au bout de cinq secondes, le vert passe à l’orange pendant une seconde (le vert doit s’éteindre), puis au rouge (l’orange doit s’éteindre) pendant que l’autre passe au vert pendant cinq secondes et ainsi de suite.
Ce n’est pas très compliqué, mais vous allez comprendre l’intérêt...
Les sorties analogiques
1. Les sorties PWM (ou MLI)
Vous avez peut-être remarqué le petit symbole ~ à côté des entrées/sorties numériques 3, 5, 6, 9, 10 et 11. Il indique qu’elles peuvent se transformer en sorties analogiques.
Enfin, pas tout à fait. Avec une vraie sortie analogique, il serait possible de varier la tension de sortie de 0 à 5 volts. Ici, la PWM (Pulse Width Modulation) ou en français MLI (Modulation de largeur d’impulsion) est toujours une sortie numérique, c’est-à-dire qu’elle ne peut prendre que deux valeurs, 0 (basse) ou 5 volts (haute). Mais elle est capable de passer très rapidement de l’une à l’autre. En envoyant moins souvent un signal haut, il est possible de créer des microcoupures et donc de baisser la tension moyenne envoyée. Cela permet de réduire la luminosité d’une LED ou la vitesse d’un moteur, car ils ne sont plus alimentés en continu.
En réalité, la LED s’allume et s’éteint si rapidement que l’œil humain perçoit une baisse de luminosité au lieu de voir un clignotement. C’est le même phénomène de persistance rétinienne qui est utilisé en vidéo pour donner l’illusion d’un mouvement avec une succession d’images fixes. Le moteur, lui, ne s’arrête pas, il continue sur son élan, mais comme il est moins souvent alimenté en électricité, il tourne moins vite.
Par défaut, les sorties analogiques de l’Arduino Uno R4 peuvent prendre 256 valeurs différentes, de 0 à 255 (8 bits). Cette valeur s’appelle le rapport cyclique. Plus il augmente et plus la sortie reste longtemps en position haute (5 V). En cas de besoin, il est possible d’augmenter la résolution jusqu’à 12 bits (de 0 à 4095).
En réalité, les sorties 0, 1, 2, 4, 7, 8, 12 et 13 sont également compatibles, mais la fondation Arduino déconseille de les utiliser en tant que sorties analogiques car il semble que cela pourrait interférer avec d’autres fonctions de la carte.
La fonction analogWrite permet de modifier la valeur d’une sortie analogique.
Petite bizarrerie du langage Arduino, il n’est pas obligatoire d’indiquer...
Le bouton-poussoir
Assortiment de boutons
C’est certainement le composant électronique le plus simple. Quand on appuie, il établit le contact (on dit que le circuit est fermé) et permet le passage du courant électrique. Si on arrête d’appuyer, un système de ressort coupe automatiquement le contact (le circuit est ouvert) et l’électricité ne passe plus.
Il en existe de nombreux modèles, vous pouvez en acheter un lot pour une somme modique ou en récupérer sur de vieux appareils hors d’usage. Par exemple, un vieux clavier à touches mécaniques contient une centaine de boutons-poussoirs d’excellente qualité, mais pour les mériter, il faudra passer quelques heures à les dessouder.
Il en existe de différents types :
-
Certains n’ont que deux pattes, ils sont donc plus faciles à utiliser.
-
Les boutons à trois pattes ont souvent une patte qui établit le contact au repos, une autre qui établit le contact quand on appuie (celle que l’on utilise le plus souvent) et la troisième est la patte commune, reliée aux deux autres en fonction de l’état du bouton (appuyé ou relâché).
-
Certains boutons ont quatre pattes. En général, les pattes sont reliées deux par deux, ainsi, si vous vous trompez, le circuit sera toujours fermé (que vous appuyiez ou non). L’astuce pour ne pas trop s’embêter est d’utiliser la diagonale pour les connecter.
En cas de doute, prenez le temps de tester au multimètre le fonctionnement d’un nouveau bouton. Cela peut éviter bien des soucis (passer des heures à vous demander pourquoi le circuit ne fonctionne pas correctement et devoir ensuite dessouder les boutons).
Nous n’avons pas encore utilisé les broches comme des entrées. Sachez qu’elles ne peuvent recevoir qu’une très faible tension (entre 0 et 5 V). L’Arduino Uno possède quatorze entrées numériques (de 0 à 13) ainsi que six entrées analogiques (A0 à A5) qui peuvent également servir d’entrées numériques.
Les entrées...
Le passage piéton
Le passage piéton
Voilà un petit exercice utilisant un bouton. Il s’agit de gérer une nouvelle fois un feu tricolore. Mais cette fois-ci, nous ne sommes pas à un carrefour, mais sur une route très fréquentée. Elle est traversée par un passage piéton. Nous avons donc besoin d’un feu tricolore (rouge, orange, vert) pour les voitures et bicolore (rouge et vert) pour les piétons. Il faut aussi un bouton d’appel piéton. Par défaut, le feu est vert pour les automobilistes et rouge pour les piétons.
Les voitures peuvent rouler tant que personne n’a besoin de traverser. Mais si un piéton se présente, il appuie sur le bouton et quelques secondes plus tard, le feu passe à l’orange, puis au rouge pour les voitures (et au vert pour les piétons). Ce n’est pas instantané, pour éviter le blocage de la circulation quand il y a beaucoup de piétons. Nous laissons aux piétons le temps de traverser. Puis, le feu des piétons redevient rouge. Pendant quelques secondes, les deux feux sont rouges pour que les derniers retardataires traversent en toute sécurité. Et enfin, le feu des automobilistes redevient vert.
Choisissez vous-même la durée de chaque feu. En sachant qu’elle n’a pas besoin d’être trop réaliste. Si elle est trop longue...
Le clignotement sans blocage
La fonction delay introduit une pause dans l’exécution du programme. Jusqu’à présent, nous l’utilisions pour faire clignoter les LED. Même si cela convient parfaitement aux sketchs les plus simples, le problème est que la fonction delay bloque tout le programme. Si, par exemple, vous appuyez sur un bouton pendant ce temps, le programme ne le détectera pas tout de suite.
Pour tester cela, nous aurons besoin de deux LED et d’un bouton utilisant la résistance de pull-up de l’Arduino (le bouton envoie donc la valeur LOW quand il est pressé et HIGH au repos). L’une des LED s’allumera une seconde sur deux (comme le sketch Blink), mais l’autre s’allumera seulement si on appuie sur le bouton. Vous pouvez reproduire ce branchement et téléverser le code correspondant.
Testons les limites de la fonction delay
/* Clignotement_bloquant
* Ce sketch montre que la fonction delay
* bloque l'exécution du programme
*/
const int BOUTON = 2; // Le bouton est relié à la pin 2
const int LEDVERTE = 8; // La LED verte est reliée à la pin 8
const int LEDROUGE = 9; // La LED rouge est reliée à la pin 9
void setup() {
pinMode(BOUTON, INPUT_PULLUP); // Entrée (avec pull-up interne)
pinMode(LEDVERTE, OUTPUT); // Sortie
pinMode(LEDROUGE, OUTPUT); // Sortie
}
void loop() {
// Blink
digitalWrite(LEDROUGE, HIGH);
delay(1000);
digitalWrite(LEDROUGE, LOW);
delay(1000);
// Allume la LED quand j'appuie sur le bouton
digitalWrite(LEDVERTE,!digitalRead(BOUTON));
} Si vous appuyez rapidement sur le bouton, la LED verte ne s’allume pas (ou rarement). En revanche, si vous laissez le doigt sur le bouton, elle finit par s’allumer. Quand vous relâchez le bouton, c’est le même principe, elle ne s’éteint pas instantanément. C’est normal, nous avons deux pauses d’une seconde dans le programme. L’Arduino passe donc beaucoup plus de temps à attendre qu’à allumer, éteindre...
Le compteur binaire
Est-il possible de concevoir un programme qui compte et affiche (en binaire) le nombre de fois où le bouton a été appuyé ?
Affichage du chiffre 5 en binaire
1. Gérer l’incrémentation du compteur
Même en appuyant très rapidement sur le bouton, cela dure forcément quelques dixièmes de seconde. Pour nous, c’est très rapide, mais cela laisse à l’Arduino le temps d’exécuter de nombreuses fois la fonction loop. Et que tant que vous gardez le doigt appuyé sur le bouton, le compteur continue à s’incrémenter. Il faut donc trouver un système qui incrémente une fois le compteur, mais qui ensuite ne fait plus rien tant que le bouton n’est pas relâché.
L’une des solutions consiste à utiliser une variable que l’on peut par exemple appeler ancienEtatBouton et qui sert à stocker l’état du bouton à la fin de la fonction loop. Pour que le compteur soit incrémenté au cours d’une boucle suivante, il faut non seulement que le bouton soit appuyé, mais aussi que l’état du bouton ait changé depuis la dernière exécution de la boucle loop.
2. Le problème du rebond
Il faut savoir que lorsqu’on appuie sur un bouton (ou quand on le relâche), le contact n’est pas instantané. Les parties métalliques du bouton rebondissent très légèrement, ce qui occasionne (pendant quelques millièmes de seconde) une alternance entre microcontacts et microcoupures. Ce phénomène mécanique n’est absolument pas perceptible par l’être humain. Cependant, l’Arduino qui est beaucoup plus rapide que nous, va croire que vous avez appuyé plusieurs fois sur le bouton.
Ce n’était pas vraiment important dans les programmes précédents, mais là, cela fausse complètement les résultats du compteur.
Pour résoudre ce problème, il existe une solution logicielle. Elle consiste à modifier le code pour qu’il y ait un léger délai (50 ms) lorsque le bouton change d’état (appuyé ou relâché). Ainsi l’Arduino attend la fin du rebond pour continuer l’exécution du programme. Ce délai...
Le potentiomètre
C’est un composant très courant, vous l’avez déjà utilisé pour augmenter (ou baisser) le volume d’un appareil.
Le potentiomètre est une résistance variable qui possède généralement trois pattes. Les bornes situées de chaque côté sont reliées l’une à la masse et l’autre à la tension maximum (la borne 5 V ou éventuellement 3,3 V pour certains modèles d’Arduino). La borne du milieu est branchée sur une des six entrées analogiques de l’Arduino Uno (A0, A1, A2, A3, A4 ou A5).
Par défaut, les entrées analogiques de l’Arduino Uno R4 possèdent une résolution de 10 bits, c’est-à-dire qu’elles sont capables de détecter 1 024 valeurs différentes sur une tension de 0 à 5 V. Une valeur de 0 correspond à une tension de 0 V et une valeur de 1 023 à 5 V. Mais il est possible d’augmenter la résolution des entrées jusqu’à 14 bits (de 0 à 16 383).
Fonctionnement du potentiomètre
En tournant (ou en bougeant) le bouton, un curseur se déplace à l’intérieur du potentiomètre. S’il se rapproche de la masse, la tension détectée sera plus petite. Et si au contraire il se rapproche de la valeur maximum (5 V ou 3,3 V), la tension mesurée sera plus élevée.
1. Programmation...
La LED RGB
Elle est composée de trois LED : Red, Green, Blue (ou Rouge, Vert, Bleu en français). En modulant l’intensité des trois couleurs, la LED RGB est capable d’en afficher plusieurs millions (ce qui dépasse les capacités de l’œil humain).
La LED RGB possède quatre pattes. L’une est commune aux trois LED et les trois autres pattes sont reliées à l’autre borne de chaque LED.
Il en existe donc deux types :
-
LED à anode commune : les trois LED sont reliées ensemble par la borne (+).
-
LED à cathode commune : les trois LED sont reliées ensemble par la borne (-).
Le branchement est légèrement différent puisque la patte commune sera, suivant le cas, reliée à la borne 5 V ou GND, et la LED s’allumera lorsque la sortie de l’Arduino sera à un potentiel différent (LOW ou HIGH, suivant le cas).
La LED RGB existe sous forme de module ; dans ce cas, les couleurs correspondant à chaque broche sont indiquées par une lettre (R, G ou B), mais elle existe aussi sous forme de LED à quatre pattes. Pour connaître la couleur qui correspond à chaque patte, consultez le petit schéma en haut à droite des deux branchements (anode ou cathode commune).
Pour tester le fonctionnement de la LED RGB, vous pouvez reproduire l’un de ces branchements (suivant...
Les LED adressables (Neopixel)
Ce sont des LED RGB dites « intelligentes » reliées en réseau. Chacune d’elles possède une puce électronique et une adresse spécifique, afin de recevoir et d’interpréter les instructions qui la concernent (allumage, extinction, luminosité, couleur). Les LED adressables sont idéales pour créer très facilement une guirlande multicolore, un éclairage d’ambiance ou simplement pour afficher des informations (par exemple : si c’est en vert, tout va bien, mais si c’est rouge il faut faire attention). Il est même possible de regrouper plusieurs bandes de LED pour fabriquer un écran où chaque LED constitue un pixel.
Si vous avez des besoins spécifiques, vous pouvez les acheter à l’unité. Sinon, il est beaucoup plus simple de se procurer un module déjà assemblé. Il en existe de nombreux types (guirlande, ruban, anneau ou carte d’extension au format Arduino classique).
Exemples de modules de LED adressables
Les anneaux sont simplement constitués de LED disposées en cercle. Comme pour les autres modules, il y a une première et une dernière LED. Le branchement est très facile car les bornes sont clairement identifiées. Il suffit de trois bornes pour contrôler le module de LED (deux pour l’alimentation et une pour les données), mais il en existe une quatrième, permettant de continuer la chaîne de LED.
Si vous n’avez qu’une dizaine de LED, vous pouvez sans problème utiliser l’alimentation de l’Arduino (5 V et GND). Connectez aussi une entrée/sortie de l’Arduino (par exemple, le port n°6) à la borne d’entrée du module afin de le contrôler.
Branchement d’un module de 8 LED adressables
Au-delà de dix LED, il est conseillé d’ajouter une alimentation externe. Cependant, vous pouvez quand même repousser cette limite en baissant la luminosité ou en évitant d’allumer...
NeoKey
C’est un bouton-poussoir (de clavier mécanique) lumineux puisqu’il est équipé d’une LED Neopixel. Il peut s’adapter facilement à de nombreux projets puisque les connecteurs ne sont pas soudés.
NeoKey (Adafruit)
Les LED adressables sont alimentées par les pins VDD et G (marquées + et - de l’autre côté). La borne In (ou I) reçoit le signal en entrée et Out (ou O) assure la sortie vers la LED suivante.
Les boutons utilisent les broches A et C. Bien sûr, le branchement sera différent si vous utilisez une résistance de pull-down. Mais le plus simple est certainement d’activer dans le programme la résistance de pull-up interne de l’Arduino.
Certains connecteurs sont en double, utilisez ceux qui vous arrangent pour le branchement.
Branchement de deux NeoKey
// NeoKey
// Appel de la bibliothèque NeoPixel
#include <Adafruit_NeoPixel.h>
// Constantes
const int BOUTON_A = 2;
const int BOUTON_B = 3;
const int PIN_NEOPIXEL = 6;
const int NB_LED = 2;
// Création de l'objet "neoPixel"
Adafruit_NeoPixel neoPixel = Adafruit_NeoPixel(NB_LED, PIN_NEOPIXEL,
NEO_GRB + NEO_KHZ800);
void setup() {
// initialisation du module de LED
neoPixel.begin(); ...NeoTrellis
Il s’agit d’un mini clavier constitué de seize boutons lumineux (4 x 4). La carte est vendue seule mais si vous disposez d’une imprimante 3D, vous pouvez télécharger un boîtier ici : https://www.printables.com/model/1230550-neotrellis-case
NeoTrellis (dans un boîtier imprimé en 3D)
Le branchement nécessite seulement quatre fils (en utilisant le bus I2C). Le NeoTrellis possède un connecteur JST-PH mais il est possible de « raboter » légèrement un connecteur Grove pour qu’il s’adapte.
Branchement du NeoTrellis
Vous pouvez également relier plusieurs modules (jusqu’à 32) pour fabriquer un énorme clavier lumineux.
Vous devez installer la bibliothèque Adafruit_NeoTrellis. Elle ajoute au langage Arduino les fonctions indispensables au contrôle du module NeoTrellis.
Pour cela, lancez l’IDE Arduino et sélectionnez le gestionnaire de bibliothèques en cliquant sur l’icône représentant des livres dans la barre latérale (ou en allant dans Croquis - Inclure une bibliothèque - Gérer les bibliothèques), saisissez « neotrellis » dans la barre de recherche et cliquez sur Installer.
Installation de la bibliothèque NeoTrellis
Si l’IDE Arduino vous propose d’installer les dépendances (d’autres bibliothèques essentielles à son fonctionnement), acceptez en cliquant sur INSTALL ALL.
Installation des dépendances de la bibliothèque
Vous disposez maintenant de nouvelles fonctions. Pour pouvoir les utiliser, vous devez appeler la bibliothèque concernée....
L’encodeur rotatif
Il ressemble au potentiomètre, mais vous pouvez le tourner à l’infini dans un sens ou dans l’autre. En effet, il est composé de deux boutons-poussoirs légèrement décalés, actionnés par la rotation de l’encodeur. Certains modèles en possèdent même un troisième actionné par appui sur le bouton.
Contrairement au potentiomètre, la rotation n’est pas libre, elle s’effectue à l’aide de petits crans. Le passage d’un cran à l’autre correspond à un appui suivi d’un relâchement du bouton 1 (dans un sens comme dans l’autre). Mais au moment où le bouton 1 est relâché, le bouton 2 reste en position appuyée si l’on tourne dans un sens, et relâchée si l’on tourne dans l’autre. Cela permet de connaître le sens de rotation.
Vous pouvez le trouver sous la forme d’un simple composant électronique à trois pattes. Celle du milieu est commune aux deux boutons, il faut donc la relier à la borne GND (ou 5 V suivant votre montage). Les deux autres correspondent à chacun des deux boutons. Sur certains modèles, vous pouvez avoir deux pattes supplémentaires de l’autre côté. Ce sont les broches prévues pour le troisième bouton, qui est indépendant.
L’encodeur...
Le buzzer
Le buzzer est un composant électronique capable de produire des sons. Il possède une lamelle qui se déforme sous l’influence d’un courant électrique. En modifiant la fréquence d’alimentation (l’alternance de périodes où le buzzer est alimenté ou non), il est possible de jouer différentes notes.
Attention, il en existe deux types :
-
Le buzzer actif, qui se contente de jouer un son (toujours le même) lorsqu’il est alimenté. Il peut être utilisé comme alarme, par exemple pour un détecteur de fumée mais ne peut pas jouer autre chose que le « bip » prévu par le constructeur.
-
Le buzzer passif, qui, si vous l’alimentez directement, émettra seulement un léger « plop ». C’est pourtant le plus intéressant avec l’Arduino puisqu’il est possible de contrôler les vibrations de la lamelle et donc de lui faire jouer de nombreux sons.
1. Utilisation du buzzer
Le module buzzer dispose de trois pins :une borne GND, une borne 5 V (ou VCC) et une 3e pour le signal. Il suffit alors de respecter les indications..
Dans le cas d’un simple composant, il y a seulement deux pins : une pour la borne GND et l’autre pour le signal (le signe + est parfois inscrit dessus). Branchez ce dernier à la sortie numérique 12, par exemple (vous pouvez choisir une autre pin de l’Arduino à condition d’adapter le code).
Branchement du buzzer
Vous pouvez tester le branchement en téléversant ce sketch. Il s’agit simplement d’une boucle qui alimente pendant 800 microsecondes (0,0008 seconde) le buzzer, puis l’arrête pendant la même durée avant de recommencer 200 fois de suite avant de faire une pause de 0,5 seconde.
// Buzzer_Test
const int BUZZER = 12;
const int DUREE = 800;
void setup() {
pinMode(BUZZER,OUTPUT);
}
void loop() {
for(int i=0; i<100; i++) {
digitalWrite(BUZZER, HIGH);
delayMicroseconds(DUREE);
digitalWrite(BUZZER, LOW);
delayMicroseconds(DUREE);
}
delay(500); // délai entre chaque...La matrice de LED
La matrice de LED (intégrée à L’Arduino Uno R4 Wi-Fi) est constituée de 12 X 8 LED rouges. Elle fonctionne parfaitement à l’intérieur, mais dehors (en plein jour), les LED sont très peu visibles.
1. Afficher un symbole
En laissant libre cours à votre créativité, vous pourrez inventer des symboles qui montrent qu’il fait chaud, froid, qu’il est heure de manger, de partir à l’école, d’aller se coucher, etc.
Il existe plusieurs méthodes pour afficher une image mais la plus simple est de la définir pixel par pixel dans un tableau de ce type (1 le pixel est allumé, 0 le pixel est éteint).
byte coeur[8][12] = {
{ 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0 },
{ 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0 },
{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0 },
{ 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 },
{ 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
}; Voici un petit exemple d’animation (constituée de deux images) :
// Matrice_Coeur
// Appel de la bibliothèque ...