Accéléromètre/gyro MPU-6050 et Arduino

Amusons-nous un peu avec un accéléromètre MPU-6050 et un Arduino Uno.

Le MPU-6050 est une centrale inertielle qui combine un accéléromètre et un gyromètre, ce qui permet de mesurer son accélération ou son inclinaison.

Connexions à l'Arduino

Le module MPU-6050 communique en I2C, et les connexions seront donc:

• VCC du MPU-6050: 5 V de l'Arduino*
• GND du MPU-6050: GND de l'Arduino
• SCL du MPU-6050: A5 de l'Arduino
• SDA du MPU-6050: A4 de l'Arduino

*: mon module comporte un régulateur de tension, sinon je l'aurais plutôt branché à 3,3 V.

Je n'ai pas utilisé les autres broches du module MPU-6050 (XDA, XCL, AD0 et INT).

Installation de la bibliothèque

J'ai eu peu de succès avec la bibliothèque de Jeff Rowberg, malgré son excellente réputation: j'obtenais de fréquents "FIFO overflows", et le sketch s'arrêtait de façon intempestive au bout de quelques secondes.

J'ai donc choisi d'utiliser la bibliothèque MPU6050_tockn, également disponible par l'entremise du gestionnaire de bibliothèques de l'IDE Arduino.

Les deux exemples fournis avec la bibliothèque, "GetAllData" et "GetAngle" permettent de vérifier rapidement le fonctionnement correct de l'accéléromètre et d'explorer les données disponibles.

Au démarrage du programme, il faut laisser le MPU-6050 immobile pendant la procédure de calibration.  Différents paramètres sont ensuite affichés dans le moniteur série à chaque seconde.

Une alarme qui retentit quand on bouge le dispositif

