Étude de CI: le compteur binaire 74LS193

Comme son nom peut le laisser deviner, un compteur est un circuit intégré qui compte le nombre d'impulsions reçues sur sa broche d'entrée.  Cette fonction peut sembler banale en cette époque où un microcontrôleur bas de gamme peut accomplir des tâches beaucoup plus complexes, mais il y a quelque années, c'était impressionnant! De plus, l'utilisation d'un compteur demeure encore pertinente  de nos jours si la fréquence des impulsions à compter est élevée (jusqu'à 32 MHz, dans le cas du compteur que nous étudiants aujourd'hui).

Il existe un grand nombre de compteurs. Nous en avons même déjà construit un à partir de quelques bascules (flip flops) CD4013. Le 74LS193 de Texas Instruments, que nous étudions aujourd'hui, est un compteur binaire synchrone de 4 bits, qui peut compter de façon ascendante et descendante. Il se présente sous la forme d'un circuit intégré comportant 16 broches.  Comme à mon habitude, je vous encourage à expérimenter avec le circuit intégré, pour vérifier qu'il se comporte bien de la façon décrite dans la fiche technique.


Broches d'alimentations

Commençons par les broches numéros 8 et 16: elles servent à alimenter le circuit intégré, qui est conçu pour fonctionner à une tension de 5 V. Ces deux broches doivent obligatoirement être branchées à une alimentation continue de 5 V, sinon le circuit intégré ne fonctionnera pas.

2 broches d'entrée

La broche numéro 4 "DOWN" et la broche numéro 5 "UP" sont les entrées.  Chaque fois que la broche "UP" retourne à une tension de 5 V après avoir brièvement été soumise à une tension nulle, la valeur du compteur augmente d'une unité. Pour la broche "DOWN", c'est la même chose, sauf que la valeur du compteur diminue d'une unité.

4 broches de sortie

La valeur du compteur est accessible sous la forme d'un nombre binaire à 4 bits grâce aux broches QA, QB, QC et QD. QD est le bit de poids fort, alors que QA est le bit de poids faible. Ainsi, si QA, QB et QC sont à 0 V pendant que QD est à 5 V, le compteur affiche le nombre binaire 1000 qui correspond à 8 en notation décimale.

Un premier circuit exploratoire

Pour tester le 74LS193, nous devons l'alimenter avec une tension de 5 V, soumettre sa broche "UP" à des impulsions de 5 V, et lire la tension de ses 4 broches de sortie: tout ça peut facilement être accompli par un Arduino Uno, c'est pourquoi je vous propose le montage illustré ci-dessous.

• Les broches 4, 11 et 16 du 74LS193 sont branchées à la sortie 5 V de l'Arduino.
• Les broches 8 et 14 du 74LS193 sont branchées à une des broches GND de l'Arduino.
• Les sorties QA, QB, QC et QD (broches 3, 2, 6, 7) du 74LS193 sont branchées respectivement aux broches 2, 3, 4 et 5 de l'Arduino.
• La broche 5 (entrée UP) du 74LS193 est branchée à la broche 6 de l'Arduino.
• Les broches 1, 9, 10, 12, 13 et 15 du 74LS193 ne sont pas branchées (nous les utiliserons plus tard).

Le sketch n'est pas très long: il consiste à envoyer chaque seconde une impulsion sur l'entrée UP du compteur, puis de lire la tension de chacune de ses 4 sorties afin d'afficher le résultat sur le moniteur série de l'IDE Arduino.

	/********************************************************
	* Un premier sketch pour explorer le compteur 74LS193.
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/06/etude-de-ci-le-compteur-binaire-74ls193.html
	*********************************************************/
	// définition des broches utilisées
	const int brocheQA = 2;
	const int brocheQB = 3;
	const int brocheQC = 4;
	const int brocheQD = 5;
	const int brocheUP = 6;
	void setup() {
	// une sortie pour contrôler l'entrée du 74LS193
	pinMode(brocheUP, OUTPUT);
	digitalWrite(brocheUP, HIGH);
	// 4 entrées pour lire les sorties du 74LS193.
	pinMode(brocheQA, INPUT);
	pinMode(brocheQB, INPUT);
	pinMode(brocheQC, INPUT);
	pinMode(brocheQD, INPUT);
	// initialisation de la communication série
	Serial.begin(9600);
	Serial.println("Test du compteur SN74LS193");
	Serial.println("");
	}
	void loop() {
	// envoi d'une impulsion: la tension prend brièvement
	// une valeur nulle avant de redevenir 5 V.
	digitalWrite(brocheUP, LOW);
	digitalWrite(brocheUP, HIGH);
	// Lecture des 4 sortiers du SN74LS193 et affichage
	// dans le moniteur série
	Serial.print("QD: ");
	Serial.print(digitalRead(brocheQD));
	Serial.print(" QC: ");
	Serial.print(digitalRead(brocheQC));
	Serial.print(" QB: ");
	Serial.print(digitalRead(brocheQB));
	Serial.print(" QA: ");
	Serial.println(digitalRead(brocheQA));
	delay(1000); // on ralentit exagérément le processus pour avoir le temps de voir ce qui se passe
	}

