Accéléromètre et gyroscope ESP32 MPU-6050 (Arduino)

Dans ce guide, vous apprendrez à utiliser le module accéléromètre et gyroscope MPU-6050 avec l’ESP32. L’IMU (unité de mesure inertielle) MPU-6050 est un accéléromètre 3 axes et un capteur gyroscope 3 axes. L’accéléromètre mesure l’accélération gravitationnelle et le gyroscope mesure la vitesse de rotation. De plus, ce module mesure également la température. Ce capteur est idéal pour déterminer l’orientation d’un objet en mouvement.

Nous avons un guide similaire pour l’ESP8266 : ESP8266 NodeMCU avec accéléromètre, gyroscope et capteur de température MPU-6050 (Arduino)

Dans ce guide, nous aborderons deux exemples :

1. Obtenez des lectures de gyroscope, d’accélération et de température (Serial Monitor)
2. Afficher les lectures du gyroscope et de l’accélération sur l’écran OLED

Présentation du capteur accéléromètre gyroscopique MPU-6050

le MPU-6050 est un module avec un accéléromètre 3 axes et un gyroscope 3 axes.

Le gyroscope mesure la vitesse de rotation (rad/s), c’est le changement de la position angulaire dans le temps le long des axes X, Y et Z (roulis, tangage et lacet). Cela nous permet de déterminer l’orientation d’un objet.

L’accéléromètre mesure l’accélération (taux de variation de la vitesse de l’objet). Il détecte les forces statiques telles que la gravité (9,8 m/s²) ou des forces dynamiques comme les vibrations ou le mouvement. Le MPU-6050 mesure l’accélération sur les axes X, Y et Z. Idéalement, dans un objet statique, l’accélération sur l’axe Z est égale à la force gravitationnelle, et elle doit être nulle sur les axes X et Y.

En utilisant les valeurs de l’accéléromètre, il est possible de calculer les angles de roulis et de tangage à l’aide de la trigonométrie. Cependant, il n’est pas possible de calculer le lacet.

Nous pouvons combiner les informations des deux capteurs pour obtenir des informations plus précises sur l’orientation du capteur.

Brochage du MPU-6050

Voici le brochage du module de capteur MPU-6050.

Préparation de l’IDE Arduino

Nous allons programmer la carte ESP32 à l’aide de l’IDE Arduino. Assurez-vous donc que le module complémentaire ESP32 est installé. Suivez le tutoriel suivant :

Si vous préférez utiliser VS Code + PlatformIO IDE, suivez le guide suivant :

Installation des bibliothèques

Il existe différentes façons d’obtenir des lectures du capteur. Dans ce tutoriel, nous utiliserons la bibliothèque Adafruit MPU6050. Pour utiliser cette bibliothèque, vous devez également installer la bibliothèque Adafruit Unified Sensor et la bibliothèque Adafruit Bus IO.

Ouvrez votre IDE Arduino et accédez à Esquisser > Inclure la bibliothèque > Gérer les bibliothèques. Le gestionnaire de bibliothèque devrait s’ouvrir.

Taper « adafruit mpu6050” dans le champ de recherche et installez la bibliothèque.

Ensuite, recherchez « Capteur unifié Adafruit”. Faites défiler vers le bas pour trouver la bibliothèque et installez-la.

Enfin, recherchez « Adafruit Bus E/S” et installez-le.

Après avoir installé les bibliothèques, redémarrez votre IDE Arduino.

Si vous utilisez VS Code avec PaltformIO, copiez les lignes suivantes dans le platformio.ini déposer.

lib_deps = adafruit/Adafruit MPU6050 @ ^2.0.3
    adafruit/Adafruit Unified Sensor @ ^1.1.4

Obtention des lectures du capteur MPU-6050 : accéléromètre, gyroscope et température

Dans cette section, vous apprendrez comment obtenir des lectures de capteur à partir du capteur MPU-6050 : accélération (x, y, z), vitesse angulaire (x, y, z) et température.

Pièces requises

Pour cet exemple, vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou accéder directement à MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Schéma de principe – ESP32 avec MPU-6050

Câblez l’ESP32 au capteur MPU-6050 comme indiqué dans le schéma suivant : connectez la broche SCL à GPIO 22 et la broche SDA à GPIO 21.

Code – Obtenir les lectures du capteur MPU-6050 : accéléromètre, gyroscope et température