Lorsque le MPU-6050 est parfaitement immobile, l'accélération mesurée est de 1 g selon l'axe vertical (c'est causé par la force de gravité). Le sketch ci-dessous active un buzzer piézoélectrique aussitôt que l'accélération mesurée selon n'importe lequel des 3 axes devient supérieure à 1 g.

(N.B.: il s'agit d'un buzzer actif, muni d'un oscillateur interne, qui émet un son aussitôt qu'il est alimenté; il est évidemment possible de modifier le sketch afin d'utiliser un buzzer passif).

Quelques secondes après le démarrage du programme, le buzzer émet un bip pour indiquer que la calibration de l'accéléromètre est terminée.

	/*
	Un objet qui fait beep quand on le secoue.
	Arduino Uno, accéléromètre MPU-6050 et buzzer.
	Pour plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/09/accelerometregyro-mpu-6050-et-arduino.html
	*/
	#include <MPU6050_tockn.h>
	#include <Wire.h>
	MPU6050 mpu6050(Wire);
	long timer = 0;
	float acceleration = 0;
	void setup() {
	Serial.begin(9600);
	pinMode(7, OUTPUT);
	digitalWrite(7, LOW);
	Wire.begin();
	mpu6050.begin();
	mpu6050.calcGyroOffsets(true);
	// un petit bip pour indiquer que l'accéléromètre est prèt
	digitalWrite(7, HIGH);
	delay(200);
	digitalWrite(7,LOW);
	}
	void loop() {
	mpu6050.update();
	acceleration = max(acceleration, abs(mpu6050.getAccX()));
	acceleration = max(acceleration, abs(mpu6050.getAccY()));
	acceleration = max(acceleration, abs(mpu6050.getAccZ()));
	if (acceleration > 1) {
	digitalWrite(7, HIGH);
	}
	else {
	digitalWrite(7, LOW);
	}
	acceleration = 0;
	}

view raw MPU6050_alarme.ino hosted with ❤ by GitHub

Une alarme qui retentit quand le dispositif est en chute libre

Si leMPU-6050 est en chute libre, l'accélération mesurée devient nulle. Une minuscule modification au sketch précédent permet d'obtenir un dispositif qui émet un son pendant qu'il tombe.

	/*
	Un objet qui fait beep quand il est en chute libre.
	Arduino Uno, accéléromètre MPU-6050 et buzzer.
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/09/accelerometregyro-mpu-6050-et-arduino.html
	*/
	#include <MPU6050_tockn.h>
	#include <Wire.h>
	MPU6050 mpu6050(Wire);
	long timer = 0;
	float acceleration = 0;
	void setup() {
	Serial.begin(9600);
	pinMode(7, OUTPUT);
	digitalWrite(7, LOW);
	Wire.begin();
	mpu6050.begin();
	mpu6050.calcGyroOffsets(true);
	// un petit bip pour indiquer que l'accéléromètre est prèt
	digitalWrite(7, HIGH);
	delay(200);
	digitalWrite(7,LOW);
	}
	void loop() {
	mpu6050.update();
	acceleration = max(acceleration, abs(mpu6050.getAccX()));
	acceleration = max(acceleration, abs(mpu6050.getAccY()));
	acceleration = max(acceleration, abs(mpu6050.getAccZ()));
	if (acceleration < 0.5) {
	digitalWrite(7, HIGH);
	}
	else {
	digitalWrite(7, LOW);
	}
	acceleration = 0;
	}

view raw MPU6050_chute_libre.ino hosted with ❤ by GitHub

Une ligne qui demeure obstinément horizontale

Finalement, je me suis amusé à afficher sur un écran OLED SH1106 une ligne qui demeure obstinément horizontale même lorsqu'on incline l'écran.

L'écran et le MPU-6050 partagent la liaison I2C. Par contre, l'écran OLED est alimenté avec 3,3 V.

	/*****************************************************
	Une droite tracée sur un écran OLED demeure obstinément
	horizontale même si on penche le dispositif.
	(Arduino Uno, accéléromètre MPU-6050 et écran OLED SH1106)
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/09/accelerometregyro-mpu-6050-et-arduino.html
	*****************************************************/
	#include <Wire.h>
	#include <MPU6050_tockn.h>
	#include <Adafruit_GFX.h>
	#include <Adafruit_SH1106.h>
	MPU6050 mpu6050(Wire);
	Adafruit_SH1106 display(23);
	void setup() {
	Serial.begin(9600);
	display.begin();
	display.setTextColor(WHITE);
	display.clearDisplay();
	display.setCursor(10, 15);
	display.println("Calibration de");
	display.setCursor(10, 25);
	display.println("l'accelerometre");
	display.setCursor(10, 40);
	display.println("Ne pas bouger.");
	display.display();
	mpu6050.begin();
	mpu6050.calcGyroOffsets(true);
	}
	void loop() {
	float angle;
	mpu6050.update();
	angle = mpu6050.getAngleZ();
	Serial.print("angleX : ");
	Serial.println(angle);
	angle = angle * PI / 180.0;
	display.clearDisplay();
	display.drawLine(64 + 60.0 * cos(angle), 32 + 60.0 * sin(angle), 64 - 60.0 * cos(angle), 32 - 60.0 * sin(angle), WHITE);
	display.display();
	delay(50);
	}

view raw MPU6050_OLED_horizon.ino hosted with ❤ by GitHub

Articles similaires

Il y a quelques années, j'avais fait quelques expériences avec un accéléromètre MMA7455: secouons cet accéléromètre!,  une boîte qui crie quand elle tombe et mesure d'un angle d'inclinaison.

Yves Pelletier   (Twitter, Facebook)

Analyse d'une communication UART

On peut probablement passer des années à utiliser l'UART de l'Arduino de façon routinière sans savoir exactement ce qui se passe sous le capot. Dans ce billet, je m'amuse à observer le contenu d'un message UART.

Tout comme SPI et I2C, l'UART est un mode de communication série, ce qui signifie que les données sont acheminées l'une à la suite de l'autre sur une même broche du microcontrôleur.

La transmission UART implique 2 broches en plus de la masse (GND): TX pour la transmission, et RX pour la réception.  Sur un Arduino Uno, la broche numéro 0 reçoit les données (RX) alors que la broche numéro 1 est émettrice (TX). Le TX d'un des appareils impliqués dans la communication est toujours relié au RX de l'autre appareil.

Avec Arduino, vous utilisez l'UART chaque fois que vous faites appel à la classe Serial: Serial.print, Serial.println, Serial.read, etc. Typiquement, on l'utilise pour la communication entre un microcontrôleur et un ordinateur, ou entre plusieurs microcontrôleurs. Le protocole MIDI, beaucoup utilisé en musique, est une liaison UART à 31250 bauds.

Le sigle UART signifie "Universal Asynchronous Receiver Transmitter": le protocole permet donc d'émettre et de recevoir des données de façon asynchrone.  "Asynchrone" signifie qu'il n'existe pas de signal d'horloge commun partagé par l'émetteur et le récepteur, d'où la nécessité de régler l'émetteur et le récepteur à une même vitesse de transmission. Par exemple, lorsque votre sketch Arduino commence par Serial.begin(9600), vous réglez la vitesse de l'UART à 9600 bauds du côté Arduino, ce qui vous oblige à régler le moniteur série, du côté ordinateur, à 9600 bauds également.

Pour observer des messages UART, j'ai branché un analyseur logique à la broche TX d'un Arduino Uno, et j'ai visualisé les résultats sur le logiciel Sigrok PulseView.

Le sketch ne surprendra personne: je règle la vitesse de la communication à 9600 bauds, et j'envoie le message A, suivi d'un court délai pour m'aider à mieux distinguer l'émission de deux messages distincts.

Voici ce que me présente l'analyseur logique lors de l'émission de ce message:

Pendant qu'aucun message n'est transmis, la broche TX est au niveau logique haut. Un message UART commence toujours par un bit de départ (start) de niveau logique bas afin d'annoncer le début d'un message.

Le bit de départ est suivi d'une succession de 8 bits qui constituent le message proprement dit. Dans ce cas, ces 8 bits sont 1, 0, 0, 0, 0, 0, 1, et 0. Puisque le message débute par le bit de poids faible et se termine par le bit de poids fort, le résultat correspond au nombre binaire 01000001, ou 65 en décimal, soit le code ASCII de la lettre "A".

Le message se termine par un bit de fin (stop) de niveau logique haut. La broche demeure ensuite au niveau logique haut jusqu'à l'émission du prochain message.

Vous pouvez constater qu'il n'y a aucune frontière visible entre l'émission de deux bits consécutifs identiques; c'est la raison pour laquelle il est important que l'émetteur et le récepteur soient réglés à la même vitesse. Avec une transmission à 9600 bauds, chaque bit dure environ 100 µs (1/9600).

Si je double la vitesse de transmission pour qu'elle soit de 19200 bauds, la durée de chaque bit sera plutôt de 1/19200, donc environ 50 µs:

Si j'envoie un message constitué de plusieurs caractères, chacun des caractères est accompagné par son bit de départ et son bit de fin. Ici, j'ai envoyé le message "OK":

Cette fois, le message est constitué d'un bit de départ, de 8 bits correspondant au nombre binaire 01001111 (ou 79 en décimal, le code ASCII pour le caractère O), d'un bit de fin, d'un deuxième bit de départ, de 8 bits correspondant au nombre binaire 01001011 (ou 75 en décimal, correspondant au code ASCII pour le caractère "K"), et d'un dernier bit de fin.

Modifier les paramètres par défaut

Par défaut, la communication UART de l'Arduino est réglée à 8 bits de données, pas de parité et un bit "stop", mais il est possible de modifier ces paramètres en ajoutant un deuxième paramètre à la fonction Serial.begin().

Quelques exemples:

• Serial.begin(9600, SERIAL_5N1) règle la vitesse de transmission à 9600 bauds, avec 5 bits de données, pas de parité, et un bit stop.

• Serial.begin(4800, SERIAL_7N2) règle la vitesse de transmission à 4800 bauds, avec 7 bits de données, pas de parité, et 2 bits stop.

• Serial.begin(19200, SERIAL_8E1) règle la vitesse de transmission à 19200 bauds, avec 8 bits de données, parité paire ("even")  et un bit stop.

• Serial.begin(115200, SERIAL_8O2) règle la vitesse de transmission à 115200 bauds, avec 8 bits de données, parité impaire ("odd"), et 2 bits stop.

(Voir cette page pour tous les cas possibles.)

Parité

Le bit de parité est un bit optionnel qui peut être ajouté entre les bits de données et le bit stop afin de vérifier sommairement que l'intégrité du message a été correctement transmise. La parité peut être paire ou impaire.

Le sketch ci-dessous envoie le symbole "a" avec un bit de parité paire:

Voici le résultat:

Le bit start est suivi du nombre binaire 01100001 (ou 97 qui est le code ASCII pour "a"), du bit de parité (1), puis du bit stop.

Lorsque la parité est paire, le bit de parité prend la valeur nécessaire pour que le nombre total de bits qui sont au niveau logique haut soit paire. Dans cet exemple, si vous comptez le nombre de "1" dans le message "01100001", vous obtenez 3, qui est un chiffre impair. Puisque nous avons réglé la parité pour qu'elle soit paire, le bit de parité a pris la valeur "1" afin que le total 3 + 1 donne un résultat pair.

Voici un deuxième exemple, toujours avec une parité paire, sauf que le message est maintenant la lettre "c":

Cette fois, le bit de parité est au niveau logique bas, car le message correspondant à la lettre "c" est 01100011, qui comporte 4 bits au niveau logique haut. Ce nombre étant déjà paire, on lui additionne un bit de parité ayant la valeur "0" afin que le total demeure paire.

Comme vous pouvez le deviner, ce sera le contraire si j'envoie les mêmes messages avec un bit de parité impaire:

Si le message est "a", le bit de parité est au niveau logique bas, afin que le total des bits de niveau haut soit impair: 1 + 1 + 1 + 0 = 3:

Si le message est "c", le bit de parité est au niveau logique haut, afin que le total des bits de niveau haut soit impair:  1 + 1 + 1 + 1 + 1 = 5:

À lire également

D'autres types de communication série ont également été abordés: Analyse d'une communication SPI et analyse d'une communication I²C.

Yves Pelletier   (Twitter, Facebook)

Jouer une mélodie avec l'ESP32

La façon la plus simple de jouer une mélodie avec un Arduino, ou même avec un ESP8266, est d'utiliser la fonction "tone", qui permet de produire sur une broche un signal carré de la fréquence de notre choix.

La fonction "tone", toutefois, ne fonctionne pas avec l'ESP32.

Le billet d'aujourd'hui consistera donc à jouer une mélodie simple au moyen de l'ESP32, malgré l'absence de la fonction "tone". Pour ce faire, nous produirons un signal PWM dont nous ferons varier la fréquence. Si vous ne vous y connaissez pas trop en production d'un signal PWM avec l'ESP32, la lecture de ce précédent article pourrait vous être utile.

Circuit

Presque toutes les broches de l'ESP32 peuvent servir à produire un signal PẀM, nous avons donc l'embarras du choix. J'ai choisi, tout à fait arbitrairement, la broche GPIO 4.

Pour transformer en onde sonore les impulsions électriques générées par cette broche, vous pouvez utiliser un buzzer piézoélectrique ou un haut-parleur.

Nous ne le répéterons jamais assez: contrairement au buzzer piézoélectrique (qui a une grande résistance), ce n'est pas une bonne idée de brancher un haut-parleur directement à la sortie d'un microcontrôleur, à cause de sa très faible résistance. On utilise plutôt un transistor comme intermédiaire.

Sketch

Dans le sketch ci-dessous, une mélodie est définie au moyen d'un tableau "melodie" qui contient la hauteur de chaque note (do, ré, mi...), le numéro de l'octave et la durée.

Au début du programme, la broche GPIO 4 est associée au canal PWM numéro 0 (ledcAttachPin).

Pendant l'exécution de la mélodie, la fréquence du canal PWM 0 est réglée à la valeur adéquate (ledcSetup) et on démarre un signal PWM dont le rapport cyclique est de 50% (ledcWrite).

Pour mieux séparer les notes les unes des autres, un très bref moment de silence est inséré à la fin de chaque note (le rapport cyclique est réglé à 0).

	/*
	L'ESP32 joue une mélodie sur sa broche GPIO4
	grâce à un signal PWM dont on varie la fréquence.
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/09/jouer-une-melodie-avec-lesp32.html
	*/
	const int brocheSortie = 4;
	// fréquence associée à chaque note
	// do, do#, ré, ré#, mi, fa, fa#, sol, sol#, la, la#, si
	const float note[12] = {65.41, 69.30, 73.42, 77.78, 82.41, 87.31, 92.50, 98.00, 103.83, 110.00, 116.54, 123.47
	};
	const int nombreDeNotes = 32;
	const int tempo = 150; // plus c'est petit, plus c'est rapide
	const int melodie[][3] = { {4, 2, 2}, {5, 2, 1}, {7, 2, 3}, {0, 3, 6},
	{2, 2, 2}, {4, 2, 1},{5, 2, 8},
	{7, 2, 2}, {9, 2, 1}, {11, 2, 3}, {5, 3, 6},
	{9, 2, 2}, {11, 2, 1}, {0, 3, 3}, {2, 3, 3}, {4, 3, 3},
	{4, 2, 2}, {5, 2, 1}, {7, 2, 3}, {0, 3, 6},
	{2, 3, 2}, {4, 3, 1},{5, 3, 8},
	{7, 2, 2}, {7, 2, 1}, {4, 3, 3}, {2, 3, 2},
	{7, 2, 1}, {5, 3, 3}, {4, 3, 2}, {2, 3, 1},{0, 3, 8}
	};
	void setup() {
	ledcAttachPin(brocheSortie, 0); //broche 18 associée au canal PWM 0
	}
	void loop() {
	int frequence;
	for ( int i = 0; i < nombreDeNotes ; i++ ) {
	frequence = round(note[melodie[i][0]] * 2.0 * (melodie[i][1] - 1));
	ledcSetup(0, frequence, 12);
	ledcWrite(0, 2048); // rapport cyclique 50%
	delay(tempo * melodie[i][2] - 50);
	ledcWrite(0, 0); // rapport cyclique 0% (silence, pour séparer les notes adjacentes)
	delay(50);
	}
	delay(2000);
	}

view raw ESP32_melodie.ino hosted with ❤ by GitHub

Résultat:

Pour finir, une courte vidéo de l'ESP32 en action...

Articles similaires

D'autres articles publiés dans ce blog expliquent comment jouer une mélodie avec un Arduino,  un STM32 Nucleo,  un  ATTiny85, ou un microcontrôleur PIC.

Vous pouvez également consulter la liste des billets impliquant l'ESP32.

Yves Pelletier   (Twitter, Facebook)

Dans un blog près de chez vous...(6)

Ça faisait longtemps...

RitonDuino

• XR2206 : le générateur de fonctions
• LNK304 : Alimentation à Découpage 120mA
• Chargeur de batterie NI-MH
• Un Logger Analogique et Digital
• Alimentations sans transformateur
• Soudure d'un microcontrôleur CMS
• Montage et chargement d'un ATMEGA328P
• Un télérupteur MYSENSORS pour rail DIN
• L'utilisation des Condensateurs

Arduiblog

• Découverte du Raspberry Pi 4
• Refroidissez votre Raspberry Pi 4
• Commandez votre cafetière avec le Micro:Bit

Framboise 314

• Installer la dernière version de wiringpi sur Raspbian Buster
• Refroidir en silence le Raspberry Pi 4 avec VentilaPi4 de Garatronic
• Un cluster de Raspberry Pi avec Kubernetes
• Une horloge avec le Raspberry Pi et Pi Juice
• ClignoDroïd un Simon pour Raspberry Pi
• Un indicateur de charge CPU/RAM à LED pour le Raspberry Pi

Raspbian-France:

• Allumer et éteindre une LED avec la Raspberry Pi et Python
• Utiliser un lecteur RFID avec la Raspberry Pi
• Acheter la Raspberry Pi 4 et ses accessoires, les pièges à éviter

Letmeknow

• Les sleep modes de l’ESP32
• Pilotage de moteur triphasé à faible vitesse
• Programmation d’un ESP32 Basic Over The Air (OTA) avec l’IDE arduino
• Mode sommeil sur Trinket

IDEHack

• Créer un objet connecté – Détecteur de mouvement avec notification
• Comment utiliser un écran OLED 124x32 I2C avec Arduino
• Configurer l'écran 3.5" TFT LCD touch screen avec le Raspberry Pi
• Capteur de mouvement PIR Arduino – HC SR501
• L’ESP32-CAM et l’Arduino IDE – Une camera IP Wifi

MCHobby

• Ventilapi4 - Refroidir son Pi avec un ventilateur silencieux
• Brochage de cartes:  Micropython Piboard, Micropython Piboard-D, Micropython WBus-Dip28
• Récupération de matériel sur une HP3015
• Alimentation de laboratoire LABPS23023
• BMPReader: classe de lecture de fichier bitmap sous micropython

Framboise au potager

• L'ESP8266 et ThingSpeak pour tracer la courbe de décharge d'un accu
• Suivi des charges et tensions avec un microcontrôleur

Félix Popineau

• Éclairage bas de porte Golf 6 avec logo VW

Bonne lecture!

Yves Pelletier   (Twitter, Facebook)

Écran OLED SH1106 I2C et ESP32 ou ESP8266

Aujourd'hui, explorons comment écrire et dessiner sur un petit écran OLED monochrome branché à une carte ESP32 ou ESP8266.

L'écran en question a une taille de 1,3 pouce (environ 3,5 cm X 1,8 cm) et une résolution de 128 X 64 pixels. Il est basé sur le contrôleur SH1106 et utilise le protocole I2C. L'image produite est blanche sur fond noir.

Cet billet pourrait possiblement vous être utile même si vous utilisez un écran différent de celui que j'ai utilisé, puisque la bibliothèque u8g2 est compatible avec un très grand nombre de modèles d'écrans monochromes.

Connexions de l'afficheur à l'ESP32

• Broche GND de l'afficheur - Broche GND de l'ESP32
• Broche VCC de l'afficheur - Broche 3V3 de l'ESP32
• Broche SCL de l'afficheur - Broche GPIO 22 de l'ESP32
• Broche SDA de l'afficheur - Broche GPIO 21 de l'ESP32

Connexions de l'afficheur à l'ESP8266

• Broche GND de l'afficheur - Broche GND de l'ESP8266
• Broche VCC de l'afficheur - Broche 3V3 de l'ESP8266
• Broche SCL de l'afficheur - Broche GPIO 5 de l'ESP8266
• Broche SDA de l'afficheur - Broche GPIO 4 de l'ESP8266

Installation de la bibliothèque u8g2

Nous utiliserons la bibliothèque u8g2, qui peut facilement être installée depuis le gestionnaire de bibliothèques de l'IDE Arduino.

Essai des exemples fournis avec la bibliothèque

Évidemment, plusieurs exemples sont fournis avec la bibliothèque. Cependant, puisque la bibliothèque supporte plusieurs modèles d'écrans différents, chaque fichier d'exemple débute par une longue liste de constructeurs: il faut décommenter la ligne qui correspond au modèle d'écran que vous utilisez (dans mon cas: SH1106 128X64  I2C).

Écriture de texte à l'écran

Plusieurs dizaines de polices de caractères peuvent être utilisées pour écrire du texte à l'écran (voir la liste complète). Si vous désirez utiliser des caractères accentués, il est important de choisir une police dont le nom se termine par "f", ce qui indique que la police inclut tous les caractères nécessaires. De plus, la fonction "enableUTF8Print()" doit être appelée au démarrage du programme.

• enableUTF8Print: pour permettre l'utilisation de caractères accentués
• setFont: pour choisir une police de caractère
• setCursor: pour choisir l'endroit sur l'écran où on désire écrire du texte
• print: écriture du texte à la position du curseur

Dans un premier temps, le texte est écrit en mémoire (buffer). Il faut ensuite utiliser sendBuffer() pour transférer l'image à l'écran.

Dessiner des formes géométriques

Plusieurs fonctions facilitent le traçage de formes géométriques à l'écran:

• drawPixel: pour dessiner un point
• drawLine: pour dessiner une ligne droite
• drawFrame: pour dessiner un contour de rectangle (vide)
• drawBox: pour dessiner un rectangle plein
• drawCircle: pour dessiner un contour circulaire (vide)
• drawDisc: pour dessiner un cercle plein
• drawTriangle: pour dessiner un triangle

Afficher un bitmap XBM

La fonction drawXBMP permet de tracer à l'écran une image bitmap de type XBM. J'ai obtenu de bons résultat en sauvegardant un petit dessin en format .xbm avec le logiciel Gimp, puis en ouvrant le fichier obtenu avec un éditeur de texte: j'en ai tiré le contenu de la variable "logoBitmap" dans le sketch de démonstration ci-dessous.

Un sketch

Pour finir, voici mon sketch complet,  qui fait apparaître des dessins et du texte à l'écran.

	/*******************************************************
	Utilisation d'un écran OLED avec ESP32, ESP8266 ou STM32
	(bibliothèque u8g2)
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/09/ecran-oled-sh1106-i2c-et-esp32-ou.html
	https://electroniqueamateur.blogspot.com/2019/11/ecran-oled-sh1106-i2c-et-stm32.html
	********************************************************/
	#include <U8g2lib.h>
	#include <Wire.h>
	U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
	// U8G2_R0 ou U8G2_R2: mode paysage, U8G2_R1 ou U8G2_R3: mode portrait
	/* Définition d'une image bitmap: logo du blog Électronique en Amateur
	sauvegardé dans un fichier XBM, puis ouvert avec un éditeur de texte: */
	static const unsigned char logoBitmap[] PROGMEM = {
	0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0x06, 0xf0, 0xff, 0x03, 0x3f, 0x04,
	0x00, 0xf8, 0x03, 0x1f, 0x06, 0x00, 0x80, 0x03, 0x0f, 0x84, 0x0f, 0x85,
	0x03, 0x07, 0x86, 0x9f, 0x8f, 0x03, 0x07, 0xc4, 0xdf, 0x8f, 0x03, 0x03,
	0xc4, 0xff, 0x9f, 0x03, 0x03, 0xc6, 0xff, 0x9f, 0x03, 0x03, 0xc4, 0xf9,
	0x9f, 0x03, 0x03, 0xc4, 0x70, 0x8e, 0x03, 0x03, 0xc4, 0x30, 0x8c, 0x03,
	0x03, 0x84, 0x39, 0x84, 0x03, 0x03, 0x04, 0x6f, 0x86, 0x03, 0x03, 0x04,
	0xc4, 0x81, 0x03, 0x03, 0x84, 0x01, 0x80, 0x03, 0x03, 0x84, 0x01, 0x98,
	0x03, 0x03, 0x04, 0x03, 0x98, 0x03, 0x03, 0x04, 0x0e, 0x8e, 0x03, 0x03,
	0x0c, 0xf8, 0x83, 0x03, 0x03, 0xff, 0x17, 0x80, 0x03, 0x83, 0x00, 0xfc,
	0x97, 0x03, 0x63, 0x00, 0x00, 0xfc, 0x03, 0x23, 0x00, 0x00, 0x80, 0x03,
	0x13, 0x00, 0x00, 0x80, 0x03, 0x0b, 0x00, 0x00, 0x80, 0x03, 0x8f, 0x07,
	0x00, 0x80, 0x03, 0x07, 0x06, 0x06, 0x80, 0x03, 0x03, 0x07, 0x07, 0x86,
	0x03, 0x03, 0x06, 0x86, 0x86, 0x03, 0x03, 0x06, 0x06, 0x86, 0x03, 0x03,
	0x06, 0x06, 0xc6, 0x03, 0x07, 0x07, 0x06, 0xe6, 0x03, 0x0f, 0x06, 0x06,
	0xf6, 0x03, 0x1f, 0x06, 0x06, 0xf6, 0x03, 0xff, 0x06, 0x06, 0xf6, 0x03,
	0xff, 0x06, 0x76, 0xf6, 0x03, 0xff, 0x76, 0x76, 0xf6, 0x03, 0xff, 0x76,
	0x76, 0xf6, 0x03, 0xff, 0x76, 0x76, 0xf6, 0x03, 0xff, 0x76, 0x76, 0xf6,
	0x03, 0xff, 0x76, 0x76, 0xf6, 0x03, 0xff, 0x76, 0x76, 0xf6, 0x03, 0xff,
	0x76, 0x76, 0xf6, 0x03, 0xff, 0x76, 0x76, 0xf6, 0x03, 0xff, 0x70, 0x74,
	0xf6, 0x03, 0xff, 0x7f, 0x7c, 0xf0, 0x03, 0xff, 0xff, 0xff, 0xf8, 0x03
	};
	void setup(void) {
	u8g2.begin();
	u8g2.enableUTF8Print(); //nécessaire pour écrire des caractères accentués
	}
	void loop(void) {
	/********* On dessine le logo (bitmap défini plus haut) ***************/
	u8g2.clearBuffer(); // on efface ce qui se trouve déjà dans le buffer
	u8g2.drawXBMP( 2, 8, 34, 48, logoBitmap); // position, largeur, hauteur
	/************** On écrit "Électronique en amateur" *********************/
	u8g2.setFont(u8g2_font_7x13B_tf); // choix d'une police de caractère
	u8g2.setCursor(40, 25); // position du début du texte
	u8g2.print("Électronique"); // écriture de texte
	u8g2.setCursor(70, 35);
	u8g2.print("en");
	u8g2.setCursor(55, 45);
	u8g2.print("amateur");
	u8g2.sendBuffer(); // l'image qu'on vient de construire est affichée à l'écran
	delay(2000);
	/******************** Dessiner une ligne ******************************************/
	u8g2.clearBuffer(); // on efface tout
	// ligne horizontale au centre de l'écran
	u8g2.drawLine(0, 32, 128 , 32); // point de départ, point d'arrivée
	// ligne verticale au centre de l'écran
	u8g2.drawLine(64, 0, 64, 64);
	/********************* Dessiner des contours de formes géométriques ******************/
	u8g2.drawFrame(15, 5, 30, 15); // coin supérieur gauche, coin inférieur droit
	u8g2.drawCircle(95, 15, 8); // centre et rayon
	u8g2.drawRFrame(15, 40, 30, 16, 5); // coin supérieur gauche, coin inférieur droit, rayon du coin
	//il n'y a pas de fonction pour tracer un triangle vide
	u8g2.drawLine(95, 40, 80, 55);
	u8g2.drawLine(80, 55, 110, 55);
	u8g2.drawLine(110, 55, 95, 40);
	u8g2.sendBuffer();
	delay(2000);
	/******************* Dessiner des formes géométriqeus pleines *************************/
	u8g2.drawBox(15, 5, 30, 15); // coin supérieur gauche, coin inférieur droit
	u8g2.drawDisc(95, 15, 8); // centre et rayon
	u8g2.drawRBox(15, 40, 30, 16, 5); // coin supérieur gauche, coin inférieur droit, rayon du coin
	u8g2.drawTriangle(95, 40, 80, 55, 110, 55); // les 3 coins
	u8g2.sendBuffer();
	delay(2000);
	/***************** dessiner pixel par pixel ***********************/
	u8g2.clearBuffer();
	// on trace une fonction sinusoidale, point par point
	for (int x = 1; x < 128; x++) {
	int y = 32 + round(16.0 * sin(x / 5.0));
	u8g2.drawPixel(x, y);
	}
	u8g2.sendBuffer();
	delay(2000);
	/******************* Écrire du texte *******************************/
	u8g2.setFont(u8g2_font_ncenB10_tf); // choix de la police
	u8g2.clearBuffer();
	u8g2.setCursor(5, 20); // position du début du texte
	u8g2.print("Caractères"); // on écrit le texte
	u8g2.setCursor(5, 35);
	u8g2.print("accentués:");
	u8g2.setCursor(5, 55);
	u8g2.print("ÀàÂâÉéÈèÊêÇç");
	u8g2.sendBuffer();
	delay(2000);
	}

view raw ESP_OLED.ino hosted with ❤ by GitHub

Articles similaires:

J'ai aussi utilisé le même écran OLED avec un Raspberry Pi , avec un Arduino et avec une carte STM32.

Avec l'ESP32 et l'ESP8266, j'ai aussi utilisé ces afficheurs:  écran couleur SPI ST7735, afficheur LCD 16 X 2, afficheur 7 segments TM1638.

Vous pouvez également consulter la liste de tous mes articles concernant l'ESP8266 et l'ESP32.

Yves Pelletier   (Twitter, Facebook)

ESP32: utilisation du capteur à effet Hall intégré

Les concepteurs de l'ESP32 ont jugé utile de le munir d'un capteur à effet Hall intégré grâce auquel il est possible de détecter le champ magnétique d'un aimant placé à proximité du module.

Ce capteur se situe à l'intérieur de la partie de la carte qui est recouverte par un bouclier métallique, à peu près au centre du rectangle; il mesure la composante du champ magnétique orientée perpendiculairement à la carte.

L'exemple "HallSensor", accessible dans l'IDE Arduino par les menus "Fichier - Exemples - ESP32 - HallSensor" constitue une façon simple et rapide de vérifier le bon fonctionnement du capteur à effet Hall (au besoin, vous pouvez vous référer à ce précédent billet pour apprendre comment programmer l'ESP32 au moyen de l'IDE Arduino).

Prenez soin de ne pas brancher quoi que ce soit aux broches GPIO36 et GPIO39, car leur ADC est utilisé lors de l'utilisation du capteur à effet Hall.

En ce qui concerne la programmation dans l'IDE Arduino, la lecture du champ magnétique au moyen du capteur à effet Hall intégré se limite à l'utilisation de la fonction "hallRead()", qui retourne un entier.

Voici ce que j'ai obtenu en avec l'exemple "HallSensor", lorsqu'aucun aimant n'était placé à proximité du module ESP32: les valeurs affichées varient entre 32 et 40.

J'ai ensuite placé un petit aimant tout proche du centre du bouclier métallique du module ESP32 (j'avais collé l'aimant à l'extrémité d'un petit support en carton afin de faciliter les manipulations).

Les valeurs mesurées dépendent du pôle de l'aimant qui fait face au module ESP32. Pour un sens, les valeurs diminuent (elles peuvent même devenir négatives).

...alors qu'en plaçant l'aimant dans l'autre sens, les valeurs augmentent aux environs de 100.

D'après mes observations, il est difficile de mesurer quoi que ce soit si l'aimant est situé à plus de quelques millimètres du centre du bouclier métallique. Pour une mesure plus précise du champ magnétique, des capteurs externes me semblent plus appropriés (voir par exemple le HMC5883L ou le A1302).

Pour détecter la présence d'un aimant tout près de l'ESP32, par contre, il n'y a pas de doute: le module à effet Hall intégré fonctionne très bien.

Détecter l'ouverture d'une porte 

On pourrait penser à une application où l'ESP32 est fixé à un cadre de porte. Lorsque la porte est fermée, un aimant est appuyé contre l'ESP32, et cet aimant s'éloigne de l'ESP32 lorsqu'on ouvre la porte. Grâce aux mesures effectuées par le capteur à effet Hall intégré, l'ESP32 sait quand la porte est ouverte ou non. Et puisqu'il s'agit d'un ESP32, pourquoi ne pas afficher les résultats dans une page web?

C'est ce que fait le sketch ci-dessous: il s'agit d'un serveur web qui affiche la date et l'heure des 10 plus récentes ouvertures de la porte.

	/**************************************************************
	Détecteur d'ouverture de porte ESP32
	L'ouverture d'une porte est détectée grâce au capteur à effet
	Hall intégré de l'ESP32. Une page web affiche la date et l'heure
	des 10 plus récentes ouvertures de portes.
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/09/esp32-utilisation-du-capteur-effet-hall.html
	*****************************************************************/
	// pour la communication WiFi
	#include <WiFi.h>
	#include <WiFiClient.h>
	#include <WebServer.h>
	// pour l'affichage de la date et de l'heure
	#include <time.h>
	const char* ssid = "**********";
	const char* password = "**********";
	const int stockage_max = 10; //nombre maximal de données stockées dans UID et dateHeure
	const int decalage = -5; // la valeur dépend de votre fuseau horaire. Essayez 2 pour la France.
	time_t date_et_heure[stockage_max]; // tableau contenant le moment des plus récentes ouvertures de porte
	int nb_de_donnees = 0; // nombre de données déjà stockées dans dateHeure
	int etat = 0; // 0 quand la porte est fermée, 1 quand elle est ouverte
	const int Hallnormal = 36; //valeur retournée par le capteur à effet Hall en absence d'aimant
	const int tolerance = 20; // ecart toléré par rapport à la valeur moyenne
	WebServer serveur(80);
	// Construction de la page web
	void handle_root() {
	struct tm * timeinfo;
	String contenu; // les informations concernant les scans de tags RFID
	for (int i = 0; i < stockage_max; i++) {
	if (date_et_heure[i] != 0)
	{
	timeinfo = localtime(&date_et_heure[i]);
	contenu.concat( "<p> Date et heure: " + String(timeinfo->tm_mday) + "-" + String(timeinfo->tm_mon + 1) + "-" + String(timeinfo->tm_year + 1900) + " " + String(timeinfo->tm_hour) + ":" + String(timeinfo->tm_min) + ":" + String(timeinfo->tm_sec) + "</p>");
	}
	}
	serveur.send(200, "html", "<head> <title>Detecteur d'ouverture de porte ESP32</title> <meta http-equiv=Refresh content=10></head> "
	"<body><H1>" + String(stockage_max) + " plus r&eacute;cents &eacute;v&eacute;nements</H1>"
	"<p>" + contenu + "<p>"
	"<p>Visitez <a href=http://electroniqueamateur.blogspot.ca/>&Eacute;lectronique en Amateur</a>!</p></body>");
	delay(100);
	}
	// Initialisation du WiFi. Les progrès s'affichent dans le moniteur série
	// pour faciliter le débogage, et pour connaître l'adresse IP de l'ESP32.
	void setup()
	{
	Serial.begin(9600);
	Serial.println();
	WiFi.begin(ssid, password);
	Serial.print("Connexion au reseau WiFi");
	while (WiFi.status() != WL_CONNECTED) {
	Serial.print(".");
	delay(1000);
	}
	Serial.println();
	Serial.print("Nom du reseau WiFi: ");
	Serial.println(ssid);
	Serial.print("Adresse IP de la page web: ");
	Serial.println(WiFi.localIP());
	serveur.on("/", handle_root);
	serveur.begin();
	Serial.println("Le serveur web est en fonction.");
	configTime(decalage * 3600, 0, "ca.pool.ntp.org"); //serveurs canadiens
	// en Europe, essayez europe.pool.ntp.org ou fr.pool.ntp.org
	Serial.print("Attente date et heure");
	while (time(nullptr) <= 100000) {
	Serial.print(".");
	delay(1000);
	}
	Serial.println();
	Serial.println("Pret.");
	}
	void loop()
	{
	// on fait la moyenne de trois lectures consécutives du champ magnétique
	// la moyenne permet d'atténuer les occasionnelles lectures aberrantes.
	int valeur1 = hallRead();
	delay(100);
	int valeur2 = hallRead();
	delay(100);
	int valeur3 = hallRead();
	int moyenne = (valeur1 + valeur2 + valeur3)/3;
	if (abs(moyenne - Hallnormal) < tolerance ) // pas d'aimant à proximité: la porte est ouverte
	{
	if (etat == 0) // lors de la dernière vérification, la porte était fermée!
	{
	Serial.println("Porte ouverte!");
	if (nb_de_donnees < stockage_max) { // il y a des lignes vides dans le tableau
	time(&date_et_heure[nb_de_donnees]); // quelle heure est-il?
	nb_de_donnees++;
	}
	else // le tableau est plein
	{
	for (int i = 0; i < stockage_max - 1; i++) { // on décale toutes les infos d'une ligne
	date_et_heure[i] = date_et_heure[i + 1];
	}
	time(&date_et_heure[stockage_max - 1]); // quelle heure est-il?
	}
	delay (1000); // pour éviter les "rebonds"
	}
	etat = 1;
	}
	else { // la porte est fermée
	if (etat == 1) {
	Serial.println("Porte refermee.");
	}
	etat = 0;
	}
	serveur.handleClient();
	}

view raw ESP32_Effet_Hall.ino hosted with ❤ by GitHub

Au démarrage, du programme, le moniteur série nous indique l'adresse IP du serveur web.

En tapant cette adresse IP dans un navigateur, on accède à la page web qui indique la date et l'heure des plus récentes ouvertures de la porte.

Si vous désirez utiliser vous-mêmes le sketch, vous devez évidemment assigner aux constantes ssid et password les valeurs correspondant à votre réseau WiFi, mais également vérifier que la valeur de la constante Hallnormal correspond à ce qu'affiche votre capteur en absence de l'aimant, et régler la constante decalage afin que l'heure affichée corresponde bien au pays dans lequel vous vous trouvez,


Yves Pelletier   (Twitter, Facebook)

ESP32: production d'un signal analogique

L'ESP32 comporte deux convertisseurs numérique / analogique (DAC) à 8 bits, ce qui permet de produire un véritable signal analogique, c'est à dire une tension pouvant prendre n'importe quelle valeur située entre 0 et 3,3 V (à ne pas confondre avec un signal modulé en largeur impulsion, PWM, que nous avons également traité dans un récent billet).

Broches GPIO

Deux broches peuvent servir de sortie analogique: GPIO 25 et GPIO 26.

La fonction dacWrite()

Si vous programmez l'ESP32 avec l'IDE Arduino, vous pouvez facilement contrôler la tension des sorties analogiques au moyen de la fonction dacWrite().

Cette fonction prend deux paramètres en argument: le numéro de la broche GPIO que vous désirez contrôler (25 ou 26) et une valeur située entre 0 et 255 qui représente la tension désirée (0 pour 0 volt, et 255 pour 3,3 volts).

Par exemple, pour régler la broche GPIO 25 à une valeur de 1 volt, vous écrivez: "dacWrite(25, 77);" puisque 77 * 3,3 / 255 = 1.

Sketch minimaliste

Le sketch ci-dessous présente le strict minimum pour produire un signal analogique périodique. Résultat: un signal en dent de scie.

	/*
	Production d'un signal en dent de scie
	sur la broche GPIO 25 de l'ESP32.
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/09/esp32-production-dun-signal-analogique.html
	*/
	void setup() {
	}
	void loop() {
	for (int i = 0; i < 255; i = i + 1) {
	dacWrite(25, i); // signal en dent de scie
	}
	}

view raw ESP32_DAC_minimal.ino hosted with ❤ by GitHub

Amplitude et fréquences contrôlables par potentiomètre

Voici un deuxième sketch un tout petit peu plus ambitieux: cette fois, nous produisons un signal sinusoïdal dont l'amplitude et la fréquence peuvent être modifiées grâce à deux potentiomètres.

	/*
	Sur la broche GPIO 25 de l'ESP32, production
	d'un sinus dont l'amplitude et la fréquence sont
	contrôlés par des potentiomètres
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2019/09/esp32-production-dun-signal-analogique.html
	*/
	const int potAmplitude = 33; // potentiomètre à GPIO 33 pour régler l'amplitude
	const int potFrequence = 32; // potentiomètre à GPIO 32 pour régler la fréquence
	unsigned long dernierTemps;
	int intervalle; //nombre de microsecondes entre deux changements de valeurs consécutifs
	int compteur = 0;
	void setup() {
	dernierTemps = micros();
	}
	void loop() {
	unsigned long nouveauTemps = micros();
	intervalle = analogRead(potFrequence) / 20;
	if ((nouveauTemps - dernierTemps) >= intervalle) {
	dacWrite(25, 128 + analogRead(potAmplitude) / 32 * sin(2 * PI * compteur / 255.0));
	compteur++;
	if (compteur == 256) {
	compteur = 0;
	}
	dernierTemps = nouveauTemps;
	}
	}

view raw ESP32_DAC_pot.ino hosted with ❤ by GitHub

Yves Pelletier   (Twitter, Facebook)