view raw 74LS193_Test_1.ino hosted with ❤ by GitHub

Tel que prévu, chaque fois qu'une impulsion est détectée par la broche UP, la valeur binaire présentée par les sorties QA, QB, QC et QD augmente d'une unité. Lorsque la valeur maximale "1111" (qui est l'équivalent de 15 en décimal) est atteinte, le compteur recommence à zéro.

Réglage de la valeur du compteur

Il est parfois utile de régler la valeur du compteur. Pour ce faire, nous plaçons les entrées A, B, C et D du compteur aux valeurs désirées, puis nous plaçons brièvement la broche LOAD (broche #11) à 0 V pour enregistrer le résultat.

Par exemple, si vous désirez régler le compteur à la valeur "0100", vous mettez D à 0 V, C à 5 V, B à 0 V et A à 0 V, puis vous envoyez une impulsion sur la broche LOAD pour enregistrer le résultat.

Modifions notre circuit afin de pouvoir régler la valeur du compteur (nous en profiterons également pour activer la broche DOWN, ce qui nous permettra de diminuer la valeur du compteur.

Il s'agit donc du même circuit que plus haut, sauf que maintenant:

• La broche DOWN (#4) du 74LS193 est branchée à la broche 7 de l'Arduino (et non à 5 V).
• La broche LOAD (#11) du 74LS193 est branchée à la broche 8 de l'Arduino (et non à 5 V).
• La broche A (#15) du 74LS193 est branchée à la broche 9 de l'Arduino.
• La broche B (#1) du 74LS193 est branchée à la broche 10 de l'Arduino.
• La broche C (#10) du 74LS193 est branchée à la broche 11 de l'Arduino.
• La broche D (#9) du 74LS193 est branchée à la broche 12 de l'Arduino.

Le sketch ci-dessous règle le compteur à la valeur "0111", puis envoie 4 signaux de soustraction par la broche "DOWN" avant de régler le compteur à "0101" et d'envoyer 4 signaux d'addition.

	/*
	Deuxième sketch pour tester le compteur 74LS193N: cette
	fois, nous réglons la valeur du compteur avant d'effectuer
	quelques soustractions, puis nous réglons le compteur à
	une autre valeur avant de faire quelques additions.
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/06/etude-de-ci-le-compteur-binaire-74ls193.html
	*/
	// définition des broches utilisées
	const int brocheQA = 2;
	const int brocheQB = 3;
	const int brocheQC = 4;
	const int brocheQD = 5;
	const int brocheUP = 6;
	const int brocheDOWN = 7;
	const int brocheLOAD = 8;
	const int brocheA = 9;
	const int brocheB = 10;
	const int brocheC = 11;
	const int brocheD = 12;
	void setup() {
	// deux sorties pour contrôler l'entrée du 74LS193
	pinMode(brocheUP, OUTPUT);
	digitalWrite(brocheUP, HIGH);
	pinMode(brocheDOWN, OUTPUT);
	digitalWrite(brocheDOWN, HIGH);
	// 4 entrées pour lire les sorties du 74LS193.
	pinMode(brocheQA, INPUT);
	pinMode(brocheQB, INPUT);
	pinMode(brocheQC, INPUT);
	pinMode(brocheQD, INPUT);
	// 5 entrées pour régler la valeur du compteur
	pinMode(brocheLOAD, OUTPUT);
	digitalWrite(brocheLOAD, HIGH);
	pinMode(brocheA, OUTPUT);
	pinMode(brocheB, OUTPUT);
	pinMode(brocheC, OUTPUT);
	pinMode(brocheD, OUTPUT);
	// affichage au moniteur série
	Serial.begin(9600);
	Serial.println("Test du compteur SN74LS193N");
	Serial.println("");
	}
	void loop() {
	// réglage du compteur à 0111
	digitalWrite(brocheD, LOW);
	digitalWrite(brocheC, HIGH);
	digitalWrite(brocheB, HIGH);
	digitalWrite(brocheA, HIGH);
	digitalWrite(brocheLOAD, LOW);
	digitalWrite(brocheLOAD, HIGH);
	Serial.println("Reglage a 0111");
	affichage();
	delay(1000);
	// on effectue 4 soustractions
	for (int i = 0; i <= 3; i++) {
	digitalWrite(brocheDOWN, LOW);
	digitalWrite(brocheDOWN, HIGH);
	affichage();
	delay(1000);
	}
	// réglage du compteur à 0101
	digitalWrite(brocheD, LOW);
	digitalWrite(brocheC, HIGH);
	digitalWrite(brocheB, LOW);
	digitalWrite(brocheA, HIGH);
	digitalWrite(brocheLOAD, LOW);
	digitalWrite(brocheLOAD, HIGH);
	Serial.println("Reglage a 0101");
	affichage();
	delay(1000);
	// on effectue 4 additions
	for (int i = 0; i <= 3; i++) {
	digitalWrite(brocheUP, LOW);
	digitalWrite(brocheUP, HIGH);
	affichage();
	delay(1000);
	}
	}
	void affichage()
	{
	Serial.print("QD: ");
	Serial.print(digitalRead(brocheQD));
	Serial.print(" QC: ");
	Serial.print(digitalRead(brocheQC));
	Serial.print(" QB: ");
	Serial.print(digitalRead(brocheQB));
	Serial.print(" QA: ");
	Serial.println(digitalRead(brocheQA));
	}

view raw 74LS193_Test_2.ino hosted with ❤ by GitHub

Notez que si vous désirez mettre le compteur à zéro, vous pouvez aussi placer temporairement la broche CLR du compteur à 5 V, puis la remettre à 0 V.

Détection des débordements

Il ne nous reste plus que 2 dernières broches du 74LS193 à explorer:  BO et CO. Ces deux sorties sont généralement à 5 V, mais leur tension devient brièvement nulle lorsque le compteur "déborde". Par exemple, lorsque vous ajoutez "1" au compteur alors qu'il se trouve à la valeur maximale "1111", la broche CO prend brièvement une valeur nulle juste avant que le compteur n'affiche "0000". De la même façon, si vous soustrayez "1" du compteur alors qu'il se trouve à la valeur minimale "0000", la tension de la broche BO devient momentanément nulle avant que le compteur n'affiche "1111".

Pour tester ces deux broches, j'ai branché CO (#12) à la broche A0 de l'Arduino, et BO (#13) à A1.

Le sketch ci-dessous effectue 25 additions, en nous alertant à chaque débordement, puis 25 soustraction, en nous alertant à chaque débordement.

	/*
	Troisième sketch pour tester le compteur 74LS193N: cette
	fois, nous utilisons les broches CO et BO pour être alertés
	lorsque le compteur retourne à zéro après avoir atteint sa limite.
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/06/etude-de-ci-le-compteur-binaire-74ls193.html
	*/
	// définition des broches utilisées
	const int brocheQA = 2;
	const int brocheQB = 3;
	const int brocheQC = 4;
	const int brocheQD = 5;
	const int brocheUP = 6;
	const int brocheDOWN = 7;
	const int brocheLOAD = 8;
	const int brocheA = 9;
	const int brocheB = 10;
	const int brocheC = 11;
	const int brocheD = 12;
	const int brocheCO = A0;
	const int brocheBO = A1;
	void setup() {
	// deux sorties pour contrôler l'entrée du 74LS193
	pinMode(brocheUP, OUTPUT);
	digitalWrite(brocheUP, HIGH);
	pinMode(brocheDOWN, OUTPUT);
	digitalWrite(brocheDOWN, HIGH);
	// 4 entrées pour lire les sorties du 74LS193.
	pinMode(brocheQA, INPUT);
	pinMode(brocheQB, INPUT);
	pinMode(brocheQC, INPUT);
	pinMode(brocheQD, INPUT);
	// 5 entrées pour régler la valeur du compteur
	pinMode(brocheLOAD, OUTPUT);
	digitalWrite(brocheLOAD, HIGH);
	pinMode(brocheA, OUTPUT);
	pinMode(brocheB, OUTPUT);
	pinMode(brocheC, OUTPUT);
	pinMode(brocheD, OUTPUT);
	// détection des débordements
	pinMode(brocheBO, INPUT);
	pinMode(brocheCO, INPUT);
	// affichage au moniteur série
	Serial.begin(9600);
	Serial.println("Test du compteur SN74LS193N");
	Serial.println("");
	}
	void loop() {
	// on effectue 25 additions
	Serial.println("25 sadditions");
	for (int i = 0; i <= 24; i++) {
	digitalWrite(brocheUP, LOW);
	if (!digitalRead(brocheCO)) {
	Serial.println("Ca deborde!");
	}
	digitalWrite(brocheUP, HIGH);
	affichage();
	delay(1000);
	}
	// on effectue 25 soustractions
	Serial.println("25 soustractions");
	for (int i = 0; i <= 24; i++) {
	digitalWrite(brocheDOWN, LOW);
	if (!digitalRead(brocheBO)) {
	Serial.println("Ca deborde!");
	}
	digitalWrite(brocheDOWN, HIGH);
	affichage();
	delay(1000);
	}
	}
	void affichage()
	{
	Serial.print("QD: ");
	Serial.print(digitalRead(brocheQD));
	Serial.print(" QC: ");
	Serial.print(digitalRead(brocheQC));
	Serial.print(" QB: ");
	Serial.print(digitalRead(brocheQB));
	Serial.print(" QA: ");
	Serial.println(digitalRead(brocheQA));
	}

view raw 74LS193_Test_3.ino hosted with ❤ by GitHub

Plusieurs compteurs en cascade

Grâce aux sorties CO et BO, il est facile de relier plusieurs compteurs en cascade. En reliant la sortie CO du premier compteur à l'entrée UP du deuxième, et en reliant la sortie BO du premier compteur à l'entrée DOWN du deuxième, vous obtenez un compteur binaire à 8 bits, capable de compter de 0 à 255.

Un circuit vintage, sans microcontrôleur

Évidemment, le 74LS193 peut être utilisé sans le moindre microcontrôleur.  Dans le circuit ci-dessous, les impulsions transmises à l'entrée UP du compteur sont générées par un timer 555 (en mode astable), et chacune des 4 sorties du compteur contrôle une LED.

Voici ce que ça donne:

Yves Pelletier   (Twitter, Facebook)

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 HMC5883 ----- 5V de l'Arduino
GND du module HMC5883 ---- GND de l'Arduino
SCL du module HMC5883 ---- A5 de l'Arduino Uno
SDA du module HMC5883 ----- A4 de l'Arduino Uno
RDY du module HMC5883 ---- pas connectée

Si vous utilisez plutôt une carte STM32, ESP32 ou ESP8266, cet article indique comment y brancher le module HMC5833.

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.

	/*****************************************************************
	Affichage dans le moniteur série des 3 composantes orthogonales
	du champ magnétique, tel que mesurées par le capteur HMC5883L.
	Basé sur l'exemple publié par Sparkfun:
	https://www.sparkfun.com/tutorials/301
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/06/fabrication-dune-boussole-avec-le.html
	******************************************************************/
	#include <Wire.h> // Bibliothèque pour i2c
	#define addresse 0x1E // Adresse i2c du capteur HMC5883
	// valeurs requises pour calibrer nos mesures (spécifique à votre module):
	const int calibration = 0; // régler à "1" pour calibrer vos mesures, "0" pour utiliser les mesures non-calibrées
	const int xmin = 0;
	const int xmax = 0;
	const int ymin = 0;
	const int ymax = 0;
	void setup() {
	Serial.begin(9600);
	Wire.begin();
	// Initialisation du HMC5883
	Wire.beginTransmission(addresse);
	Wire.write(0x02);
	Wire.write(0x00); // mode de mesure continue
	Wire.endTransmission();
	}
	void loop() {
	int xbrut, ybrut, zbrut, xcalibree, ycalibree;
	// On demande une prise de mesure
	Wire.beginTransmission(addresse);
	Wire.write(0x03);
	Wire.endTransmission();
	// Lecture des mesures
	Wire.requestFrom(addresse, 6);
	if (6 <= Wire.available()) {
	xbrut = Wire.read() << 8; //X msb
	xbrut |= Wire.read(); //X lsb
	zbrut = Wire.read() << 8; //Z msb
	zbrut |= Wire.read(); //Z lsb
	ybrut = Wire.read() << 8; //Y msb
	ybrut |= Wire.read(); //Y lsb
	}
	// calibration, si désirée:
	if (calibration) {
	xcalibree = map(xbrut, xmin, xmax, -1000, 1000);
	ycalibree = map(ybrut, ymin, ymax, -1000, 1000);
	// affichage au moniteur série
	Serial.print(xcalibree); Serial.print("\t");
	Serial.print(ycalibree); Serial.print("\t");
	Serial.println(zbrut);
	}
	else // on affiche les valeurs brutes
	{
	Serial.print(xbrut); Serial.print("\t");
	Serial.print(ybrut); Serial.print("\t");
	Serial.println(zbrut);
	}
	delay(250); // court délai pour ralentir un peu le processus
	}

view raw HMC5883_minimal.ino hosted with ❤ by GitHub

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:

	/*****************************************************************
	Affichage dans le moniteur série de la valeur maximale et de
	la valeur minimale des 3 composantes orthogonales
	du champ magnétique, tel que mesurées par le capteur HMC5883L.
	Utile pour calibrer le capteur.
	Basé sur l'exemple publié par Sparkfun:
	https://www.sparkfun.com/tutorials/301
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/06/fabrication-dune-boussole-avec-le.html
	******************************************************************/
	#include <Wire.h> // Bibliothèque pour i2c
	#define addresse 0x1E // Adresse i2c du capteur HMC5883
	int xmax, xmin, ymax, ymin, zmax, zmin;
	void setup() {
	Serial.begin(9600);
	Wire.begin();
	// Initialisation du HMC5883
	Wire.beginTransmission(addresse);
	Wire.write(0x02);
	Wire.write(0x00); // mode de mesure continue
	Wire.endTransmission();
	// On demande une prise de mesure
	Wire.beginTransmission(addresse);
	Wire.write(0x03);
	Wire.endTransmission();
	// Première lecture
	Wire.requestFrom(addresse, 6);
	if (6 <= Wire.available()) {
	xmin = Wire.read() << 8; //X msb
	xmin |= Wire.read(); //X lsb
	zmin = Wire.read() << 8; //Z msb
	zmin |= Wire.read(); //Z lsb
	ymin = Wire.read() << 8; //Y msb
	ymin |= Wire.read(); //Y lsb
	}
	xmax = xmin;
	ymax = ymin;
	zmax = zmin;
	}
	void loop() {
	int xbrut, ybrut, zbrut;
	// On demande une prise de mesure
	Wire.beginTransmission(addresse);
	Wire.write(0x03);
	Wire.endTransmission();
	// Lecture des mesures
	Wire.requestFrom(addresse, 6);
	if (6 <= Wire.available()) {
	xbrut = Wire.read() << 8; //X msb
	xbrut |= Wire.read(); //X lsb
	zbrut = Wire.read() << 8; //Z msb
	zbrut |= Wire.read(); //Z lsb
	ybrut = Wire.read() << 8; //Y msb
	ybrut |= Wire.read(); //Y lsb
	}
	// si une valeur qu'on vient de mesurer est plus petite ou plus grande que toutes
	// les autres, on la conserve.
	if (xbrut < xmin) {
	xmin = xbrut;
	}
	if (xbrut > xmax) {
	xmax = xbrut;
	}
	if (ybrut < ymin) {
	ymin = ybrut;
	}
	if (ybrut > ymax) {
	ymax = ybrut;
	}
	if (zbrut < zmin) {
	zmin = zbrut;
	}
	if (zbrut > zmax) {
	zmax = zbrut;
	}
	//Affichage des valeurs min et max:
	Serial.print("xmin: ");
	Serial.print(xmin);
	Serial.print(" xmax: ");
	Serial.print(xmax);
	Serial.print(" ymin: ");
	Serial.print(ymin);
	Serial.print(" ymax: ");
	Serial.print(ymax);
	Serial.print(" zmin: ");
	Serial.print(zmin);
	Serial.print(" zmax: ");
	Serial.println(zmax);
	delay(250);
	}

view raw HMC5883_calibration.ino hosted with ❤ by GitHub

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".

	/**********************************************************
	Boussole constituée d'un Arduino, d'un magnétomètre
	HMC5883 et d'un écran LCD Nokia.
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/06/fabrication-dune-boussole-avec-le.html
	***********************************************************/
	#include <Wire.h> // i2c pour le capteur HMC5883
	#define adresse 0x1E // Adresse i2c du capteur HMC5883
	// bibliothèques pour l'écran LCD Nokia
	#include <SPI.h>
	#include <Adafruit_GFX.h>
	#include <Adafruit_PCD8544.h>
	// valeurs requises pour calibrer nos mesures (spécifique à votre module):
	const int xmin = -564;
	const int xmax = -62;
	const int ymin = -277;
	const int ymax = 254;
	// Pour pointer vers le nord géographique plutôt que vers
	// le nord magnétique, on additionne la déclinaison, qui dépend
	// de l'endroit où vous êtes:
	// http://www.magnetic-declination.com/
	float declinaison = 0.22; // en radians
	Adafruit_PCD8544 display = Adafruit_PCD8544(5, 4, 3);
	// D/C broche 5,CSE ou CS broche 4, RST broche 3
	const int rayon = 20; //rayon du cercle en pixels, sur l'afficheur LCD
	void setup(void)
	{
	// initialiation du capteur HMC5883
	Wire.begin();
	Wire.beginTransmission(adresse);
	Wire.write(0x02);
	Wire.write(0x00);
	Wire.endTransmission();
	// initialisation de l'afficheur
	display.begin();
	display.setContrast(60); // réglage du contraste (40-60) variable selon votre écran
	display.clearDisplay();
	}
	void loop(void)
	{
	int xbrut, ybrut, zbrut, xcalibree, ycalibree;
	// On demande les informations au capteur HMC5883
	Wire.beginTransmission(adresse);
	Wire.write(0x03); //select register 3, X MSB register
	Wire.endTransmission();
	//Lecture des composantes du champ magnétique
	Wire.requestFrom(adresse, 6);
	if (6 <= Wire.available()) {
	xbrut = Wire.read() << 8; //X msb
	xbrut |= Wire.read(); //X lsb
	zbrut = Wire.read() << 8; //Z msb
	zbrut |= Wire.read(); //Z lsb
	ybrut = Wire.read() << 8; //Y msb
	ybrut |= Wire.read(); //Y lsb
	}
	// valeurs calibrées:
	xcalibree = map(xbrut, xmin, xmax, -1000, 1000);
	ycalibree = map(ybrut, ymin, ymax, -1000, 1000);
	// Calcul de l'angle entre le nord magnétique et l'axe x du capteur
	float orientationNord = atan2(ycalibree, xcalibree);
	// Pour pointer vers le nord géographique plutôt que vers
	// le nord magnétique, on additionne la déclinaison
	orientationNord += declinaison;
	// on dessine la flèche à l'angle approprié sur l'afficheur LCD
	display.clearDisplay();
	display.drawCircle(display.width() / 2, display.height() / 2, rayon, BLACK); // contour d'un cercle
	display.drawLine(display.width() / 2, display.height() / 2, display.width() / 2 + rayon * cos(orientationNord) , display.height() / 2 - rayon * sin(orientationNord), BLACK);
	display.display();
	delay(50);
	}

view raw HMC5883_boussole.ino hosted with ❤ by GitHub

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   (Twitter, Facebook)

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).

	/*******************************************************
	Contrôles de 6 LEDs, chacune étant branchée
	à sa propre sortie de l'Arduino.
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/06/controler-plusieurs-leds-avec-arduino.html
	*******************************************************/
	#define BROCHE_A 3
	#define BROCHE_B 4
	#define BROCHE_C 5
	#define BROCHE_D 6
	#define BROCHE_E 7
	#define BROCHE_F 8
	const int nombre_de_motifs = 12;
	// état de chaque LED, pour 12 motifs différents
	const int motif[nombre_de_motifs][6] = {{1, 0, 0, 0, 0, 0}, {0, 1, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0},
	{0, 0, 0, 1, 0, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 0, 1},
	{1, 1, 0, 0, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 0, 0, 0, 1, 1},
	{1, 0, 1, 0, 1, 0}, {0, 1, 0, 1, 0, 1}, {1, 1, 1, 1, 1, 1}
	};
	int etat = 0; // numéro du motif actuellement affiché
	const long intervalle = 500; // temps écoulé avant de changer de motif
	void setup() {
	// les 6 broches sont des sorties
	pinMode(BROCHE_A, OUTPUT);
	pinMode(BROCHE_B, OUTPUT);
	pinMode(BROCHE_C, OUTPUT);
	pinMode(BROCHE_D, OUTPUT);
	pinMode(BROCHE_E, OUTPUT);
	pinMode(BROCHE_F, OUTPUT);
	}
	void loop() {
	// on allume ou éteint chacune des 6 LEDs, selon les information du tableau "motif"
	digitalWrite(BROCHE_A, motif[etat][0]);
	digitalWrite(BROCHE_B, motif[etat][1]);
	digitalWrite(BROCHE_C, motif[etat][2]);
	digitalWrite(BROCHE_D, motif[etat][3]);
	digitalWrite(BROCHE_E, motif[etat][4]);
	digitalWrite(BROCHE_F, motif[etat][5]);
	delay(intervalle); // on attend 0,5 seconde...
	etat++; // ... et on change de motif
	if (etat == nombre_de_motifs) {
	etat = 0;
	}
	}

view raw Six_LEDs_trad.ino hosted with ❤ by GitHub

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.

	/*******************************************************
	Démonstration de multiplexing
	5 sorties, 6 LEDs
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/06/controler-plusieurs-leds-avec-arduino.html
	********************************************************/
	// définition des broches de l'Arduino utilisées pouir contrôler les LEDs
	#define BROCHE_A 3
	#define BROCHE_B 4
	#define BROCHE_C 5
	#define BROCHE_D 6
	#define BROCHE_E 7
	const int nombre_de_motifs = 12;
	// état de chaque LED, pour 12 motifs différents
	const int motif[nombre_de_motifs][6] = {{1, 0, 0, 0, 0, 0}, {0, 1, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0},
	{0, 0, 0, 1, 0, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 0, 1},
	{1, 1, 0, 0, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 0, 0, 0, 1, 1},
	{1, 0, 1, 0, 1, 0}, {0, 1, 0, 1, 0, 1}, {1, 1, 1, 1, 1, 1}
	};
	int etat = 0; // numéro du motif actuellement affiché
	unsigned long avant = 0; // plus récent changement de motif
	const long intervalle = 500; // temps écoulé avant de changer de motif
	void setup()
	{
	// toutes les broches seront des sorties
	pinMode(BROCHE_A, OUTPUT);
	pinMode(BROCHE_B, OUTPUT);
	pinMode(BROCHE_C, OUTPUT);
	pinMode(BROCHE_D, OUTPUT);
	pinMode(BROCHE_E, OUTPUT);
	efface_tout();
	}
	void loop()
	{
	// réglage de chacune des 6 LEDs, une après l'autre
	for (int i = 1; i <= 6; i++)
	{
	if (motif[etat][i - 1] == 1) {
	reglage_led(i);
	}
	else {
	efface_tout(); // pour que l'intensité lumineuse ne dépende pas du nombre de LEDs allumées
	}
	}
	// on vérifie si le temps est venu de changer de motif:
	unsigned long maintenant = millis();
	if (maintenant - avant >= intervalle) {
	avant = maintenant;
	etat++;
	if (etat == nombre_de_motifs) {
	etat = 0;
	}
	}
	}
	void efface_tout() // on met les broches dans l'état où tout est éteint
	{
	digitalWrite(BROCHE_A, LOW);
	digitalWrite(BROCHE_B, LOW);
	digitalWrite(BROCHE_C, HIGH);
	digitalWrite(BROCHE_D, HIGH);
	digitalWrite(BROCHE_E, HIGH);
	}
	void reglage_led(int numero)
	{
	efface_tout(); // on éteint la LED précédente, s'il y a lieu
	switch (numero)
	{
	case 1:
	digitalWrite(BROCHE_A, HIGH);
	digitalWrite(BROCHE_C, LOW);
	break;
	case 2:
	digitalWrite(BROCHE_B, HIGH);
	digitalWrite(BROCHE_C, LOW);
	break;
	case 3:
	digitalWrite(BROCHE_A, HIGH);
	digitalWrite(BROCHE_D, LOW);
	break;
	case 4:
	digitalWrite(BROCHE_B, HIGH);
	digitalWrite(BROCHE_D, LOW);
	break;
	case 5:
	digitalWrite(BROCHE_A, HIGH);
	digitalWrite(BROCHE_E, LOW);
	break;
	case 6:
	digitalWrite(BROCHE_B, HIGH);
	digitalWrite(BROCHE_E, LOW);
	break;
	}
	}

view raw Six_LEDs_multiplex.ino hosted with ❤ by GitHub

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.

	/*****************************************
	Démonstration de Charlieplexing
	3 sorties, 6 LEDs
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/06/controler-plusieurs-leds-avec-arduino.html
	******************************************/
	// déclaration des 3 broches de l'Arduino utilisées pour
	// contrôler les 6 LEDs
	#define BROCHE_A 3
	#define BROCHE_B 4
	#define BROCHE_C 5
	const int nombre_de_motifs = 12;
	// état de chaque LED, pour 12 motifs différents
	const int motif[nombre_de_motifs][6] = {{1, 0, 0, 0, 0, 0}, {0, 1, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0},
	{0, 0, 0, 1, 0, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 0, 1},
	{1, 1, 0, 0, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 0, 0, 0, 1, 1},
	{1, 0, 1, 0, 1, 0}, {0, 1, 0, 1, 0, 1}, {1, 1, 1, 1, 1, 1}
	};
	int etat = 0; // numéro du motif actuellement affiché
	unsigned long avant = 0; // plus récent changement de motif
	const long intervalle = 500; // temps écoulé avant de changer de motif
	void setup()
	{
	efface_tout();
	}
	void loop()
	{
	// réglage de chacune des 6 LEDs, une après l'autre
	for (int i = 1; i <= 6; i++)
	{
	if (motif[etat][i - 1] == 1) {
	reglage_led(i);
	}
	else {
	efface_tout(); // pour que l'intensité lumineuse ne dépende pas du nombre de LEDs allumées
	}
	}
	// on vérifie si le temps est venu de changer de motif:
	unsigned long maintenant = millis();
	if (maintenant - avant >= intervalle) {
	avant = maintenant;
	etat++;
	if (etat == nombre_de_motifs) {
	etat = 0;
	}
	}
	}
	void efface_tout() // on met les broches dans l'état où tout est éteint
	{
	pinMode(BROCHE_A, INPUT);
	pinMode(BROCHE_B, INPUT);
	pinMode(BROCHE_C, INPUT);
	}
	void reglage_broches(int anode, int cathode)
	{
	efface_tout(); // on éteint la LED précédente, s'il y a lieu
	pinMode(anode, OUTPUT);
	digitalWrite(anode, HIGH);
	digitalWrite(cathode, LOW);
	pinMode(cathode, OUTPUT);
	}
	void reglage_led(int numero)
	{
	switch (numero)
	{
	case 1:
	reglage_broches(BROCHE_B, BROCHE_A);
	break;
	case 2:
	reglage_broches(BROCHE_A, BROCHE_B);
	break;
	case 3:
	reglage_broches(BROCHE_C, BROCHE_B);
	break;
	case 4:
	reglage_broches(BROCHE_B, BROCHE_C);
	break;
	case 5:
	reglage_broches(BROCHE_C, BROCHE_A);
	break;
	case 6:
	reglage_broches(BROCHE_A, BROCHE_C);
	break;
	}
	}

view raw Six_LEDs_charlieplexing.ino hosted with ❤ by GitHub

Yves Pelletier   (Twitter, Facebook)

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.

	/**************************************************************************
	Ajout de 8 entrées analogiques à l'ESP8266 grâce à un MPC3008.
	Utilise la bibliothèque MCP3008 par Uros Petrevski, Nodesign.net 2013:
	https://github.com/nodesign/MCP3008
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/06/ajout-de-8-entrees-analogiques-lesp8266.html
	**************************************************************************/
	#include <MCP3008.h>
	// définition des broches utilisées
	#define CLK_PIN 14 // broche 13 (CLK) du MCP3008 branchée à GPIO 14 de l'ESP8266
	#define DIN_PIN 13 // broche 11 (DIN) du MCP3008 branchée à GPIO 13 de l'ESP8266
	#define DOUT_PIN 12 // broche 12 (DOUT) du MCP3008 branchée à GPIO 12 de l'ESP8266
	#define CS_PIN 15 // broche 10 (CS) du MCP3008 branchée à GPIO 15 de l'ESP8266
	MCP3008 adc(CLK_PIN, DIN_PIN, DOUT_PIN, CS_PIN);
	void setup() {
	Serial.begin(9600); // pour affichage des valeurs mensurées
	}
	void loop() {
	int mesure = adc.readADC(0); // lecture du canal 0 (broche 1) du MCP3008
	Serial.println(mesure); // affichage dans le moniteur série
	delay(500); // on ralentit un peu l'affichage des mesures, pour avoir le temps de les lire...
	}

view raw ESP8266_MCP3008.ino hosted with ❤ by GitHub

Yves Pelletier   (Twitter, Facebook)

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   (Twitter, Facebook)

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   (Twitter, Facebook)