La bibliothèque Adafruit fournit plusieurs exemples pour ce capteur. Dans cette section, nous allons jeter un œil à l’exemple de base qui imprime les lectures des capteurs dans le moniteur série.

Aller à Déposer > Exemples > Adafruit MPU6050 > lectures_de_base. Le code suivant devrait se charger.

Il obtient la vitesse angulaire (gyroscope) sur les axes x, y et z, l’accélération sur les axes x, y et z et la température.

// Basic demo for accelerometer readings from Adafruit MPU6050

// ESP32 Guide: https://Raspberryme.com/esp32-mpu-6050-accelerometer-gyroscope-arduino/
// ESP8266 Guide: https://Raspberryme.com/esp8266-nodemcu-mpu-6050-accelerometer-gyroscope-arduino/
// Arduino Guide: https://Raspberryme.com/arduino-mpu-6050-accelerometer-gyroscope/

#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>

Adafruit_MPU6050 mpu;

void setup(void) {
  Serial.begin(115200);
  while (!Serial)
    delay(10); // will pause Zero, Leonardo, etc until serial console opens

  Serial.println("Adafruit MPU6050 test!");

  // Try to initialize!
  if (!mpu.begin()) {
    Serial.println("Failed to find MPU6050 chip");
    while (1) {
      delay(10);
    }
  }
  Serial.println("MPU6050 Found!");

  mpu.setAccelerometerRange(MPU6050_RANGE_8_G);
  Serial.print("Accelerometer range set to: ");
  switch (mpu.getAccelerometerRange()) {
  case MPU6050_RANGE_2_G:
    Serial.println("+-2G");
    break;
  case MPU6050_RANGE_4_G:
    Serial.println("+-4G");
    break;
  case MPU6050_RANGE_8_G:
    Serial.println("+-8G");
    break;
  case MPU6050_RANGE_16_G:
    Serial.println("+-16G");
    break;
  }
  mpu.setGyroRange(MPU6050_RANGE_500_DEG);
  Serial.print("Gyro range set to: ");
  switch (mpu.getGyroRange()) {
  case MPU6050_RANGE_250_DEG:
    Serial.println("+- 250 deg/s");
    break;
  case MPU6050_RANGE_500_DEG:
    Serial.println("+- 500 deg/s");
    break;
  case MPU6050_RANGE_1000_DEG:
    Serial.println("+- 1000 deg/s");
    break;
  case MPU6050_RANGE_2000_DEG:
    Serial.println("+- 2000 deg/s");
    break;
  }

  mpu.setFilterBandwidth(MPU6050_BAND_5_HZ);
  Serial.print("Filter bandwidth set to: ");
  switch (mpu.getFilterBandwidth()) {
  case MPU6050_BAND_260_HZ:
    Serial.println("260 Hz");
    break;
  case MPU6050_BAND_184_HZ:
    Serial.println("184 Hz");
    break;
  case MPU6050_BAND_94_HZ:
    Serial.println("94 Hz");
    break;
  case MPU6050_BAND_44_HZ:
    Serial.println("44 Hz");
    break;
  case MPU6050_BAND_21_HZ:
    Serial.println("21 Hz");
    break;
  case MPU6050_BAND_10_HZ:
    Serial.println("10 Hz");
    break;
  case MPU6050_BAND_5_HZ:
    Serial.println("5 Hz");
    break;
  }

  Serial.println("");
  delay(100);
}

void loop() {
  /* Get new sensor events with the readings */
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);

  /* Print out the values */
  Serial.print("Acceleration X: ");
  Serial.print(a.acceleration.x);
  Serial.print(", Y: ");
  Serial.print(a.acceleration.y);
  Serial.print(", Z: ");
  Serial.print(a.acceleration.z);
  Serial.println(" m/s^2");

  Serial.print("Rotation X: ");
  Serial.print(g.gyro.x);
  Serial.print(", Y: ");
  Serial.print(g.gyro.y);
  Serial.print(", Z: ");
  Serial.print(g.gyro.z);
  Serial.println(" rad/s");

  Serial.print("Temperature: ");
  Serial.print(temp.temperature);
  Serial.println(" degC");

  Serial.println("");
  delay(500);
}

Afficher le code brut

Comment fonctionne le code

