Mesurer la capacité d'un condensateur avec un Arduino Uno...et rien d'autre

Jonathan Nethercott a publié sur son blog "PIC Tutorials" un sketch permettant de mesurer la capacité d'un condensateur en le branchant à un Arduino.

Utiliser un microcontrôleur pour mesurer une capacité n'a peut-être rien de révolutionnaire, mais une particularité de la présente méthode, c'est qu'aucun composant supplémentaire n'est requis: vous branchez le condensateur dans les entrées A0 et A2, et sa capacité s'affiche dans le moniteur série.

Dans sa version la plus récente (25 janvier 2014),. le sketch de Jonathan Nethercott utilise deux méthodes différentes pour mesurer la capacité, ce qui lui permet de couvrir une gamme allant de  1 pF à plus de 1000 uF!

La première méthode consiste à mesurer la tension du condensateur alors qu'il est branché en série avec la capacité parasite de l'Arduino, ce qui donne des résultats satisfaisants à la condition que la capacité ne soit pas trop grande.  Puisque la capacité interne n'est pas identique d'un Arduino à l'autre, vous devez faire des tests au moyen d'un condensateur de valeur connue afin calibrer le dispositif (il s'agit de modifier la valeur de la constante IN_STRAY_CAP_TO_GND).

Si le résultat est supérieur à 1 nF (auquel cas la capacité du condensateur à tester est trop grande par rapport à l'étalon), l'Arduino prend une deuxième mesure en chargeant le condensateur à travers la résistance de tirage (pull-up) interne du microcontrôleur, de façon à déterminer la constante de temps du circuit RC. Encore une fois, il est nécessaire d'effectuer une calibration à partir d'un condensateur dont la capacité est connue, puisque la valeur exacte de la résistance pull-up interne peut être différente d'un Arduino à l'autre (il faut modifier la valeur de la constante R_PULLUP).

Je l'ai essayé, et ça fonctionne remarquablement bien:  simple et efficace!

Yves Pelletier (Twitter:  @ElectroAmateur)

Boutons sans rebond (bascules de Schmitt)

Supposons que vous désirez allumer et éteindre une LED au moyen d'un seul bouton poussoir:  la LED s'allumera si vous appuyez sur le bouton, et s'éteindra lorsque vous appuierez à nouveau sur le même bouton.

Toutefois, lors de la mise à l'essai de votre circuit, vous constatez que la LED réagit de façon aléatoire à vos commandes:  une fois sur deux, il ne se passe rien lorsque vous appuyez sur le bouton!

La raison:  votre bouton poussoir rebondit à la manière d'un ballon de basket.  Pendant une fraction de seconde, l'interrupteur se met successivement en état "fermé" et "ouvert" plusieurs fois de suite... Même si vous n'avez appuyé qu'une seule fois sur le bouton, le reste du circuit a reçu plusieurs signaux consécutifs en provenance de l'interrupteur.

Si votre bouton poussoir est relié à un microcontrôleur (Arduino, par exemple), la solution anti-rebond généralement préconisée est purement logicielle:  lorsque le microcontrôleur détecte que le bouton est pressé, on le fait attendre quelques dizaines de millisecondes, le temps que les rebonds soient terminés (voir le sketch fourni avec l'IDE Arduino:  Fichier - Exemples - 02.Digital - Debounce).

Mais je n'aime pas trop cette solution:  elle alourdit le code, et pour des raisons qui demeurent nébuleuses, je n'obtiens pas toujours des résultats impeccables lorsque je l'applique.  De plus, on n'a pas le choix de procéder autrement si le bouton actionne autre chose qu'un microcontrôleur (une bascule, par exemple).

Pour toutes ces raisons, j'ai assemblé un module comportant 6 boutons munis d'un circuit anti-rebond.  Chaque bouton est associé à un condensateur de 10 nanofarads et à une résistance de tirage ("pull up") de 10 kΩ.

Lorsque le bouton n'est pas enfoncé, aucun courant ne peut circuler dans la résistance et cette dernière n'est donc soumise à aucune différence de potentiel; le condensateur est chargé, puisqu'il est soumis à une différence de potentiel de 5 V (le signal de sortie est de 5 V).   Lorsqu'on appuie sur le bouton, le signal de sortie chute à 0, mais pas instantanément, car le condensateur doit d'abord se décharger.  Lors d'un rebond du bouton, le contact est trop bref pour que le condensateur ait le temps de se décharger et le signal de sortie n'a pas le temps de descendre à zéro.

Un problème demeure:  nous voulons quand même obtenir à la sortie un signal logique qui passe brusquement de 5 V à 0 V, et non un signal qui varie progressivement de 5 V à 0 V (la courbe de décharge est de forme exponentielle).  La solution:  une bascule de Schmitt.  Aussi longtemps que le signal de sortie du bouton est supérieur à un certain seuil, la sortie de la bascule de Schmitt sera à 0 V.  Et la sortie de la bascule de Schmitt passera soudainement à 5 V lorsque le signal de sortie du bouton descendra en-dessous du seuil.  De plus, la bascule de Schmitt est munie d'une hystérésis:  le seuil d'un signal décroissant est plus bas que celui d'un signal montant, pour éviter qu'un signal d'entrée très rapproché du seuil cause une instabilité à la sortie.

Modules RF 433 MHz, VirtualWire et Arduino

N.B.: Puisque la bibliothèque VirtualWire n'est plus mise à jour par son auteur, vous préférerez peut-être consulter cet article plus récent, dans lequel on utilise la bibliothèque RadioHead.

Aujourd'hui, je vous présente quelques expérimentations réalisées avec un émetteur et un récepteur radiofréquence à 433 MHz obtenus sur eBay pour un prix ridiculement bas (on parle d'environ 1 euro pour une paire émetteur/récepteur).

Contrairement aux modules NRF24L01 2,4 GHz (qui coûtent à peine plus cher mais sont plus sophistiqués), ces modules ne permettent qu'une communication unidirectionnelle:  l'émetteur peut envoyer un message au récepteur, mais ce dernier ne peut pas envoyer de réponse à l'émetteur, ne serait-ce que pour confirmer que le message a bel et bien été reçu (une communication bidirectionnelle est toutefois possible si vous disposez de deux paires émetteur-récepteur).

L'émetteur

Il est de forme carrée et porte les numéros XY-FST et FS1000A.  Il est muni de 3 pins: DATA transmettra les données à émettre et sera branché à la sortie 12 de votre Arduino.  Sans trop de surprise, vous branchez la pin "VCC" au 5 volts de l'Arduino et la pin "GND" à une des pins "GND" de l'Arduino.

Une connexion identifiée "ANT" vous permet de souder une antenne à votre émetteur.  Cette antenne n'est pas indispensable si votre émetteur est à proximité du récepteur.

Quelques tests m'ont permis de constater qu'en absence d'antenne, un nombre assez important de données émises n'atteignent pas le récepteur à partir d'une distance d'environ 2 m.

En ajoutant une antenne de 17 cm à l'émetteur et au récepteur, la portée atteint facilement une dizaine de mètres.

Le récepteur

Le récepteur est de forme rectangulaire et porte le numéro "XY-MK-5V".  Pour une raison qui m'échappe il est muni de 4 pins mais d'après ce que j'ai constaté les deux pins centrales identifiées "DATA" sont identiques et interchangeables.  Vous reliez donc une de ces deux pins "DATA" à l'entrée 11 d'un deuxième Arduino (ce deuxième Arduino peut très bien être branché au même ordinateur que l'Arduino qui contrôle l'émetteur).

Encore une fois, vous branchez la pin "VCC" du récepteur à la pin 5 V de l'Arduino, et vous reliez les masses (GND).

La bibliothèque VirtualWire

Assurez-vous d'installer la bibliothèque VirtualWire, qui va énormément nous simplifier la vie lors de la conception des sketches.

Les exemples qui accompagnent la bibliothèque VirtualWire montrent qu'il est très facile d'envoyer des chaînes de caractères de l'émetteur vers le récepteur (message du genre "Hello World").  Mais il est souvent beaucoup plus utile et pertinent d'émettre des valeurs numériques (des données provenant d'un capteur, par exemple) .  La lecture du blog Generic Nerd de Markus Ulfberg m'a rappelé l'importance des fonctions atoi et itoa pour transformer un nombre entier en chaîne de caractères et inversement.


Premier test:  envoi et réception de nombres croissants

Cette première paire de sketches est bien utile pour vérifier le bon fonctionnement de notre paire émetteur/récepteur:  plutôt qu'envoyer sans cesse le même message, l'Arduino émetteur envoi des nombres entiers en ordre croissants, et l'Arduino récepteur les affiche dans le moniteur série.   Vous pouvez donc vérifier si la totalité des  messages émis par l'émetteur sont bel et bien reçus par le récepteur.



Deuxième test:  contrôle à distance de la luminosité d'une LED au moyen d'un potentiomètre

Cette fois, un potentiomètre est branché à l'entrée A0 de l'Arduino émetteur, et une LED (accompagnée de sa résistance de protection) est branchée à la sortie 5 de l'Arduino.  L'émetteur envoie l'état du potentiomètre (entier entre 0 et 1023) et le récepteur utilise cette valeur pour contrôler la luminosité de la LED par PWM (la valeur doit toutefois être divisée par 4, puisque analogWrite accepte un paramètre entre 0 et 255).

Fabrication d'un arpégiateur MIDI à base d'Arduino

Cet article a été mis à jour le 6 décembre 2020 (compatibilité avec la version actuelle de la bibliothèque MIDI).

Après avoir transformé mon Arduino en séquenceur MIDI, voici un projet où l'Arduino servira plutôt d'arpégiateur MIDI.

Lorsque cet arpégiateur est branché à un clavier MIDI, il s'agit d'enfoncer quelques touches du clavier de façon à former un accord:  votre clavier se met alors à jouer les notes qui correspondent aux touches enfoncées, mais de façon séquentielle (arpège).  Cet arpège est jouée en boucle, à une vitesse réglable par un potentiomètre, même après que les touches du clavier aient été relâchées.  Vous formez un autre accord sur le clavier et le nouvel arpège est joué en boucle...vous voilà transformé en virtuose de la musique nouvel-âge!  L'intérêt de ce dispositif, c'est que vous pouvez obtenir des effets très intéressants en exécutant l'arpège beaucoup plus rapidement que vous ne pourriez le faire vous-mêmes, et vos mains peuvent jouer autre chose pendant que les arpèges sont répétés.

Le circuit

Le circuit est le même que pour mon séquenceur, mais avec un bouton et une LED en moins: donc un Arduino Uno auquel on branchera un circuit de communication MIDI, un interrupteur, une LED indicatrice et deux potentiomètres.

Je présente donc pour la troisième fois le schéma du circuit de communication MIDI, pour plus de détails je vous invite à consulter l'article complet.  Il existe des shields déjà prêts à l'emploi, le plus connu est probablement celui conçu par Sparkfun

Sans surprises l'interrupteur "on-off" servira à mettre l'arpégiateur en fonction, et à l'arrêter (sinon, vos arpèges continueraient de jouer jusqu'à ce que vous débranchiez l'Arduino...).  Remarquez qu'il s'agit d'un interrupteur à deux positions (on-off) et non d'un bouton-poussoir momentané.  Cet interrupteur est placé entre l'entrée 7 de l'Arduino et la masse (GND).   Nul besoin d'ajouter une résistance, puisque le sketch utilise la résistance pull-up interne de cette broche.

La LED s'allumera pour indiquer que l'arpégiateur est en fonction:  on la branche entre la broche 9 de l'Arduino et la masse (GND), en n'oubliant pas de lui associer une résistance protectrice de 220 Ω.

Finalement, un premier potentiomètre (de 10 kΩ ou plus) est branché à l'entrée analogique A0 de façon à contrôler la vitesse à laquelle les arpèges seront exécutés.  J'ai aussi ajouté un deuxième potentiomètre (branché à A1) qui permet de modifier le programme MIDI, c'est à dire la sonorité utilisée par votre clavier pour jouer les sons (onde carrée, piano, cornemuse, etc.).  Ce potentiomètre n'est pas essentiel, mais il peut permettre des effets intéressants.

Le dessin ci-dessous illustre toutes les connexions autres que la liaison MIDI qui avait déjà été illustrée plus haut.

La bibliothèque MIDI

Pour utiliser avec succès le sketch qui se trouve à la fin de cet article, il faut avoir installé la bibliothèque MIDI de Forty Seven Effects.  Pour ce faire, on peut passer par le gestionnaire de bibliothèques.

Le sketch

Il faut d'abord savoir quelles touches du clavier sont enfoncées.  Puisque le protocole MIDI fonctionne à base de messages "note on" (lorsqu'une nouvelle touche est enfoncée) et "note off" (lorsqu'une touche est relâchée), le sketch utilise ces messages pour tenir à jour un registre des touches enfoncées (c'est le tableau touchesActives[]).  

La première version de mon sketch se contentait de jouer en arpèges les touches enfoncées, et les arpèges s'interrompaient aussitôt qu'on relâchait les notes.   Cette interruption engendrait un effet sonore plutôt désagréable chaque fois qu'on changeait d'accord sur le clavier, c'est pourquoi j'ai modifié mon sketch pour que les arpèges continuent d'être joués après que les touches aient été relâchées.

Ça complique un peu le programme, car il est impossible pour le musicien de relâcher toutes les touches exactement au même moment:  on attend donc qu'un même accord soit maintenu pendant  au moins 50 millisecondes avant de le copier dans le tableau notesActives[], qui contient les notes qui doivent être jouées en arpège.

Voilà!  Bien entendu, il serait relativement facile de fusionner ce sketch avec celui du séquenceur pour qu'un même appareil puisse remplir n'importe laquelle de ces deux fonctions.

- -

À lire également

Beaucoup d'autres projets MIDI avec l'Arduino:

• Communication MIDI OUT avec une carte Arduino
• Fabrication d'un module MIDI (in et out) pour Arduino
• Jouer des fichiers MIDI avec Arduino
• S'entraîner à lire les notes sur une portée avec Arduino
• Séquenceur MIDI à base d'Arduino
• Identificateur d'accords MIDI
• Clavier MIDI à base d'Arduino
• Pédalier d'orgue MIDI à base d'Arduino
• Flûte à bec MIDI à base d'Arduino
• MIDI par usb avec Arduino Leonardo
• MIDI sans fil avec Arduino

Yves Pelletier (Twitter:  @ElectroAmateur)

Séquenceur MIDI à base d'Arduino

Aujourd'hui, on fabrique un séquenceur MIDI avec un Arduino!

C'est quoi, un séquenceur MIDI?

Un séquenceur musical est un dispositif qui permet de programmer un motif musical (une suite de notes), puis de jouer ce motif en boucle à une vitesse choisie par l'utilisateur.

Le séquenceur que j'ai construit utilise la norme MIDI pour communiquer avec un clavier musical.  Lorsqu'il est en mode "record", il mémorise les notes jouées sur le clavier.  Lorsqu'il est en mode "play", il envoie au clavier musical les instructions nécessaires pour que les notes soient jouées en boucle.

L'intérêt principal de ce séquenceur si on le compare à celui que j'avais déjà fabriqué auparavant, c'est que vous pouvez le brancher à un instrument de musique de bonne qualité et obtenir des résultats professionnels, plutôt que produire des sonorités assez primitives au moyen de la fonction "tone" de l'Arduino.  Par contre ce séquenceur ne vous sera d'aucune utilité si vous ne disposez pas d'un instrument adhérant à la norme MIDI.


Le circuit

Tout d'abord vous avez besoin d'un Arduino (j'ai utilisé un vieux Duemilanove, qui est l'équivalent du Uno).

Pour la communication MIDI, j'ai utilisé ce module MIDI que j'avais fabriqué il y a quelques mois.  Vous avez besoin du circuit complet, avec l'optocoupleur et tout, car les messages MIDI circuleront dans les deux sens.

Si vous êtes riche et paresseux (ou riche et impatient), vous pouvez également vous procurer le MIDI shield de Sparkfun, mais ça me semble cher pour un circuit pas très compliqué.

Ensuite, il y a les boutons-poussoirs:  un premier qui permet d'entrer et sortir du mode "play", et un deuxième qui permet d'entrer et sortir du mode "record".    Au départ, j'avais utilisé des boutons-poussoirs momentanés:  chaque fois que le bouton est abaissé, le mode associé au bouton change d'état.  Mais j'avais d'irritants problèmes de rebonds qui persistaient malgré l'ajout de procédures anti-rebond dans le sketch.  Je les ai donc remplacé par des interrupteurs à deux position:  lorsqu'on appuie dessus, ils ferment le circuit, et lorsqu'on appuie dessus à nouveau, ils ouvrent le circuit.  Si vous utilisez des boutons-poussoirs momentanés, vous devrez modifier mon sketch en conséquence (ou garder le doigt sur le bouton, ce qui n'est pas très pratique).


Maintenant que j'y pense, l'idéal serait un seul commutateur à trois positions:  record - off - play.  Ça éviterait que les deux modes "record" et "play" soient actifs en même temps, ce qui n'est pas souhaitable et n'a pas été prévu dans le sketch.

Donc l'interrupteur qui contrôle le mode "record" relie l'entrée 6 à la masse (GND), alors que celui qui contrôle le mode "play" relie l'entrée 7 à la masse.  Le sketch utilise les pull-ups internes, donc pas la peine d'ajouter des résistances au circuit.

Nous avons aussi deux LEDs indicatrices:  une LED rouge (branchée à la sortie 8) qui s'allume pour indiquer qu'on est en mode "record", et une LED verte (branchée à la sortie 9 ) qui s'allume pour indiquer qu'on est en mode "play".  Prévoir une résistance protectrice de 220 Ω pour chaque LED.

Finalement, deux potentiomètre (j'ai utilisé 10kΩ, mais ça n'a pas une très grande importance).  Un premier potentiomètre (branché à A0) contrôle le tempo, en d'autres mots la rapidité à laquelle les notes sont jouées.  Un deuxième potentiomètre (branché à A1) permet de sélectionner le programme, c'est à dire le timbre utilisé par le clavier MIDI pour jouer la mélodie (piano, trompette, guitare, etc.).

Le sketch

Au départ, j'espérais utiliser tel quel ce sketch de Vance Gloster, conçu pour être utilisé avec le shield MIDI de Sparkfun:  Old-School Arduino MIDI Sequencer.  Malheureusement, je ne parvenais pas à enregistrer mes motifs à partir de son sketch (j'ignore s'il s'agit d'une erreur de ma part ou d'une particularité de mon clavier MIDI).  J'ai vainement tenté de modifier son sketch, mais je ne m'y retrouvais pas du tout.  Alors je me suis résigné à écrire mon propre sketch à partir de zéro, ce qui s'est avéré beaucoup plus simple que ce que j'avais prévu.

