L'innovation sans limites

L'innovation sans limites

Module MPU6050 et Arduino : Une question d’équilibre

Sommaire

Présentation

Les MPU 6050/6500/9250 sont des modules intégrant des accéléromètres, gyroscopes et magnétomètres (boussole pour ceux qui n’ont pas compris – uniquement le 9250). Ils incluent également un capteur de température. Ces modules sont largement utilisés dans diverses applications de détection et de contrôle de mouvement.

Qu’est-ce qu’un gyroscope ?

Un gyroscope est un appareil qui exploite le principe de la conservation du moment cinétique en physique, également connu sous le nom de stabilité gyroscopique. Cette loi fondamentale de la mécanique stipule qu’en l’absence de couple appliqué à un solide en rotation autour d’un de ses axes principaux, celui-ci conserve son axe de rotation invariable. En termes simples, un gyroscope est un capteur de position angulaire sur trois axes (x, y, z).

Qu’est-ce qu’un accéléromètre ?

Un accéléromètre est un capteur utilisé pour mesurer l’accélération d’un corps. Par exemple, il peut être utilisé pour calculer l’accélération d’une voiture qui passe de 0 à 100 km/h en quelques secondes. Les accéléromètres mesurent les forces de l’accélération linéaire le long de plusieurs axes (généralement x, y et z).

Illustration représentant un système de coordonnées tridimensionnel. Elle comprend trois flèches représentant les axes X, Y et Z. La flèche de l'axe X est colorée en rouge et pointe vers la droite, la flèche de l'axe Y est verte et pointe vers le haut, tandis que la flèche de l'axe Z est bleue et pointe vers l'avant. Chaque axe est clairement étiqueté avec sa lettre correspondante en couleur assortie à la flèche.

Montage

Pour réaliser ce projet, vous aurez besoin des éléments suivants :

  • Une carte Arduino Uno
  • Quelques câbles de connexion
  • Un module MPU6050, MPU6500 ou MPU9250

Ces composants de base sont tout ce qu’il vous faut pour commencer à expérimenter l’équilibrage avec le MPU.

  1. Connexion des composants :
    • Connectez la broche VCC du module MPU6050 à la broche 3.3V de l’Arduino Uno.
    • Connectez la broche GND du module MPU6050 à la broche GND de l’Arduino.
    • Connectez la broche SCL du MPU6050 à la broche A5 de l’Arduino (broche de l’horloge série).
    • Connectez la broche SDA du MPU6050 à la broche A4 de l’Arduino (broche des données série).

Assurez-vous que toutes les connexions sont sécurisées pour éviter tout problème de communication entre le MPU et l’Arduino.

Illustration montrant un Arduino Uno connecté à un petit module électronique par des fils colorés. L'Arduino Uno, de couleur bleue, est représenté au centre avec des composants clairement visibles comme les ports d'entrée-sortie et le microcontrôleur. Le petit module, situé en bas à gauche, est connecté à l'Arduino par quatre fils de couleurs différentes (rouge, jaune, bleu, noir), indiquant différents signaux ou alimentations. Les fils semblent être connectés à des broches spécifiques sur l'Arduino, suggérant une configuration pour un projet spécifique.

Programmation

Nous allons explorer les possibilités d’utilisation du module MPU6050 à travers trois programmes :

  • Utilisation simple d’un module MPU6050
  • Le module MPU6050 et notre shield Joystick
  • Gestion d’un robot avec le module MPU6050

Utilisation simple d'un module MPU6050

Dans ce premier programme, nous allons lire les données du MPU6050 et les afficher sur le moniteur série d’Arduino. Cela nous permettra de comprendre comment interagir avec le capteur et d’obtenir des informations sur les angles de rotation mesurés par le gyroscope.

				
					#include <Wire.h>

// Adresse I2C du MPU6050
const int MPU_addr = 0x68; 
int16_t AcX, AcY, AcZ, Tmp, GyX, GyY, GyZ;
int minVal = 265;
int maxVal = 402;

double x;
double y;
double z;

void setup() {
  // Initialisation de la communication I2C
  Wire.begin();
  Wire.beginTransmission(MPU_addr);
  Wire.write(0x6B); // Registre de configuration du MPU6050
  Wire.write(0); // Réveille le MPU6050
  Wire.endTransmission(true);
  
  // Initialisation de la communication série pour l'affichage des résultats
  Serial.begin(9600);
}