Commencez par inclure les bibliothèques requises pour le capteur MPU-6050 : Adafruit_MPU6050 et Adafruit_Sensor.

#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>

Créé un Adafruit_MPU6050 objet appelé mpu pour manipuler le capteur.

Adafruit_MPU6050 mpu;

mettre en place()

Dans le mettre en place(), initialisez le moniteur série à un débit en bauds de 115 200.

Serial.begin(115200);

Initialisez le capteur MPU-6050.

if (!mpu.begin()) {
  Serial.println("Sensor init failed");
  while (1)
    yield();
}

Définissez la plage de mesure de l’accéléromètre :

mpu.setAccelerometerRange(MPU6050_RANGE_8_G);

Réglez la plage de mesure du gyroscope :

mpu.setGyroRange(MPU6050_RANGE_500_DEG);

Définissez la bande passante du filtre :

mpu.setFilterBandwidth(MPU6050_BAND_5_HZ);

boucler()

Dans le boucler() nous obtiendrons les lectures des capteurs et les afficherons dans le moniteur série.

Tout d’abord, vous devez obtenir de nouveaux événements de capteur avec les lectures actuelles.

sensors_event_t a, g, temp;
mpu.getEvent(&a, &g, &temp);

Enfin, imprimez les lectures. Pour l’accélération :

• a.accélération.x: obtient l’accélération sur l’axe x ;
• a.accélération.y: obtient l’accélération sur l’axe y ;
• a.accélération.z: obtient l’accélération sur l’axe z.

L’accélération est mesurée en mètres par seconde carrée (m/s²)

Serial.print("Acceleration X: ");
Serial.print(a.acceleration.x);
Serial.print(", Y: ");
Serial.print(a.acceleration.y);
Serial.print(", Z: ");
Serial.print(a.acceleration.z);
Serial.println(" m/s^2");

Pour obtenir des lectures de gyroscope :

• g.gyro.x: obtient la vitesse angulaire sur l’axe x ;
• g.gyro.y: obtient la vitesse angulaire sur l’axe y ;
• g.gyro.z: obtient la vitesse angulaire sur l’axe z.

La vitesse angulaire est mesurée en radians par seconde (rad/s).

Serial.print("Rotation X: ");
Serial.print(g.gyro.x);
Serial.print(", Y: ");
Serial.print(g.gyro.y);
Serial.print(", Z: ");
Serial.print(g.gyro.z);
Serial.println(" rad/s");

Enfin, imprimez la température – elle est mesurée en degrés Celsius. Pour accéder à la lecture de la température, utilisez temp.température.

Serial.print("Temperature: ");
Serial.print(temp.temperature);
Serial.println(" degC");

De nouvelles lectures de capteur sont affichées toutes les 500 millisecondes.

delay(500);

Manifestation

Téléchargez le code sur votre carte ESP32. Aller à Outils > Conseil et sélectionnez la carte ESP32 que vous utilisez. Aller à Outils > Port et sélectionnez le port auquel votre carte est connectée. Ensuite, cliquez sur le bouton Télécharger.

Ouvrez le moniteur série à un débit en bauds de 115200, appuyez sur le bouton RST intégré. Les mesures du capteur seront affichées.

Déplacez l’orientation du capteur et voyez les valeurs changer en conséquence.

Étalonnage du capteur

Idéalement, lorsque le capteur est statique, les valeurs du gyroscope doivent être nulles sur tous les axes, ce qui n’arrive pas dans notre cas. Lorsque le capteur est statique, voici les valeurs du gyroscope que nous obtenons :

• x : 0,06 rad/s
• y : -0,02 rad/s
• z : 0,00 rad/s

Sur les applications pratiques, vous devez prendre en compte l’erreur et corriger les valeurs dans le code pour obtenir des lectures plus précises.

Il en va de même pour les valeurs d’accélération. L’accélération sur l’axe z doit être plus proche de la force gravitationnelle (9,8 m/s²) et il doit être plus proche de zéro sur les axes x et y. Dans notre cas, ce sont les valeurs approximatives que nous obtenons lorsque le capteur est statique :

• x : 0,71 m/s²
• y : 0,28 m/s²
• z : 9,43 m/s²

Afficher les lectures du MPU-6050 sur l’écran OLED

La bibliothèque Adafruit MPU6050 fournit un exemple qui affiche les lectures du gyroscope et de l’accéléromètre MPU-6050 sur un écran OLED.

