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.



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.

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.

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



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)