Accéléromètre Gyroscope MPU6050

Le MPU-6050 est le module de mouvement le plus utilisé du monde de l’électronique : sous son petit circuit bleu se cachent un accéléromètre 3 axes, un gyroscope 3 axes, un capteur de température et un processeur de mouvement. Six degrés de liberté sur une carte de la taille d’un timbre-poste, pour quelques fils et deux résistances de tirage.

La carte que nous livrons est une GY-521, le support standard du MPU-6050 : elle ajoute le régulateur 3,3 V nécessaire au circuit et ramène tout le brochage sur une rangée de 2,54 mm. Elle communique en I2C, deux fils seulement, et se branche aussi bien sur un Arduino que sur un ESP32, un STM32 ou un Raspberry Pi.

Ce que fait réellement cette carte

Les deux capteurs ne mesurent pas la même chose, et c’est ce qui les rend complémentaires :

• L’accéléromètre mesure une accélération, donc aussi la pesanteur. Immobile et à plat, il lit 1 g sur l’axe vertical. C’est lui qui donne l’inclinaison : un robot qui penche vers l’avant, un écran qui pivote, un niveleur de caméra.
• Le gyroscope mesure une vitesse de rotation en degrés par seconde. Il détecte le mouvement même quand l’axe tourne à l’horizontale — précisément le cas où l’accéléromètre ne voit rien. C’est lui qui donne le cap et la vitesse d’un drone.
• Le capteur de température mesure la température de la puce elle-même, à un degré près. Utile pour compenser la dérive des deux autres capteurs, pas pour mesurer la température d’une pièce.
• Le DMP (Digital Motion Processor) est un petit calculateur intégré qui peut fusionner les six axes et délivrer directement un angle, sans que le microcontrôleur ait à faire le calcul. Il demande une bibliothèque dédiée et un chargement de micrologiciel au démarrage.

Trois applications typiques reviennent sans cesse : le robot auto-équilibré qui corrige son inclinaison plusieurs dizaines de fois par seconde, le drone qui stabilise son attitude, et le compteur de pas ou de gestes dans un objet porté. S’y ajoutent la détection de chute, l’orientation automatique d’un afficheur et la mesure d’un angle de bras mécanique.

Caractéristiques techniques

Brochage : huit broches, quatre utiles

Les huit broches sont sérigraphiées sur la carte. Quatre suffisent à faire fonctionner le module :

Deux points pratiques. D’abord, les barrettes de broches ne sont pas soudées sur la carte : il faut les souder soi-même, en quinconce ou vers le bas selon que le module ira sur une plaque d’essai ou au bout de fils. Ensuite, les lignes SDA et SCL d’un bus I2C sont tirées vers la tension d’alimentation par des résistances et non pilotées en permanence : alimenter le module en 3,3 V met les deux côtés du bus au même niveau et supprime toute question de compatibilité, y compris avec un ESP32 ou un Raspberry Pi, qui sont en 3,3 V.

Adresse I2C : 0x68 ou 0x69

L’adresse par défaut est 0x68, et sur un bus I2C elle n’appartient qu’à un seul composant. Deux conséquences :

• Si l’adresse 0x68 ne répond pas, c’est presque toujours le câblage — SDA et SCL inversés, ou masse non commune — et non le module.
• Elle ne vous limite pas à un seul capteur : un afficheur LCD 16×02 I2C, un driver PCA9685 ou toute autre carte I2C peut partager le même bus, chacun avec son adresse. C’est tout l’intérêt d’un bus : deux fils pour une dizaine de périphériques.

Ce que le MPU-6050 ne fait pas

Une précision qui évite d’acheter deux fois. Le MPU-6050 n’a pas de magnétomètre : il ne connaît pas le nord, et un cap calculé avec lui seul dérive lentement. Pour un vrai compas, il faut un capteur de champ magnétique en plus. De même, si vous cherchez un module 9 axes prêt à l’emploi, le MPU-6050 n’est pas la bonne référence — mais il reste de loin le plus simple à mettre en œuvre, et sa bibliothèque est la mieux documentée.

Mini-projet : lire l’inclinaison et la rotation

Le montage tient en quatre fils et le programme fait une trentaine de lignes utiles : il interroge le module, convertit les mesures brutes en unités lisibles, puis affiche l’inclinaison et la vitesse de rotation dans le moniteur série.

Ce qu’il faut

Le câblage

Le programme

À copier dans l’IDE Arduino, puis à téléverser :

