samedi 22 juin 2019

Fabrication d'une boussole avec le module HMC5883L (Arduino)


Le HMC5883L est un capteur qui permet de mesurer les 3 composantes orthogonales du champ magnétique dans lequel il se trouve (je vous l'avais brièvement présenté il y a quelques années). Dans ce billet, je vous propose la fabrication d'une boussole constituée d'un capteur HMC5883, d'un Arduino et d'un afficheur LCD de type "Nokia".

Dans le produit final, l'écran LCD affichera une flèche qui pointera obstinément vers le nord.



Le champ magnétique terrestre 

Notre planète est un gigantesque aimant: elle produit un champ magnétique. Ce champ magnétique comporte une composante verticale (orientée vers le haut si vous vous trouvez dans l'hémisphère sud, et vers le bas si vous êtes dans l'hémisphère nord) et une composante horizontale orientée vers le nord magnétique.

Le HMC5883L comporte 3 capteurs de champ magnétique: il mesure le champ magnétique dans la direction x (le sens de x est indiqué sur le capteur), dans la direction y (également indiquée sur le capteur), et dans la direction z (perpendiculaire au module).

Pour l'utilisation comme boussole, il s'agit de placer le capteur à l'horizontale (bien à plat sur une table, par exemple). L'orientation horizontale du champ magnétique (donc l'orientation de la résultante des composantes x et y) représente l'angle que fait l'axe x du capteur par rapport au nord.

Branchement du capteur HMC5883L à l'Arduino Uno

Commençons par brancher le module HCM5883L à l'Arduino. Comme nous le verrons, il sera utile de tester et de calibrer ce capteur, et ce n'est qu'ensuite que j'ajouterai l'afficheur LCD.


Mon module HMC5833 comporte un régulateur de tension et des résistances de tirage, il se branche donc à l'Arduino de la façon suivante:

VCC du module HMC5833 ----- 5V de l'Arduino
GND du module HMC5833 ---- GND de l'Arduino
SCL du module HMC5833 ---- A5 de l'Arduino Uno
SDA du module HMC5833 ----- A4 de l'Arduino Uno
RDY du module HMC5833 ---- pas connectée

Calibration nécessaire!

Faisons un petit test pour vérifier la fiabilité des mesures prises par le capteur: on place le capteur à plat sur une table: on le fait lentement tourner sur lui-même sur au moins un tour complet tout en mesurant les 3 composantes du champ magnétique. J'ai utilisé le sketch ci-dessous (basé sur un sketch publié par l'équipe de Sparkfun) pour enregistrer les 3 composantes du champ magnétique, que j'ai ensuite copiées dans un tableur.



Si les mesures sont correctes, le graphique de la composante y en fonction de la composante x devrait former un cercle centré autour de la valeur 0. Quant à la composante z, elle devrait demeurer constante.

Mais voici ce que j'ai obtenu:


Ça ne va pas du tout!  Les données forment une ellipse plutôt qu'un cercle, ce qui signifie qu'un même champ magnétique ne génère pas la même valeur numérique selon qu'il est mesuré par le capteur x ou par le capteur y. De plus, les mesures du capteur x ne sont pas réparties de façon symétrique autour de 0, ce qui signifie qu'un même champ magnétique ne génère pas la même mesure (en valeur absolue) selon qu'il est orienté dans le sens positif ou dans le sens négatif de l'axe.

Dans ce cas précis, x a varié entre -561 et -63, alors que y a varié entre -263 et +242. Quant à la composante z, qu'on ne voit pas sur le graphique, elle est demeurée presque constante, tel que prévu, fluctuant entre -613 et -587.

Pour faciliter la prise des mesures utiles à la calibration, j'ai légèrement modifié le sketch afin qu'il affiche la valeur minimale et la valeur maximale de x et y pendant une rotation complète du module:


En faisant à nouveau tourner le capteur à plat sur une table, ce deuxième sketch a affiché les informations suivantes:

xmin: -564     xmax: -62     ymin: -277     ymax: 254     zmin: -616     zmax: -606

(ce qui confirme approximativement les valeurs constatées dans le test précédent).

Nous pouvons maintenant utiliser la fonction "map" d'Arduino pour redistribuer nos valeurs entre une valeur minimale de -1000 et une valeur maximale de 1000, selon les deux axes (cette valeur de 1000 est arbitraire, mais nous ne nous intéressons qu'à l'orientation du champ magnétique; nous devons simplement nous assurer que l'échelle est la même dans les 2 directions):

       xcalibree = map(xbrut, xmin, xmax, -1000, 1000);
       ycalibree = map(ybrut, ymin, ymax, -1000, 1000);