void loop() {
  // Demande de lecture des données des capteurs du MPU6050
  Wire.beginTransmission(MPU_addr);
  Wire.write(0x3B); // Registre de début des données de capteur
  Wire.endTransmission(false);
  Wire.requestFrom(MPU_addr, 14, true); // Lecture des 14 registres

  // Lecture des valeurs de l'accéléromètre et du gyroscope
  AcX = Wire.read() << 8 | Wire.read();
  AcY = Wire.read() << 8 | Wire.read();
  AcZ = Wire.read() << 8 | Wire.read();
  Tmp = Wire.read() << 8 | Wire.read();
  GyX = Wire.read() << 8 | Wire.read();
  GyY = Wire.read() << 8 | Wire.read();
  GyZ = Wire.read() << 8 | Wire.read();

  // Calcul des angles de rotation
  int xAng = map(AcX, minVal, maxVal, -90, 90);
  int yAng = map(AcY, minVal, maxVal, -90, 90);
  int zAng = map(AcZ, minVal, maxVal, -90, 90);

  x = RAD_TO_DEG * (atan2(-yAng, -zAng) + PI);
  y = RAD_TO_DEG * (atan2(-xAng, -zAng) + PI);
  z = RAD_TO_DEG * (atan2(-yAng, -xAng) + PI);

  // Affichage des résultats sur le moniteur série
  Serial.print("AngleX = ");
  Serial.println(x);
  Serial.print("AngleY = ");
  Serial.println(y);
  Serial.print("AngleZ = ");
  Serial.println(z);
  Serial.println("-----------------------------------------");

  delay(400); // Pause de 400 ms avant la prochaine lecture
}

Explication du code

  1. Initialisation : La fonction setup() initialise la communication I2C avec le MPU6050 et configure la communication série pour l’affichage des résultats.
  2. Lecture des données : La fonction loop() demande les données du MPU6050, lit les valeurs des accéléromètres et gyroscopes, puis les convertit en angles de rotation.
  3. Affichage : Les angles calculés sont affichés sur le moniteur série, permettant de visualiser les mouvements détectés par le capteur.
Capture d'écran de l'interface de l'IDE Arduino affichant un programme de code source. Le code inclut des instructions pour lire les données d'un capteur MPU via le protocole I2C et calculer des angles en degrés à partir des accélérations mesurées. Des fonctions telles que 'Wire.begin()', 'Wire.read()', et des calculs mathématiques sont visibles. Le code est organisé dans les fonctions 'setup()' et 'loop()', avec des commentaires pour faciliter la compréhension des différentes étapes. La fenêtre du moniteur série à droite affiche des résultats en temps réel, indiquant les angles calculés 'AngleX', 'AngleY', et 'AngleZ' avec des valeurs numériques.

Shield Joystick et module MPU6050

Nous allons maintenant explorer une utilisation avancée du MPU6050 en le combinant avec un shield joystick équipé d’un écran OLED. Cette configuration permet d’afficher en temps réel les données capturées par le capteur. Idéale pour des projets de contrôle de mouvement et de mesure, cette solution offre une interface visuelle directe pour les lectures du capteur. Dans cet exemple, nous afficherons les valeurs mesurées par l’accéléromètre et le gyroscope du MPU6050 sur un écran OLED de 0,96 pouces.

				
					#include "SPI.h"
#include "Wire.h"
#include "Adafruit_GFX.h"
#include "Adafruit_SSD1306.h"

#define SCREEN_WIDTH 128 // Largeur de l'écran OLED en pixels
#define SCREEN_HEIGHT 64 // Hauteur de l'écran OLED en pixels

// Declaration de l'écran SSD1306 connecté en I2C (pins SDA, SCL)
#define OLED_RESET 4  
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

const int MPU_addr=0x68; // Adresse I2C du MPU-6050
int16_t AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ;
double x; double y; double z;
int minVal=265; int maxVal=402;
void setup() {

Serial.begin(9600);

Wire.begin();
Wire.beginTransmission(MPU_addr);
Wire.write(0x6B); 
Wire.write(0); // Reveil du MPU-6050
Wire.endTransmission(true);
// accès à l'écran
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // ou 0x3D 
Serial.println(F("connection impossible"));
for(;;);
}

}