/*
 * Accelerometre et gyroscope MPU-6050 (carte GY-521)
 * Carte : Arduino Uno R3 -- bus I2C : SDA sur A4, SCL sur A5
 * Alimentation du module : 3,3 V
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

#include "Wire.h"

const byte ADRESSE_MPU = 0x68;   // 0x69 si la broche AD0 est portee au 3,3 V

// Registres utiles du MPU-6050
const byte REG_REVEIL     = 0x6B;  // gestion de l alimentation
const byte REG_GYRO_CONF  = 0x1B;  // pleine echelle du gyroscope
const byte REG_ACCEL_CONF = 0x1C;  // pleine echelle de l accelerometre
const byte REG_MESURES    = 0x3B;  // debut des 14 octets de mesures

// Facteurs de conversion correspondant aux pleines echelles choisies
const float PAR_G         = 16384.0;  // +/- 2 g
const float PAR_DEGRE_SEC = 131.0;    // +/- 250 degres par seconde

void ecrireRegistre(byte registre, byte valeur) {
  Wire.beginTransmission(ADRESSE_MPU);
  Wire.write(registre);
  Wire.write(valeur);
  Wire.endTransmission();
}

void lireMesures(byte *tampon, byte nombre) {
  Wire.beginTransmission(ADRESSE_MPU);
  Wire.write(REG_MESURES);
  Wire.endTransmission(false);          // liaison gardee ouverte pour la relecture

  Wire.requestFrom((byte)ADRESSE_MPU, nombre);

  byte recus = 0;
  while (recus != nombre) {
    if (Wire.available() == 0) {
      break;                            // pas de reponse du circuit : on arrete
    }
    tampon[recus] = Wire.read();
    recus++;
  }
}

void setup() {
  Wire.begin();
  Serial.begin(9600);

  ecrireRegistre(REG_REVEIL, 0x00);      // sort le circuit du mode veille
  ecrireRegistre(REG_GYRO_CONF, 0x00);   // gyroscope a +/- 250 degres par seconde
  ecrireRegistre(REG_ACCEL_CONF, 0x00);  // accelerometre a +/- 2 g

  delay(100);
  Serial.println("MPU-6050 pret.");
}

void loop() {
  byte mesures[14];
  lireMesures(mesures, 14);

  // Mesures en 16 bits signes, octet de poids fort en premier
  int16_t brutAx = (int16_t)(mesures[0] * 256 + mesures[1]);
  int16_t brutAy = (int16_t)(mesures[2] * 256 + mesures[3]);
  int16_t brutAz = (int16_t)(mesures[4] * 256 + mesures[5]);
  int16_t brutGx = (int16_t)(mesures[8] * 256 + mesures[9]);
  int16_t brutGy = (int16_t)(mesures[10] * 256 + mesures[11]);
  int16_t brutGz = (int16_t)(mesures[12] * 256 + mesures[13]);

  float ax = brutAx / PAR_G;             // acceleration en g
  float ay = brutAy / PAR_G;
  float az = brutAz / PAR_G;

  float gx = brutGx / PAR_DEGRE_SEC;     // rotation en degres par seconde
  float gy = brutGy / PAR_DEGRE_SEC;
  float gz = brutGz / PAR_DEGRE_SEC;

  // Inclinaison sur l axe X, deduite de l accelerometre
  float inclinaison = atan2(ay, az) * 180.0 / PI;

  Serial.print("Inclinaison : ");
  Serial.print(inclinaison, 1);
  Serial.print(" deg  |  rotation : ");
  Serial.print(gx, 1);
  Serial.println(" deg/s");

  Serial.print("Acceleration : ");
  Serial.print(ax, 2);
  Serial.print(" g / ");
  Serial.print(ay, 2);
  Serial.print(" g / ");
  Serial.print(az, 2);
  Serial.println(" g");

  delay(200);
}

Comment ça marche

• Le module est en veille à la mise sous tension : le premier échange avec le registre 0x6B le réveille. Sans cette ligne, toutes les mesures valent zéro, ce qui laisse croire à un module mort.
• Les registres 0x1B et 0x1C fixent la pleine échelle. Droite veut dire précision : ±2 g et ±250 °/s donnent la meilleure résolution, mais saturent sur un mouvement violent. Pour un drone, élargissez le gyroscope ; les facteurs de conversion changent alors proportionnellement.
• Les quatorze octets lus d’un seul bloc à partir de 0x3B contiennent les trois axes de l’accéléromètre, la température, puis les trois axes du gyroscope. Une lecture unique garantit que les six axes sont mesurés au même instant, alors que six lectures séparées les décaleraient de quelques millisecondes.
• Chaque axe arrive en 16 bits signés, octet de poids fort en premier. La multiplication par 256 reconstruit la valeur sans opérateur de décalage, et la division par 16384 ou 131 la convertit en g et en degrés par seconde.
• atan2(ay, az) donne l’inclinaison à partir de la seule pesanteur, donc uniquement quand le module ne subit pas d’autre accélération. Le gyroscope, lui, donne la rotation instantanée mais dérive avec le temps. C’est exactement pour cela que les deux sont réunis sur la même puce : la bibliothèque MotionFusion du DMP combine l’un et l’autre pour obtenir un angle stable.

L’étalonnage : l’étape à ne pas sauter

Posé bien à plat et immobile, le module ne lit pas exactement zéro : le gyroscope affiche quelques degrés par seconde et l’accéléromètre décale légèrement la pesanteur. Ce sont des décalages à l’offset, normaux, différents d’une carte à l’autre.

La méthode est simple : mesurez deux cents échantillons au repos, faites-en la moyenne, puis soustrayez cette moyenne à chaque mesure suivante. Deux cents lectures suffisent, et le résultat devient parfaitement exploitable. Sans cette correction, un angle calculé en intégrant le gyroscope dérive de plusieurs degrés par minute — c’est la première cause de « mon robot penche sans raison ».

Questions fréquentes

Le module n’apparaît pas sur le bus I2C, que vérifier ?

Dans l’ordre : la masse commune est-elle bien reliée au GND de l’Arduino ? SDA est-il bien sur A4 et SCL sur A5 — la confusion des deux est l’erreur la plus fréquente ? Les barrettes sont-elles réellement soudées, et non simplement enfilées dans les trous ? Un scan I2C affichera 0x68 si tout est en ordre, et rien du tout sinon.

Puis-je l’alimenter en 5 V ?

Sur cette carte, oui : elle porte un régulateur 3,3 V. Le circuit lui-même ne supporte pas plus de 3,46 V, c’est le régulateur qui fait l’adaptation. Le 3,3 V reste la solution la plus simple et la plus sûre, en particulier si vous partagez le bus I2C avec un ESP32 ou un Raspberry Pi, qui sont en 3,3 V. Dans tous les cas, ne dépassez jamais 5 V sur VCC.

Quelle précision puis-je espérer ?

La tolérance de calibrage constructeur est de ±3 %, et la résolution est de 16 bits — largement plus fine que ce dont un projet amateur a besoin. En pratique, c’est le bruit d’échantillonnage et la dérive du gyroscope qui limitent la précision, pas la puce. Une moyenne glissante sur une dizaine de mesures lisse déjà beaucoup.

Est-ce suffisant pour un robot auto-équilibré ?

Oui, c’est le capteur classique de ces montages : il faut corriger l’assiette plusieurs dizaines de fois par seconde, et le MPU-6050 délivre ses six axes en quelques millisecondes. Vous aurez en plus besoin d’un étage de puissance pour les moteurs — un module L298N ou un driver équivalent — et d’une boucle de régulation qui corrige dès que l’angle s’écarte de la verticale.

Puis-je envoyer les mesures à un téléphone ?

Sur un Arduino Uno, oui, en ajoutant un module Bluetooth HC-05 : le même programme, auquel on ajoute quelques lignes qui écrivent l’angle sur la liaison série du module. L’ESP32 et le Raspberry Pi disposent du WiFi ou du Bluetooth nativement et se passent de ce module.

À combiner avec

Le socle de tout montage avec ce capteur est la carte Uno R3, sa plaque d’essai et quelques fils femelle-femelle : c’est ce que décrit le mini-projet de cette page, et le KIT Starter réunit déjà la carte, la plaque, les fils et les résistances pour partir de zéro. Côté robotique, le kit robot 4WD fournit châssis, moteurs et roues, auxquels il ne manque qu’un capteur de mouvement pour se repérer. Pour situer le robot ou le drone sur une carte, ce module d’assiette se marie naturellement avec un module GPS NEO-6M : le GPS donne la position, le MPU-6050 donne l’orientation. Et si votre projet demande Linux plutôt qu’un microcontrôleur, le Raspberry Pi 4 B communique avec ce module par la même liaison I2C.