En utilisant à nouveau le premier sketch de ce billet, nous réglons la constante "calibration" à 1, et nous assignons les valeurs qui conviennent à notre capteur pour les constantes xmin, xmax, ymin et ymax.




Nouvelle prise de mesure, et transfert des données dans un tableur, après calibration:


Voilà qui est beaucoup mieux: après calibration, les deux capteurs x et y mesurent un champ magnétique maximal de 1000. La résultante de x et y (le rayon du cercle) est la même peu importe l'orientation du module. Lorsque la valeur en x est maximale, celle en y est nulle, etc.

Ajout de l'afficheur LCD

Pour créer notre boussole, il ne reste plus qu'à ajouter l'afficheur LCD; le circuit est le même que lors de mes utilisations précédentes de cet afficheur; j'utilise un circuit intégré 4050 pour abaisser à 3,3 V la communication entre l'Arduino et l'afficheur.



  • La broche VCC de l'afficheur et la broche 1 du 4050 sont branchés à la sortie 3.3 V de l'Arduino.
  • La broche GND de l'afficheur et la broche 8 du 4050 sont branchés à la broche GND de l'Arduino.
  • La broche 3 de l'Arduino est branchée à la broche 3 du 4050
  • La broche 4 de l'Arduino est branchée à la broche 5 du 4050
  • La broche 5 de l'Arduino est branchée à la broche 7 du 4050
  • La broche 11 de l'Arduino est branchée à la broche 14 du 4050
  • La broche 13 de l'Arduino est branchée à la broche 11 du 4050
  • La broche SCE ou CS de l'afficheur est branchée à la broche 4 du 4050
  • La broche RST de l'afficheur est branchée à la broche 2 du 4050
  • La broche D/C de l'afficheur est branchée à la broche 6 du 4050
  • La broche DN (MOSI) ou DIN de l'afficheur est branchée à la broche 15 du 4050
  • La broche SCLK ou CLK de l'afficheur est branchée à la broche 12 du 4050
  • La broche LED de l'afficheur n'est pas branchée (je n'avais pas besoin du rétroéclairage).

Rien n'a changé en ce qui concerne le capteur magnétique:

  • VCC du module HMC5833 ----- 5V de l'Arduino
  • GND du module HMC5833 ---- GND de l'Arduino
  • SCL du module HMC5833 ---- A5 de l'Arduino Uno
  • SDA du module HMC5833 ----- A4 de l'Arduino Uno
  • RDY du module HMC5833 ---- pas connectée


Sketch de la boussole

Ce dernier sketch est assez similaire aux précédents, mais plutôt qu'afficher les composantes du champ magnétique dans le moniteur série, ces composantes servent à tracer sur l'écran LCD une flèche qui pointe vers le nord (le sketch est conçu en supposant que l'axe x du capteur pointe vers le côté droit du LCD).

Attention: pour que la boussole fonctionne correctement, il est important que vous écriviez les constantes appropriées pour la calibration de votre capteur HMC5883 (xmin, xmax, ymin, ymax). Vous devez également trouver l'angle de déclinaison de l'endroit où vous vous trouvez, et mettre la bonne valeur (en radians) dans la constante "declinaison".



Modifications envisageables:

Il est possible que le module HMC5883L nécessite de fréquentes recalibrations: on pourrait envisager d'insérer la procédure de calibration à l'intérieur du sketch de la boussole. En appuyant sur un bouton (où à chaque démarrage du sketch), on afficherait un message à l'écran demandant d'effectuer une rotation complète de la boussole afin de redéfinir les valeurs à utiliser lors du calcul de calibration. De plus, on pourrait surveiller la composante z du champ magnétique pour s'assurer que la boussole est bien tenue à l'horizontale (l'écran pourrait indiquer que la boussole est trop inclinée pour que la mesure soit fiable).

Yves Pelletier   (TwitterFacebook)

jeudi 13 juin 2019

Contrôler plusieurs LEDs avec Arduino: multiplexing et charlieplexing

Multi quoi??? Charlie qui???

Le multiplexing et le charliplexing sont des façon de brancher des LEDs à l'Arduino (ou tout autre microcontrôleur) de façon à utiliser le moins de broches possible. Par exemple, si vous désirez contrôler 30 LEDs, vous auriez besoin, en principe, de 30 sorties de l'Arduino, ce qui exigerait donc l'ajout de sorties supplémentaires par l'entremise, par exemple, de registres à décalage. Mais grâce au multiplexing, vous pourrez contrôler individuellement chacune de ces 30 LEDs avec seulement 11 sorties de l'Arduino. Si vous optez pour le charlieplexing, 6 sorties de l'Arduino suffiront pour contrôler les 30 LEDs.

Pour explorer tout ça, je vous propose une petite expérience consistant à contrôler 6 LEDs au moyen d'un Arduino Uno. Pour contrôler ces 6 LEDs, nous allons successivement procéder de 3 façons différentes: branchement direct, multiplexing et charlieplexing.

Les 6 LEDs sont disposées sur une breadboard de façon à former un rectangle (2 LEDs de largeur, 3 LEDs de hauteur). Pour chacune des trois versions du programme, la routine consistera à allumer chaque LED individuellement pendant une demi seconde, puis allumer les LEDs par groupes de deux, ensuite allumer les LEDs par groupe de 3, et finalement allumer toutes les LEDs.  Vous pouvez voir le résultat dans la vidéo ci-dessous.




Connexion directe

La façon classique de faire les choses consiste à brancher chaque LED en série avec une résistance de protection, et de l'insérer entre une sortie de l'Arduino et la masse (GND) (sur le schéma, A, B, C, D, E et F représentent les 6 broches de l'Arduino qui sont utilisées pour contrôler nos 6 LEDs).

Cette méthode accapare beaucoup de sorties, mais le fonctionnement est simple: pour allumer la LED L1, vous placez la broche A au niveau logique HAUT. Pour éteindre la LED L1, vous placez la broche A au niveau logique BAS. Et ainsi de suite pour les 5 autres LEDs.
Voici donc le sketch correspondant à ce circuit (les broches 3 à 8 de l'Arduino sont utilisées). Comme ce sera le cas dans les autres programmes de ce billet, les 12 motifs qui seront successivement affichés par les 6 LEDs sont définis dès le départ dans un tableau bidimensionnel ("1" quand la LED est allumée, "0" quand elle est éteinte).


Multiplexing

Essayons maintenant le multiplexing, qui consiste à associer une broche de l'Arduino pour chaque ligne, ainsi qu'une broche de l'Arduino pour chaque colonne de notre matrice de LEDs. Puisque nos 6 LEDs forment un rectangle de 2 LEDs de largeur et de 3 LEDs de hauteur, nous avons 2 colonnes et 3 lignes, donc un total de 5 broches sont nécessaires (d'accord, ce n'est qu'une broche de moins que pour le montage précédent, mais plus contrôlez un grand nombre de LEDs, plus l'économie de broches sera substantiel).

Cette fois, nous ne branchons rien à la masse (GND). Si vous désirez allumer la LED L1 dans le schéma ci-dessous, vous devez mettre la broche A au niveau logique HAUT, et la broche C au niveau logique BAS, ce qui fera circuler un courant de A vers C. Si la broche B est au niveau logique BAS, et les broches D et E sont au niveau logique HAUT, toutes les autres LEDs demeureront éteintes (soit parce qu'il n'y a pas de différence de potentiel, soit parce que le courant essaie sans succès de circuler dans le sens bloquant de la diode).
Le tableau ci-dessous montre l'état logique que doit avoir chacune des 5 broches pour allumer chaque LED individuellement.

LED
A
B
C
D
E
L1
HAUT
BAS
BAS
HAUT
HAUT
L2
BAS
HAUT
BAS
HAUT
HAUT
L3
HAUT
BAS
HAUT
BAS
HAUT
L4
BAS
HAUT
HAUT
BAS
HAUT
L5
HAUT
BAS
HAUT
HAUT
BAS
L6
BAS
HAUT
HAUT
HAUT
BAS

Là où les choses se corsent un peu, c'est si vous désirez allumer plusieurs LEDs à la fois. Par exemple, supposons que vous désirez allumer L1 et L4 en même temps, pendant que toutes les autres LEDs demeurent éteintes. Vous pourriez penser que la solution consiste à placer la broche A au niveau logique HAUT et la broche C au niveau logique BAS pour allumer L1, tout en plaçant la broche B au niveau logique HAUT et la broche D au niveau logique BAS pour allumer L4.  Mais si vous procédez de cette façon, 2 autres LEDs vont s'allumer: L2 (puisque B est HAUT et C est bas) et L3 (puisque A est HAUT et D est BAS).

Pour ne pas perdre le contrôle, en multiplexing, on n'allume qu'une seule LED à la fois. On peut par contre donner l'illusion que plusieurs LEDs sont allumées en même temps grâce à la persistance rétinienne: si vous allumer L1, puis ensuite L4, puis ensuite L1, etc., très rapidement, le clignotement rapide des LEDs sera imperceptible à l'oeil nu, et les deux LEDs sembleront allumées en même temps (alors qu'elles ne le sont pas vraiment).

Voici ce que ça donne comme sketch: c'est un tout petit peu plus complexe que le précédent. Par exemple, on ne peut pas se contenter d'allumer deux LEDs et de paralyser le processus au moyen d'un delay(): en attendant le prochain changement de motif, on doit continuer d'allumer par alternance les LEDs qui doivent l'être.

Il faut également s'assurer que l'intensité lumineuse de chaque LED demeurera la même peu importe le nombre de LEDs allumées: si la LED 1 doit paraître allumée pendant que toutes les autres sont éteintes, elle sera en réalité allumée une fois sur six, soit la même fréquence que lorsque toutes les LEDs semblent allumées en même temps.


Charlieplexing

Le schéma ci-dessous montre 6 LEDs connectées à la façon charlieplexing: cette fois, 3 broches de l'Arduino seront suffisantes pour contrôler chacune de nos 6 LEDs.

Par exemple, pour allumer la LED L1, il faut que la broche B soit au niveau logique haut, et que la broche A soit au niveau logique bas. Mais attention: la broche C ne doit pas être au niveau logique haut (sinon L5 va s'allumer aussi), ni au niveau logique bas (sinon L4 va s'allumer aussi)! Il faut plutôt la régler en mode INPUT (entrée), ce qui aura pour effet de lui procurer une très grande impédance (équivalent d'un circuit ouvert) et pour cette raison aucun courant ne la traversera.
Le tableau ci-dessous montre l'état que doit avoir chacune des trois broches A, B et C pour allumer chaque LED individuellement.

LED
A
B
C
L1
BAS
HAUT
ENTREE
L2
HAUT
BAS
ENTREE
L3
ENTREE
BAS
HAUT
L4
ENTREE
HAUT
BAS
L5
BAS
ENTREE
HAUT
L6
HAUT
ENTREE
BAS

Tout comme c'est le cas en multiplexing, nous allumons les LEDs une à la fois, et c'est le phénomène de persistance rétinienne qui nous donne l'illusion que plusieurs LEDs sont allumées en même temps.


Yves Pelletier   (TwitterFacebook)

mardi 11 juin 2019

Ajout de 8 entrées analogiques à l'ESP8266 grâce au MCP3008

L'ESP8266 ne comporte qu'une seule entrée analogique. Pour certaines applications, c'est parfaitement suffisant, alors que pour d'autres, ça ne l'est pas du tout!


Il s'agit d'un problème pour lequel nous avons déjà décrit deux solutions élégantes et efficaces: l'utilisation d'un convertisseur analogique-numérique PCF8591, et l'utilisation d'un multiplexeur CD4051.

Aujourd'hui, nous explorons une troisième option: l'utilisation d'un circuit intégré MCP3008; il s'agit d'un convertisseur analogique-numérique à 8 canaux, ayant une résolution de 10 bits. Grâce à ce circuit intégré, vous pouvez donc ajouter 8 entrées analogiques à votre ESP8266.


Connexions du MCP3008 à l'ESP8266

Le schéma ci-contre, tirée de la fiche technique du MCP3008, montre son brochage.

Les 8 entrées analogiques (canal 0 à canal 7) se trouvent sur les broches 1 à 8, du côté gauche du circuit intégré.

Du côté droit, on retrouve l'alimentation (VDD), la tension de référence (VREF), les masses (AGND et DGND), l'horloge (CLK), la sortie des signaux numériques vers l'ESP8266 (DOUT), l'entrée des signaux numériques en provenance de l'ESP8266 (DIN) et la broche "chip select" (CS/SHDN) qui permet d'activer ou de désactiver le circuit intégré.

Le circuit illustré ci-dessous permet de mesurer une tension variant entre 0 et 3,3 V (contrôlée par un potentiomètre) au canal 0 du convertisseur.  VDD et VREF sont à 3,3 V, AGND et DGND sont branchés à la masse de l'ESP8266.

J'ai branché CLK à la broche GPIO 14  de l'ESP8266, DIN à GPIO 13, DOUT à GPIO 12 et CS/SHDN 15 à GPIO 15. Mais tout ça se définit dans le sketch, vous pouvez donc utiliser d'autres broches de l'ESP8266 au besoin.

N.B.: mon schéma montre les branchements sur ma carte Wemos D1 R1, mais vous utilisez évidemment n'importe quel module ESP8266. Puisque j'ai utilisé la sortie 3,3 V de la carte Wemos, j'ai branché un condensateur de 100 nF aux broches 16 et 14 du MCP3008 pour assurer une meilleure stabilité de l'alimentation (sans le condensateur, le MCP3008 refusait parfois de fonctionner, retournant la valeur 1023 peu importe la tension d'entrée).

Installation de la bibliothèque MCP3008

J'ai utilisé  la bibliothèque MCP3008 réalisée par Uros Petrevski.

Exemple de sketch

L'utilisation de la bibliothèque est très simple: pour lire une valeur, on utilise la méthode readADC()readADC(0) pour lire la valeur du canal 0 (donc la broche numéro 1), readADC(1) pour lire le canal 1 (broche 2), etc.

Puisque la résolution est de 10 bits, la valeur retournée se situe entre 0 et 1023. Elle varie lorsque vous tournez le potentiomètre.






Yves Pelletier   (TwitterFacebook)

samedi 8 juin 2019

Utilisation du moteur pas à pas d'un lecteur de CD (Arduino)


Il y a quelques années, à peu près tous les ordinateurs comportaient un indispensable lecteur ou graveur de CD-ROM ou de DVD. Par conséquent, il n'est pas très difficile d'en trouver un de nos jours, encore en état de marche, mais qui ne sert plus.

Une partie intéressante d'un lecteur de CD est le mécanisme qui permet le déplacement du laser: ils s'agit généralement d'un moteur pas à pas qui fait tourner une vis sans fin ou un engrenage, provoquant le mouvement linéaire de la diode laser.

Lorsqu'on démonte un lecteur CD pour récupérer ses composants, il est généralement préférable de conserver la totalité du mécanisme: le moteur pas à pas, la partie mobile, les deux tiges qui guident la partie mobile, et le châssis qui tient tout ça ensemble.

Le principal avantage du mécanisme, c'est sa précision: on peu régler la position de la partie mobile avec une précision d'environ 0,2 mm. On doit par contre se contenter d'un déplacement total ne dépassant guère 4 cm.


Ce moteur pas à pas est bipolaire: il comporte donc 4 connecteurs permettant d'alimenter deux bobinages distincts à l'intérieur du moteur. Il m'a semblé plus pratique de retirer le connecteur à ruban afin de souder 4 fils conducteurs directement sur les bornes du moteur.


Au moyen d'un multimètre, c'est facile de déterminer quels connecteurs partagent la même bobine.

Contrôle du moteur pas à pas au moyen d'un Arduino et d'un L9110S

On ne branche pas le moteur directement aux fragiles sorties de l'Arduino: il faut utiliser, comme intermédiaire, un circuit intégré spécialement conçu pour le contrôle d'un moteur. Dans le présent billet, j'utilise un module L9110S, car il s'agit probablement de l'option la plus économique (le module comporte en fait 2 circuits intégrés L9110S).

Si vous avez en main un autre module conçu pour le pilotage d'un moteur, utilisez-le! Par exemple, vous pouvez vous référer à ces autres billets qui expliquent l'utilisation d'un circuit intégré L293D, d'un circuit intégré L6205, ou d'un module L298N.

Comme le montre le schéma ci-dessous, les connecteurs du moteur pas à pas sont branchés aux 4 sorties du module L9110S (bornier à vis); les deux extrémités d'une même bobine sont branchées sur deux vis adjacentes.

De l'autre côté du module L9110S, on retrouve les entrées, qui sont branchées aux broches 8, 9, 10 et 11 de l'Arduino. Le module L9110S nécessite une alimentation située entre d'au moins 2,5 V (cette alimentation sert à la fois aux moteurs et aux circuits intégrés du module). J'ignore pour quelle tension mon moteur a été conçu, mais j'ai eu du succès avec aussi peu que 3,3 V.



Le sketch

Comme point de départ, je vous recommande l'exemple "stepper_oneRevolution" qui se trouve dans la catégorie "Stepper" de l'IDE Arduino. Dans mon cas, le moteur comporte 20 pas par tour (c'est donc cette valeur que j'ai utilisé pour la constante stepsPerRevolution).


Votre moteur devrait répétitivement effectuer un tour dans un sens, puis un tour dans l'autre sens. Si le moteur ne fait que vibrer plutôt que tourner, essayer de modifier l'ordre dans lequel les fils sont branchés à la sortie du module L9110S.

La vidéo ci-dessous montre mon dispositif en action (je l'ai réglé pour effectuer 12 tours, ce qui représente environ le maximum de déplacement possible, avec une vitesse de 300 tours par minute).



Et à quoi ça peut servir?

Vous trouverez facilement sur le web une grande quantité de projets du genre robot dessinateur, graveuse laser ou même imprimante 3D, comportant 2 ou 3 mécanismes de ce genre. Toutefois, le déplacement maximal de 4 cm constitue souvent une contrainte frustrante.

Pour ma part, puisque je me plaignais dernièrement du manque de précision du support de mon microscope USB, je prévois tenter de créer un support convenant mieux à mes besoins: un moteur réglerait la hauteur du microscope (axe z), et deux autres moteurs permettraient de positionner l'échantillon à observer (axes x et y).

Yves Pelletier   (TwitterFacebook)

mercredi 5 juin 2019

Microscope USB

Aujourd'hui, je vous relate la mise l'essai d'un microscope USB bas de gamme que j'ai acheté sur eBay pour la modique somme de 11 euros.

Il s'agit d'une web cam conçue pour photographier ou filmer des petits objets de très près.  Le grossissement annoncé est de 1000X, et les images ont une résolution de 640 X 480 pixels.

Plus l'objet à étudier se trouve près du microscope, plus l'image est agrandie.  La distance entre l'objet et le microscope peut être réglée en ajustant un support plutôt rudimentaire qui, contrairement à un microscope optique conventionnel, ne comporte pas de vis micrométrique permettant un positionnement de précision.

Ce support est tellement peu pratique que dans bien des cas, lorsqu'on désire obtenir le grossissement maximal, il est plus simple de tenir l'appareil à mains nues en l'appuyant sur l'objet qu'on désire étudier.


Une fois le microscope positionné pour obtenir le grossissement désiré, une molette argentée permet de faire la mise au point. Un potentiomètre situé sur le câble USB permet de varier l'intensité de l'éclairage (8 LEDs disposées en cercle autour du capteur). Un bouton "zoom" semble totalement inopérant ("due to software upgrade", d'après le manuel d'instructions). Les photos présentées sur l'annonce eBay montraient un bouton "snap" qui est carrément absent sur le modèle que j'ai reçu (ce qui n'a pas la moindre importance, à mon avis: il est facile de tout contrôler par logiciel).


Je vous présente quelques images captées avec mon microscope USB.

Quelques grains de sable de plage:


Du sucre:


Tissus de mon T-shirt:


Une zone blanche sur l'écran de mon ordinateur:


Stigmates d'une fleur de pissenlit (recouverts de pollen):


Comme exemple de vidéo, voici un être vivant trouvé dans un échantillon d'eau puisé dans un étang près de chez moi. Je ne sais pas ce que c'est, ni ce qu'il est en train de faire, mais ça nous change des vidéos de chats.



Logiciels

On peut se procurer le logiciel HiView (Windows ou Mac) sur le site www.hvscam.com. En plus d'afficher l'image à l'écran en temps réel et de permettre son enregistrement sous forme de jpeg ou de vidéo, le logiciel comporte des outils permettant de prendre des mesures sur l'image affichée.


Pour que ces mesures correspondent à la réalité, on calibre le logiciel avec la carte fournie avec le microscope.


Le logiciel HiView n'est malheureusement pas disponible en version Linux, mais n'importe quel logiciel pour webcam devrait faire l'affaire (nous ne disposons pas des outils permettant de prendre des mesures sur l'image, toutefois). Sous Ubuntu, j'ai obtenu d'excellent résultats avec le logiciel Cheese.

J'ai également observé quelques grains de sel avec VNC Viewer sur mon Raspberry Pi, sans le moindre problème.



Yves Pelletier   (TwitterFacebook)

lundi 20 mai 2019

Et pendant ce temps, dans un blog près de chez vous...(4)



Quelques publications récentes qui ont éveillé mon intérêt:

Sur BreizhMakers:

Sur Arduiblog:

Sur Cyanuretech:

Sur RitonDuino:
Sur Framboise314:

Sur iTechnoFrance:

Sur MCHobby:

Yves Pelletier   (TwitterFacebook)

dimanche 19 mai 2019

Mini clavier sans fil et Raspberry Pi


La plupart du temps, quand j'utilise un Raspberry Pi, c'est par SSH ou VNC: aucun écran, clavier ou souris n'est alors branché au Raspberry Pi. Mais il m'arrive quand même occasionnellement d'avoir besoin de le brancher à un écran HDMI (ne serait-ce que pour configurer le Wifi suite à l'installation d'un nouvel OS). Dans ces occasions, mon téléviseur fait parfaitement l'affaire, à un détail près: je ne dispose pas, devant le téléviseur, d'une table ou d'un bureau sur lequel je pourrais placer un clavier et une souris USB.

Ce petit clavier sans fil, doté d'un pavé tactile (trackpad), se révèle bien pratique dans ce genre de situation, puisqu'il est conçu pour être utilisé pendant qu'on le tient dans ses mains, un peu comme une manette de jeu. Il est livré avec un petit récepteur qui se branche dans un port USB du Raspberry Pi. Sous Linux, aucune installation de pilote n'est nécessaire: ça fonctionne immédiatement dès le premier démarrage.

On peut le trouver sur eBay ou autre pour moins de 10 euros (cherchez "mini wireless touchpad keyboard"). Il existe également une version rétroéclairée, et il est possible de se le procurer en version AZERTY ou QWERTY.

Je ne m'imaginerais pas utiliser un tel clavier pour taper du texte toute la journée (les touches de style télécommande de téléviseur ne survivraient probablement pas longtemps), mais pour une utilisation occasionnelle, ça convient parfaitement à mes besoins.

Addendum (3 juin 2019): Quelques jours après la publication de ce billet, mon mini-clavier a cessé de fonctionné; il est désormais impossible d'établir une connexion entre le dongle USB et le clavier. Je me permet d'émettre une petite mise en garde concernant la durabilité, donc...

Yves Pelletier   (TwitterFacebook)

dimanche 5 mai 2019

Obtenir les grands titres de l'actualité avec l'ESP8266 (flux RSS)

Pour la petite expérience d'aujourd'hui, mon objectif était d'utiliser un ESP8266 afin de récupérer le flux RSS d'une agence de presse et de présenter dans le moniteur série les grands titres de l'Actualité.


RSS (Really Simple Syndication) est un format de données créé il y a une vingtaine d'années: il s'agit de texte encadré par des balises assez similaires à celles du html:  title, description, pubDate, link, etc.  Il est surtout utilisé pour diffuser des dépêches d'actualité, ou encore pour signaler les publications les plus récentes d'un site web.

Mon point de départ a été ce billet du blog Runtime Projects, qui présente une modification de l'exemple WiFiClient.ino (disponible dans l'IDE Arduino lorsque l'ESP8266 y a été installé) pour récupérer le flux RSS de l'agence Reuters.

Lors de mes tentatives d'utiliser ce sketch pour récupérer d'autres flux RSS, j'ai pu constater une certaine diversité dans le monde des serveurs RSS. Par exemple, plusieurs d'entre eux exigent une connexion sécurisée sur le port 443, alors que d'autres prévoient une connexion non sécurisée sur le port 80.  Certains flux de données comportent des sauts de lignes, alors que d'autres n'en comportent pas. Dans la plupart des cas, un titre est identifié par la balise title ; mais dans certains cas (plus rares), ce sera plutôt la balise title type="text".

J'ai donc tenté d'écrire un sketch relativement universel qui procédera de façon légèrement différente selon le serveur RSS qu'on désire interroger.

Au début du skech, nous fournissons des informations concernant le flux RSS à consulter. Par défaut, mon sketch utilise le fil de nouvelles de Radio-Canada, en français. Nous souhaitons extraire uniquement les grands titres, qui sont encadrés par la balise "title", sans conserver les résumés plus détaillés, les images, les liens, etc. De plus, puisque ce serveur exige que la connexion soit sécurisée, nous avons ajouté une instruction pour le préprocesseur: "#define SECURISE".










Avant d'aller plus loin dans le sketch, jetons immédiatement un oeil sur les caractéristiques d'un serveur RSS radicalement différent: le flux RSS du blog "Électronique en Amateur".









Contrairement au serveur précédent, celui-ci n'exige pas de connexion sécurisée. De plus, il retourne un flux qui comporte des fins de ligne, ce qui nous permettra d'analyser les données ligne par ligne (d'où l'instruction de préprocesseur: #define FIN_DE_LIGNE). Pour compliquer les choses encore davantage, les titres sont annoncés par la balise title type="text" plutôt que simplement title. Notez que lorsque nous utilisons la possibilité de lire l'information ligne par ligne, nous devons également fournir la balise de fermeture (dans la constante baliseFin).

Au lignes 59 à 65, vous pouvez constater ce qui différencie la connexion à un serveur qui est sécurisé et un serveur qui ne l'est pas:










Les lignes 91 à 108 concernent uniquement un flux qui comporte des indications de fin de ligne (et qui a été déclaré comme tel avec la mention "#define FIN_DE_LIGNE"). Nous lisons l'information une ligne à la fois, grâce à l'instruction "ligne = client.readStringUntil('\r');".

Le reste consiste à détecter la présence de la balise "title" au moyen de la fonction "indexOf()" qui retourne sa position dans la chaîne de caractères (ou -1 si elle ne si trouve pas). S'il s'agit bien d'un titre, nous affichons dans le moniteur série la partie de la chaîne de caractères qui se trouve entre les deux balises.

Pour les flux ne comportant pas de saut de ligne, la stratégie précédente fonctionnait, mais la totalité de l'information était placée dans une même chaîne de caractères, ce qui entraînait un assez long délai avant que l'information apparaisse dans le moniteur série.

J'ai préféré utiliser une stratégie différente, qui se trouve aux lignes 110 à 117. L'information est lue jusqu'au symbole "<" qui indique le début d'une balise. On vérifie ensuite si notre chaîne de caractères contient bien la balise title et, si c'est le cas, on affiche dans le moniteur série la portion de texte qui se trouve après cette balise.












La capture d'écran ci-dessous montre le résultat lorsqu'on consulte le flux RSS de mon blog...


La suite logique de ce projet consistera probablement à présenter cette information sur un afficheur plutôt que dans le moniteur série.

Yves Pelletier   (TwitterFacebook)


vendredi 19 avril 2019

Synthèse sonore avec Mozzi et Arduino (3)

Pour cette troisième exploration des possibilités de la bibliothèque Mozzi, nous allons faire jouer par l'Arduino un échantillon ("sample") sonore que nous aurons nous-mêmes produit. Cet échantillon peut être n'importe quel son de courte durée: une note jouée par un instrument de musique, un cri d'animal, un mot que vous aurez vous-même prononcé... Ce son, toutefois, devra être très court (1 seconde ou 2), à cause du peu de mémoire disponible dans l'Arduino Uno.

Trouver un son

Vous pouvez enregistrer le son vous-même, ou encore trouver un son dans une des nombreuses banques d'effets sonores libres de droits disponibles sur internet comme La Sonothèque, par exemple. Puisque je suis enrhumé aujourd'hui, j'ai choisi un son d'éternuement.

Préparation d'un fichier .raw avec Audacity

Le fichier audio de type .wav doit d'abord être épuré au moyen de l'indispensable logiciel (gratuit) Audacity.  Après avoir ouvert votre fichier .wav dans Audacity et, au besoin, effacé toute partie que vous ne désirez pas conserver, réglez la valeur du "Taux du projet (Hz)", dans le coin inférieur gauche de la fenêtre, à 16384.


On choisit ensuite le menu Exporter / Exporter l'audio...


Il faut ensuite modifier les options d'enregistrement: "Autres formats non-compressés", entête "RAW (header-less)" et encodage "Signed 8-bit PCM".



Transformation du fichier .raw en fichier d'entête pour Mozzi avec char2mozzi.py

Le fichier de type ".raw" que nous venons tout juste de produire au moyen d'Audacity doit ensuite être analysé par le script "char2mozzi.py", qui est fourni avec Mozzi dans le répertoire libraries/Mozzi/extra/python.

Vous placez le fichier sonore ".raw" dans le même répertoire que le script "char2mozzi.py". Avec le terminal, vous naviguez jusqu'à ce répertoire, et vous écrivez la commande suivante:

python char2mozzi.py "atchoum.raw" "atchoum.h" "echantillon" "16384"

Dans mon cas, "atchoum.raw" était le nom de mon fichier source, "atchoum.h" est le nom que je désirais donner à mon fichier texte utilisable par mozzi, "echantillon" est le nom que je désirais donner à la variable contenant les données (à l'intérieur du fichier atchoum.h), et 16384 est la fréquence d'échantillonnage.


Tel que prévu, le fichier "atchoum.h" est créé dans le même répertoire que "char2mozzi.py".


Voici le contenu du fichier "atchoum.h":


Sketch qui fait jouer notre échantillon

Finalement, voici un sketch qui fera jouer notre échantillon (il s'agit, à peu de choses près, de l'exemple "Sample" fourni avec Mozzi). Pour que ça fonctionne, le fichier "atchoum.h" doit se situer dans le même répertoire que le sketch.

Yves Pelletier   (TwitterFacebook)

Related Posts Plugin for WordPress, Blogger...