Arduino et perception des couleurs: construction d'une sonde RGB

Saviez-vous qu'il est facile et peu coûteux de fabriquer une sonde qui permettra à votre Arduino de connaître la couleur d'un objet?  Par exemple, grâce à cette sonde, votre robot pourrait reconnaître la pièce de la maison dans laquelle il se trouve en se basant sur la couleur des murs et du plancher. Vous pouvez aussi vous en servir dans cette impressionnante machine à trier les bonbons­.


Matériel:

Pour la fabrication de cette sonde, je me suis beaucoup inspiré de ce projet publié par Fjordcarver sur Instructables, par contre j'ai ajouté deux boutons poussoir qui déclenchent la calibration du capteur et la lecture de la couleur (dans le projet de Fjordcarver, la calibration se faisait au démarrage, et la lecture de la couleur se faisait ensuite sans arrêt).  Tout le matériel est facile à trouver:  une LED RGB à cathode commune (qu'on peut très bien remplacer par trois LEDs distinctes:  une rouge, une verte et une bleue), une photorésistance, une résistance de 220 Ω pour protéger la LED, une autre résistance pour mettre en série avec le photorésistance (j'ai utilisé 10 kΩ), deux boutons poussoir,  et bien sûr l'Arduino de votre choix (j'ai utilisé un Uno).  


Principe de fonctionnement:

Pour mesurer la couleur d'un objet, nous allons utiliser le système "RGB" qui consiste à assigner un nombre entre 0 et 255 pour chacune de ses trois composantes, soit le rouge (R), le vert (G) et le bleu (B).  Pour ce faire, nous allons éclairer l'objet avec une source de lumière rouge et mesurer au moyen de la photorésistance la quantité de lumière réfléchie par l'objet, puis répéter la mesure avec la lumière verte et la lumière bleue.

Un objet rouge réfléchira fortement la couleur émise par la LED rouge, mais beaucoup plus faiblement la lumière émise par la LED verte et la LED bleue.  Un objet blanc réfléchira fortement chacune des 3 couleurs, etc.

Puisque la couleur est mesurée par réflexion, ce dispositif ne permet pas de déterminer la couleur émise par une source de lumière (par exemple une LED colorée).

Le montage électrique:

Le montage est tellement simple que Fritzing fera parfaitement l'affaire pour l'illustrer:

La LED RGB est branchée aux entrées 2 (rouge), 3 (vert) et 4 (bleu) de l'Arduino.  La cathode commune à toutes les couleurs est branchée à une résistance protectrice de 220 Ω, qui est elle-même reliée à la masse (GND).  Une broche de la photorésistance est reliée à la masse (GND), et son autre broche est reliée à la fois à l'entrée A0 de l'Arduino, ainsi qu'à une résistance fixe (j'ai utilisé 10 kΩ). L'autre broche de la résistance fixe est reliée à + 5 V.

Deux boutons poussoirs sont reliés directement à la masse (GND); j'utilise les résistances pull-up interne de l'Arduino, donc pas besoin de résistance externe pour accompagner ces boutons.  L'autre borne du bouton de lecture des couleurs est branchée à l'entrée 5 de l'Arduino, alors que le bouton de calibration est relié à l'entrée 6.

Assurez-vous que la photoésistance est placée à proximité de la LED.  Mais attention:  vous voulez que la photorésistance capte la lumière réfléchie par l'objet et non la lumière provenant directement de la LED: pensez à insérer un carton noir ou autre obstacle opaque entre la LED et la photorésistance:

Pour mes tests sur breadboard, tout mon circuit était enfermé dans un récipient en carton noir afin d'éviter que la lumière ambiante n'affecte mes résultats (l'objet coloré était placé au dessus de ce récipient):

Après que les tests sur breadboard se soient révélé concluants, j'ai ensuite construit une sonde plus permanente en soudant les composants à l'extrémité d'un câble à six conducteurs (long de quelques dizaines de centimètres) ayant jadis servi à brancher un quelconque périphérique d'ordinateur:

...et en les enfermant dans un récipient opaque (un récipeint de Kinder Surprise dont l'intérieur est peint en noir; le diamètre est inutilement grand, mais c'est ce que j'avais de mieux sous la main):