Pièces requises

Voici une liste avec les pièces nécessaires pour compléter cet exemple :

Vous pouvez utiliser les liens précédents ou accéder directement à MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Schéma de principe – ESP32 avec MPU-6050 et écran OLED

Câblez toutes les pièces comme indiqué dans le diagramme schématique suivant. Comme l’écran OLED et les capteurs MPU-6050 utilisent des adresses I2C différentes, nous pouvons les connecter au même bus I2C (mêmes broches sur l’ESP32).

En savoir plus sur l’utilisation de l’écran OLED avec l’ESP32 : Écran OLED ESP32 avec Arduino IDE

Code – Afficher les lectures du capteur MPU-6050 sur l’écran OLED

Pour utiliser cet exemple, assurez-vous que la bibliothèque Adafruit SSD1306 est installée. Cette bibliothèque peut être installée via le gestionnaire de bibliothèque Arduino.

Aller à Esquisser > Bibliothèque > Gérer les bibliothèques et recherchez « SSD1306” et installez la bibliothèque SSD1306 d’Adafruit.

Pour cet exemple, copiez le code suivant ou accédez à Déposer > Exemples > Adafruit MPU6050 > MPU6050_oled.

// Basic OLED demo for accelerometer readings from Adafruit MPU6050

// ESP32 Guide: https://Raspberryme.com/esp32-mpu-6050-accelerometer-gyroscope-arduino/
// ESP8266 Guide: https://Raspberryme.com/esp8266-nodemcu-mpu-6050-accelerometer-gyroscope-arduino/
// Arduino Guide: https://Raspberryme.com/arduino-mpu-6050-accelerometer-gyroscope/

#include <Adafruit_MPU6050.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_Sensor.h>

Adafruit_MPU6050 mpu;
Adafruit_SSD1306 display = Adafruit_SSD1306(128, 64, &Wire);

void setup() {
  Serial.begin(115200);
  // while (!Serial);
  Serial.println("MPU6050 OLED demo");

  if (!mpu.begin()) {
    Serial.println("Sensor init failed");
    while (1)
      yield();
  }
  Serial.println("Found a MPU-6050 sensor");

  // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3C for 128x64
    Serial.println(F("SSD1306 allocation failed"));
    for (;;)
      ; // Don't proceed, loop forever
  }
  display.display();
  delay(500); // Pause for 2 seconds
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setRotation(0);
}

void loop() {
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);

  display.clearDisplay();
  display.setCursor(0, 0);

  Serial.print("Accelerometer ");
  Serial.print("X: ");
  Serial.print(a.acceleration.x, 1);
  Serial.print(" m/s^2, ");
  Serial.print("Y: ");
  Serial.print(a.acceleration.y, 1);
  Serial.print(" m/s^2, ");
  Serial.print("Z: ");
  Serial.print(a.acceleration.z, 1);
  Serial.println(" m/s^2");

  display.println("Accelerometer - m/s^2");
  display.print(a.acceleration.x, 1);
  display.print(", ");
  display.print(a.acceleration.y, 1);
  display.print(", ");
  display.print(a.acceleration.z, 1);
  display.println("");

  Serial.print("Gyroscope ");
  Serial.print("X: ");
  Serial.print(g.gyro.x, 1);
  Serial.print(" rps, ");
  Serial.print("Y: ");
  Serial.print(g.gyro.y, 1);
  Serial.print(" rps, ");
  Serial.print("Z: ");
  Serial.print(g.gyro.z, 1);
  Serial.println(" rps");

  display.println("Gyroscope - rps");
  display.print(g.gyro.x, 1);
  display.print(", ");
  display.print(g.gyro.y, 1);
  display.print(", ");
  display.print(g.gyro.z, 1);
  display.println("");

  display.display();
  delay(100);
}

Afficher le code brut

Comment fonctionne le code

Commencez par inclure les bibliothèques requises pour le capteur MPU-6050 et pour l’écran OLED.

#include <Adafruit_MPU6050.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_Sensor.h>

Créé un Adafruit_MPU6050 objet appelé mpu pour manipuler le capteur.

Adafruit_MPU6050 mpu;

Créé un Adafruit_SSD1306 objet appelé affichage pour gérer l’écran OLED. C’est pour un écran de 128×64 pixels.