void loop() {

adxl();

delay(40);
}

void adxl(){
Wire.beginTransmission(MPU_addr);
Wire.write(0x3B);
Wire.endTransmission(false);
Wire.requestFrom(MPU_addr,14,true);
AcX=Wire.read()<<8|Wire.read(); // 0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L)
AcY=Wire.read()<<8|Wire.read(); // 0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L)
AcZ=Wire.read()<<8|Wire.read(); // 0x3F (ACCEL_ZOUT_H) & 0x40 (ACCEL_ZOUT_L)
Tmp=Wire.read()<<8|Wire.read(); // 0x41 (TEMP_OUT_H) & 0x42 (TEMP_OUT_L)
GyX=Wire.read()<<8|Wire.read(); // 0x43 (GYRO_XOUT_H) & 0x44 (GYRO_XOUT_L)
GyY=Wire.read()<<8|Wire.read(); // 0x45 (GYRO_YOUT_H) & 0x46 (GYRO_YOUT_L)
GyZ=Wire.read()<<8|Wire.read(); // 0x47 (GYRO_ZOUT_H) & 0x48 (GYRO_ZOUT_L)
Serial.print("AcX = "); Serial.print(AcX);
Serial.print(" | AcY = "); Serial.print(AcY);
Serial.print(" | AcZ = "); Serial.print(AcZ);
Serial.print(" | Tmp = "); Serial.print(Tmp/340.00+36.53); //Température en degrés celcius
Serial.print(" | GyX = "); Serial.print(GyX);
Serial.print(" | GyY = "); Serial.print(GyY);
Serial.print(" | GyZ = "); Serial.println(GyZ);
int xAng = map(AcX,minVal,maxVal,-90,90);
int yAng = map(AcY,minVal,maxVal,-90,90);
int zAng = map(AcZ,minVal,maxVal,-90,90);
x= RAD_TO_DEG * (atan2(-yAng, -zAng)+PI);
y= RAD_TO_DEG * (atan2(-xAng, -zAng)+PI);
z= RAD_TO_DEG * (atan2(-yAng, -xAng)+PI);

//Affichage du résultat sur l'écran 0.96 pouces
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(SSD1306_WHITE);
display.setCursor(0,0);
display.println(F("X"));
display.setCursor(50,0);
display.println(x);
display.setCursor(0,20);
display.println(F("Y"));
display.setCursor(50,20);
display.println(y);
display.setCursor(0,40);
display.println(F("Z"));
display.setCursor(50,40);
display.println(z);
display.display();
delay(300);
}

Explication du code

  1. Initialisation :

    • Les bibliothèques Wire.h, Adafruit_GFX.h et Adafruit_SSD1306.h sont incluses pour la communication I2C et la gestion de l’affichage OLED.
    • Les constantes SCREEN_WIDTH et SCREEN_HEIGHT définissent les dimensions de l’écran OLED.
    • Un objet Adafruit_SSD1306 est déclaré pour contrôler l’écran OLED.
    • L’adresse I2C du MPU6050 est définie (MPU_addr).

  2. Configuration :

    • La fonction setup() initialise la communication I2C avec le MPU6050 et l’écran OLED.
    • Le MPU6050 est configuré et réveillé pour la lecture des données.
    • L’écran OLED est initialisé et un message d’erreur est affiché en cas d’échec.

  3. Boucle principale :

    • La fonction loop() lit les données des capteurs du MPU6050 (accéléromètre et gyroscope) et les affiche sur l’écran OLED.
    • Les valeurs de l’accéléromètre et du gyroscope sont affichées sous forme de texte sur l’écran OLED.
Photographie d'un circuit électronique sur une carte de développement rouge portant l'inscription 'eaglerobotics.com'. La carte est équipée de divers composants, dont un joystick noir, des boutons-poussoirs, et plusieurs LED. Sur le côté droit de la carte, un petit écran OLED bleu affiche des valeurs numériques sous les légendes X, Y, et Z, indiquant probablement des mesures de position ou d'orientation. Un câble USB bleu est connecté à la carte, suggérant qu'elle est alimentée ou contrôlée via un ordinateur.

Piloter un robot avec le module MPU6050 et Arduino