Adafruit_SSD1306 display = Adafruit_SSD1306(128, 64, &Wire);

mettre en place()

Dans le mettre en place(), initialisez le moniteur série à un débit en bauds de 115 200.

Serial.begin(115200);

Initialisez le capteur MPU-6050.

if (!mpu.begin()) {
  Serial.println("Sensor init failed");
  while (1)
    yield();
}

Initialiser l’affichage OLED.

// SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3C for 128x64
  Serial.println(F("SSD1306 allocation failed"));
  for (;;)
    ; // Don't proceed, loop forever
}
display.display();

Définissez la taille et la couleur de la police pour l’affichage.

display.setTextSize(1);
display.setTextColor(WHITE);
display.setRotation(0);

boucler()

Dans le boucler() C’est là que nous obtiendrons les lectures des capteurs et les afficherons sur l’OLED.

Commencez par créer des événements pour chaque mesure, accéléromètre, gyroscope et température.

sensors_event_t a, g, temp;

Obtenez de nouvelles lectures de capteur.

mpu.getEvent(&a, &g, &temp);

Effacer l’affichage dans chaque boucler() écrire de nouvelles lectures.

display.clearDisplay();

Réglez le curseur d’affichage sur (0,0) – le coin supérieur gauche. Il commencera à écrire du texte à partir de cet emplacement.

display.setCursor(0, 0);

Les lignes suivantes impriment les lectures de l’accéléromètre dans le moniteur série.

Serial.print("Accelerometer ");
Serial.print("X: ");
Serial.print(a.acceleration.x, 1);
Serial.print(" m/s^2, ");
Serial.print("Y: ");
Serial.print(a.acceleration.y, 1);
Serial.print(" m/s^2, ");
Serial.print("Z: ");
Serial.print(a.acceleration.z, 1);
Serial.println(" m/s^2");

Les lignes suivantes affichent les valeurs d’accélération x, y et z sur l’écran OLED.

display.println("Accelerometer - m/s^2");
display.print(a.acceleration.x, 1);
display.print(", ");
display.print(a.acceleration.y, 1);
display.print(", ");
display.print(a.acceleration.z, 1);
display.println("");

Affichez les lectures du gyroscope sur le moniteur série.

Serial.print("Gyroscope ");
Serial.print("X: ");
Serial.print(g.gyro.x, 1);
Serial.print(" rps, ");
Serial.print("Y: ");
Serial.print(g.gyro.y, 1);
Serial.print(" rps, ");
Serial.print("Z: ");
Serial.print(g.gyro.z, 1);
Serial.println(" rps");

Enfin, imprimez les lectures du gyroscope sur l’écran.

display.println("Gyroscope - rps");
display.print(g.gyro.x, 1);
display.print(", ");
display.print(g.gyro.y, 1);
display.print(", ");
display.print(g.gyro.z, 1);
display.println("");

Enfin, appelez display.display() pour afficher réellement les lectures sur l’OLED.

display.display();

De nouvelles lectures sont affichées toutes les 100 millisecondes.

delay(100);

Manifestation

Téléchargez le code sur votre carte ESP32. Aller à Outils > Conseil et sélectionnez la carte ESP32 que vous utilisez. Aller à Outils > Port et sélectionnez le port auquel votre carte est connectée. Ensuite, cliquez sur le bouton de téléchargement.

Ouvrez le moniteur série à un débit en bauds de 115200, appuyez sur le bouton RST intégré. Les mesures du capteur seront affichées à la fois sur le moniteur série et sur l’écran OLED.

Déplacez le capteur et voyez les valeurs changer.

Vous pouvez regarder la vidéo de démonstration :

Conclusion

Le MPU-6050 est un accéléromètre et un gyroscope. Il mesure l’accélération sur les axes x, y et z ainsi que la vitesse angulaire. Ce module mesure également la température.

Ces modules de capteurs communiquent via le protocole de communication I2C. Ainsi, le câblage est très simple. Connectez simplement le capteur aux broches I2C par défaut de l’ESP32.

Dans ce didacticiel, vous avez appris à câbler le capteur et à obtenir des lectures de capteur. Nous espérons que vous avez trouvé ce guide de démarrage utile. Nous avons des guides pour d’autres capteurs populaires :

En savoir plus sur l’ESP32 avec nos ressources :

Merci d’avoir lu.