Dans cette section, nous allons voir comment utiliser le module MPU6050 pour piloter un robot à l’aide d’un Arduino. En exploitant les capacités de détection de mouvement du MPU6050, nous pouvons contrôler le comportement d’un robot en fonction de son inclinaison et de ses mouvements. Ce projet est parfait pour ceux qui souhaitent explorer l’intégration de capteurs dans des systèmes robotiques.

				
					// Programme côté Shield:

#include "SPI.h"
#include "Wire.h"
#include "Adafruit_GFX.h"
#include "Adafruit_SSD1306.h"
#include "SoftwareSerial.h"

#define SCREEN_WIDTH 128 // Largeur de l'écran OLED en pixels
#define SCREEN_HEIGHT 64 // Hauteur de l'écran OLED en pixels

// Déclaration de l'écran SSD1306 connecté en I2C (pins SDA, SCL)
#define OLED_RESET 4 // 
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

SoftwareSerial BT (7,8);
const int MPU_addr=0x68; // I2C address of the MPU-6050
int16_t AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ;
double x; double y; double z; double w;
int minVal=265; int maxVal=402;
char a; // Donnée si on veut recevoir de la donnée Bluetooth

void setup() {

BT.begin(9600); //Activation du Bluetooth

Serial.begin(9600); // Activation du Port série

Wire.begin(); // Activation du MPU6050
Wire.beginTransmission(MPU_addr);
Wire.write(0x6B); 
Wire.write(0); 
Wire.endTransmission(true);

// Activation du Display
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // ou Adresse 0x3D
Serial.println(F("Connection impossible"));
for(;;); 
}

}

void loop() {

Wire.beginTransmission(MPU_addr);
Wire.write(0x3B);
Wire.endTransmission(false);
Wire.requestFrom(MPU_addr,14,true);
AcX=Wire.read()<<8|Wire.read(); // 0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L)
AcY=Wire.read()<<8|Wire.read(); // 0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L)
AcZ=Wire.read()<<8|Wire.read(); // 0x3F (ACCEL_ZOUT_H) & 0x40 (ACCEL_ZOUT_L)
Tmp=Wire.read()<<8|Wire.read(); // 0x41 (TEMP_OUT_H) & 0x42 (TEMP_OUT_L)
GyX=Wire.read()<<8|Wire.read(); // 0x43 (GYRO_XOUT_H) & 0x44 (GYRO_XOUT_L)
GyY=Wire.read()<<8|Wire.read(); // 0x45 (GYRO_YOUT_H) & 0x46 (GYRO_YOUT_L)
GyZ=Wire.read()<<8|Wire.read(); // 0x47 (GYRO_ZOUT_H) & 0x48 (GYRO_ZOUT_L)
int xAng = map(AcX,minVal,maxVal,-90,90);
int yAng = map(AcY,minVal,maxVal,-90,90);
int zAng = map(AcZ,minVal,maxVal,-90,90);
x= RAD_TO_DEG * (atan2(-yAng, -zAng)+PI);
y= RAD_TO_DEG * (atan2(-xAng, -zAng)+PI);
z= RAD_TO_DEG * (atan2(-yAng, -xAng)+PI);
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(SSD1306_WHITE);
display.setCursor(0,0);
display.println(F("X"));
display.setCursor(50,0);
display.println(x);
display.setCursor(0,20);
display.println(F("Y"));
display.setCursor(50,20);
display.println(y);
display.setCursor(0,40);
display.println(F("Z"));
display.setCursor(50,40);
display.println(z);
display.display();
delay(300);
w = x + y + z;
if( w >= 50 && w <= 80){
Serial.print(w);
Serial.println("mode droite");
BT.write('r');
while(w >= 50 && w <= 80){
delay(1);
adxl();
}
Serial.println("exit de droite");
BT.write('s');
}
else if (w >= 190 && w <= 260){
Serial.print(w);
Serial.println("mode arriere");
BT.write('b');
while(w >= 190 && w <= 260){
delay(1);
adxl();
}
Serial.println("exit de arriere");
BT.write('s');
}
else if (w >= 280 && w <= 350){
Serial.print(w);
Serial.println("mode gauche");
BT.write('l');
while(w >= 280 && w <= 350){
delay(1);
adxl();
}
Serial.println("exit de gauche");
BT.write('s');
}
else if (w >= 680 && w <= 720){
Serial.print(w);
Serial.println("mode avant");
BT.write('f');
while(w >= 680 && w <= 720){
delay(1);
adxl();
}
Serial.println("exit de avant");
BT.write('s');
}
else {
Serial.print(w);
Serial.println("mode stop");
}

delay(40);
}

void adxl(){
Wire.beginTransmission(MPU_addr);
Wire.write(0x3B);
Wire.endTransmission(false);
Wire.requestFrom(MPU_addr,14,true);
AcX=Wire.read()<<8|Wire.read(); // 0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L)
AcY=Wire.read()<<8|Wire.read(); // 0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L)
AcZ=Wire.read()<<8|Wire.read(); // 0x3F (ACCEL_ZOUT_H) & 0x40 (ACCEL_ZOUT_L)
Tmp=Wire.read()<<8|Wire.read(); // 0x41 (TEMP_OUT_H) & 0x42 (TEMP_OUT_L)
GyX=Wire.read()<<8|Wire.read(); // 0x43 (GYRO_XOUT_H) & 0x44 (GYRO_XOUT_L)
GyY=Wire.read()<<8|Wire.read(); // 0x45 (GYRO_YOUT_H) & 0x46 (GYRO_YOUT_L)
GyZ=Wire.read()<<8|Wire.read(); // 0x47 (GYRO_ZOUT_H) & 0x48 (GYRO_ZOUT_L)

int xAng = map(AcX,minVal,maxVal,-90,90);
int yAng = map(AcY,minVal,maxVal,-90,90);
int zAng = map(AcZ,minVal,maxVal,-90,90);
x= RAD_TO_DEG * (atan2(-yAng, -zAng)+PI);
y= RAD_TO_DEG * (atan2(-xAng, -zAng)+PI);
z= RAD_TO_DEG * (atan2(-yAng, -xAng)+PI);
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(SSD1306_WHITE);
display.setCursor(0,0);
display.println(F("X"));
display.setCursor(50,0);
display.println(x);
display.setCursor(0,20);
display.println(F("Y"));
display.setCursor(50,20);
display.println(y);
display.setCursor(0,40);
display.println(F("Z"));
display.setCursor(50,40);
display.println(z);
display.display();
delay(300);
w = x + y + z;
}

Conclusion

L’intégration du module MPU6050 avec Arduino ouvre un large éventail de possibilités pour les projets de détection de mouvement et de contrôle de système. Nous avons exploré trois applications différentes : l’utilisation simple du module pour lire et afficher les données du capteur, la combinaison du MPU6050 avec un shield joystick et un écran OLED pour une interface visuelle en temps réel, et enfin, l’application de ces lectures pour piloter un robot en fonction de son inclinaison.

Ces exemples démontrent la polyvalence et la puissance du MPU6050 lorsqu’il est utilisé en conjonction avec Arduino. En maîtrisant ces concepts, vous pouvez créer des systèmes complexes et interactifs qui répondent précisément aux mouvements et aux changements d’orientation. Que ce soit pour des projets de robotique, des dispositifs portables ou des systèmes de stabilisation, le MPU6050 offre une solution robuste et fiable.

Nous espérons que ce guide vous a fourni une base solide pour commencer à explorer les nombreuses applications possibles avec le MPU6050 et Arduino. N’hésitez pas à expérimenter davantage et à adapter ces exemples pour répondre à vos besoins spécifiques. Avec de la créativité et de l’ingéniosité, les possibilités sont infinies.

Pour aller plus loin, explorez notre sélection de capteurs et modules complémentaires pour enrichir vos projets. Vous pouvez trouver tout ce dont vous avez besoin, y compris des modules MPU6050, des cartes Arduino, des shields joystick avec écran OLED et bien plus encore, dans notre Boutique. Profitez de nos offres spéciales et démarrez dès aujourd’hui votre prochain projet technologique !

Bonjour ! 🌟 Rejoignez notre newsletter pour ne rien manquer.

Recevez nos offres spéciales et les derniers articles directement dans votre boîte de réception

Nous ne faisons pas de spam, promis ! Consultez notre politique de confidentialité pour en savoir plus.

Retour en haut

Projet sur mesure